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

<resources xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="byteShort" msgid="8340973892742019101">"B"</string>
    <string name="kilobyteShort" msgid="5973789783504771878">"KB"</string>
    <string name="megabyteShort" msgid="6355851576770428922">"MB"</string>
    <string name="gigabyteShort" msgid="3259882455212193214">"GB"</string>
    <string name="terabyteShort" msgid="231613018159186962">"TB"</string>
    <string name="petabyteShort" msgid="5637816680144990219">"PB"</string>
    <string name="fileSizeSuffix" msgid="9164292791500531949">"<xliff:g id="NUMBER">%1$s</xliff:g><xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="untitled" msgid="4638956954852782576">"&lt;Untitled&gt;"</string>
    <string name="ellipsis" msgid="7899829516048813237">"…"</string>
    <string name="ellipsis_two_dots" msgid="1228078994866030736">"‥"</string>
    <string name="emptyPhoneNumber" msgid="7694063042079676517">"(No phone number)"</string>
    <string name="unknownName" msgid="2277556546742746522">"(Unknown)"</string>
    <string name="defaultVoiceMailAlphaTag" msgid="2660020990097733077">"Voicemail"</string>
    <string name="defaultMsisdnAlphaTag" msgid="2850889754919584674">"MSISDN1"</string>
    <string name="mmiError" msgid="5154499457739052907">"Connection problem or invalid MMI code."</string>
    <string name="mmiFdnError" msgid="5224398216385316471">"Operation is restricted to fixed dialling numbers only."</string>
    <string name="serviceEnabled" msgid="8147278346414714315">"Service was enabled."</string>
    <string name="serviceEnabledFor" msgid="6856228140453471041">"Service was enabled for:"</string>
    <string name="serviceDisabled" msgid="1937553226592516411">"Service has been disabled."</string>
    <string name="serviceRegistered" msgid="6275019082598102493">"Registration was successful."</string>
    <string name="serviceErased" msgid="1288584695297200972">"Erase successful."</string>
    <string name="passwordIncorrect" msgid="7612208839450128715">"Incorrect password."</string>
    <string name="mmiComplete" msgid="8232527495411698359">"MMI complete."</string>
    <string name="badPin" msgid="9015277645546710014">"The old PIN that you typed is incorrect."</string>
    <string name="badPuk" msgid="5487257647081132201">"The PUK that you typed isn\'t correct."</string>
    <string name="mismatchPin" msgid="609379054496863419">"The PINs that you typed don\'t match."</string>
    <string name="invalidPin" msgid="3850018445187475377">"Type a PIN that is 4 to 8 numbers."</string>
    <string name="invalidPuk" msgid="8761456210898036513">"Type a PUK that is 8 numbers or longer."</string>
    <string name="needPuk" msgid="919668385956251611">"Your SIM card is PUK-locked. Type the PUK code to unlock it."</string>
    <string name="needPuk2" msgid="4526033371987193070">"Type PUK2 to unblock SIM card."</string>
    <string name="enablePin" msgid="209412020907207950">"Unsuccessful, enable SIM/RUIM Lock."</string>
  <plurals name="pinpuk_attempts">
    <item quantity="one" msgid="6596245285809790142">"You have <xliff:g id="NUMBER">%d</xliff:g> remaining attempt/s before SIM is locked."</item>
    <item quantity="other" msgid="7530597808358774740">"You have <xliff:g id="NUMBER">%d</xliff:g> remaining attempt/s before SIM is locked."</item>
  </plurals>
    <string name="imei" msgid="2625429890869005782">"IMEI"</string>
    <string name="meid" msgid="4841221237681254195">"MEID"</string>
    <string name="ClipMmi" msgid="6952821216480289285">"Incoming Caller ID"</string>
    <string name="ClirMmi" msgid="7784673673446833091">"Outgoing Caller ID"</string>
    <string name="CfMmi" msgid="5123218989141573515">"Call forwarding"</string>
    <string name="CwMmi" msgid="9129678056795016867">"Call waiting"</string>
    <string name="BaMmi" msgid="455193067926770581">"Call barring"</string>
    <string name="PwdMmi" msgid="7043715687905254199">"Password change"</string>
    <string name="PinMmi" msgid="3113117780361190304">"PIN change"</string>
    <string name="CnipMmi" msgid="3110534680557857162">"Calling number present"</string>
    <string name="CnirMmi" msgid="3062102121430548731">"Calling number restricted"</string>
    <string name="ThreeWCMmi" msgid="9051047170321190368">"Three-way calling"</string>
    <string name="RuacMmi" msgid="7827887459138308886">"Rejection of undesired annoying calls"</string>
    <string name="CndMmi" msgid="3116446237081575808">"Calling number delivery"</string>
    <string name="DndMmi" msgid="1265478932418334331">"Do not disturb"</string>
    <string name="CLIRDefaultOnNextCallOn" msgid="429415409145781923">"Caller ID defaults to restricted. Next call: Restricted"</string>
    <string name="CLIRDefaultOnNextCallOff" msgid="3092918006077864624">"Caller ID defaults to restricted. Next call: Not restricted"</string>
    <string name="CLIRDefaultOffNextCallOn" msgid="6179425182856418465">"Caller ID defaults to not restricted. Next call: Restricted"</string>
    <string name="CLIRDefaultOffNextCallOff" msgid="2567998633124408552">"Caller ID defaults to not restricted. Next call: Not restricted"</string>
    <string name="serviceNotProvisioned" msgid="8614830180508686666">"Service not provisioned."</string>
    <string name="CLIRPermanent" msgid="3377371145926835671">"You can\'t change the caller ID setting."</string>
    <string name="RestrictedChangedTitle" msgid="5592189398956187498">"Restricted access changed"</string>
    <string name="RestrictedOnData" msgid="8653794784690065540">"Data service is blocked."</string>
    <string name="RestrictedOnEmergency" msgid="6581163779072833665">"Emergency service is blocked."</string>
    <string name="RestrictedOnNormal" msgid="4953867011389750673">"Voice service is blocked."</string>
    <string name="RestrictedOnAllVoice" msgid="3396963652108151260">"All voice services are blocked."</string>
    <string name="RestrictedOnSms" msgid="8314352327461638897">"SMS service is blocked."</string>
    <string name="RestrictedOnVoiceData" msgid="996636487106171320">"Voice/Data services are blocked."</string>
    <string name="RestrictedOnVoiceSms" msgid="1888588152792023873">"Voice/SMS services are blocked."</string>
    <string name="RestrictedOnAll" msgid="5643028264466092821">"All voice/data/SMS services are blocked."</string>
    <string name="serviceClassVoice" msgid="1258393812335258019">"Voice"</string>
    <string name="serviceClassData" msgid="872456782077937893">"Data"</string>
    <string name="serviceClassFAX" msgid="5566624998840486475">"FAX"</string>
    <string name="serviceClassSMS" msgid="2015460373701527489">"SMS"</string>
    <string name="serviceClassDataAsync" msgid="4523454783498551468">"Async"</string>
    <string name="serviceClassDataSync" msgid="7530000519646054776">"Sync"</string>
    <string name="serviceClassPacket" msgid="6991006557993423453">"Packet"</string>
    <string name="serviceClassPAD" msgid="3235259085648271037">"PAD"</string>
    <string name="roamingText0" msgid="7170335472198694945">"Roaming Indicator On"</string>
    <string name="roamingText1" msgid="5314861519752538922">"Roaming Indicator Off"</string>
    <string name="roamingText2" msgid="8969929049081268115">"Roaming Indicator Flashing"</string>
    <string name="roamingText3" msgid="5148255027043943317">"Out of local area"</string>
    <string name="roamingText4" msgid="8808456682550796530">"Out of Building"</string>
    <string name="roamingText5" msgid="7604063252850354350">"Roaming - Preferred System"</string>
    <string name="roamingText6" msgid="2059440825782871513">"Roaming - Available System"</string>
    <string name="roamingText7" msgid="7112078724097233605">"Roaming - Alliance Partner"</string>
    <string name="roamingText8" msgid="5989569778604089291">"Roaming - Premium Partner"</string>
    <string name="roamingText9" msgid="7969296811355152491">"Roaming - Full Service Functionality"</string>
    <string name="roamingText10" msgid="3992906999815316417">"Roaming - Partial Service Functionality"</string>
    <string name="roamingText11" msgid="4154476854426920970">"Roaming Banner On"</string>
    <string name="roamingText12" msgid="1189071119992726320">"Roaming Banner Off"</string>
    <string name="roamingTextSearching" msgid="8360141885972279963">"Searching for Service"</string>
    <string name="cfTemplateNotForwarded" msgid="1683685883841272560">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: Not forwarded"</string>
    <string name="cfTemplateForwarded" msgid="1302922117498590521">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: <xliff:g id="DIALING_NUMBER">{1}</xliff:g>"</string>
    <string name="cfTemplateForwardedTime" msgid="9206251736527085256">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: <xliff:g id="DIALING_NUMBER">{1}</xliff:g> after <xliff:g id="TIME_DELAY">{2}</xliff:g> seconds"</string>
    <string name="cfTemplateRegistered" msgid="5073237827620166285">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: Not forwarded"</string>
    <string name="cfTemplateRegisteredTime" msgid="6781621964320635172">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: Not forwarded"</string>
    <string name="fcComplete" msgid="3118848230966886575">"Feature code complete."</string>
    <string name="fcError" msgid="3327560126588500777">"Connection problem or invalid feature code."</string>
    <string name="httpErrorOk" msgid="1191919378083472204">"OK"</string>
    <string name="httpError" msgid="7956392511146698522">"There was a network error."</string>
    <string name="httpErrorLookup" msgid="4711687456111963163">"Couldn\'t find the URL."</string>
    <string name="httpErrorUnsupportedAuthScheme" msgid="6299980280442076799">"The site authentication scheme isn\'t supported."</string>
    <string name="httpErrorAuth" msgid="1435065629438044534">"Couldn\'t authenticate."</string>
    <string name="httpErrorProxyAuth" msgid="1788207010559081331">"Authentication via the proxy server was unsuccessful."</string>
    <string name="httpErrorConnect" msgid="8714273236364640549">"Couldn\'t connect to the server."</string>
    <string name="httpErrorIO" msgid="2340558197489302188">"Couldn\'t communicate with the server. Try again later."</string>
    <string name="httpErrorTimeout" msgid="4743403703762883954">"The connection to the server timed out."</string>
    <string name="httpErrorRedirectLoop" msgid="8679596090392779516">"The page contains too many server redirects."</string>
    <string name="httpErrorUnsupportedScheme" msgid="5015730812906192208">"The protocol isn\'t supported."</string>
    <string name="httpErrorFailedSslHandshake" msgid="96549606000658641">"Couldn\'t establish a secure connection."</string>
    <string name="httpErrorBadUrl" msgid="3636929722728881972">"Couldn\'t open the page because the URL is invalid."</string>
    <string name="httpErrorFile" msgid="2170788515052558676">"Couldn\'t access the file."</string>
    <string name="httpErrorFileNotFound" msgid="6203856612042655084">"Couldn\'t find the requested file."</string>
    <string name="httpErrorTooManyRequests" msgid="1235396927087188253">"Too many requests are being processed. Try again later."</string>
    <string name="notification_title" msgid="8967710025036163822">"Sign-in error for <xliff:g id="ACCOUNT">%1$s</xliff:g>"</string>
    <string name="contentServiceSync" msgid="8353523060269335667">"Sync"</string>
    <string name="contentServiceSyncNotificationTitle" msgid="397743349191901458">"Sync"</string>
    <string name="contentServiceTooManyDeletesNotificationDesc" msgid="8100981435080696431">"Too many <xliff:g id="CONTENT_TYPE">%s</xliff:g> deletions."</string>
    <string name="low_memory" product="tablet" msgid="6494019234102154896">"Tablet storage is full. Delete some files to free space."</string>
    <string name="low_memory" product="default" msgid="3475999286680000541">"Phone storage is full. Delete some files to free space."</string>
    <string name="ssl_ca_cert_warning" msgid="5848402127455021714">"Network may be monitored"</string>
    <string name="ssl_ca_cert_noti_by_unknown" msgid="4475437862189850602">"By an unknown third party"</string>
    <string name="ssl_ca_cert_noti_managed" msgid="4030263497686867141">"By <xliff:g id="MANAGING_DOMAIN">%s</xliff:g>"</string>
    <string name="me" msgid="6545696007631404292">"Me"</string>
    <string name="power_dialog" product="tablet" msgid="8545351420865202853">"Tablet options"</string>
    <string name="power_dialog" product="default" msgid="1319919075463988638">"Phone options"</string>
    <string name="silent_mode" msgid="7167703389802618663">"Silent mode"</string>
    <string name="turn_on_radio" msgid="3912793092339962371">"Turn on wireless"</string>
    <string name="turn_off_radio" msgid="8198784949987062346">"Turn off wireless"</string>
    <string name="screen_lock" msgid="799094655496098153">"Screen lock"</string>
    <string name="power_off" msgid="4266614107412865048">"Power off"</string>
    <string name="silent_mode_silent" msgid="319298163018473078">"Ringer off"</string>
    <string name="silent_mode_vibrate" msgid="7072043388581551395">"Ringer vibrate"</string>
    <string name="silent_mode_ring" msgid="8592241816194074353">"Ringer on"</string>
    <string name="shutdown_progress" msgid="2281079257329981203">"Shutting down…"</string>
    <string name="shutdown_confirm" product="tablet" msgid="3385745179555731470">"Your tablet will shut down."</string>
    <string name="shutdown_confirm" product="default" msgid="649792175242821353">"Your phone will shut down."</string>
    <string name="shutdown_confirm_question" msgid="2906544768881136183">"Do you want to shut down?"</string>
    <string name="reboot_safemode_title" msgid="7054509914500140361">"Reboot to safe mode"</string>
    <string name="reboot_safemode_confirm" msgid="55293944502784668">"Do you want to reboot into safe mode? This will disable all third-party applications that you have installed. They will be restored when you reboot again."</string>
    <string name="recent_tasks_title" msgid="3691764623638127888">"Recent"</string>
    <string name="no_recent_tasks" msgid="8794906658732193473">"No recent apps"</string>
    <string name="global_actions" product="tablet" msgid="408477140088053665">"Tablet options"</string>
    <string name="global_actions" product="default" msgid="2406416831541615258">"Phone options"</string>
    <string name="global_action_lock" msgid="2844945191792119712">"Screen lock"</string>
    <string name="global_action_power_off" msgid="4471879440839879722">"Power off"</string>
    <string name="global_action_bug_report" msgid="7934010578922304799">"Bug report"</string>
    <string name="bugreport_title" msgid="2667494803742548533">"Take bug report"</string>
    <string name="bugreport_message" msgid="398447048750350456">"This will collect information about your current device state, to send as an email message. It will take a little time from starting the bug report until it is ready to be sent. Please be patient."</string>
    <string name="global_action_toggle_silent_mode" msgid="8219525344246810925">"Silent mode"</string>
    <string name="global_action_silent_mode_on_status" msgid="3289841937003758806">"Sound is OFF"</string>
    <string name="global_action_silent_mode_off_status" msgid="1506046579177066419">"Sound is ON"</string>
    <string name="global_actions_toggle_airplane_mode" msgid="5884330306926307456">"Aeroplane mode"</string>
    <string name="global_actions_airplane_mode_on_status" msgid="2719557982608919750">"Aeroplane mode is ON"</string>
    <string name="global_actions_airplane_mode_off_status" msgid="5075070442854490296">"Aeroplane mode is OFF"</string>
    <string name="status_bar_notification_info_overflow" msgid="5301981741705354993">"999+"</string>
    <string name="safeMode" msgid="2788228061547930246">"Safe mode"</string>
    <string name="android_system_label" msgid="6577375335728551336">"Android System"</string>
    <string name="permgrouplab_costMoney" msgid="5429808217861460401">"Services that cost you money"</string>
    <string name="permgroupdesc_costMoney" msgid="3293301903409869495">"Do things that can cost you money."</string>
    <string name="permgrouplab_messages" msgid="7521249148445456662">"Your messages"</string>
    <string name="permgroupdesc_messages" msgid="7821999071003699236">"Read and write your SMS, email and other messages."</string>
    <string name="permgrouplab_personalInfo" msgid="3519163141070533474">"Your personal information"</string>
    <string name="permgroupdesc_personalInfo" msgid="8426453129788861338">"Direct access to information about you, stored in on your contact card."</string>
    <string name="permgrouplab_socialInfo" msgid="5799096623412043791">"Your social information"</string>
    <string name="permgroupdesc_socialInfo" msgid="7129842457611643493">"Direct access to information about your contacts and social connections."</string>
    <string name="permgrouplab_location" msgid="635149742436692049">"Your location"</string>
    <string name="permgroupdesc_location" msgid="5704679763124170100">"Monitor your physical location."</string>
    <string name="permgrouplab_network" msgid="5808983377727109831">"Network communication"</string>
    <string name="permgroupdesc_network" msgid="4478299413241861987">"Access various network features."</string>
    <string name="permgrouplab_bluetoothNetwork" msgid="1585403544162128109">"Bluetooth"</string>
    <string name="permgroupdesc_bluetoothNetwork" msgid="5625288577164282391">"Access devices and networks through Bluetooth."</string>
    <string name="permgrouplab_audioSettings" msgid="8329261670151871235">"Audio Settings"</string>
    <string name="permgroupdesc_audioSettings" msgid="2641515403347568130">"Change audio settings."</string>
    <string name="permgrouplab_affectsBattery" msgid="6209246653424798033">"Affects Battery"</string>
    <string name="permgroupdesc_affectsBattery" msgid="6441275320638916947">"Use features that can quickly drain battery."</string>
    <string name="permgrouplab_calendar" msgid="5863508437783683902">"Calendar"</string>
    <string name="permgroupdesc_calendar" msgid="5777534316982184416">"Direct access to calendar and events."</string>
    <string name="permgrouplab_dictionary" msgid="4148597128843641379">"Read User Dictionary"</string>
    <string name="permgroupdesc_dictionary" msgid="7921166355964764490">"Read words in user dictionary."</string>
    <string name="permgrouplab_writeDictionary" msgid="8090237702432576788">"Write User Dictionary"</string>
    <string name="permgroupdesc_writeDictionary" msgid="2711561994497361646">"Add words to the user dictionary."</string>
    <string name="permgrouplab_bookmarks" msgid="1949519673103968229">"Bookmarks and History"</string>
    <string name="permgroupdesc_bookmarks" msgid="4169771606257963028">"Direct access to bookmarks and browser history."</string>
    <string name="permgrouplab_deviceAlarms" msgid="6117704629728824101">"Alarm"</string>
    <string name="permgroupdesc_deviceAlarms" msgid="4769356362251641175">"Set the alarm clock."</string>
    <string name="permgrouplab_voicemail" msgid="4162237145027592133">"Voicemail"</string>
    <string name="permgroupdesc_voicemail" msgid="2498403969862951393">"Direct access to voicemail."</string>
    <string name="permgrouplab_microphone" msgid="171539900250043464">"Microphone"</string>
    <string name="permgroupdesc_microphone" msgid="7106618286905738408">"Direct access to the microphone to record audio."</string>
    <string name="permgrouplab_camera" msgid="4820372495894586615">"Camera"</string>
    <string name="permgroupdesc_camera" msgid="2933667372289567714">"Direct access to camera for image or video capture."</string>
    <string name="permgrouplab_screenlock" msgid="8275500173330718168">"Lock screen"</string>
    <string name="permgroupdesc_screenlock" msgid="7067497128925499401">"Ability to affect behaviour of the lock screen on your device."</string>
    <string name="permgrouplab_appInfo" msgid="8028789762634147725">"Your applications information"</string>
    <string name="permgroupdesc_appInfo" msgid="3950378538049625907">"Ability to affect behaviour of other applications on your device."</string>
    <string name="permgrouplab_wallpaper" msgid="3850280158041175998">"Wallpaper"</string>
    <string name="permgroupdesc_wallpaper" msgid="5630417854750540154">"Change the device wallpaper settings."</string>
    <string name="permgrouplab_systemClock" msgid="406535759236612992">"Clock"</string>
    <string name="permgroupdesc_systemClock" msgid="3944359833624094992">"Change the device time or timezone."</string>
    <string name="permgrouplab_statusBar" msgid="2095862568113945398">"Status Bar"</string>
    <string name="permgroupdesc_statusBar" msgid="6242593432226807171">"Change the device status bar settings."</string>
    <string name="permgrouplab_syncSettings" msgid="3341990986147826541">"Sync Settings"</string>
    <string name="permgroupdesc_syncSettings" msgid="7603195265129031797">"Access to the sync settings."</string>
    <string name="permgrouplab_accounts" msgid="3359646291125325519">"Your accounts"</string>
    <string name="permgroupdesc_accounts" msgid="4948732641827091312">"Access the available accounts."</string>
    <string name="permgrouplab_hardwareControls" msgid="7998214968791599326">"Hardware controls"</string>
    <string name="permgroupdesc_hardwareControls" msgid="4357057861225462702">"Direct access to hardware on the handset."</string>
    <string name="permgrouplab_phoneCalls" msgid="9067173988325865923">"Phone calls"</string>
    <string name="permgroupdesc_phoneCalls" msgid="7489701620446183770">"Monitor, record and process phone calls."</string>
    <string name="permgrouplab_systemTools" msgid="4652191644082714048">"System tools"</string>
    <string name="permgroupdesc_systemTools" msgid="8162102602190734305">"Lower-level access and control of the system."</string>
    <string name="permgrouplab_developmentTools" msgid="3446164584710596513">"Development tools"</string>
    <string name="permgroupdesc_developmentTools" msgid="7058828032358142018">"Features only needed for app developers."</string>
    <string name="permgrouplab_display" msgid="4279909676036402636">"Other Application UI"</string>
    <string name="permgroupdesc_display" msgid="6051002031933013714">"Effect the UI of other applications."</string>
    <string name="permgrouplab_storage" msgid="1971118770546336966">"Storage"</string>
    <string name="permgroupdesc_storage" product="nosdcard" msgid="7442318502446874999">"Access the USB storage."</string>
    <string name="permgroupdesc_storage" product="default" msgid="9203302214915355774">"Access the SD card."</string>
    <string name="permgrouplab_accessibilityFeatures" msgid="7919025602283593907">"Accessibility features"</string>
    <string name="permgroupdesc_accessibilityFeatures" msgid="4205196881678144335">"Features that assistive technology can request."</string>
    <string name="capability_title_canRetrieveWindowContent" msgid="3901717936930170320">"Retrieve window content"</string>
    <string name="capability_desc_canRetrieveWindowContent" msgid="3772225008605310672">"Inspect the content of a window that you\'re interacting with."</string>
    <string name="capability_title_canRequestTouchExploration" msgid="3108723364676667320">"Turn on Explore by Touch"</string>
    <string name="capability_desc_canRequestTouchExploration" msgid="5800552516779249356">"Touched items will be spoken aloud and the screen can be explored using gestures."</string>
    <string name="capability_title_canRequestEnhancedWebAccessibility" msgid="1739881766522594073">"Turn on enhanced web accessibility"</string>
    <string name="capability_desc_canRequestEnhancedWebAccessibility" msgid="7881063961507511765">"Scripts may be installed to make app content more accessible."</string>
    <string name="capability_title_canRequestFilterKeyEvents" msgid="2103440391902412174">"Observe text that you type"</string>
    <string name="capability_desc_canRequestFilterKeyEvents" msgid="7463135292204152818">"Includes personal data such as credit card numbers and passwords."</string>
    <string name="permlab_statusBar" msgid="7417192629601890791">"disable or modify status bar"</string>
    <string name="permdesc_statusBar" msgid="8434669549504290975">"Allows the app to disable the status bar or add and remove system icons."</string>
    <string name="permlab_statusBarService" msgid="7247281911387931485">"status bar"</string>
    <string name="permdesc_statusBarService" msgid="716113660795976060">"Allows the app to be the status bar."</string>
    <string name="permlab_expandStatusBar" msgid="1148198785937489264">"expand/collapse status bar"</string>
    <string name="permdesc_expandStatusBar" msgid="6917549437129401132">"Allows the app to expand or collapse the status bar."</string>
    <string name="permlab_install_shortcut" msgid="4279070216371564234">"install shortcuts"</string>
    <string name="permdesc_install_shortcut" msgid="8341295916286736996">"Allows an application to add Home screen shortcuts without user intervention."</string>
    <string name="permlab_uninstall_shortcut" msgid="4729634524044003699">"uninstall shortcuts"</string>
    <string name="permdesc_uninstall_shortcut" msgid="6745743474265057975">"Allows the application to remove Home screen shortcuts without user intervention."</string>
    <string name="permlab_processOutgoingCalls" msgid="3906007831192990946">"reroute outgoing calls"</string>
    <string name="permdesc_processOutgoingCalls" msgid="5331318931937402040">"Allows the app to process outgoing calls and change the number to be dialled. This permission allows the app to monitor, redirect or prevent outgoing calls."</string>
    <string name="permlab_receiveSms" msgid="8673471768947895082">"receive text messages (SMS)"</string>
    <string name="permdesc_receiveSms" msgid="6424387754228766939">"Allows the app to receive and process SMS messages. This means that the app could monitor or delete messages sent to your device without showing them to you."</string>
    <string name="permlab_receiveMms" msgid="1821317344668257098">"receive text messages (MMS)"</string>
    <string name="permdesc_receiveMms" msgid="533019437263212260">"Allows the app to receive and process MMS messages. This means that the app could monitor or delete messages sent to your device without showing them to you."</string>
    <string name="permlab_receiveEmergencyBroadcast" msgid="1803477660846288089">"receive emergency broadcasts"</string>
    <string name="permdesc_receiveEmergencyBroadcast" msgid="848524070262431974">"Allows the app to receive and process emergency broadcast messages. This permission is only available for system apps."</string>
    <string name="permlab_readCellBroadcasts" msgid="1598328843619646166">"read mobile broadcast messages"</string>
    <string name="permdesc_readCellBroadcasts" msgid="6361972776080458979">"Allows the app to read mobile broadcast messages received by your device. Cell broadcast alerts are delivered in some locations to warn you of emergency situations. Malicious apps may interfere with the performance or operation of your device when an emergency mobile broadcast is received."</string>
    <string name="permlab_sendSms" msgid="5600830612147671529">"send SMS messages"</string>
    <string name="permdesc_sendSms" msgid="7094729298204937667">"Allows the app to send SMS messages. This may result in unexpected charges. Malicious apps may cost you money by sending messages without your confirmation."</string>
    <string name="permlab_sendRespondViaMessageRequest" msgid="8713889105305943200">"send respond-via-message events"</string>
    <string name="permdesc_sendRespondViaMessageRequest" msgid="7107648548468778734">"Allows the app to send requests to other messaging apps to handle respond-via-message events for incoming calls."</string>
    <string name="permlab_readSms" msgid="8745086572213270480">"read your text messages (SMS or MMS)"</string>
    <string name="permdesc_readSms" product="tablet" msgid="2467981548684735522">"Allows the app to read SMS messages stored on your tablet or SIM card. This allows the app to read all SMS messages, regardless of content or confidentiality."</string>
    <string name="permdesc_readSms" product="default" msgid="3695967533457240550">"Allows the app to read SMS messages stored on your phone or SIM card. This allows the app to read all SMS messages, regardless of content or confidentiality."</string>
    <string name="permlab_writeSms" msgid="3216950472636214774">"edit your text messages (SMS or MMS)"</string>
    <string name="permdesc_writeSms" product="tablet" msgid="5160413947794501538">"Allows the app to write to SMS messages stored on your tablet or SIM card. Malicious apps may delete your messages."</string>
    <string name="permdesc_writeSms" product="default" msgid="7268668709052328567">"Allows the app to write to SMS messages stored on your phone or SIM card. Malicious apps may delete your messages."</string>
    <string name="permlab_receiveWapPush" msgid="5991398711936590410">"receive text messages (WAP)"</string>
    <string name="permdesc_receiveWapPush" msgid="748232190220583385">"Allows the app to receive and process WAP messages. This permission includes the ability to monitor or delete messages sent to you without showing them to you."</string>
    <string name="permlab_getTasks" msgid="6466095396623933906">"retrieve running apps"</string>
    <string name="permdesc_getTasks" msgid="7454215995847658102">"Allows the app to retrieve information about currently and recently running tasks. This may allow the app to discover information about which applications are used on the device."</string>
    <string name="permlab_interactAcrossUsers" msgid="7114255281944211682">"interact across users"</string>
    <string name="permdesc_interactAcrossUsers" msgid="364670963623385786">"Allows the app to perform actions across different users on the device. Malicious apps may use this to violate the protection between users."</string>
    <string name="permlab_interactAcrossUsersFull" msgid="2567734285545074105">"full license to interact across users"</string>
    <string name="permdesc_interactAcrossUsersFull" msgid="376841368395502366">"Allows all possible interactions across users."</string>
    <string name="permlab_manageUsers" msgid="1676150911672282428">"manage users"</string>
    <string name="permdesc_manageUsers" msgid="8409306667645355638">"Allows apps to manage users on the device, including query, creation and deletion."</string>
    <string name="permlab_getDetailedTasks" msgid="6229468674753529501">"retrieve details of running apps"</string>
    <string name="permdesc_getDetailedTasks" msgid="153824741440717599">"Allows the app to retrieve detailed information about currently and recently running tasks. Malicious apps may discover private information about other apps."</string>
    <string name="permlab_reorderTasks" msgid="2018575526934422779">"re-order running apps"</string>
    <string name="permdesc_reorderTasks" msgid="7734217754877439351">"Allows the app to move tasks to the foreground and background. The app may do this without your input."</string>
    <string name="permlab_removeTasks" msgid="6821513401870377403">"stop running apps"</string>
    <string name="permdesc_removeTasks" msgid="1394714352062635493">"Allows the app to remove tasks and kill their apps. Malicious apps may disrupt the behaviour of other apps."</string>
    <string name="permlab_manageActivityStacks" msgid="7391191384027303065">"manage activity stacks"</string>
    <string name="permdesc_manageActivityStacks" msgid="1615881933034084440">"Allows the app to add, remove and modify the activity stacks in which other apps run. Malicious apps may disrupt the behaviour of other apps."</string>
    <string name="permlab_startAnyActivity" msgid="2918768238045206456">"start any activity"</string>
    <string name="permdesc_startAnyActivity" msgid="997823695343584001">"Allows the app to start any activity, regardless of permission protection or exported state."</string>
    <string name="permlab_setScreenCompatibility" msgid="6975387118861842061">"set screen compatibility"</string>
    <string name="permdesc_setScreenCompatibility" msgid="692043618693917374">"Allows the app to control the screen compatibility mode of other applications. Malicious applications may break the behaviour of other applications."</string>
    <string name="permlab_setDebugApp" msgid="3022107198686584052">"enable app debugging"</string>
    <string name="permdesc_setDebugApp" msgid="4474512416299013256">"Allows the app to turn on debugging for another app. Malicious apps may use this to kill other apps."</string>
    <string name="permlab_changeConfiguration" msgid="4162092185124234480">"change system display settings"</string>
    <string name="permdesc_changeConfiguration" msgid="4372223873154296076">"Allows the app to change the current configuration, such as the locale or overall font size."</string>
    <string name="permlab_enableCarMode" msgid="5684504058192921098">"enable car mode"</string>
    <string name="permdesc_enableCarMode" msgid="4853187425751419467">"Allows the app to enable the car mode."</string>
    <string name="permlab_killBackgroundProcesses" msgid="3914026687420177202">"close other apps"</string>
    <string name="permdesc_killBackgroundProcesses" msgid="4593353235959733119">"Allows the app to end background processes of other apps. This may cause other apps to stop running."</string>
    <string name="permlab_forceStopPackages" msgid="2329627428832067700">"force stop other apps"</string>
    <string name="permdesc_forceStopPackages" msgid="5253157296183940812">"Allows the app to forcibly stop other apps."</string>
    <string name="permlab_forceBack" msgid="652935204072584616">"force app to close"</string>
    <string name="permdesc_forceBack" msgid="3892295830419513623">"Allows the app to force any activity that is in the foreground to close and go back. Should never be needed for normal apps."</string>
    <string name="permlab_dump" msgid="1681799862438954752">"retrieve system internal status"</string>
    <string name="permdesc_dump" msgid="1778299088692290329">"Allows the app to retrieve the internal state of the system. Malicious apps may retrieve a wide variety of private and secure information that they should never normally need."</string>
    <string name="permlab_retrieve_window_content" msgid="8022588608994589938">"retrieve screen content"</string>
    <string name="permdesc_retrieve_window_content" msgid="3193269069469700265">"Allows the app to retrieve the content of the active window. Malicious apps may retrieve the entire window content and examine all its text except passwords."</string>
    <string name="permlab_temporary_enable_accessibility" msgid="2312612135127310254">"temporary enable accessibility"</string>
    <string name="permdesc_temporary_enable_accessibility" msgid="8079456293182975464">"Allows an application to temporarily enable accessibility on the device. Malicious apps may enable accessibility without user consent."</string>
    <string name="permlab_retrieve_window_info" msgid="8532295199112519378">"retrieve window info"</string>
    <string name="permdesc_retrieve_window_info" msgid="4998836370424186849">"Allows an application to retrieve information about the windows from the window manager. Malicious apps may retrieve information that is intended for internal system usage."</string>
    <string name="permlab_filter_events" msgid="8675535648807427389">"filter events"</string>
    <string name="permdesc_filter_events" msgid="8006236315888347680">"Allows an application to register an input filter which filters the stream of all user events before they are dispatched. Malicious app may control the system UI without user intervention."</string>
    <string name="permlab_magnify_display" msgid="5973626738170618775">"magnify display"</string>
    <string name="permdesc_magnify_display" msgid="7121235684515003792">"Allows an application to magnify the content of a display. Malicious apps may transform the display content in a way that renders the device unusable."</string>
    <string name="permlab_shutdown" msgid="7185747824038909016">"partial shutdown"</string>
    <string name="permdesc_shutdown" msgid="7046500838746291775">"Puts the activity manager into a shut-down state. Does not perform a complete shut down."</string>
    <string name="permlab_stopAppSwitches" msgid="4138608610717425573">"prevent app switches"</string>
    <string name="permdesc_stopAppSwitches" msgid="8262195802582255021">"Prevents the user from switching to another app."</string>
    <string name="permlab_getTopActivityInfo" msgid="2537922311411546016">"get current app info"</string>
    <string name="permdesc_getTopActivityInfo" msgid="2512448855496067131">"Allows the holder to retrieve private information about the current application in the foreground of the screen."</string>
    <string name="permlab_runSetActivityWatcher" msgid="892239094867182656">"monitor and control all app launching"</string>
    <string name="permdesc_runSetActivityWatcher" msgid="6003603162578577406">"Allows the app to monitor and control how the system launches activities. Malicious apps may completely compromise the system. This permission is only needed for development, never for normal use."</string>
    <string name="permlab_broadcastPackageRemoved" msgid="2576333434893532475">"send package removed broadcast"</string>
    <string name="permdesc_broadcastPackageRemoved" msgid="6621901216207931089">"Allows the app to broadcast a notification that an app package has been removed. Malicious apps may use this to kill any other running app."</string>
    <string name="permlab_broadcastSmsReceived" msgid="5689095009030336593">"send SMS-received broadcast"</string>
    <string name="permdesc_broadcastSmsReceived" msgid="4152037720034365492">"Allows the app to broadcast a notification that an SMS message has been received. Malicious apps may use this to forge incoming SMS messages."</string>
    <string name="permlab_broadcastWapPush" msgid="3145347413028582371">"send WAP-PUSH-received broadcast"</string>
    <string name="permdesc_broadcastWapPush" msgid="4783402525039442729">"Allows the app to broadcast a notification that a WAP PUSH message has been received. Malicious apps may use this to forge MMS message receipt or to silently replace the content of any web page with malicious variants."</string>
    <string name="permlab_setProcessLimit" msgid="2451873664363662666">"limit number of running processes"</string>
    <string name="permdesc_setProcessLimit" msgid="7318061314040879542">"Allows the app to control the maximum number of processes that will run. Never needed for normal apps."</string>
    <string name="permlab_setAlwaysFinish" msgid="550958507798796965">"force background apps to close"</string>
    <string name="permdesc_setAlwaysFinish" msgid="7471310652868841499">"Allows the app to control whether activities are always finished as soon as they go to the background. Never needed for normal apps."</string>
    <string name="permlab_batteryStats" msgid="2789610673514103364">"read battery statistics"</string>
    <string name="permdesc_batteryStats" msgid="5897346582882915114">"Allows an application to read the current low-level battery use data. May allow the application to find out detailed information about which apps you use."</string>
    <string name="permlab_updateBatteryStats" msgid="3719689764536379557">"modify battery statistics"</string>
    <string name="permdesc_updateBatteryStats" msgid="6862817857178025002">"Allows the app to modify collected battery statistics. Not for use by normal apps."</string>
    <string name="permlab_getAppOpsStats" msgid="1508779687436585744">"retrieve app ops statistics"</string>
    <string name="permdesc_getAppOpsStats" msgid="6243887041577912877">"Allows the app to retrieve collected application operation statistics. Not for use by normal apps."</string>
    <string name="permlab_updateAppOpsStats" msgid="8829097373851521505">"modify app ops statistics"</string>
    <string name="permdesc_updateAppOpsStats" msgid="50784596594403483">"Allows the app to modify collected component usage statistics. Not for use by normal apps."</string>
    <string name="permlab_backup" msgid="470013022865453920">"control system back up and restore"</string>
    <string name="permdesc_backup" msgid="6912230525140589891">"Allows the app to control the system\'s backup and restore mechanism. Not for use by normal apps."</string>
    <string name="permlab_confirm_full_backup" msgid="5557071325804469102">"confirm a full backup or restore operation"</string>
    <string name="permdesc_confirm_full_backup" msgid="1748762171637699562">"Allows the app to launch the full backup confirmation UI. Not to be used by any app."</string>
    <string name="permlab_internalSystemWindow" msgid="2148563628140193231">"display unauthorised windows"</string>
    <string name="permdesc_internalSystemWindow" msgid="7458387759461466397">"Allows the app to create windows that are intended to be used by the internal system user interface. Not for use by normal apps."</string>
    <string name="permlab_systemAlertWindow" msgid="3543347980839518613">"draw over other apps"</string>
    <string name="permdesc_systemAlertWindow" msgid="8584678381972820118">"Allows the app to draw on top of other applications or parts of the user interface. They may interfere with your use of the interface in any application, or change what you think you are seeing in other applications."</string>
    <string name="permlab_setAnimationScale" msgid="2805103241153907174">"modify global animation speed"</string>
    <string name="permdesc_setAnimationScale" msgid="7690063428924343571">"Allows the app to change the global animation speed (faster or slower animations) at any time."</string>
    <string name="permlab_manageAppTokens" msgid="1286505717050121370">"manage app tokens"</string>
    <string name="permdesc_manageAppTokens" msgid="8043431713014395671">"Allows the app to create and manage their own tokens, bypassing their normal Z-ordering. Should never be needed for normal apps."</string>
    <string name="permlab_freezeScreen" msgid="4708181184441880175">"freeze screen"</string>
    <string name="permdesc_freezeScreen" msgid="8558923789222670064">"Allows the application to temporarily freeze the screen for a full-screen transition."</string>
    <string name="permlab_injectEvents" msgid="1378746584023586600">"press keys and control buttons"</string>
    <string name="permdesc_injectEvents" product="tablet" msgid="206352565599968632">"Allows the app to deliver its own input events (key presses, etc.) to other apps. Malicious apps may use this to take over the tablet."</string>
    <string name="permdesc_injectEvents" product="default" msgid="653128057572326253">"Allows the app to deliver its own input events (key presses, etc.) to other apps. Malicious apps may use this to take over the phone."</string>
    <string name="permlab_readInputState" msgid="469428900041249234">"record what you type and actions that you take"</string>
    <string name="permdesc_readInputState" msgid="8387754901688728043">"Allows the app to watch the keys that you press even when interacting with another app (such as typing a password). Should never be needed for normal apps."</string>
    <string name="permlab_bindInputMethod" msgid="3360064620230515776">"bind to an input method"</string>
    <string name="permdesc_bindInputMethod" msgid="3250440322807286331">"Allows the holder to bind to the top-level interface of an input method. Should never be needed for normal apps."</string>
    <string name="permlab_bindAccessibilityService" msgid="5357733942556031593">"bind to an accessibility service"</string>
    <string name="permdesc_bindAccessibilityService" msgid="7034615928609331368">"Allows the holder to bind to the top-level interface of an accessibility service. Should never be needed for normal apps."</string>
    <string name="permlab_bindPrintService" msgid="8462815179572748761">"bind to a print service"</string>
    <string name="permdesc_bindPrintService" msgid="7960067623209111135">"Allows the holder to bind to the top-level interface of a print service. Should never be needed for normal apps."</string>
    <string name="permlab_bindPrintSpoolerService" msgid="6807762783744125954">"bind to a print spooler service"</string>
    <string name="permdesc_bindPrintSpoolerService" msgid="3680552285933318372">"Allows the holder to bind to the top-level interface of a print spooler service. Should never be needed for normal apps."</string>
    <string name="permlab_bindNfcService" msgid="2752731300419410724">"bind to NFC service"</string>
    <string name="permdesc_bindNfcService" msgid="6120647629174066862">"Allows the holder to bind to applications that are emulating NFC cards. Should never be needed for normal apps."</string>
    <string name="permlab_bindTextService" msgid="7358378401915287938">"bind to a text service"</string>
    <string name="permdesc_bindTextService" msgid="8151968910973998670">"Allows the holder to bind to the top-level interface of a text service (e.g. SpellCheckerService). Should never be needed for normal applications."</string>
    <string name="permlab_bindVpnService" msgid="4708596021161473255">"bind to a VPN service"</string>
    <string name="permdesc_bindVpnService" msgid="2067845564581693905">"Allows the holder to bind to the top-level interface of a Vpn service. Should never be needed for normal apps."</string>
    <string name="permlab_bindWallpaper" msgid="8716400279937856462">"bind to wallpaper"</string>
    <string name="permdesc_bindWallpaper" msgid="7108428692595491668">"Allows the holder to bind to the top-level interface of wallpaper. Should never be needed for normal applications."</string>
    <string name="permlab_bindRemoteDisplay" msgid="1782923938029941960">"bind to a remote display"</string>
    <string name="permdesc_bindRemoteDisplay" msgid="1261242718727295981">"Allows the holder to bind to the top-level interface of a remote display. Should never be needed for normal apps."</string>
    <string name="permlab_bindRemoteViews" msgid="5697987759897367099">"bind to a widget service"</string>
    <string name="permdesc_bindRemoteViews" msgid="4717987810137692572">"Allows the holder to bind to the top-level interface of a widget service. Should never be needed for normal apps."</string>
    <string name="permlab_bindDeviceAdmin" msgid="8704986163711455010">"interact with device admin"</string>
    <string name="permdesc_bindDeviceAdmin" msgid="569715419543907930">"Allows the holder to send intents to a device administrator. Should never be needed for normal apps."</string>
    <string name="permlab_manageDeviceAdmins" msgid="4248828900045808722">"add or remove a device admin"</string>
    <string name="permdesc_manageDeviceAdmins" msgid="5025608167709942485">"Allows the holder to add or remove active device administrators. Should never be needed for normal apps."</string>
    <string name="permlab_setOrientation" msgid="3365947717163866844">"change screen orientation"</string>
    <string name="permdesc_setOrientation" msgid="3046126619316671476">"Allows the app to change the rotation of the screen at any time. Should never be needed for normal apps."</string>
    <string name="permlab_setPointerSpeed" msgid="9175371613322562934">"change pointer speed"</string>
    <string name="permdesc_setPointerSpeed" msgid="6866563234274104233">"Allows the app to change the mouse or touch pad pointer speed at any time. Should never be needed for normal apps."</string>
    <string name="permlab_setKeyboardLayout" msgid="4778731703600909340">"change keyboard layout"</string>
    <string name="permdesc_setKeyboardLayout" msgid="8480016771134175879">"Allows the app to change the keyboard layout. Should never be needed for normal apps."</string>
    <string name="permlab_signalPersistentProcesses" msgid="4539002991947376659">"send Linux signals to apps"</string>
    <string name="permdesc_signalPersistentProcesses" msgid="4896992079182649141">"Allows the app to request that the supplied signal be sent to all persistent processes."</string>
    <string name="permlab_persistentActivity" msgid="8841113627955563938">"make app always run"</string>
    <string name="permdesc_persistentActivity" product="tablet" msgid="8525189272329086137">"Allows the app to make parts of itself persistent in memory. This can limit the memory available to other apps, slowing down the tablet."</string>
    <string name="permdesc_persistentActivity" product="default" msgid="4384760047508278272">"Allows the app to make parts of itself persistent in memory. This can limit the memory available to other apps, slowing down the phone."</string>
    <string name="permlab_deletePackages" msgid="184385129537705938">"delete apps"</string>
    <string name="permdesc_deletePackages" msgid="7411480275167205081">"Allows the app to delete Android packages. Malicious apps may use this to delete important apps."</string>
    <string name="permlab_clearAppUserData" msgid="274109191845842756">"delete other apps\' data"</string>
    <string name="permdesc_clearAppUserData" msgid="4625323684125459488">"Allows the app to clear user data."</string>
    <string name="permlab_deleteCacheFiles" msgid="3128665571837408675">"delete other apps\' caches"</string>
    <string name="permdesc_deleteCacheFiles" msgid="3812998599006730196">"Allows the app to delete cache files."</string>
    <string name="permlab_getPackageSize" msgid="7472921768357981986">"measure app storage space"</string>
    <string name="permdesc_getPackageSize" msgid="3921068154420738296">"Allows the app to retrieve its code, data and cache sizes"</string>
    <string name="permlab_installPackages" msgid="2199128482820306924">"directly install apps"</string>
    <string name="permdesc_installPackages" msgid="5628530972548071284">"Allows the app to install new or updated Android packages. Malicious apps may use this to add new apps with arbitrarily powerful permissions."</string>
    <string name="permlab_clearAppCache" msgid="7487279391723526815">"delete all app cache data"</string>
    <string name="permdesc_clearAppCache" product="tablet" msgid="8974640871945434565">"Allows the app to free tablet storage by deleting files in the cache directories of other applications. This may cause other applications to start up more slowly as they need to re-retrieve their data."</string>
    <string name="permdesc_clearAppCache" product="default" msgid="2459441021956436779">"Allows the app to free phone storage by deleting files in the cache directories of other applications. This may cause other applications to start up more slowly as they need to re-retrieve their data."</string>
    <string name="permlab_movePackage" msgid="3289890271645921411">"move app resources"</string>
    <string name="permdesc_movePackage" msgid="319562217778244524">"Allows the app to move app resources from internal to external media and vice versa."</string>
    <string name="permlab_readLogs" msgid="6615778543198967614">"read sensitive log data"</string>
    <string name="permdesc_readLogs" product="tablet" msgid="82061313293455151">"Allows the app to read from the system\'s various log files. This allows it to discover general information about what you are doing with the tablet, potentially including personal or private information."</string>
    <string name="permdesc_readLogs" product="default" msgid="2063438140241560443">"Allows the app to read from the system\'s various log files. This allows it to discover general information about what you are doing with the phone, potentially including personal or private information."</string>
    <string name="permlab_anyCodecForPlayback" msgid="715805555823881818">"use any media decoder for playback"</string>
    <string name="permdesc_anyCodecForPlayback" msgid="8283912488433189010">"Allows the app to use any installed media decoder to decode for playback."</string>
    <string name="permlab_manageCaCertificates" msgid="1678391896786882014">"manage trusted credentials"</string>
    <string name="permdesc_manageCaCertificates" msgid="4015644047196937014">"Allows the app to install and uninstall CA certificates as trusted credentials."</string>
    <string name="permlab_diagnostic" msgid="8076743953908000342">"read/write to resources owned by diag"</string>
    <string name="permdesc_diagnostic" msgid="6608295692002452283">"Allows the app to read and write to any resource owned by the diag group; for example, files in /dev. This could potentially affect system stability and security. This should ONLY be used for hardware-specific diagnostics by the manufacturer or operator."</string>
    <string name="permlab_changeComponentState" msgid="6335576775711095931">"enable or disable app components"</string>
    <string name="permdesc_changeComponentState" product="tablet" msgid="8887435740982237294">"Allows the app to change whether a component of another app is enabled or not. Malicious apps may use this to disable important tablet capabilities. Care must be taken with this permission, as it is possible to get app components into an unusable, inconsistent or unstable state."</string>
    <string name="permdesc_changeComponentState" product="default" msgid="1827232484416505615">"Allows the app to change whether a component of another app is enabled or not. Malicious apps may use this to disable important phone capabilities. Care must be taken with this permission, as it is possible to get app components into an unusable, inconsistent or unstable state."</string>
    <string name="permlab_grantRevokePermissions" msgid="4627315351093508795">"grant or revoke permissions"</string>
    <string name="permdesc_grantRevokePermissions" msgid="4088642654085850662">"Allows an application to grant or revoke specific permissions for it or other applications. Malicious applications may use this to access features for which you have not granted them permission."</string>
    <string name="permlab_setPreferredApplications" msgid="8463181628695396391">"set preferred apps"</string>
    <string name="permdesc_setPreferredApplications" msgid="4973986762241783712">"Allows the app to modify your preferred apps. Malicious apps may silently change the apps that are run, spoofing your existing apps to collect private data from you."</string>
    <string name="permlab_writeSettings" msgid="2226195290955224730">"modify system settings"</string>
    <string name="permdesc_writeSettings" msgid="7775723441558907181">"Allows the app to modify the system\'s settings data. Malicious apps may corrupt your system\'s configuration."</string>
    <string name="permlab_writeSecureSettings" msgid="204676251876718288">"modify secure system settings"</string>
    <string name="permdesc_writeSecureSettings" msgid="8159535613020137391">"Allows the app to modify the system\'s secure settings data. Not for use by normal apps."</string>
    <string name="permlab_writeGservices" msgid="2149426664226152185">"modify the Google services map"</string>
    <string name="permdesc_writeGservices" msgid="1287309437638380229">"Allows the app to modify the Google services map. Not for use by normal apps."</string>
    <string name="permlab_receiveBootCompleted" msgid="5312965565987800025">"run at startup"</string>
    <string name="permdesc_receiveBootCompleted" product="tablet" msgid="7390304664116880704">"Allows the app to have itself started as soon as the system has finished booting. This can make it take longer to start the tablet and allow the app to slow down the overall tablet by always running."</string>
    <string name="permdesc_receiveBootCompleted" product="default" msgid="513950589102617504">"Allows the app to have itself started as soon as the system has finished booting. This can make it take longer to start the phone and allow the app to slow down the overall phone by always running."</string>
    <string name="permlab_broadcastSticky" msgid="7919126372606881614">"send sticky broadcast"</string>
    <string name="permdesc_broadcastSticky" product="tablet" msgid="7749760494399915651">"Allows the app to send sticky broadcasts, which remain after the broadcast ends. Excessive use may make the tablet slow or unstable by causing it to use too much memory."</string>
    <string name="permdesc_broadcastSticky" product="default" msgid="2825803764232445091">"Allows the app to send sticky broadcasts, which remain after the broadcast ends. Excessive use may make the phone slow or unstable by causing it to use too much memory."</string>
    <string name="permlab_readContacts" msgid="8348481131899886131">"read your contacts"</string>
    <string name="permdesc_readContacts" product="tablet" msgid="5294866856941149639">"Allows the app to read data about your contacts stored on your tablet, including the frequency with which you\'ve called, emailed or communicated in other ways with specific individuals. This permission allows apps to save your contact data, and malicious apps may share contact data without your knowledge."</string>
    <string name="permdesc_readContacts" product="default" msgid="8440654152457300662">"Allows the app to read data about your contacts stored on your phone, including the frequency with which you\'ve called, emailed or communicated in other ways with specific individuals. This permission allows apps to save your contact data, and malicious apps may share contact data without your knowledge."</string>
    <string name="permlab_writeContacts" msgid="5107492086416793544">"modify your contacts"</string>
    <string name="permdesc_writeContacts" product="tablet" msgid="897243932521953602">"Allows the app to modify the data about your contacts stored on your tablet, including the frequency with which you\'ve called, emailed or communicated in other ways with specific contacts. This permission allows apps to delete contact data."</string>
    <string name="permdesc_writeContacts" product="default" msgid="589869224625163558">"Allows the app to modify the data about your contacts stored on your phone, including the frequency with which you\'ve called, emailed or communicated in other ways with specific contacts. This permission allows apps to delete contact data."</string>
    <string name="permlab_readCallLog" msgid="3478133184624102739">"read call log"</string>
    <string name="permdesc_readCallLog" product="tablet" msgid="3700645184870760285">"Allows the app to read your tablet\'s call log, including data about incoming and outgoing calls. This permission allows apps to save your call log data, and malicious apps may share call log data without your knowledge."</string>
    <string name="permdesc_readCallLog" product="default" msgid="5777725796813217244">"Allows the app to read your phone\'s call log, including data about incoming and outgoing calls. This permission allows apps to save your call log data, and malicious apps may share call log data without your knowledge."</string>
    <string name="permlab_writeCallLog" msgid="8552045664743499354">"write call log"</string>
    <string name="permdesc_writeCallLog" product="tablet" msgid="6661806062274119245">"Allows the app to modify your tablet\'s call log, including data about incoming and outgoing calls. Malicious apps may use this to erase or modify your call log."</string>
    <string name="permdesc_writeCallLog" product="default" msgid="683941736352787842">"Allows the app to modify your phone\'s call log, including data about incoming and outgoing calls. Malicious apps may use this to erase or modify your call log."</string>
    <string name="permlab_readProfile" msgid="4701889852612716678">"read your own contact card"</string>
    <string name="permdesc_readProfile" product="default" msgid="5462475151849888848">"Allows the app to read personal profile information stored on your device, such as your name and contact information. This means that the app can identify you and may send your profile information to others."</string>
    <string name="permlab_writeProfile" msgid="907793628777397643">"modify your own contact card"</string>
    <string name="permdesc_writeProfile" product="default" msgid="5552084294598465899">"Allows the app to change or add to personal profile information stored on your device, such as your name and contact information. This means that the app can identify you and may send your profile information to others."</string>
    <string name="permlab_readSocialStream" product="default" msgid="1268920956152419170">"read your social stream"</string>
    <string name="permdesc_readSocialStream" product="default" msgid="4255706027172050872">"Allows the app to access and sync social updates from you and your friends. Be careful when sharing information - this allows the app to read communications between you and your friends on social networks, regardless of confidentiality. Note: this permission may not be enforced on all social networks."</string>
    <string name="permlab_writeSocialStream" product="default" msgid="3504179222493235645">"write to your social stream"</string>
    <string name="permdesc_writeSocialStream" product="default" msgid="3086557552204114849">"Allows the app to display social updates from your friends. Be careful when sharing information - this allows the app to produce messages that may appear to come from a friend. Note: this permission may not be enforced on all social networks."</string>
    <string name="permlab_readCalendar" msgid="5972727560257612398">"read calendar events plus confidential information"</string>
    <string name="permdesc_readCalendar" product="tablet" msgid="4216462049057658723">"Allows the app to read all calendar events stored on your tablet, including those of friends or co-workers. This may allow the app to share or save your calendar data, regardless of confidentiality or sensitivity."</string>
    <string name="permdesc_readCalendar" product="default" msgid="7434548682470851583">"Allows the app to read all calendar events stored on your phone, including those of friends or co-workers. This may allow the app to share or save your calendar data, regardless of confidentiality or sensitivity."</string>
    <string name="permlab_writeCalendar" msgid="8438874755193825647">"add or modify calendar events and send emails to guests without owners\' knowledge"</string>
    <string name="permdesc_writeCalendar" product="tablet" msgid="6679035520113668528">"Allows the app to add, remove and change events that you can modify on your tablet, including those of friends or co-workers. This may allow the app to send messages that appear to come from calendar owners, or modify events without the owners\' knowledge."</string>
    <string name="permdesc_writeCalendar" product="default" msgid="2324469496327249376">"Allows the app to add, remove and change events that you can modify on your phone, including those of friends or co-workers. This may allow the app to send messages that appear to come from calendar owners, or modify events without the owners\' knowledge."</string>
    <string name="permlab_accessMockLocation" msgid="8688334974036823330">"mock location sources for testing"</string>
    <string name="permdesc_accessMockLocation" msgid="5808711039482051824">"Create mock location sources for testing or install a new location provider. This allows the app to override the location and/or status returned by other location sources such as GPS or location providers."</string>
    <string name="permlab_accessLocationExtraCommands" msgid="2836308076720553837">"access extra location provider commands"</string>
    <string name="permdesc_accessLocationExtraCommands" msgid="5945166642335800763">"Allows the app to access extra location provider commands. This may allow the app to interfere with the operation of the GPS or other location sources."</string>
    <string name="permlab_installLocationProvider" msgid="6578101199825193873">"permission to install a location provider"</string>
    <string name="permdesc_installLocationProvider" msgid="9066146120470591509">"Create mock location sources for testing or install a new location provider. This allows the app to override the location and/or status returned by other location sources such as GPS or location providers."</string>
    <string name="permlab_accessFineLocation" msgid="1191898061965273372">"precise location (GPS and network-based)"</string>
    <string name="permdesc_accessFineLocation" msgid="5295047563564981250">"Allows the app to get your precise location using the Global Positioning System (GPS) or network location sources such as mobile towers and Wi-Fi. These location services must be turned on and available to your device for the app to use them. Apps may use this to determine where you are, and may consume additional battery power."</string>
    <string name="permlab_accessCoarseLocation" msgid="4887895362354239628">"approximate location (network-based)"</string>
    <string name="permdesc_accessCoarseLocation" msgid="2538200184373302295">"Allows the app to get your approximate location. This location is derived by location services using network location sources such as mobile towers and Wi-Fi. These location services must be turned on and available to your device for the app to use them. Apps may use this to determine approximately where you are."</string>
    <string name="permlab_accessSurfaceFlinger" msgid="2363969641792388947">"access SurfaceFlinger"</string>
    <string name="permdesc_accessSurfaceFlinger" msgid="1041619516733293551">"Allows the app to use SurfaceFlinger low-level features."</string>
    <string name="permlab_readFrameBuffer" msgid="6690504248178498136">"read frame buffer"</string>
    <string name="permdesc_readFrameBuffer" msgid="4937405521809454680">"Allows the app to read the content of the frame buffer."</string>
    <string name="permlab_configureWifiDisplay" msgid="5595661694746742168">"configure Wi-Fi displays"</string>
    <string name="permdesc_configureWifiDisplay" msgid="7916815158690218065">"Allows the app to configure and connect to Wi-Fi displays."</string>
    <string name="permlab_controlWifiDisplay" msgid="393641276723695496">"control Wi-Fi displays"</string>
    <string name="permdesc_controlWifiDisplay" msgid="4543912292681826986">"Allows the app to control low-level features of Wi-Fi displays."</string>
    <string name="permlab_captureAudioOutput" msgid="6857134498402346708">"capture audio output"</string>
    <string name="permdesc_captureAudioOutput" msgid="6210597754212208853">"Allows the app to capture and redirect audio output."</string>
    <string name="permlab_captureAudioHotword" msgid="1890553935650349808">"Hotword detection"</string>
    <string name="permdesc_captureAudioHotword" msgid="9151807958153056810">"Allows the app to capture audio for Hotword detection. The capture can happen in the background but does not prevent other audio capture (e.g. Camcorder)."</string>
    <string name="permlab_captureVideoOutput" msgid="2246828773589094023">"capture video output"</string>
    <string name="permdesc_captureVideoOutput" msgid="359481658034149860">"Allows the app to capture and redirect video output."</string>
    <string name="permlab_captureSecureVideoOutput" msgid="7815398969303382016">"capture secure video output"</string>
    <string name="permdesc_captureSecureVideoOutput" msgid="2779793064709350289">"Allows the app to capture and redirect secure video output."</string>
    <string name="permlab_mediaContentControl" msgid="8749790560720562511">"control media playback and metadata access"</string>
    <string name="permdesc_mediaContentControl" msgid="1637478200272062">"Allows the app to control media playback and access the media information (title, author...)."</string>
    <string name="permlab_modifyAudioSettings" msgid="6095859937069146086">"change your audio settings"</string>
    <string name="permdesc_modifyAudioSettings" msgid="3522565366806248517">"Allows the app to modify global audio settings such as volume and which speaker is used for output."</string>
    <string name="permlab_recordAudio" msgid="3876049771427466323">"record audio"</string>
    <string name="permdesc_recordAudio" msgid="4906839301087980680">"Allows the app to record audio with the microphone. This permission allows the app to record audio at any time without your confirmation."</string>
    <string name="permlab_camera" msgid="3616391919559751192">"take pictures and videos"</string>
    <string name="permdesc_camera" msgid="8497216524735535009">"Allows the app to take pictures and videos with the camera. This permission allows the app to use the camera at any time without your confirmation."</string>
    <string name="permlab_cameraDisableTransmitLed" msgid="2651072630501126222">"disable transmit indicator LED when camera is in use"</string>
    <string name="permdesc_cameraDisableTransmitLed" msgid="4764585465480295341">"Allows a pre-installed system application to disable the camera use indicator LED."</string>
    <string name="permlab_brick" product="tablet" msgid="2961292205764488304">"permanently disable tablet"</string>
    <string name="permlab_brick" product="default" msgid="8337817093326370537">"permanently disable phone"</string>
    <string name="permdesc_brick" product="tablet" msgid="4334818808001699530">"Allows the app to permanently disable the entire tablet. This is very dangerous."</string>
    <string name="permdesc_brick" product="default" msgid="5788903297627283099">"Allows the app to permanently disable the entire phone. This is very dangerous."</string>
    <string name="permlab_reboot" product="tablet" msgid="3436634972561795002">"force tablet reboot"</string>
    <string name="permlab_reboot" product="default" msgid="2898560872462638242">"force phone reboot"</string>
    <string name="permdesc_reboot" product="tablet" msgid="8172056180063700741">"Allows the app to force the tablet to reboot."</string>
    <string name="permdesc_reboot" product="default" msgid="5326008124289989969">"Allows the app to force the phone to reboot."</string>
    <string name="permlab_mount_unmount_filesystems" product="nosdcard" msgid="2927361537942591841">"access USB storage filesystem"</string>
    <string name="permlab_mount_unmount_filesystems" product="default" msgid="4402305049890953810">"access SD Card filesystem"</string>
    <string name="permdesc_mount_unmount_filesystems" msgid="1829290701658992347">"Allows the app to mount and unmount file systems for removable storage."</string>
    <string name="permlab_mount_format_filesystems" product="nosdcard" msgid="6227819582624904972">"Erase USB storage"</string>
    <string name="permlab_mount_format_filesystems" product="default" msgid="262582698639274056">"erase SD Card"</string>
    <string name="permdesc_mount_format_filesystems" msgid="8784268246779198627">"Allows the app to format removable storage."</string>
    <string name="permlab_asec_access" msgid="3411338632002193846">"get information on internal storage"</string>
    <string name="permdesc_asec_access" msgid="3094563844593878548">"Allows the application to access information on internal storage."</string>
    <string name="permlab_asec_create" msgid="6414757234789336327">"create internal storage"</string>
    <string name="permdesc_asec_create" msgid="4558869273585856876">"Allows the application to create internal storage."</string>
    <string name="permlab_asec_destroy" msgid="526928328301618022">"destroy internal storage"</string>
    <string name="permdesc_asec_destroy" msgid="7218749286145526537">"Allows the app to destroy internal storage."</string>
    <string name="permlab_asec_mount_unmount" msgid="8877998101944999386">"mount/unmount internal storage"</string>
    <string name="permdesc_asec_mount_unmount" msgid="3451360114902490929">"Allows the app to mount/unmount internal storage."</string>
    <string name="permlab_asec_rename" msgid="7496633954080472417">"rename internal storage"</string>
    <string name="permdesc_asec_rename" msgid="1794757588472127675">"Allows the app to rename internal storage."</string>
    <string name="permlab_vibrate" msgid="7696427026057705834">"control vibration"</string>
    <string name="permdesc_vibrate" msgid="6284989245902300945">"Allows the app to control the vibrator."</string>
    <string name="permlab_flashlight" msgid="2155920810121984215">"control flashlight"</string>
    <string name="permdesc_flashlight" msgid="6522284794568368310">"Allows the app to control the flashlight."</string>
    <string name="permlab_manageUsb" msgid="1113453430645402723">"manage preferences and permissions for USB devices"</string>
    <string name="permdesc_manageUsb" msgid="7776155430218239833">"Allows the app to manage preferences and permissions for USB devices."</string>
    <string name="permlab_accessMtp" msgid="4953468676795917042">"implement MTP protocol"</string>
    <string name="permdesc_accessMtp" msgid="6532961200486791570">"Allows access to the kernel MTP driver to implement the MTP USB protocol."</string>
    <string name="permlab_hardware_test" msgid="4148290860400659146">"test hardware"</string>
    <string name="permdesc_hardware_test" msgid="6597964191208016605">"Allows the app to control various peripherals for the purpose of hardware testing."</string>
    <string name="permlab_callPhone" msgid="3925836347681847954">"directly call phone numbers"</string>
    <string name="permdesc_callPhone" msgid="3740797576113760827">"Allows the app to call phone numbers without your intervention. This may result in unexpected charges or calls. Note that this doesn\'t allow the app to call emergency numbers. Malicious apps may cost you money by making calls without your confirmation."</string>
    <string name="permlab_callPrivileged" msgid="4198349211108497879">"directly call any phone numbers"</string>
    <string name="permdesc_callPrivileged" msgid="1689024901509996810">"Allows the app to call any phone number, including emergency numbers, without your intervention. Malicious apps may place unnecessary and illegal calls to emergency services."</string>
    <string name="permlab_performCdmaProvisioning" product="tablet" msgid="4842576994144604821">"directly start CDMA tablet setup"</string>
    <string name="permlab_performCdmaProvisioning" product="default" msgid="5604848095315421425">"directly start CDMA phone setup"</string>
    <string name="permdesc_performCdmaProvisioning" msgid="1994193538802314186">"Allows the app to start CDMA provisioning. Malicious apps may unnecessarily start CDMA provisioning."</string>
    <string name="permlab_locationUpdates" msgid="7785408253364335740">"control location update notifications"</string>
    <string name="permdesc_locationUpdates" msgid="1120741557891438876">"Allows the app to enable/disable location update notifications from the radio. Not for use by normal apps."</string>
    <string name="permlab_checkinProperties" msgid="7855259461268734914">"access check-in properties"</string>
    <string name="permdesc_checkinProperties" msgid="4024526968630194128">"Allows the app read/write access to properties uploaded by the check-in service. Not for use by normal apps."</string>
    <string name="permlab_bindGadget" msgid="776905339015863471">"choose widgets"</string>
    <string name="permdesc_bindGadget" msgid="8261326938599049290">"Allows the app to tell the system which widgets can be used by which app. An app with this permission can give other apps access to personal data. Not for use by normal apps."</string>
    <string name="permlab_modifyPhoneState" msgid="8423923777659292228">"modify phone status"</string>
    <string name="permdesc_modifyPhoneState" msgid="1029877529007686732">"Allows the app to control the phone features of the device. An app with this permission can switch networks, turn the phone radio on and off and the like without ever notifying you."</string>
    <string name="permlab_readPhoneState" msgid="9178228524507610486">"read phone status and identity"</string>
    <string name="permdesc_readPhoneState" msgid="1639212771826125528">"Allows the app to access the phone features of the device. This permission allows the app to determine the phone number and device IDs, whether a call is active and the remote number connected by a call."</string>
    <string name="permlab_wakeLock" product="tablet" msgid="1531731435011495015">"prevent tablet from sleeping"</string>
    <string name="permlab_wakeLock" product="default" msgid="573480187941496130">"prevent phone from sleeping"</string>
    <string name="permdesc_wakeLock" product="tablet" msgid="7311319824400447868">"Allows the app to prevent the tablet from going to sleep."</string>
    <string name="permdesc_wakeLock" product="default" msgid="8559100677372928754">"Allows the app to prevent the phone from going to sleep."</string>
    <string name="permlab_transmitIr" msgid="7545858504238530105">"transmit infrared"</string>
    <string name="permdesc_transmitIr" product="tablet" msgid="5358308854306529170">"Allows the app to use the tablet\'s infrared transmitter."</string>
    <string name="permdesc_transmitIr" product="default" msgid="7957763745020300725">"Allows the app to use the phone\'s infrared transmitter."</string>
    <string name="permlab_devicePower" product="tablet" msgid="2787034722616350417">"turn tablet on or off"</string>
    <string name="permlab_devicePower" product="default" msgid="4928622470980943206">"turn phone on or off"</string>
    <string name="permdesc_devicePower" product="tablet" msgid="6689862878984631831">"Allows the app to turn the tablet on or off."</string>
    <string name="permdesc_devicePower" product="default" msgid="6037057348463131032">"Allows the app to turn the phone on or off."</string>
    <string name="permlab_factoryTest" msgid="3715225492696416187">"run in factory test mode"</string>
    <string name="permdesc_factoryTest" product="tablet" msgid="3952059318359653091">"Run as a low-level manufacturer test, allowing complete access to the tablet hardware. Only available when a tablet is running in manufacturer test mode."</string>
    <string name="permdesc_factoryTest" product="default" msgid="8136644990319244802">"Run as a low-level manufacturer test, allowing complete access to the phone hardware. Only available when a phone is running in manufacturer test mode."</string>
    <string name="permlab_setWallpaper" msgid="6627192333373465143">"set wallpaper"</string>
    <string name="permdesc_setWallpaper" msgid="7373447920977624745">"Allows the app to set the system wallpaper."</string>
    <string name="permlab_setWallpaperHints" msgid="3278608165977736538">"adjust your wallpaper size"</string>
    <string name="permdesc_setWallpaperHints" msgid="8235784384223730091">"Allows the app to set the system wallpaper size hints."</string>
    <string name="permlab_masterClear" msgid="2315750423139697397">"reset system to factory defaults"</string>
    <string name="permdesc_masterClear" msgid="3665380492633910226">"Allows the app to completely reset the system to its factory settings, erasing all data, configuration and installed apps."</string>
    <string name="permlab_setTime" msgid="2021614829591775646">"set time"</string>
    <string name="permdesc_setTime" product="tablet" msgid="1896341438151152881">"Allows the app to change the tablet\'s clock time."</string>
    <string name="permdesc_setTime" product="default" msgid="1855702730738020">"Allows the app to change the phone\'s clock time."</string>
    <string name="permlab_setTimeZone" msgid="2945079801013077340">"set time zone"</string>
    <string name="permdesc_setTimeZone" product="tablet" msgid="1676983712315827645">"Allows the app to change the tablet\'s time zone."</string>
    <string name="permdesc_setTimeZone" product="default" msgid="4499943488436633398">"Allows the app to change the phone\'s time zone."</string>
    <string name="permlab_accountManagerService" msgid="4829262349691386986">"act as the Account Manager Service"</string>
    <string name="permdesc_accountManagerService" msgid="1948455552333615954">"Allows the app to make calls to Account Authenticators."</string>
    <string name="permlab_getAccounts" msgid="1086795467760122114">"find accounts on the device"</string>
    <string name="permdesc_getAccounts" product="tablet" msgid="2741496534769660027">"Allows the app to get the list of accounts known by the tablet. This may include any accounts created by applications that you have installed."</string>
    <string name="permdesc_getAccounts" product="default" msgid="3448316822451807382">"Allows the app to get the list of accounts known by the phone. This may include any accounts created by applications that you have installed."</string>
    <string name="permlab_authenticateAccounts" msgid="5265908481172736933">"create accounts and set passwords"</string>
    <string name="permdesc_authenticateAccounts" msgid="5472124296908977260">"Allows the app to use the account authenticator capabilities of the Account Manager, including creating accounts and getting and setting their passwords."</string>
    <string name="permlab_manageAccounts" msgid="4983126304757177305">"add or remove accounts"</string>
    <string name="permdesc_manageAccounts" msgid="8698295625488292506">"Allows the app to perform operations like adding and removing accounts, and deleting their password."</string>
    <string name="permlab_useCredentials" msgid="235481396163877642">"use accounts on the device"</string>
    <string name="permdesc_useCredentials" msgid="7984227147403346422">"Allows the app to request authentication tokens."</string>
    <string name="permlab_accessNetworkState" msgid="4951027964348974773">"view network connections"</string>
    <string name="permdesc_accessNetworkState" msgid="8318964424675960975">"Allows the app to view information about network connections such as which networks exist and are connected."</string>
    <string name="permlab_createNetworkSockets" msgid="8018758136404323658">"full network access"</string>
    <string name="permdesc_createNetworkSockets" msgid="3403062187779724185">"Allows the app to create network sockets and use customised network protocols. The browser and other applications provide means to send data to the Internet, so this permission is not required to send data to the Internet."</string>
    <string name="permlab_writeApnSettings" msgid="505660159675751896">"change/intercept network settings and traffic"</string>
    <string name="permdesc_writeApnSettings" msgid="5333798886412714193">"Allows the app to change network settings and to intercept and inspect all network traffic, for example to change the proxy and port of any APN. Malicious apps may monitor, redirect or modify network packets without your knowledge."</string>
    <string name="permlab_changeNetworkState" msgid="958884291454327309">"change network connectivity"</string>
    <string name="permdesc_changeNetworkState" msgid="6789123912476416214">"Allows the app to change the state of network connectivity."</string>
    <string name="permlab_changeTetherState" msgid="5952584964373017960">"change tethered connectivity"</string>
    <string name="permdesc_changeTetherState" msgid="1524441344412319780">"Allows the app to change the state of tethered network connectivity."</string>
    <string name="permlab_changeBackgroundDataSetting" msgid="1400666012671648741">"change background data usage setting"</string>
    <string name="permdesc_changeBackgroundDataSetting" msgid="5347729578468744379">"Allows the app to change the background data usage setting."</string>
    <string name="permlab_accessWifiState" msgid="5202012949247040011">"view Wi-Fi connections"</string>
    <string name="permdesc_accessWifiState" msgid="5002798077387803726">"Allows the app to view information about Wi-Fi networking, such as whether Wi-Fi is enabled and name of connected Wi-Fi devices."</string>
    <string name="permlab_changeWifiState" msgid="6550641188749128035">"connect and disconnect from Wi-Fi"</string>
    <string name="permdesc_changeWifiState" msgid="7137950297386127533">"Allows the app to connect to and disconnect from Wi-Fi access points and to make changes to device configuration for Wi-Fi networks."</string>
    <string name="permlab_changeWifiMulticastState" msgid="1368253871483254784">"allow Wi-Fi Multicast reception"</string>
    <string name="permdesc_changeWifiMulticastState" product="tablet" msgid="7969774021256336548">"Allows the app to receive packets sent to all devices on a Wi-Fi network using multicast addresses, not just your tablet. It uses more power than the non-multicast mode."</string>
    <string name="permdesc_changeWifiMulticastState" product="default" msgid="6851949706025349926">"Allows the app to receive packets sent to all devices on a Wi-Fi network using multicast addresses, not just your phone. It uses more power than the non-multicast mode."</string>
    <string name="permlab_bluetoothAdmin" msgid="6006967373935926659">"access Bluetooth settings"</string>
    <string name="permdesc_bluetoothAdmin" product="tablet" msgid="6921177471748882137">"Allows the app to configure the local Bluetooth tablet and to discover and pair with remote devices."</string>
    <string name="permdesc_bluetoothAdmin" product="default" msgid="8931682159331542137">"Allows the app to configure the local Bluetooth phone and to discover and pair with remote devices."</string>
    <string name="permlab_bluetoothPriv" msgid="4009494246009513828">"allow Bluetooth pairing by Application"</string>
    <string name="permdesc_bluetoothPriv" product="tablet" msgid="8045735193417468857">"Allows the app to pair with remote devices without user interaction."</string>
    <string name="permdesc_bluetoothPriv" product="default" msgid="8045735193417468857">"Allows the app to pair with remote devices without user interaction."</string>
    <string name="permlab_accessWimaxState" msgid="4195907010610205703">"connect and disconnect from WiMAX"</string>
    <string name="permdesc_accessWimaxState" msgid="6360102877261978887">"Allows the app to determine whether WiMAX is enabled and information about any WiMAX networks that are connected."</string>
    <string name="permlab_changeWimaxState" msgid="2405042267131496579">"change WiMAX state"</string>
    <string name="permdesc_changeWimaxState" product="tablet" msgid="3156456504084201805">"Allows the app to connect the tablet to and disconnect the tablet from WiMAX networks."</string>
    <string name="permdesc_changeWimaxState" product="default" msgid="697025043004923798">"Allows the app to connect the phone to and disconnect the phone from WiMAX networks."</string>
    <string name="permlab_bluetooth" msgid="6127769336339276828">"pair with Bluetooth devices"</string>
    <string name="permdesc_bluetooth" product="tablet" msgid="3480722181852438628">"Allows the app to view the configuration of Bluetooth on the tablet and to make and accept connections with paired devices."</string>
    <string name="permdesc_bluetooth" product="default" msgid="3207106324452312739">"Allows the app to view the configuration of the Bluetooth on the phone and to make and accept connections with paired devices."</string>
    <string name="permlab_nfc" msgid="4423351274757876953">"control Near-Field Communication"</string>
    <string name="permdesc_nfc" msgid="7120611819401789907">"Allows the app to communicate with Near Field Communication (NFC) tags, cards and readers."</string>
    <string name="permlab_disableKeyguard" msgid="3598496301486439258">"disable your screen lock"</string>
    <string name="permdesc_disableKeyguard" msgid="6034203065077122992">"Allows the app to disable the keylock and any associated password security. For example, the phone disables the keylock when receiving an incoming phone call, then re-enables the keylock when the call is finished."</string>
    <string name="permlab_readSyncSettings" msgid="6201810008230503052">"read sync settings"</string>
    <string name="permdesc_readSyncSettings" msgid="2706745674569678644">"Allows the app to read the sync settings for an account. For example, this can determine whether the People app is synced with an account."</string>
    <string name="permlab_writeSyncSettings" msgid="5408694875793945314">"toggle sync on and off"</string>
    <string name="permdesc_writeSyncSettings" msgid="8956262591306369868">"Allows an app to modify the sync settings for an account. For example, this can be used to enable syncing of the People app with an account."</string>
    <string name="permlab_readSyncStats" msgid="7396577451360202448">"read sync statistics"</string>
    <string name="permdesc_readSyncStats" msgid="1510143761757606156">"Allows an app to read the sync stats for an account, including the history of sync events and how much data is synced."</string>
    <string name="permlab_subscribedFeedsRead" msgid="4756609637053353318">"read subscribed feeds"</string>
    <string name="permdesc_subscribedFeedsRead" msgid="5557058907906144505">"Allows the app to get details about the currently synced feeds."</string>
    <string name="permlab_subscribedFeedsWrite" msgid="9015246325408209296">"write subscribed feeds"</string>
    <string name="permdesc_subscribedFeedsWrite" msgid="6928930188826089413">"Allows the app to modify your currently synced feeds. Malicious apps may change your synced feeds."</string>
    <string name="permlab_readDictionary" msgid="4107101525746035718">"read terms you added to the dictionary"</string>
    <string name="permdesc_readDictionary" msgid="659614600338904243">"Allows the app to read all words, names and phrases that the user may have stored in the user dictionary."</string>
    <string name="permlab_writeDictionary" msgid="2183110402314441106">"add words to user-defined dictionary"</string>
    <string name="permdesc_writeDictionary" msgid="8185385716255065291">"Allows the app to write new words into the user dictionary."</string>
    <string name="permlab_sdcardRead" product="nosdcard" msgid="367275095159405468">"read the contents of your USB storage"</string>
    <string name="permlab_sdcardRead" product="default" msgid="2188156462934977940">"read the contents of your SD card"</string>
    <string name="permdesc_sdcardRead" product="nosdcard" msgid="3446988712598386079">"Allows the app to read the contents of your USB storage."</string>
    <string name="permdesc_sdcardRead" product="default" msgid="2607362473654975411">"Allows the app to read the contents of your SD card."</string>
    <string name="permlab_sdcardWrite" product="nosdcard" msgid="8485979062254666748">"modify or delete the contents of your USB storage"</string>
    <string name="permlab_sdcardWrite" product="default" msgid="8805693630050458763">"modify or delete the contents of your SD card"</string>
    <string name="permdesc_sdcardWrite" product="nosdcard" msgid="6175406299445710888">"Allows the app to write to the USB storage."</string>
    <string name="permdesc_sdcardWrite" product="default" msgid="4337417790936632090">"Allows the app to write to the SD card."</string>
    <string name="permlab_mediaStorageWrite" product="default" msgid="6859839199706879015">"modify/delete internal media storage contents"</string>
    <string name="permdesc_mediaStorageWrite" product="default" msgid="8189160597698529185">"Allows the app to modify the contents of the internal media storage."</string>
    <string name="permlab_manageDocs" product="default" msgid="5778318598448849829">"manage document storage"</string>
    <string name="permdesc_manageDocs" product="default" msgid="8704323176914121484">"Allows the app to manage document storage."</string>
    <string name="permlab_sdcardAccessAll" msgid="8150613823900460576">"access external storage of all users"</string>
    <string name="permdesc_sdcardAccessAll" msgid="3215208357415891320">"Allows the app to access external storage for all users."</string>
    <string name="permlab_cache_filesystem" msgid="5656487264819669824">"access the cache file system"</string>
    <string name="permdesc_cache_filesystem" msgid="5578967642265550955">"Allows the app to read and write the cache file system."</string>
    <string name="permlab_use_sip" msgid="5986952362795870502">"make/receive Internet calls"</string>
    <string name="permdesc_use_sip" msgid="4717632000062674294">"Allows the app to use the SIP service to make/receive Internet calls."</string>
    <string name="permlab_bind_call_service" msgid="6724009726671246551">"interact with in-call screen"</string>
    <string name="permdesc_bind_call_service" msgid="8732547662442572435">"Allows the app to control when and how the user sees the in-call screen."</string>
    <string name="permlab_readNetworkUsageHistory" msgid="7862593283611493232">"read historical network usage"</string>
    <string name="permdesc_readNetworkUsageHistory" msgid="7689060749819126472">"Allows the app to read historical network usage for specific networks and apps."</string>
    <string name="permlab_manageNetworkPolicy" msgid="2562053592339859990">"manage network policy"</string>
    <string name="permdesc_manageNetworkPolicy" msgid="7537586771559370668">"Allows the app to manage network policies and define app-specific rules."</string>
    <string name="permlab_modifyNetworkAccounting" msgid="5088217309088729650">"modify network usage accounting"</string>
    <string name="permdesc_modifyNetworkAccounting" msgid="5443412866746198123">"Allows the app to modify how network usage is accounted against apps. Not for use by normal apps."</string>
    <string name="permlab_markNetworkSocket" msgid="3658527214914959749">"modify socket marks"</string>
    <string name="permdesc_markNetworkSocket" msgid="7655568433696356578">"Allows the app to modify socket marks for routing"</string>
    <string name="permlab_accessNotifications" msgid="7673416487873432268">"access notifications"</string>
    <string name="permdesc_accessNotifications" msgid="458457742683431387">"Allows the app to retrieve, examine, and clear notifications, including those posted by other apps."</string>
    <string name="permlab_bindNotificationListenerService" msgid="7057764742211656654">"bind to a notification listener service"</string>
    <string name="permdesc_bindNotificationListenerService" msgid="985697918576902986">"Allows the holder to bind to the top-level interface of a notification listener service. Should never be needed for normal apps."</string>
    <string name="permlab_invokeCarrierSetup" msgid="3699600833975117478">"invoke the carrier-provided configuration app"</string>
    <string name="permdesc_invokeCarrierSetup" msgid="4159549152529111920">"Allows the holder to invoke the carrier-provided configuration app. Should never be needed for normal apps."</string>
    <string name="permlab_accessNetworkConditions" msgid="8206077447838909516">"listen for observations on network conditions"</string>
    <string name="permdesc_accessNetworkConditions" msgid="6899102075825272211">"Allows an application to listen for observations on network conditions. Should never be needed for normal apps."</string>
    <string name="policylab_limitPassword" msgid="4497420728857585791">"Set password rules"</string>
    <string name="policydesc_limitPassword" msgid="3252114203919510394">"Control the length and the characters allowed in screen-unlock passwords."</string>
    <string name="policylab_watchLogin" msgid="914130646942199503">"Monitor screen-unlock attempts"</string>
    <string name="policydesc_watchLogin" product="tablet" msgid="3215729294215070072">"Monitor the number of incorrect passwords typed when unlocking the screen and lock the tablet or erase all the tablet\'s data if too many incorrect passwords are typed."</string>
    <string name="policydesc_watchLogin" product="default" msgid="5712323091846761073">"Monitor the number of incorrect passwords typed when unlocking the screen and lock the phone or erase all the phone\'s data if too many incorrect passwords are typed."</string>
    <string name="policylab_resetPassword" msgid="2620077191242688955">"Change the screen-unlock password"</string>
    <string name="policydesc_resetPassword" msgid="605963962301904458">"Change the screen-unlock password."</string>
    <string name="policylab_forceLock" msgid="2274085384704248431">"Lock the screen"</string>
    <string name="policydesc_forceLock" msgid="1141797588403827138">"Control how and when the screen locks."</string>
    <string name="policylab_wipeData" msgid="3910545446758639713">"Erase all data"</string>
    <string name="policydesc_wipeData" product="tablet" msgid="4306184096067756876">"Erase the tablet\'s data without warning by performing a factory data reset."</string>
    <string name="policydesc_wipeData" product="default" msgid="5096895604574188391">"Erase the phone\'s data without warning by performing a factory data reset."</string>
    <string name="policylab_setGlobalProxy" msgid="2784828293747791446">"Set the device global proxy"</string>
    <string name="policydesc_setGlobalProxy" msgid="6387497466660154931">"Set the device\'s global proxy to be used while policy is enabled. Only the first device admin sets the effective global proxy."</string>
    <string name="policylab_expirePassword" msgid="885279151847254056">"Set lock-screen password expiry"</string>
    <string name="policydesc_expirePassword" msgid="1729725226314691591">"Control how frequently the lock-screen password must be changed."</string>
    <string name="policylab_encryptedStorage" msgid="8901326199909132915">"Set storage encryption"</string>
    <string name="policydesc_encryptedStorage" msgid="2637732115325316992">"Require that stored app data be encrypted."</string>
    <string name="policylab_disableCamera" msgid="6395301023152297826">"Disable cameras"</string>
    <string name="policydesc_disableCamera" msgid="2306349042834754597">"Prevent use of all device cameras."</string>
    <string name="policylab_disableKeyguardFeatures" msgid="266329104542638802">"Disable features in keyguard"</string>
    <string name="policydesc_disableKeyguardFeatures" msgid="3467082272186534614">"Prevent use of some features in keyguard."</string>
  <string-array name="phoneTypes">
    <item msgid="8901098336658710359">"Home"</item>
    <item msgid="869923650527136615">"Mobile"</item>
    <item msgid="7897544654242874543">"Work"</item>
    <item msgid="1103601433382158155">"Work Fax"</item>
    <item msgid="1735177144948329370">"Home Fax"</item>
    <item msgid="603878674477207394">"Pager"</item>
    <item msgid="1650824275177931637">"Other"</item>
    <item msgid="9192514806975898961">"Custom"</item>
  </string-array>
  <string-array name="emailAddressTypes">
    <item msgid="8073994352956129127">"Home"</item>
    <item msgid="7084237356602625604">"Work"</item>
    <item msgid="1112044410659011023">"Other"</item>
    <item msgid="2374913952870110618">"Custom"</item>
  </string-array>
  <string-array name="postalAddressTypes">
    <item msgid="6880257626740047286">"Home"</item>
    <item msgid="5629153956045109251">"Work"</item>
    <item msgid="4966604264500343469">"Other"</item>
    <item msgid="4932682847595299369">"Custom"</item>
  </string-array>
  <string-array name="imAddressTypes">
    <item msgid="1738585194601476694">"Home"</item>
    <item msgid="1359644565647383708">"Work"</item>
    <item msgid="7868549401053615677">"Other"</item>
    <item msgid="3145118944639869809">"Custom"</item>
  </string-array>
  <string-array name="organizationTypes">
    <item msgid="7546335612189115615">"Work"</item>
    <item msgid="4378074129049520373">"Other"</item>
    <item msgid="3455047468583965104">"Custom"</item>
  </string-array>
  <string-array name="imProtocols">
    <item msgid="8595261363518459565">"AIM"</item>
    <item msgid="7390473628275490700">"Windows Live"</item>
    <item msgid="7882877134931458217">"Yahoo"</item>
    <item msgid="5035376313200585242">"Skype"</item>
    <item msgid="7532363178459444943">"QQ"</item>
    <item msgid="3713441034299660749">"Google Talk"</item>
    <item msgid="2506857312718630823">"ICQ"</item>
    <item msgid="1648797903785279353">"Jabber"</item>
  </string-array>
    <string name="phoneTypeCustom" msgid="1644738059053355820">"Custom"</string>
    <string name="phoneTypeHome" msgid="2570923463033985887">"Home"</string>
    <string name="phoneTypeMobile" msgid="6501463557754751037">"Mobile"</string>
    <string name="phoneTypeWork" msgid="8863939667059911633">"Work"</string>
    <string name="phoneTypeFaxWork" msgid="3517792160008890912">"Work Fax"</string>
    <string name="phoneTypeFaxHome" msgid="2067265972322971467">"Home Fax"</string>
    <string name="phoneTypePager" msgid="7582359955394921732">"Pager"</string>
    <string name="phoneTypeOther" msgid="1544425847868765990">"Other"</string>
    <string name="phoneTypeCallback" msgid="2712175203065678206">"Callback"</string>
    <string name="phoneTypeCar" msgid="8738360689616716982">"Car"</string>
    <string name="phoneTypeCompanyMain" msgid="540434356461478916">"Company Main"</string>
    <string name="phoneTypeIsdn" msgid="8022453193171370337">"ISDN"</string>
    <string name="phoneTypeMain" msgid="6766137010628326916">"Main"</string>
    <string name="phoneTypeOtherFax" msgid="8587657145072446565">"Other Fax"</string>
    <string name="phoneTypeRadio" msgid="4093738079908667513">"Radio"</string>
    <string name="phoneTypeTelex" msgid="3367879952476250512">"Telex"</string>
    <string name="phoneTypeTtyTdd" msgid="8606514378585000044">"TTY/TDD"</string>
    <string name="phoneTypeWorkMobile" msgid="1311426989184065709">"Work Mobile"</string>
    <string name="phoneTypeWorkPager" msgid="649938731231157056">"Work Pager"</string>
    <string name="phoneTypeAssistant" msgid="5596772636128562884">"Assistant"</string>
    <string name="phoneTypeMms" msgid="7254492275502768992">"MMS"</string>
    <string name="eventTypeCustom" msgid="7837586198458073404">"Customised"</string>
    <string name="eventTypeBirthday" msgid="2813379844211390740">"Birthday"</string>
    <string name="eventTypeAnniversary" msgid="3876779744518284000">"Anniversary"</string>
    <string name="eventTypeOther" msgid="7388178939010143077">"Other"</string>
    <string name="emailTypeCustom" msgid="8525960257804213846">"Custom"</string>
    <string name="emailTypeHome" msgid="449227236140433919">"Home"</string>
    <string name="emailTypeWork" msgid="3548058059601149973">"Work"</string>
    <string name="emailTypeOther" msgid="2923008695272639549">"Other"</string>
    <string name="emailTypeMobile" msgid="119919005321166205">"Mobile"</string>
    <string name="postalTypeCustom" msgid="8903206903060479902">"Custom"</string>
    <string name="postalTypeHome" msgid="8165756977184483097">"Home"</string>
    <string name="postalTypeWork" msgid="5268172772387694495">"Work"</string>
    <string name="postalTypeOther" msgid="2726111966623584341">"Other"</string>
    <string name="imTypeCustom" msgid="2074028755527826046">"Custom"</string>
    <string name="imTypeHome" msgid="6241181032954263892">"Home"</string>
    <string name="imTypeWork" msgid="1371489290242433090">"Work"</string>
    <string name="imTypeOther" msgid="5377007495735915478">"Other"</string>
    <string name="imProtocolCustom" msgid="6919453836618749992">"Custom"</string>
    <string name="imProtocolAim" msgid="7050360612368383417">"AIM"</string>
    <string name="imProtocolMsn" msgid="144556545420769442">"Windows Live"</string>
    <string name="imProtocolYahoo" msgid="8271439408469021273">"Yahoo"</string>
    <string name="imProtocolSkype" msgid="9019296744622832951">"Skype"</string>
    <string name="imProtocolQq" msgid="8887484379494111884">"QQ"</string>
    <string name="imProtocolGoogleTalk" msgid="493902321140277304">"Hangouts"</string>
    <string name="imProtocolIcq" msgid="1574870433606517315">"ICQ"</string>
    <string name="imProtocolJabber" msgid="2279917630875771722">"Jabber"</string>
    <string name="imProtocolNetMeeting" msgid="8287625655986827971">"Net Meeting"</string>
    <string name="orgTypeWork" msgid="29268870505363872">"Work"</string>
    <string name="orgTypeOther" msgid="3951781131570124082">"Other"</string>
    <string name="orgTypeCustom" msgid="225523415372088322">"Custom"</string>
    <string name="relationTypeCustom" msgid="3542403679827297300">"Customised"</string>
    <string name="relationTypeAssistant" msgid="6274334825195379076">"Assistant"</string>
    <string name="relationTypeBrother" msgid="8757913506784067713">"Brother"</string>
    <string name="relationTypeChild" msgid="1890746277276881626">"Child"</string>
    <string name="relationTypeDomesticPartner" msgid="6904807112121122133">"Domestic Partner"</string>
    <string name="relationTypeFather" msgid="5228034687082050725">"Father"</string>
    <string name="relationTypeFriend" msgid="7313106762483391262">"Friend"</string>
    <string name="relationTypeManager" msgid="6365677861610137895">"Manager"</string>
    <string name="relationTypeMother" msgid="4578571352962758304">"Mother"</string>
    <string name="relationTypeParent" msgid="4755635567562925226">"Parent"</string>
    <string name="relationTypePartner" msgid="7266490285120262781">"Partner"</string>
    <string name="relationTypeReferredBy" msgid="101573059844135524">"Referred by"</string>
    <string name="relationTypeRelative" msgid="1799819930085610271">"Relative"</string>
    <string name="relationTypeSister" msgid="1735983554479076481">"Sister"</string>
    <string name="relationTypeSpouse" msgid="394136939428698117">"Spouse"</string>
    <string name="sipAddressTypeCustom" msgid="2473580593111590945">"Customised"</string>
    <string name="sipAddressTypeHome" msgid="6093598181069359295">"Home"</string>
    <string name="sipAddressTypeWork" msgid="6920725730797099047">"Work"</string>
    <string name="sipAddressTypeOther" msgid="4408436162950119849">"Other"</string>
    <string name="keyguard_password_enter_pin_code" msgid="3037685796058495017">"Type PIN code"</string>
    <string name="keyguard_password_enter_puk_code" msgid="4800725266925845333">"Type PUK and new PIN code"</string>
    <string name="keyguard_password_enter_puk_prompt" msgid="1341112146710087048">"PUK code"</string>
    <string name="keyguard_password_enter_pin_prompt" msgid="8027680321614196258">"New PIN Code"</string>
    <string name="keyguard_password_entry_touch_hint" msgid="7858547464982981384"><font size="17">"Touch to type password"</font></string>
    <string name="keyguard_password_enter_password_code" msgid="1054721668279049780">"Type password to unlock"</string>
    <string name="keyguard_password_enter_pin_password_code" msgid="6391755146112503443">"Type PIN to unlock"</string>
    <string name="keyguard_password_wrong_pin_code" msgid="2422225591006134936">"Incorrect PIN code."</string>
    <string name="keyguard_label_text" msgid="861796461028298424">"To unlock, press Menu, then 0."</string>
    <string name="emergency_call_dialog_number_for_display" msgid="696192103195090970">"Emergency number"</string>
    <string name="lockscreen_carrier_default" msgid="8963839242565653192">"No service"</string>
    <string name="lockscreen_screen_locked" msgid="7288443074806832904">"Screen locked."</string>
    <string name="lockscreen_instructions_when_pattern_enabled" msgid="46154051614126049">"Press Menu to unlock or place emergency call."</string>
    <string name="lockscreen_instructions_when_pattern_disabled" msgid="686260028797158364">"Press Menu to unlock."</string>
    <string name="lockscreen_pattern_instructions" msgid="7478703254964810302">"Draw pattern to unlock"</string>
    <string name="lockscreen_emergency_call" msgid="5347633784401285225">"Emergency call"</string>
    <string name="lockscreen_return_to_call" msgid="5244259785500040021">"Return to call"</string>
    <string name="lockscreen_pattern_correct" msgid="9039008650362261237">"Correct!"</string>
    <string name="lockscreen_pattern_wrong" msgid="4317955014948108794">"Try again"</string>
    <string name="lockscreen_password_wrong" msgid="5737815393253165301">"Try again"</string>
    <string name="faceunlock_multiple_failures" msgid="754137583022792429">"Maximum Face Unlock attempts exceeded"</string>
    <string name="lockscreen_plugged_in" msgid="8057762828355572315">"Charging, <xliff:g id="NUMBER">%d</xliff:g><xliff:g id="PERCENT">%%</xliff:g>"</string>
    <string name="lockscreen_charged" msgid="321635745684060624">"Charged"</string>
    <string name="lockscreen_battery_short" msgid="4477264849386850266">"<xliff:g id="NUMBER">%d</xliff:g><xliff:g id="PERCENT">%%</xliff:g>"</string>
    <string name="lockscreen_low_battery" msgid="1482873981919249740">"Connect your charger."</string>
    <string name="lockscreen_missing_sim_message_short" msgid="5099439277819215399">"No SIM card"</string>
    <string name="lockscreen_missing_sim_message" product="tablet" msgid="151659196095791474">"No SIM card in tablet."</string>
    <string name="lockscreen_missing_sim_message" product="default" msgid="2186920585695169078">"No SIM card in phone."</string>
    <string name="lockscreen_missing_sim_instructions" msgid="5372787138023272615">"Insert a SIM card."</string>
    <string name="lockscreen_missing_sim_instructions_long" msgid="3526573099019319472">"The SIM card is missing or not readable. Insert a SIM card."</string>
    <string name="lockscreen_permanent_disabled_sim_message_short" msgid="5096149665138916184">"Unusable SIM card."</string>
    <string name="lockscreen_permanent_disabled_sim_instructions" msgid="910904643433151371">"Your SIM card has been permanently disabled.\n Contact your wireless service provider for another SIM card."</string>
    <string name="lockscreen_transport_prev_description" msgid="201594905152746886">"Previous track button"</string>
    <string name="lockscreen_transport_next_description" msgid="6089297650481292363">"Next-track button"</string>
    <string name="lockscreen_transport_pause_description" msgid="7659088786780128001">"Pause button"</string>
    <string name="lockscreen_transport_play_description" msgid="5888422938351019426">"Play button"</string>
    <string name="lockscreen_transport_stop_description" msgid="4562318378766987601">"Stop button"</string>
    <string name="emergency_calls_only" msgid="6733978304386365407">"Emergency calls only"</string>
    <string name="lockscreen_network_locked_message" msgid="143389224986028501">"Network locked"</string>
    <string name="lockscreen_sim_puk_locked_message" msgid="7441797339976230">"SIM card is PUK-locked."</string>
    <string name="lockscreen_sim_puk_locked_instructions" msgid="8127916255245181063">"See the User Guide or contact Customer Care."</string>
    <string name="lockscreen_sim_locked_message" msgid="8066660129206001039">"SIM card is locked."</string>
    <string name="lockscreen_sim_unlock_progress_dialog_message" msgid="595323214052881264">"Unlocking SIM card…"</string>
    <string name="lockscreen_too_many_failed_attempts_dialog_message" msgid="6481623830344107222">"You have incorrectly drawn your unlock pattern <xliff:g id="NUMBER_0">%d</xliff:g> times. \n\nTry again in <xliff:g id="NUMBER_1">%d</xliff:g> seconds."</string>
    <string name="lockscreen_too_many_failed_password_attempts_dialog_message" msgid="2725973286239344555">"You have incorrectly typed your password <xliff:g id="NUMBER_0">%d</xliff:g> times. \n\nTry again in <xliff:g id="NUMBER_1">%d</xliff:g> seconds."</string>
    <string name="lockscreen_too_many_failed_pin_attempts_dialog_message" msgid="6216672706545696955">"You have incorrectly typed your PIN <xliff:g id="NUMBER_0">%d</xliff:g> times. \n\nTry again in <xliff:g id="NUMBER_1">%d</xliff:g> seconds."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="tablet" msgid="9191611984625460820">"You have incorrectly drawn your unlock pattern <xliff:g id="NUMBER_0">%d</xliff:g> times. After <xliff:g id="NUMBER_1">%d</xliff:g> more unsuccessful attempts, you will be asked to unlock your tablet using your Google sign-in.\n\n Try again in <xliff:g id="NUMBER_2">%d</xliff:g> seconds."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="default" msgid="2590227559763762751">"You have drawn your unlock pattern incorrectly <xliff:g id="NUMBER_0">%d</xliff:g> times. After <xliff:g id="NUMBER_1">%d</xliff:g> more unsuccessful attempts, you will be asked to unlock your phone using your Google sign-in.\n\n Please try again in <xliff:g id="NUMBER_2">%d</xliff:g> seconds."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="tablet" msgid="6128106399745755604">"You have incorrectly attempted to unlock the tablet <xliff:g id="NUMBER_0">%d</xliff:g> times. After <xliff:g id="NUMBER_1">%d</xliff:g> more unsuccessful attempts, the tablet will be reset to factory default and all user data will be lost."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="default" msgid="8603565142156826565">"You have incorrectly attempted to unlock the phone <xliff:g id="NUMBER_0">%d</xliff:g> times. After <xliff:g id="NUMBER_1">%d</xliff:g> more unsuccessful attempts, the phone will be reset to factory default and all user data will be lost."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="tablet" msgid="280873516493934365">"You have incorrectly attempted to unlock the tablet <xliff:g id="NUMBER">%d</xliff:g> times. The tablet will now be reset to factory default."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="default" msgid="3025504721764922246">"You have incorrectly attempted to unlock the phone <xliff:g id="NUMBER">%d</xliff:g> times. The phone will now be reset to factory default."</string>
    <string name="lockscreen_too_many_failed_attempts_countdown" msgid="6251480343394389665">"Try again in <xliff:g id="NUMBER">%d</xliff:g> seconds."</string>
    <string name="lockscreen_forgot_pattern_button_text" msgid="2626999449610695930">"Forgotten pattern?"</string>
    <string name="lockscreen_glogin_forgot_pattern" msgid="2588521501166032747">"Account unlock"</string>
    <string name="lockscreen_glogin_too_many_attempts" msgid="2751368605287288808">"Too many pattern attempts"</string>
    <string name="lockscreen_glogin_instructions" msgid="3931816256100707784">"To unlock, sign in with your Google account."</string>
    <string name="lockscreen_glogin_username_hint" msgid="8846881424106484447">"Username (email)"</string>
    <string name="lockscreen_glogin_password_hint" msgid="5958028383954738528">"Password"</string>
    <string name="lockscreen_glogin_submit_button" msgid="7130893694795786300">"Sign in"</string>
    <string name="lockscreen_glogin_invalid_input" msgid="1364051473347485908">"Invalid username or password."</string>
    <string name="lockscreen_glogin_account_recovery_hint" msgid="1696924763690379073">"Forgot your username or password?\nVisit "<b>"google.co.uk/accounts/recovery"</b>"."</string>
    <string name="lockscreen_glogin_checking_password" msgid="7114627351286933867">"Checking…"</string>
    <string name="lockscreen_unlock_label" msgid="737440483220667054">"Unlock"</string>
    <string name="lockscreen_sound_on_label" msgid="9068877576513425970">"Sound on"</string>
    <string name="lockscreen_sound_off_label" msgid="996822825154319026">"Sound off"</string>
    <string name="lockscreen_access_pattern_start" msgid="3941045502933142847">"Pattern started"</string>
    <string name="lockscreen_access_pattern_cleared" msgid="5583479721001639579">"Pattern cleared"</string>
    <string name="lockscreen_access_pattern_cell_added" msgid="6756031208359292487">"Cell added"</string>
    <string name="lockscreen_access_pattern_detected" msgid="4988730895554057058">"Pattern completed"</string>
    <string name="keyguard_accessibility_widget_changed" msgid="5678624624681400191">"%1$s. Widget %2$d of %3$d."</string>
    <string name="keyguard_accessibility_add_widget" msgid="8273277058724924654">"Add widget"</string>
    <string name="keyguard_accessibility_widget_empty_slot" msgid="1281505703307930757">"Empty"</string>
    <string name="keyguard_accessibility_unlock_area_expanded" msgid="2278106022311170299">"Unlock area expanded."</string>
    <string name="keyguard_accessibility_unlock_area_collapsed" msgid="6366992066936076396">"Unlock area collapsed."</string>
    <string name="keyguard_accessibility_widget" msgid="6527131039741808240">"<xliff:g id="WIDGET_INDEX">%1$s</xliff:g> widget."</string>
    <string name="keyguard_accessibility_user_selector" msgid="1226798370913698896">"User selector"</string>
    <string name="keyguard_accessibility_status" msgid="8008264603935930611">"Status"</string>
    <string name="keyguard_accessibility_camera" msgid="8904231194181114603">"Camera"</string>
    <string name="keygaurd_accessibility_media_controls" msgid="262209654292161806">"Media controls"</string>
    <string name="keyguard_accessibility_widget_reorder_start" msgid="8736853615588828197">"Widget reordering started."</string>
    <string name="keyguard_accessibility_widget_reorder_end" msgid="7170190950870468320">"Widget reordering ended."</string>
    <string name="keyguard_accessibility_widget_deleted" msgid="4426204263929224434">"Widget <xliff:g id="WIDGET_INDEX">%1$s</xliff:g> deleted."</string>
    <string name="keyguard_accessibility_expand_lock_area" msgid="519859720934178024">"Expand unlock area."</string>
    <string name="keyguard_accessibility_slide_unlock" msgid="2959928478764697254">"Slide unlock."</string>
    <string name="keyguard_accessibility_pattern_unlock" msgid="1490840706075246612">"Pattern unlock."</string>
    <string name="keyguard_accessibility_face_unlock" msgid="4817282543351718535">"Face unlock."</string>
    <string name="keyguard_accessibility_pin_unlock" msgid="2469687111784035046">"Pin unlock."</string>
    <string name="keyguard_accessibility_password_unlock" msgid="7675777623912155089">"Password unlock."</string>
    <string name="keyguard_accessibility_pattern_area" msgid="7679891324509597904">"Pattern area."</string>
    <string name="keyguard_accessibility_slide_area" msgid="6736064494019979544">"Slide area."</string>
    <string name="password_keyboard_label_symbol_key" msgid="992280756256536042">"?123"</string>
    <string name="password_keyboard_label_alpha_key" msgid="8001096175167485649">"ABC"</string>
    <string name="password_keyboard_label_alt_key" msgid="1284820942620288678">"ALT"</string>
    <string name="granularity_label_character" msgid="7336470535385009523">"character"</string>
    <string name="granularity_label_word" msgid="7075570328374918660">"word"</string>
    <string name="granularity_label_link" msgid="5815508880782488267">"link"</string>
    <string name="granularity_label_line" msgid="5764267235026120888">"line"</string>
    <string name="hour_ampm" msgid="4584338083529355982">"<xliff:g id="HOUR">%-l</xliff:g><xliff:g id="AMPM">%P</xliff:g>"</string>
    <string name="hour_cap_ampm" msgid="2083465992940444366">"<xliff:g id="HOUR">%-l</xliff:g><xliff:g id="AMPM">%p</xliff:g>"</string>
    <string name="factorytest_failed" msgid="5410270329114212041">"Factory test failed"</string>
    <string name="factorytest_not_system" msgid="4435201656767276723">"The FACTORY_TEST action is only supported for packages installed in /system/app."</string>
    <string name="factorytest_no_action" msgid="872991874799998561">"No package was found that provides the FACTORY_TEST action."</string>
    <string name="factorytest_reboot" msgid="6320168203050791643">"Reboot"</string>
    <string name="js_dialog_title" msgid="1987483977834603872">"The page at \"<xliff:g id="TITLE">%s</xliff:g>\" says:"</string>
    <string name="js_dialog_title_default" msgid="6961903213729667573">"JavaScript"</string>
    <string name="js_dialog_before_unload_title" msgid="2619376555525116593">"Confirm Navigation"</string>
    <string name="js_dialog_before_unload_positive_button" msgid="3112752010600484130">"Leave this Page"</string>
    <string name="js_dialog_before_unload_negative_button" msgid="5614861293026099715">"Stay on this Page"</string>
    <string name="js_dialog_before_unload" msgid="3468816357095378590">"<xliff:g id="MESSAGE">%s</xliff:g>\n\nAre you sure you want to navigate away from this page?"</string>
    <string name="save_password_label" msgid="6860261758665825069">"Confirm"</string>
    <string name="double_tap_toast" msgid="4595046515400268881">"Tip: double-tap to zoom in and out."</string>
    <string name="autofill_this_form" msgid="4616758841157816676">"Auto-fill"</string>
    <string name="setup_autofill" msgid="7103495070180590814">"Set up Auto-fill"</string>
    <string name="autofill_address_name_separator" msgid="6350145154779706772">" "</string>
    <string name="autofill_address_summary_name_format" msgid="3268041054899214945">"$1$2$3"</string>
    <string name="autofill_address_summary_separator" msgid="7483307893170324129">", "</string>
    <string name="autofill_address_summary_format" msgid="4874459455786827344">"$1$2$3"</string>
    <string name="autofill_province" msgid="2231806553863422300">"Province"</string>
    <string name="autofill_postal_code" msgid="4696430407689377108">"Postcode"</string>
    <string name="autofill_state" msgid="6988894195520044613">"State"</string>
    <string name="autofill_zip_code" msgid="8697544592627322946">"Zip code"</string>
    <string name="autofill_county" msgid="237073771020362891">"County"</string>
    <string name="autofill_island" msgid="4020100875984667025">"Island"</string>
    <string name="autofill_district" msgid="8400735073392267672">"District"</string>
    <string name="autofill_department" msgid="5343279462564453309">"Department"</string>
    <string name="autofill_prefecture" msgid="2028499485065800419">"Prefecture"</string>
    <string name="autofill_parish" msgid="8202206105468820057">"Parish"</string>
    <string name="autofill_area" msgid="3547409050889952423">"Area"</string>
    <string name="autofill_emirate" msgid="2893880978835698818">"Emirate"</string>
    <string name="permlab_readHistoryBookmarks" msgid="3775265775405106983">"read your Web bookmarks and history"</string>
    <string name="permdesc_readHistoryBookmarks" msgid="8462378226600439658">"Allows the app to read the history of all URLs that the Browser has visited, and all of the Browser\'s bookmarks. Note: this permission may not be enforced by third-party browsers or other applications with web browsing capabilities."</string>
    <string name="permlab_writeHistoryBookmarks" msgid="3714785165273314490">"write web bookmarks and history"</string>
    <string name="permdesc_writeHistoryBookmarks" product="tablet" msgid="6825527469145760922">"Allows the app to modify the Browser\'s history or bookmarks stored on your tablet. This may allow the app to delete or modify Browser data. Note: this permission may not be enforced by third-party browsers or other applications with web browsing capabilities."</string>
    <string name="permdesc_writeHistoryBookmarks" product="default" msgid="8497389531014185509">"Allows the app to modify the Browser\'s history or bookmarks stored on your phone. This may allow the app to delete or modify Browser data. Note: this permission may not be enforced by third-party browsers or other applications with web browsing capabilities."</string>
    <string name="permlab_setAlarm" msgid="1379294556362091814">"set an alarm"</string>
    <string name="permdesc_setAlarm" msgid="316392039157473848">"Allows the app to set an alarm in an installed alarm clock app. Some alarm clock apps may not implement this feature."</string>
    <string name="permlab_addVoicemail" msgid="5525660026090959044">"add voicemail"</string>
    <string name="permdesc_addVoicemail" msgid="6604508651428252437">"Allows the app to add messages to your voicemail inbox."</string>
    <string name="permlab_writeGeolocationPermissions" msgid="5962224158955273932">"Modify Browser geo-location permissions"</string>
    <string name="permdesc_writeGeolocationPermissions" msgid="1083743234522638747">"Allows the app to modify the Browser\'s geo-location permissions. Malicious apps may use this to allow sending location information to arbitrary websites."</string>
    <string name="permlab_packageVerificationAgent" msgid="5568139100645829117">"verify packages"</string>
    <string name="permdesc_packageVerificationAgent" msgid="8437590190990843381">"Allows the app to verify a package is installable."</string>
    <string name="permlab_bindPackageVerifier" msgid="4187786793360326654">"bind to a package verifier"</string>
    <string name="permdesc_bindPackageVerifier" msgid="3180741773233862126">"Allows the holder to make requests of package verifiers. Should never be needed for normal apps."</string>
    <string name="permlab_serialPort" msgid="546083327654631076">"access serial ports"</string>
    <string name="permdesc_serialPort" msgid="2991639985224598193">"Allows the holder to access serial ports using the SerialManager API."</string>
    <string name="permlab_accessContentProvidersExternally" msgid="5077774297943409285">"access content providers externally"</string>
    <string name="permdesc_accessContentProvidersExternally" msgid="4544346486697853685">"Allows the holder to access content providers from the shell. Should never be needed for normal apps."</string>
    <string name="permlab_updateLock" msgid="3527558366616680889">"discourage automatic device updates"</string>
    <string name="permdesc_updateLock" msgid="1655625832166778492">"Allows the holder to offer information to the system about when would be a good time for a non-interactive reboot to upgrade the device."</string>
    <string name="save_password_message" msgid="767344687139195790">"Do you want the browser to remember this password?"</string>
    <string name="save_password_notnow" msgid="6389675316706699758">"Not now"</string>
    <string name="save_password_remember" msgid="6491879678996749466">"Remember"</string>
    <string name="save_password_never" msgid="8274330296785855105">"Never"</string>
    <string name="open_permission_deny" msgid="7374036708316629800">"You don\'t have permission to open this page."</string>
    <string name="text_copied" msgid="4985729524670131385">"Text copied to clipboard."</string>
    <string name="more_item_label" msgid="4650918923083320495">"More"</string>
    <string name="prepend_shortcut_label" msgid="2572214461676015642">"Menu+"</string>
    <string name="menu_space_shortcut_label" msgid="2410328639272162537">"space"</string>
    <string name="menu_enter_shortcut_label" msgid="2743362785111309668">"enter"</string>
    <string name="menu_delete_shortcut_label" msgid="3658178007202748164">"delete"</string>
    <string name="search_go" msgid="8298016669822141719">"Search"</string>
    <string name="searchview_description_search" msgid="6749826639098512120">"Search"</string>
    <string name="searchview_description_query" msgid="5911778593125355124">"Search query"</string>
    <string name="searchview_description_clear" msgid="1330281990951833033">"Clear query"</string>
    <string name="searchview_description_submit" msgid="2688450133297983542">"Submit query"</string>
    <string name="searchview_description_voice" msgid="2453203695674994440">"Voice search"</string>
    <string name="enable_explore_by_touch_warning_title" msgid="7460694070309730149">"Enable Explore by Touch?"</string>
    <string name="enable_explore_by_touch_warning_message" product="tablet" msgid="8655887539089910577">"<xliff:g id="ACCESSIBILITY_SERVICE_NAME">%1$s</xliff:g> wants to enable Explore by Touch. When Explore by Touch is turned on, you can hear or see descriptions of what\'s under your finger or perform gestures to interact with the tablet."</string>
    <string name="enable_explore_by_touch_warning_message" product="default" msgid="2708199672852373195">"<xliff:g id="ACCESSIBILITY_SERVICE_NAME">%1$s</xliff:g> wants to enable Explore by Touch. When Explore by Touch is turned on, you can hear or see descriptions of what\'s under your finger or perform gestures to interact with the phone."</string>
    <string name="oneMonthDurationPast" msgid="7396384508953779925">"1 month ago"</string>
    <string name="beforeOneMonthDurationPast" msgid="909134546836499826">"Before 1 month ago"</string>
  <plurals name="num_seconds_ago">
    <item quantity="one" msgid="4869870056547896011">"1 second ago"</item>
    <item quantity="other" msgid="3903706804349556379">"<xliff:g id="COUNT">%d</xliff:g> seconds ago"</item>
  </plurals>
  <plurals name="num_minutes_ago">
    <item quantity="one" msgid="3306787433088810191">"1 minute ago"</item>
    <item quantity="other" msgid="2176942008915455116">"<xliff:g id="COUNT">%d</xliff:g> minutes ago"</item>
  </plurals>
  <plurals name="num_hours_ago">
    <item quantity="one" msgid="9150797944610821849">"1 hour ago"</item>
    <item quantity="other" msgid="2467273239587587569">"<xliff:g id="COUNT">%d</xliff:g> hours ago"</item>
  </plurals>
  <plurals name="last_num_days">
    <item quantity="other" msgid="3069992808164318268">"Last <xliff:g id="COUNT">%d</xliff:g> days"</item>
  </plurals>
    <string name="last_month" msgid="3959346739979055432">"Last month"</string>
    <string name="older" msgid="5211975022815554840">"Older"</string>
  <plurals name="num_days_ago">
    <item quantity="one" msgid="861358534398115820">"yesterday"</item>
    <item quantity="other" msgid="2479586466153314633">"<xliff:g id="COUNT">%d</xliff:g> days ago"</item>
  </plurals>
  <plurals name="in_num_seconds">
    <item quantity="one" msgid="2729745560954905102">"in 1 second"</item>
    <item quantity="other" msgid="1241926116443974687">"in <xliff:g id="COUNT">%d</xliff:g> seconds"</item>
  </plurals>
  <plurals name="in_num_minutes">
    <item quantity="one" msgid="8793095251325200395">"in 1 minute"</item>
    <item quantity="other" msgid="3330713936399448749">"in <xliff:g id="COUNT">%d</xliff:g> minutes"</item>
  </plurals>
  <plurals name="in_num_hours">
    <item quantity="one" msgid="7164353342477769999">"in 1 hour"</item>
    <item quantity="other" msgid="547290677353727389">"in <xliff:g id="COUNT">%d</xliff:g> hours"</item>
  </plurals>
  <plurals name="in_num_days">
    <item quantity="one" msgid="5413088743009839518">"tomorrow"</item>
    <item quantity="other" msgid="5109449375100953247">"in <xliff:g id="COUNT">%d</xliff:g> days"</item>
  </plurals>
  <plurals name="abbrev_num_seconds_ago">
    <item quantity="one" msgid="1849036840200069118">"1 sec ago"</item>
    <item quantity="other" msgid="3699169366650930415">"<xliff:g id="COUNT">%d</xliff:g> secs ago"</item>
  </plurals>
  <plurals name="abbrev_num_minutes_ago">
    <item quantity="one" msgid="6361490147113871545">"1 min ago"</item>
    <item quantity="other" msgid="851164968597150710">"<xliff:g id="COUNT">%d</xliff:g> mins ago"</item>
  </plurals>
  <plurals name="abbrev_num_hours_ago">
    <item quantity="one" msgid="4796212039724722116">"1 hour ago"</item>
    <item quantity="other" msgid="6889970745748538901">"<xliff:g id="COUNT">%d</xliff:g> hours ago"</item>
  </plurals>
  <plurals name="abbrev_num_days_ago">
    <item quantity="one" msgid="8463161711492680309">"yesterday"</item>
    <item quantity="other" msgid="3453342639616481191">"<xliff:g id="COUNT">%d</xliff:g> days ago"</item>
  </plurals>
  <plurals name="abbrev_in_num_seconds">
    <item quantity="one" msgid="5842225370795066299">"in 1 sec"</item>
    <item quantity="other" msgid="5495880108825805108">"in <xliff:g id="COUNT">%d</xliff:g> secs"</item>
  </plurals>
  <plurals name="abbrev_in_num_minutes">
    <item quantity="one" msgid="562786149928284878">"in 1 min"</item>
    <item quantity="other" msgid="4216113292706568726">"in <xliff:g id="COUNT">%d</xliff:g> mins"</item>
  </plurals>
  <plurals name="abbrev_in_num_hours">
    <item quantity="one" msgid="3274708118124045246">"in 1 hour"</item>
    <item quantity="other" msgid="3705373766798013406">"in <xliff:g id="COUNT">%d</xliff:g> hours"</item>
  </plurals>
  <plurals name="abbrev_in_num_days">
    <item quantity="one" msgid="2178576254385739855">"tomorrow"</item>
    <item quantity="other" msgid="2973062968038355991">"in <xliff:g id="COUNT">%d</xliff:g> days"</item>
  </plurals>
    <string name="preposition_for_date" msgid="9093949757757445117">"on <xliff:g id="DATE">%s</xliff:g>"</string>
    <string name="preposition_for_time" msgid="5506831244263083793">"at <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="preposition_for_year" msgid="5040395640711867177">"in<xliff:g id="YEAR">%s</xliff:g>"</string>
    <string name="day" msgid="8144195776058119424">"day"</string>
    <string name="days" msgid="4774547661021344602">"days"</string>
    <string name="hour" msgid="2126771916426189481">"hour"</string>
    <string name="hours" msgid="894424005266852993">"hours"</string>
    <string name="minute" msgid="9148878657703769868">"min"</string>
    <string name="minutes" msgid="5646001005827034509">"mins"</string>
    <string name="second" msgid="3184235808021478">"sec"</string>
    <string name="seconds" msgid="3161515347216589235">"secs"</string>
    <string name="week" msgid="5617961537173061583">"week"</string>
    <string name="weeks" msgid="6509623834583944518">"weeks"</string>
    <string name="year" msgid="4001118221013892076">"year"</string>
    <string name="years" msgid="6881577717993213522">"years"</string>
  <plurals name="duration_seconds">
    <item quantity="one" msgid="6962015528372969481">"1 second"</item>
    <item quantity="other" msgid="1886107766577166786">"<xliff:g id="COUNT">%d</xliff:g> seconds"</item>
  </plurals>
  <plurals name="duration_minutes">
    <item quantity="one" msgid="4915414002546085617">"1 minute"</item>
    <item quantity="other" msgid="3165187169224908775">"<xliff:g id="COUNT">%d</xliff:g> minutes"</item>
  </plurals>
  <plurals name="duration_hours">
    <item quantity="one" msgid="8917467491248809972">"1 hour"</item>
    <item quantity="other" msgid="3863962854246773930">"<xliff:g id="COUNT">%d</xliff:g> hours"</item>
  </plurals>
    <string name="VideoView_error_title" msgid="3534509135438353077">"Video problem"</string>
    <string name="VideoView_error_text_invalid_progressive_playback" msgid="3186670335938670444">"This video isn\'t valid for streaming to this device."</string>
    <string name="VideoView_error_text_unknown" msgid="3450439155187810085">"Can\'t play this video."</string>
    <string name="VideoView_error_button" msgid="2822238215100679592">"OK"</string>
    <string name="relative_time" msgid="1818557177829411417">"<xliff:g id="DATE">%1$s</xliff:g>, <xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="noon" msgid="7245353528818587908">"noon"</string>
    <string name="Noon" msgid="3342127745230013127">"Noon"</string>
    <string name="midnight" msgid="7166259508850457595">"midnight"</string>
    <string name="Midnight" msgid="5630806906897892201">"Midnight"</string>
    <string name="elapsed_time_short_format_mm_ss" msgid="4431555943828711473">"<xliff:g id="MINUTES">%1$02d</xliff:g>:<xliff:g id="SECONDS">%2$02d</xliff:g>"</string>
    <string name="elapsed_time_short_format_h_mm_ss" msgid="1846071997616654124">"<xliff:g id="HOURS">%1$d</xliff:g>:<xliff:g id="MINUTES">%2$02d</xliff:g>:<xliff:g id="SECONDS">%3$02d</xliff:g>"</string>
    <string name="selectAll" msgid="6876518925844129331">"Select all"</string>
    <string name="cut" msgid="3092569408438626261">"Cut"</string>
    <string name="copy" msgid="2681946229533511987">"Copy"</string>
    <string name="paste" msgid="5629880836805036433">"Paste"</string>
    <string name="replace" msgid="5781686059063148930">"Replace..."</string>
    <string name="delete" msgid="6098684844021697789">"Delete"</string>
    <string name="copyUrl" msgid="2538211579596067402">"Copy URL"</string>
    <string name="selectTextMode" msgid="1018691815143165326">"Select text"</string>
    <string name="textSelectionCABTitle" msgid="5236850394370820357">"Text selection"</string>
    <string name="addToDictionary" msgid="4352161534510057874">"Add to dictionary"</string>
    <string name="deleteText" msgid="6979668428458199034">"Delete"</string>
    <string name="inputMethod" msgid="1653630062304567879">"Input method"</string>
    <string name="editTextMenuTitle" msgid="4909135564941815494">"Text actions"</string>
    <string name="low_internal_storage_view_title" msgid="5576272496365684834">"Storage space running out"</string>
    <string name="low_internal_storage_view_text" msgid="6640505817617414371">"Some system functions may not work"</string>
    <string name="app_running_notification_title" msgid="8718335121060787914">"<xliff:g id="APP_NAME">%1$s</xliff:g> is running"</string>
    <string name="app_running_notification_text" msgid="4653586947747330058">"Touch for more information or to stop the app."</string>
    <string name="ok" msgid="5970060430562524910">"OK"</string>
    <string name="cancel" msgid="6442560571259935130">"Cancel"</string>
    <string name="yes" msgid="5362982303337969312">"OK"</string>
    <string name="no" msgid="5141531044935541497">"Cancel"</string>
    <string name="dialog_alert_title" msgid="2049658708609043103">"Attention"</string>
    <string name="loading" msgid="7933681260296021180">"Loading…"</string>
    <string name="capital_on" msgid="1544682755514494298">"ON"</string>
    <string name="capital_off" msgid="6815870386972805832">"OFF"</string>
    <string name="whichApplication" msgid="4533185947064773386">"Complete action using"</string>
    <string name="whichHomeApplication" msgid="4616420172727326782">"Select a home app"</string>
    <string name="alwaysUse" msgid="4583018368000610438">"Use by default for this action."</string>
    <string name="clearDefaultHintMsg" msgid="3252584689512077257">"Clear default in System settings &gt; Apps &gt; Downloaded."</string>
    <string name="chooseActivity" msgid="7486876147751803333">"Choose an action"</string>
    <string name="chooseUsbActivity" msgid="6894748416073583509">"Choose an app for the USB device"</string>
    <string name="noApplications" msgid="2991814273936504689">"No apps can perform this action."</string>
    <string name="aerr_title" msgid="1905800560317137752"></string>
    <string name="aerr_application" msgid="932628488013092776">"Unfortunately, <xliff:g id="APPLICATION">%1$s</xliff:g> has stopped."</string>
    <string name="aerr_process" msgid="4507058997035697579">"Unfortunately, the process <xliff:g id="PROCESS">%1$s</xliff:g> has stopped."</string>
    <string name="anr_title" msgid="4351948481459135709"></string>
    <string name="anr_activity_application" msgid="1904477189057199066">"<xliff:g id="APPLICATION">%2$s</xliff:g> isn\'t responding.\n\nDo you want to close it?"</string>
    <string name="anr_activity_process" msgid="5776209883299089767">"Activity <xliff:g id="ACTIVITY">%1$s</xliff:g> isn\'t responding.\n\nDo you want to close it?"</string>
    <string name="anr_application_process" msgid="8941757607340481057">"<xliff:g id="APPLICATION">%1$s</xliff:g> isn\'t responding. Do you want to close it?"</string>
    <string name="anr_process" msgid="6513209874880517125">"Process <xliff:g id="PROCESS">%1$s</xliff:g> isn\'t responding.\n\nDo you want to close it?"</string>
    <string name="force_close" msgid="8346072094521265605">"OK"</string>
    <string name="report" msgid="4060218260984795706">"Report"</string>
    <string name="wait" msgid="7147118217226317732">"Wait"</string>
    <string name="webpage_unresponsive" msgid="3272758351138122503">"The page has become unresponsive.\n\nDo you want to close it?"</string>
    <string name="launch_warning_title" msgid="1547997780506713581">"App redirected"</string>
    <string name="launch_warning_replace" msgid="6202498949970281412">"<xliff:g id="APP_NAME">%1$s</xliff:g> is now running."</string>
    <string name="launch_warning_original" msgid="188102023021668683">"<xliff:g id="APP_NAME">%1$s</xliff:g> was originally launched."</string>
    <string name="screen_compat_mode_scale" msgid="3202955667675944499">"Scale"</string>
    <string name="screen_compat_mode_show" msgid="4013878876486655892">"Always show"</string>
    <string name="screen_compat_mode_hint" msgid="1064524084543304459">"Re-enable this in System settings &gt; Apps &gt; Downloaded."</string>
    <string name="smv_application" msgid="3307209192155442829">"The app <xliff:g id="APPLICATION">%1$s</xliff:g> (process <xliff:g id="PROCESS">%2$s</xliff:g>) has violated its self-enforced Strict Mode policy."</string>
    <string name="smv_process" msgid="5120397012047462446">"The process <xliff:g id="PROCESS">%1$s</xliff:g> has violated its self-enforced StrictMode policy."</string>
    <string name="android_upgrading_title" msgid="1584192285441405746">"Android is upgrading…"</string>
    <string name="android_upgrading_apk" msgid="7904042682111526169">"Optimising app <xliff:g id="NUMBER_0">%1$d</xliff:g> of <xliff:g id="NUMBER_1">%2$d</xliff:g>."</string>
    <string name="android_upgrading_starting_apps" msgid="451464516346926713">"Starting apps."</string>
    <string name="android_upgrading_complete" msgid="1405954754112999229">"Finishing boot."</string>
    <string name="heavy_weight_notification" msgid="9087063985776626166">"<xliff:g id="APP">%1$s</xliff:g> running"</string>
    <string name="heavy_weight_notification_detail" msgid="1721681741617898865">"Touch to switch to app"</string>
    <string name="heavy_weight_switcher_title" msgid="7153167085403298169">"Switch apps?"</string>
    <string name="heavy_weight_switcher_text" msgid="7022631924534406403">"Another app is already running that must be stopped before you can start a new one."</string>
    <string name="old_app_action" msgid="493129172238566282">"Return to <xliff:g id="OLD_APP">%1$s</xliff:g>"</string>
    <string name="old_app_description" msgid="2082094275580358049">"Don\'t start the new app."</string>
    <string name="new_app_action" msgid="5472756926945440706">"Start <xliff:g id="OLD_APP">%1$s</xliff:g>"</string>
    <string name="new_app_description" msgid="1932143598371537340">"Stop the old app without saving."</string>
    <string name="sendText" msgid="5209874571959469142">"Choose an action for text"</string>
    <string name="volume_ringtone" msgid="6885421406845734650">"Ringer volume"</string>
    <string name="volume_music" msgid="5421651157138628171">"Media volume"</string>
    <string name="volume_music_hint_playing_through_bluetooth" msgid="9165984379394601533">"Playing through Bluetooth"</string>
    <string name="volume_music_hint_silent_ringtone_selected" msgid="8310739960973156272">"Silent ringtone set"</string>
    <string name="volume_call" msgid="3941680041282788711">"In-call volume"</string>
    <string name="volume_bluetooth_call" msgid="2002891926351151534">"Bluetooth in-call volume"</string>
    <string name="volume_alarm" msgid="1985191616042689100">"Alarm volume"</string>
    <string name="volume_notification" msgid="2422265656744276715">"Notification volume"</string>
    <string name="volume_unknown" msgid="1400219669770445902">"Volume"</string>
    <string name="volume_icon_description_bluetooth" msgid="6538894177255964340">"Bluetooth volume"</string>
    <string name="volume_icon_description_ringer" msgid="3326003847006162496">"Ringtone volume"</string>
    <string name="volume_icon_description_incall" msgid="8890073218154543397">"Call volume"</string>
    <string name="volume_icon_description_media" msgid="4217311719665194215">"Media volume"</string>
    <string name="volume_icon_description_notification" msgid="7044986546477282274">"Notification volume"</string>
    <string name="ringtone_default" msgid="3789758980357696936">"Default ringtone"</string>
    <string name="ringtone_default_with_actual" msgid="8129563480895990372">"Default ringtone (<xliff:g id="ACTUAL_RINGTONE">%1$s</xliff:g>)"</string>
    <string name="ringtone_silent" msgid="7937634392408977062">"None"</string>
    <string name="ringtone_picker_title" msgid="3515143939175119094">"Ringtones"</string>
    <string name="ringtone_unknown" msgid="5477919988701784788">"Unknown ringtone"</string>
  <plurals name="wifi_available">
    <item quantity="one" msgid="6654123987418168693">"Wi-Fi network available"</item>
    <item quantity="other" msgid="4192424489168397386">"Wi-Fi networks available"</item>
  </plurals>
  <plurals name="wifi_available_detailed">
    <item quantity="one" msgid="1634101450343277345">"Open available Wi-Fi network"</item>
    <item quantity="other" msgid="7915895323644292768">"Open Wi-Fi networks available"</item>
  </plurals>
    <string name="wifi_available_sign_in" msgid="4029489716605255386">"Sign in to Wi-Fi network"</string>
    <string name="network_available_sign_in" msgid="8495155593358054676">"Sign in to network"</string>
    <!-- no translation found for network_available_sign_in_detailed (8000081941447976118) -->
    <skip />
    <string name="wifi_watchdog_network_disabled" msgid="7904214231651546347">"Couldn\'t connect to Wi-Fi"</string>
    <string name="wifi_watchdog_network_disabled_detailed" msgid="5548780776418332675">" has a poor Internet connection."</string>
    <string name="wifi_p2p_dialog_title" msgid="97611782659324517">"Wi-Fi Direct"</string>
    <string name="wifi_p2p_turnon_message" msgid="2909250942299627244">"Start Wi-Fi Direct. This will turn off Wi-Fi client/hotspot."</string>
    <string name="wifi_p2p_failed_message" msgid="3763669677935623084">"Couldn\'t start Wi-Fi Direct."</string>
    <string name="wifi_p2p_enabled_notification_title" msgid="2068321881673734886">"Wi-Fi Direct is on"</string>
    <string name="wifi_p2p_enabled_notification_message" msgid="1638949953993894335">"Touch for settings"</string>
    <string name="accept" msgid="1645267259272829559">"Accept"</string>
    <string name="decline" msgid="2112225451706137894">"Decline"</string>
    <string name="wifi_p2p_invitation_sent_title" msgid="1318975185112070734">"Invitation sent"</string>
    <string name="wifi_p2p_invitation_to_connect_title" msgid="4958803948658533637">"Invitation to connect"</string>
    <string name="wifi_p2p_from_message" msgid="570389174731951769">"From:"</string>
    <string name="wifi_p2p_to_message" msgid="248968974522044099">"To:"</string>
    <string name="wifi_p2p_enter_pin_message" msgid="5920929550367828970">"Type the required PIN:"</string>
    <string name="wifi_p2p_show_pin_message" msgid="8530563323880921094">"PIN:"</string>
    <string name="wifi_p2p_frequency_conflict_message" product="tablet" msgid="8012981257742232475">"The tablet will temporarily disconnect from Wi-Fi while it\'s connected to <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_p2p_frequency_conflict_message" product="default" msgid="7363907213787469151">"The phone will temporarily disconnect from Wi-Fi while it\'s connected to <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="select_character" msgid="3365550120617701745">"Insert character"</string>
    <string name="sms_control_title" msgid="7296612781128917719">"Sending SMS messages"</string>
    <string name="sms_control_message" msgid="3867899169651496433">"&lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; is sending a large number of SMS messages. Do you want to allow this app to continue sending messages?"</string>
    <string name="sms_control_yes" msgid="3663725993855816807">"Allow"</string>
    <string name="sms_control_no" msgid="625438561395534982">"Deny"</string>
    <string name="sms_short_code_confirm_message" msgid="1645436466285310855">"&lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; would like to send a message to &lt;b&gt;<xliff:g id="DEST_ADDRESS">%2$s</xliff:g>&lt;/b&gt;."</string>
    <string name="sms_short_code_details" msgid="3492025719868078457">"This "<font fgcolor="#ffffb060">"may cause charges"</font>" on your mobile account."</string>
    <string name="sms_premium_short_code_details" msgid="5523826349105123687"><font fgcolor="#ffffb060">"This will cause charges on your mobile account."</font></string>
    <string name="sms_short_code_confirm_allow" msgid="4458878637111023413">"Send"</string>
    <string name="sms_short_code_confirm_deny" msgid="2927389840209170706">"Cancel"</string>
    <string name="sms_short_code_remember_choice" msgid="5289538592272218136">"Remember my choice"</string>
    <string name="sms_short_code_remember_undo_instruction" msgid="4960944133052287484">"You can change this later in Settings &gt; Apps"</string>
    <string name="sms_short_code_confirm_always_allow" msgid="3241181154869493368">"Always Allow*"</string>
    <string name="sms_short_code_confirm_never_allow" msgid="446992765774269673">"Never Allow"</string>
    <string name="sim_removed_title" msgid="6227712319223226185">"SIM card removed"</string>
    <string name="sim_removed_message" msgid="2333164559970958645">"The mobile network will be unavailable until you restart with a valid SIM card inserted."</string>
    <string name="sim_done_button" msgid="827949989369963775">"Done"</string>
    <string name="sim_added_title" msgid="3719670512889674693">"SIM card added"</string>
    <string name="sim_added_message" msgid="6599945301141050216">"Restart your device to access the mobile network."</string>
    <string name="sim_restart_button" msgid="4722407842815232347">"Restart"</string>
    <string name="time_picker_dialog_title" msgid="8349362623068819295">"Set time"</string>
    <string name="date_picker_dialog_title" msgid="5879450659453782278">"Set date"</string>
    <string name="date_time_set" msgid="5777075614321087758">"Set"</string>
    <string name="date_time_done" msgid="2507683751759308828">"Done"</string>
    <string name="perms_new_perm_prefix" msgid="8257740710754301407"><font size="12" fgcolor="#ff33b5e5">"NEW: "</font></string>
    <string name="perms_description_app" msgid="5139836143293299417">"Provided by <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="no_permissions" msgid="7283357728219338112">"No permission required"</string>
    <string name="perm_costs_money" msgid="4902470324142151116">"this may cost you money"</string>
    <string name="usb_storage_activity_title" msgid="4465055157209648641">"USB mass storage"</string>
    <string name="usb_storage_title" msgid="5901459041398751495">"USB connected"</string>
    <string name="usb_storage_message" product="nosdcard" msgid="3308538094316477839">"You\'ve connected to your computer via USB. Touch the button below if you want to copy files between your computer and your Android\'s USB storage."</string>
    <string name="usb_storage_message" product="default" msgid="805351000446037811">"You\'ve connected to your computer via USB. Touch the button below if you want to copy files between your computer and your Android\'s SD card."</string>
    <string name="usb_storage_button_mount" msgid="1052259930369508235">"Turn on USB storage"</string>
    <string name="usb_storage_error_message" product="nosdcard" msgid="3017045217365540658">"There\'s a problem using your USB storage for USB mass storage."</string>
    <string name="usb_storage_error_message" product="default" msgid="2876018512716970313">"There\'s a problem using your SD card for USB mass storage."</string>
    <string name="usb_storage_notification_title" msgid="8175892554757216525">"USB connected"</string>
    <string name="usb_storage_notification_message" msgid="939822783828183763">"Touch to copy files to/from your computer."</string>
    <string name="usb_storage_stop_notification_title" msgid="2336058396663516017">"Turn off USB storage"</string>
    <string name="usb_storage_stop_notification_message" msgid="1656852098555623822">"Touch to turn off USB storage."</string>
    <string name="usb_storage_stop_title" msgid="660129851708775853">"USB storage in use"</string>
    <string name="usb_storage_stop_message" product="nosdcard" msgid="4264025280777219521">"Before turning off USB storage, unmount (\"eject\") your Android\'s USB storage from your computer."</string>
    <string name="usb_storage_stop_message" product="default" msgid="8043969782460613114">"Before turning off USB storage, unmount (\"eject\") your Android\'s SD card from your computer."</string>
    <string name="usb_storage_stop_button_mount" msgid="7060218034900696029">"Turn off USB storage"</string>
    <string name="usb_storage_stop_error_message" msgid="1970374898263063836">"There was a problem turning off USB storage. Check that you\'ve unmounted the USB host, then try again."</string>
    <string name="dlg_confirm_kill_storage_users_title" msgid="963039033470478697">"Turn off USB storage"</string>
    <string name="dlg_confirm_kill_storage_users_text" msgid="5100428757107469454">"If you turn on USB storage, some apps that you\'re using will stop and may be unavailable until you turn off USB storage."</string>
    <string name="dlg_error_title" msgid="7323658469626514207">"USB operation unsuccessful"</string>
    <string name="dlg_ok" msgid="7376953167039865701">"OK"</string>
    <string name="usb_mtp_notification_title" msgid="3699913097391550394">"Connected as a media device"</string>
    <string name="usb_ptp_notification_title" msgid="1960817192216064833">"Connected as a camera"</string>
    <string name="usb_cd_installer_notification_title" msgid="6774712827892090754">"Connected as an installer"</string>
    <string name="usb_accessory_notification_title" msgid="7848236974087653666">"Connected to a USB accessory"</string>
    <string name="usb_notification_message" msgid="2290859399983720271">"Touch for other USB options."</string>
    <string name="extmedia_format_title" product="nosdcard" msgid="9020092196061007262">"Format USB storage?"</string>
    <string name="extmedia_format_title" product="default" msgid="3648415921526526069">"Format SD card?"</string>
    <string name="extmedia_format_message" product="nosdcard" msgid="3934016853425761078">"All files stored in your USB storage will be erased. This action can\'t be reversed!"</string>
    <string name="extmedia_format_message" product="default" msgid="14131895027543830">"All data on your card will be lost."</string>
    <string name="extmedia_format_button_format" msgid="4131064560127478695">"Format"</string>
    <string name="adb_active_notification_title" msgid="6729044778949189918">"USB debugging connected"</string>
    <string name="adb_active_notification_message" msgid="1016654627626476142">"Touch to disable USB debugging."</string>
    <string name="select_input_method" msgid="4653387336791222978">"Choose input method"</string>
    <string name="configure_input_methods" msgid="9091652157722495116">"Set up input methods"</string>
    <string name="use_physical_keyboard" msgid="6203112478095117625">"Physical keyboard"</string>
    <string name="hardware" msgid="7517821086888990278">"Hardware"</string>
    <string name="select_keyboard_layout_notification_title" msgid="1407367017263030773">"Select keyboard layout"</string>
    <string name="select_keyboard_layout_notification_message" msgid="4465907700449257063">"Touch to select a keyboard layout."</string>
    <string name="fast_scroll_alphabet" msgid="5433275485499039199">" ABCDEFGHIJKLMNOPQRSTUVWXYZ"</string>
    <string name="fast_scroll_numeric_alphabet" msgid="4030170524595123610">" 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"</string>
    <string name="candidates_style" msgid="4333913089637062257"><u>"candidates"</u></string>
    <string name="ext_media_checking_notification_title" product="nosdcard" msgid="3449816005351468560">"Preparing USB storage"</string>
    <string name="ext_media_checking_notification_title" product="default" msgid="5457603418970994050">"Preparing SD card"</string>
    <string name="ext_media_checking_notification_message" msgid="8287319882926737053">"Checking for errors."</string>
    <string name="ext_media_nofs_notification_title" product="nosdcard" msgid="7788040745686229307">"Blank USB storage"</string>
    <string name="ext_media_nofs_notification_title" product="default" msgid="780477838241212997">"Blank SD card"</string>
    <string name="ext_media_nofs_notification_message" product="nosdcard" msgid="7840121067427269500">"USB storage is blank or has unsupported filesystem."</string>
    <string name="ext_media_nofs_notification_message" product="default" msgid="8641065641786923604">"SD card is blank or has unsupported file system."</string>
    <string name="ext_media_unmountable_notification_title" product="nosdcard" msgid="2090046769532713563">"Damaged USB storage"</string>
    <string name="ext_media_unmountable_notification_title" product="default" msgid="6410723906019100189">"Damaged SD card"</string>
    <string name="ext_media_unmountable_notification_message" product="nosdcard" msgid="1795917578395333280">"USB storage is damaged. Try reformatting it."</string>
    <string name="ext_media_unmountable_notification_message" product="default" msgid="1753898567525568253">"SD card is damaged. Try reformatting it."</string>
    <string name="ext_media_badremoval_notification_title" product="nosdcard" msgid="1661683031330951073">"USB storage removed unexpectedly"</string>
    <string name="ext_media_badremoval_notification_title" product="default" msgid="6872152882604407837">"SD card removed unexpectedly"</string>
    <string name="ext_media_badremoval_notification_message" product="nosdcard" msgid="4329848819865594241">"Unmount USB storage before removing to avoid data loss."</string>
    <string name="ext_media_badremoval_notification_message" product="default" msgid="7260183293747448241">"Unmount SD card before removing to avoid data loss."</string>
    <string name="ext_media_safe_unmount_notification_title" product="nosdcard" msgid="3967973893270360230">"USB storage safe to remove"</string>
    <string name="ext_media_safe_unmount_notification_title" product="default" msgid="6729801130790616200">"SD card safe to remove"</string>
    <string name="ext_media_safe_unmount_notification_message" product="nosdcard" msgid="6142195361606493530">"You can safely remove USB storage."</string>
    <string name="ext_media_safe_unmount_notification_message" product="default" msgid="568841278138377604">"You can safely remove SD card."</string>
    <string name="ext_media_nomedia_notification_title" product="nosdcard" msgid="4486377230140227651">"Removed USB storage"</string>
    <string name="ext_media_nomedia_notification_title" product="default" msgid="8902518030404381318">"Removed SD card"</string>
    <string name="ext_media_nomedia_notification_message" product="nosdcard" msgid="6921126162580574143">"USB storage removed. Insert new media."</string>
    <string name="ext_media_nomedia_notification_message" product="default" msgid="3870120652983659641">"SD card removed. Insert a new one."</string>
    <string name="activity_list_empty" msgid="1675388330786841066">"No matching activities found."</string>
    <string name="permlab_pkgUsageStats" msgid="8787352074326748892">"update component usage statistics"</string>
    <string name="permdesc_pkgUsageStats" msgid="1106612424254277630">"Allows the app to modify collected component usage statistics. Not for use by normal apps."</string>
    <string name="permlab_copyProtectedData" msgid="4341036311211406692">"copy content"</string>
    <string name="permdesc_copyProtectedData" msgid="4390697124288317831">"Allows the app to invoke default container service to copy content. Not for use by normal apps."</string>
    <string name="permlab_route_media_output" msgid="1642024455750414694">"Route media output"</string>
    <string name="permdesc_route_media_output" msgid="4932818749547244346">"Allows an application to route media output to other external devices."</string>
    <string name="permlab_access_keyguard_secure_storage" msgid="7565552237977815047">"Access keyguard secure storage"</string>
    <string name="permdesc_access_keyguard_secure_storage" msgid="5866245484303285762">"Allows an application to access keyguard secure storage."</string>
    <string name="permlab_control_keyguard" msgid="172195184207828387">"Control displaying and hiding keyguard"</string>
    <string name="permdesc_control_keyguard" msgid="3043732290518629061">"Allows an application to control keyguard."</string>
    <string name="tutorial_double_tap_to_zoom_message_short" msgid="4070433208160063538">"Touch twice for zoom control"</string>
    <string name="gadget_host_error_inflating" msgid="4882004314906466162">"Couldn\'t add widget."</string>
    <string name="ime_action_go" msgid="8320845651737369027">"Go"</string>
    <string name="ime_action_search" msgid="658110271822807811">"Search"</string>
    <string name="ime_action_send" msgid="2316166556349314424">"Send"</string>
    <string name="ime_action_next" msgid="3138843904009813834">"Next"</string>
    <string name="ime_action_done" msgid="8971516117910934605">"Done"</string>
    <string name="ime_action_previous" msgid="1443550039250105948">"Prev"</string>
    <string name="ime_action_default" msgid="2840921885558045721">"Execute"</string>
    <string name="dial_number_using" msgid="5789176425167573586">"Dial number\n using <xliff:g id="NUMBER">%s</xliff:g>"</string>
    <string name="create_contact_using" msgid="4947405226788104538">"Create contact\n using <xliff:g id="NUMBER">%s</xliff:g>"</string>
    <string name="grant_credentials_permission_message_header" msgid="2106103817937859662">"The following one or more applications request permission to access your account, now and in the future."</string>
    <string name="grant_credentials_permission_message_footer" msgid="3125211343379376561">"Do you want to allow this request?"</string>
    <string name="grant_permissions_header_text" msgid="6874497408201826708">"Access request"</string>
    <string name="allow" msgid="7225948811296386551">"Allow"</string>
    <string name="deny" msgid="2081879885755434506">"Deny"</string>
    <string name="permission_request_notification_title" msgid="6486759795926237907">"Permission requested"</string>
    <string name="permission_request_notification_with_subtitle" msgid="8530393139639560189">"Permission requested\nfor account <xliff:g id="ACCOUNT">%s</xliff:g>."</string>
    <string name="input_method_binding_label" msgid="1283557179944992649">"Input Method"</string>
    <string name="sync_binding_label" msgid="3687969138375092423">"Sync"</string>
    <string name="accessibility_binding_label" msgid="4148120742096474641">"Accessibility"</string>
    <string name="wallpaper_binding_label" msgid="1240087844304687662">"Wallpaper"</string>
    <string name="chooser_wallpaper" msgid="7873476199295190279">"Change wallpaper"</string>
    <string name="notification_listener_binding_label" msgid="2014162835481906429">"Notification listener"</string>
    <string name="vpn_title" msgid="19615213552042827">"VPN activated"</string>
    <string name="vpn_title_long" msgid="6400714798049252294">"VPN is activated by <xliff:g id="APP">%s</xliff:g>"</string>
    <string name="vpn_text" msgid="3011306607126450322">"Touch to manage the network."</string>
    <string name="vpn_text_long" msgid="6407351006249174473">"Connected to <xliff:g id="SESSION">%s</xliff:g>. Touch to manage the network."</string>
    <string name="vpn_lockdown_connecting" msgid="6443438964440960745">"Always-on VPN connecting…"</string>
    <string name="vpn_lockdown_connected" msgid="8202679674819213931">"Always-on VPN connected"</string>
    <string name="vpn_lockdown_error" msgid="6009249814034708175">"Always-on VPN error"</string>
    <string name="vpn_lockdown_config" msgid="6415899150671537970">"Touch to configure"</string>
    <string name="upload_file" msgid="2897957172366730416">"Choose file"</string>
    <string name="no_file_chosen" msgid="6363648562170759465">"No file chosen"</string>
    <string name="reset" msgid="2448168080964209908">"Reset"</string>
    <string name="submit" msgid="1602335572089911941">"Submit"</string>
    <string name="car_mode_disable_notification_title" msgid="3164768212003864316">"Car mode enabled"</string>
    <string name="car_mode_disable_notification_message" msgid="8035230537563503262">"Touch to exit car mode."</string>
    <string name="tethered_notification_title" msgid="3146694234398202601">"Tethering or hotspot active"</string>
    <string name="tethered_notification_message" msgid="6857031760103062982">"Touch to set up."</string>
    <string name="back_button_label" msgid="2300470004503343439">"Back"</string>
    <string name="next_button_label" msgid="1080555104677992408">"Next"</string>
    <string name="skip_button_label" msgid="1275362299471631819">"Skip"</string>
    <string name="throttle_warning_notification_title" msgid="4890894267454867276">"High mobile data use"</string>
    <string name="throttle_warning_notification_message" msgid="3340822228599337743">"Touch to learn more about mobile data use."</string>
    <string name="throttled_notification_title" msgid="6269541897729781332">"Mobile data limit exceeded"</string>
    <string name="throttled_notification_message" msgid="5443457321354907181">"Touch to learn more about mobile data use."</string>
    <string name="no_matches" msgid="8129421908915840737">"No matches"</string>
    <string name="find_on_page" msgid="1946799233822820384">"Find on page"</string>
  <plurals name="matches_found">
    <item quantity="one" msgid="8167147081136579439">"1 Match"</item>
    <item quantity="other" msgid="4641872797067609177">"<xliff:g id="INDEX">%d</xliff:g> of <xliff:g id="TOTAL">%d</xliff:g>"</item>
  </plurals>
    <string name="action_mode_done" msgid="7217581640461922289">"Done"</string>
    <string name="progress_unmounting" product="nosdcard" msgid="3923810448507612746">"Unmounting USB storage…"</string>
    <string name="progress_unmounting" product="default" msgid="1327894998409537190">"Unmounting SD card…"</string>
    <string name="progress_erasing" product="nosdcard" msgid="4521573321524340058">"Erasing USB storage..."</string>
    <string name="progress_erasing" product="default" msgid="6596988875507043042">"Erasing SD card…"</string>
    <string name="format_error" product="nosdcard" msgid="6299769563624776948">"Couldn\'t erase USB storage."</string>
    <string name="format_error" product="default" msgid="7315248696644510935">"Couldn\'t erase SD card."</string>
    <string name="media_bad_removal" msgid="7960864061016603281">"SD card was removed before being unmounted."</string>
    <string name="media_checking" product="nosdcard" msgid="418188720009569693">"USB storage is currently being checked."</string>
    <string name="media_checking" product="default" msgid="7334762503904827481">"SD card is currently being checked."</string>
    <string name="media_removed" msgid="7001526905057952097">"SD card has been removed."</string>
    <string name="media_shared" product="nosdcard" msgid="5830814349250834225">"USB storage is currently in use by a computer."</string>
    <string name="media_shared" product="default" msgid="5706130568133540435">"SD card is currently in use by a computer."</string>
    <string name="media_unknown_state" msgid="729192782197290385">"External media in unknown state."</string>
    <string name="share" msgid="1778686618230011964">"Share"</string>
    <string name="find" msgid="4808270900322985960">"Find"</string>
    <string name="websearch" msgid="4337157977400211589">"Web Search"</string>
    <string name="find_next" msgid="5742124618942193978">"Find next"</string>
    <string name="find_previous" msgid="2196723669388360506">"Find previous"</string>
    <string name="gpsNotifTicker" msgid="5622683912616496172">"Location request from <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="gpsNotifTitle" msgid="5446858717157416839">"Location request"</string>
    <string name="gpsNotifMessage" msgid="1374718023224000702">"Requested by <xliff:g id="NAME">%1$s</xliff:g> (<xliff:g id="SERVICE">%2$s</xliff:g>)"</string>
    <string name="gpsVerifYes" msgid="2346566072867213563">"Yes"</string>
    <string name="gpsVerifNo" msgid="1146564937346454865">"No"</string>
    <string name="sync_too_many_deletes" msgid="5296321850662746890">"Deletion limit exceeded"</string>
    <string name="sync_too_many_deletes_desc" msgid="496551671008694245">"There are <xliff:g id="NUMBER_OF_DELETED_ITEMS">%1$d</xliff:g> deleted items for <xliff:g id="TYPE_OF_SYNC">%2$s</xliff:g>, account <xliff:g id="ACCOUNT_NAME">%3$s</xliff:g>. What do you want to do?"</string>
    <string name="sync_really_delete" msgid="2572600103122596243">"Delete the items"</string>
    <string name="sync_undo_deletes" msgid="2941317360600338602">"Undo the deletes"</string>
    <string name="sync_do_nothing" msgid="3743764740430821845">"Do nothing for now"</string>
    <string name="choose_account_label" msgid="5655203089746423927">"Choose an account"</string>
    <string name="add_account_label" msgid="2935267344849993553">"Add an account"</string>
    <string name="add_account_button_label" msgid="3611982894853435874">"Add account"</string>
    <string name="number_picker_increment_button" msgid="2412072272832284313">"Increase"</string>
    <string name="number_picker_decrement_button" msgid="476050778386779067">"Decrease"</string>
    <string name="number_picker_increment_scroll_mode" msgid="3073101067441638428">"<xliff:g id="VALUE">%s</xliff:g> touch and hold."</string>
    <string name="number_picker_increment_scroll_action" msgid="9101473045891835490">"Slide up to increase and down to decrease."</string>
    <string name="time_picker_increment_minute_button" msgid="8865885114028614321">"Increase minute"</string>
    <string name="time_picker_decrement_minute_button" msgid="6246834937080684791">"Decrease minute"</string>
    <string name="time_picker_increment_hour_button" msgid="3652056055810223139">"Increase hour"</string>
    <string name="time_picker_decrement_hour_button" msgid="1377479863429214792">"Decrease hour"</string>
    <string name="time_picker_increment_set_pm_button" msgid="4147590696151230863">"Set p.m."</string>
    <string name="time_picker_decrement_set_am_button" msgid="8302140353539486752">"Set a.m."</string>
    <string name="date_picker_increment_month_button" msgid="5369998479067934110">"Increase month"</string>
    <string name="date_picker_decrement_month_button" msgid="1832698995541726019">"Decrease month"</string>
    <string name="date_picker_increment_day_button" msgid="7130465412308173903">"Increase day"</string>
    <string name="date_picker_decrement_day_button" msgid="4131881521818750031">"Decrease day"</string>
    <string name="date_picker_increment_year_button" msgid="6318697384310808899">"Increase year"</string>
    <string name="date_picker_decrement_year_button" msgid="4482021813491121717">"Decrease year"</string>
    <string name="keyboardview_keycode_alt" msgid="4856868820040051939">"Alt"</string>
    <string name="keyboardview_keycode_cancel" msgid="1203984017245783244">"Cancel"</string>
    <string name="keyboardview_keycode_delete" msgid="3337914833206635744">"Delete"</string>
    <string name="keyboardview_keycode_done" msgid="1992571118466679775">"Done"</string>
    <string name="keyboardview_keycode_mode_change" msgid="4547387741906537519">"Mode change"</string>
    <string name="keyboardview_keycode_shift" msgid="2270748814315147690">"Shift"</string>
    <string name="keyboardview_keycode_enter" msgid="2985864015076059467">"Enter"</string>
    <string name="activitychooserview_choose_application" msgid="2125168057199941199">"Choose an app"</string>
    <string name="activitychooserview_choose_application_error" msgid="8624618365481126668">"Couldn\'t launch <xliff:g id="APPLICATION_NAME">%s</xliff:g>"</string>
    <string name="shareactionprovider_share_with" msgid="806688056141131819">"Share with"</string>
    <string name="shareactionprovider_share_with_application" msgid="5627411384638389738">"Share with <xliff:g id="APPLICATION_NAME">%s</xliff:g>"</string>
    <string name="content_description_sliding_handle" msgid="415975056159262248">"Sliding handle. Touch &amp; hold."</string>
    <string name="description_direction_up" msgid="7169032478259485180">"Slide up for <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
    <string name="description_direction_down" msgid="5087739728639014595">"Slide down for <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
    <string name="description_direction_left" msgid="7207478719805562165">"Slide left for <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
    <string name="description_direction_right" msgid="8034433242579600980">"Slide right for <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
    <string name="description_target_unlock" msgid="2228524900439801453">"Unlock"</string>
    <string name="description_target_camera" msgid="969071997552486814">"Camera"</string>
    <string name="description_target_silent" msgid="893551287746522182">"Silent"</string>
    <string name="description_target_soundon" msgid="30052466675500172">"Sound on"</string>
    <string name="description_target_search" msgid="3091587249776033139">"Search"</string>
    <string name="description_target_unlock_tablet" msgid="3833195335629795055">"Swipe to unlock."</string>
    <string name="keyboard_headset_required_to_hear_password" msgid="7011927352267668657">"Plug in a headset to hear password keys spoken."</string>
    <string name="keyboard_password_character_no_headset" msgid="2859873770886153678">"Dot"</string>
    <string name="action_bar_home_description" msgid="5293600496601490216">"Navigate home"</string>
    <string name="action_bar_up_description" msgid="2237496562952152589">"Navigate up"</string>
    <string name="action_menu_overflow_description" msgid="2295659037509008453">"More options"</string>
    <string name="action_bar_home_description_format" msgid="7965984360903693903">"%1$s, %2$s"</string>
    <string name="action_bar_home_subtitle_description_format" msgid="6985546530471780727">"%1$s, %2$s, %3$s"</string>
    <string name="storage_internal" msgid="4891916833657929263">"Internal storage"</string>
    <string name="storage_sd_card" msgid="3282948861378286745">"SD card"</string>
    <string name="storage_usb" msgid="3017954059538517278">"USB storage"</string>
    <string name="extract_edit_menu_button" msgid="8940478730496610137">"Edit"</string>
    <string name="data_usage_warning_title" msgid="1955638862122232342">"Data usage warning"</string>
    <string name="data_usage_warning_body" msgid="2814673551471969954">"Touch to view usage and settings."</string>
    <string name="data_usage_3g_limit_title" msgid="7093334419518706686">"2G-3G data disabled"</string>
    <string name="data_usage_4g_limit_title" msgid="7636489436819470761">"4G data disabled"</string>
    <string name="data_usage_mobile_limit_title" msgid="7869402519391631884">"Mobile data disabled"</string>
    <string name="data_usage_wifi_limit_title" msgid="8992154736441284865">"Wi-Fi data disabled"</string>
    <string name="data_usage_limit_body" msgid="3317964706973601386">"Touch to enable."</string>
    <string name="data_usage_3g_limit_snoozed_title" msgid="7026739121138005231">"2G-3G data limit exceeded"</string>
    <string name="data_usage_4g_limit_snoozed_title" msgid="1106562779311209039">"4G data limit exceeded"</string>
    <string name="data_usage_mobile_limit_snoozed_title" msgid="279240572165412168">"Mobile data limit exceeded"</string>
    <string name="data_usage_wifi_limit_snoozed_title" msgid="8743856006384825974">"Wi-Fi data limit exceeded"</string>
    <string name="data_usage_limit_snoozed_body" msgid="7035490278298441767">"<xliff:g id="SIZE">%s</xliff:g> over specified limit."</string>
    <string name="data_usage_restricted_title" msgid="5965157361036321914">"Background data restricted"</string>
    <string name="data_usage_restricted_body" msgid="6741521330997452990">"Touch to remove restriction."</string>
    <string name="ssl_certificate" msgid="6510040486049237639">"Security certificate"</string>
    <string name="ssl_certificate_is_valid" msgid="6825263250774569373">"This certificate is valid."</string>
    <string name="issued_to" msgid="454239480274921032">"Issued to:"</string>
    <string name="common_name" msgid="2233209299434172646">"Common name:"</string>
    <string name="org_name" msgid="6973561190762085236">"Organisation:"</string>
    <string name="org_unit" msgid="7265981890422070383">"Organisational unit:"</string>
    <string name="issued_by" msgid="2647584988057481566">"Issued by:"</string>
    <string name="validity_period" msgid="8818886137545983110">"Validity:"</string>
    <string name="issued_on" msgid="5895017404361397232">"Issued on:"</string>
    <string name="expires_on" msgid="3676242949915959821">"Expires on:"</string>
    <string name="serial_number" msgid="758814067660862493">"Serial number:"</string>
    <string name="fingerprints" msgid="4516019619850763049">"Fingerprints:"</string>
    <string name="sha256_fingerprint" msgid="4391271286477279263">"SHA-256 fingerprint"</string>
    <string name="sha1_fingerprint" msgid="7930330235269404581">"SHA-1 fingerprint"</string>
    <string name="activity_chooser_view_see_all" msgid="4292569383976636200">"See all"</string>
    <string name="activity_chooser_view_dialog_title_default" msgid="4710013864974040615">"Choose activity"</string>
    <string name="share_action_provider_share_with" msgid="5247684435979149216">"Share with"</string>
    <string name="list_delimeter" msgid="3975117572185494152">", "</string>
    <string name="sending" msgid="3245653681008218030">"Sending…"</string>
    <string name="launchBrowserDefault" msgid="2057951947297614725">"Launch Browser?"</string>
    <string name="SetupCallDefault" msgid="5834948469253758575">"Accept call?"</string>
    <string name="activity_resolver_use_always" msgid="8017770747801494933">"Always"</string>
    <string name="activity_resolver_use_once" msgid="2404644797149173758">"Just once"</string>
    <string name="default_audio_route_name" product="tablet" msgid="4617053898167127471">"Tablet"</string>
    <string name="default_audio_route_name" product="default" msgid="4239291273420140123">"Phone"</string>
    <string name="default_audio_route_name_headphones" msgid="8119971843803439110">"Headphones"</string>
    <string name="default_audio_route_name_dock_speakers" msgid="6240602982276591864">"Dock speakers"</string>
    <string name="default_media_route_name_hdmi" msgid="2450970399023478055">"HDMI"</string>
    <string name="default_audio_route_category_name" msgid="3722811174003886946">"System"</string>
    <string name="bluetooth_a2dp_audio_route_name" msgid="8575624030406771015">"Bluetooth audio"</string>
    <string name="wireless_display_route_description" msgid="9070346425023979651">"Wireless display"</string>
    <string name="media_route_button_content_description" msgid="5758553567065145276">"Media output"</string>
    <string name="media_route_chooser_title" msgid="1751618554539087622">"Connect to device"</string>
    <string name="media_route_chooser_searching" msgid="4776236202610828706">"Searching for devices…"</string>
    <string name="media_route_chooser_extended_settings" msgid="87015534236701604">"Settings"</string>
    <string name="media_route_controller_disconnect" msgid="8966120286374158649">"Disconnect"</string>
    <string name="media_route_status_scanning" msgid="7279908761758293783">"Scanning..."</string>
    <string name="media_route_status_connecting" msgid="6422571716007825440">"Connecting..."</string>
    <string name="media_route_status_available" msgid="6983258067194649391">"Available"</string>
    <string name="media_route_status_not_available" msgid="6739899962681886401">"Not available"</string>
    <string name="media_route_status_in_use" msgid="4533786031090198063">"In use"</string>
    <string name="display_manager_built_in_display_name" msgid="2583134294292563941">"Built-in Screen"</string>
    <string name="display_manager_hdmi_display_name" msgid="1555264559227470109">"HDMI Screen"</string>
    <string name="display_manager_overlay_display_name" msgid="5142365982271620716">"Overlay #<xliff:g id="ID">%1$d</xliff:g>"</string>
    <string name="display_manager_overlay_display_title" msgid="652124517672257172">"<xliff:g id="NAME">%1$s</xliff:g>: <xliff:g id="WIDTH">%2$d</xliff:g>x<xliff:g id="HEIGHT">%3$d</xliff:g>, <xliff:g id="DPI">%4$d</xliff:g> dpi"</string>
    <string name="display_manager_overlay_display_secure_suffix" msgid="6022119702628572080">", secure"</string>
    <!-- no translation found for wifi_display_notification_connecting_title (9102788196896266990) -->
    <skip />
    <!-- no translation found for wifi_display_notification_connecting_message (5837350993752841389) -->
    <skip />
    <!-- no translation found for wifi_display_notification_connected_title (4118323329495921271) -->
    <skip />
    <!-- no translation found for wifi_display_notification_connected_message (2587209325701109715) -->
    <skip />
    <string name="wifi_display_notification_disconnect" msgid="6183754463561153372">"Disconnect"</string>
    <string name="kg_emergency_call_label" msgid="684946192523830531">"Emergency call"</string>
    <string name="kg_forgot_pattern_button_text" msgid="8852021467868220608">"Forgot Pattern"</string>
    <string name="kg_wrong_pattern" msgid="1850806070801358830">"Wrong Pattern"</string>
    <string name="kg_wrong_password" msgid="2333281762128113157">"Wrong Password"</string>
    <string name="kg_wrong_pin" msgid="1131306510833563801">"Wrong PIN"</string>
    <string name="kg_too_many_failed_attempts_countdown" msgid="6358110221603297548">"Try again in <xliff:g id="NUMBER">%1$d</xliff:g> seconds."</string>
    <string name="kg_pattern_instructions" msgid="398978611683075868">"Draw your pattern"</string>
    <string name="kg_sim_pin_instructions" msgid="2319508550934557331">"Enter SIM PIN"</string>
    <string name="kg_pin_instructions" msgid="2377242233495111557">"Enter PIN"</string>
    <string name="kg_password_instructions" msgid="5753646556186936819">"Enter Password"</string>
    <string name="kg_puk_enter_puk_hint" msgid="453227143861735537">"SIM is now disabled. Enter PUK code to continue. Contact carrier for details."</string>
    <string name="kg_puk_enter_pin_hint" msgid="7871604527429602024">"Enter desired PIN code"</string>
    <string name="kg_enter_confirm_pin_hint" msgid="325676184762529976">"Confirm desired PIN code"</string>
    <string name="kg_sim_unlock_progress_dialog_message" msgid="8950398016976865762">"Unlocking SIM card…"</string>
    <string name="kg_password_wrong_pin_code" msgid="1139324887413846912">"Incorrect PIN code."</string>
    <string name="kg_invalid_sim_pin_hint" msgid="8795159358110620001">"Type a PIN that is 4 to 8 numbers."</string>
    <string name="kg_invalid_sim_puk_hint" msgid="7553388325654369575">"PUK code should be 8 numbers or more."</string>
    <string name="kg_invalid_puk" msgid="3638289409676051243">"Re-enter the correct PUK code. Repeated attempts will permanently disable the SIM."</string>
    <string name="kg_invalid_confirm_pin_hint" product="default" msgid="7003469261464593516">"PIN codes do not match"</string>
    <string name="kg_login_too_many_attempts" msgid="6486842094005698475">"Too many pattern attempts"</string>
    <string name="kg_login_instructions" msgid="1100551261265506448">"To unlock, sign in with your Google account."</string>
    <string name="kg_login_username_hint" msgid="5718534272070920364">"Username (email)"</string>
    <string name="kg_login_password_hint" msgid="9057289103827298549">"Password"</string>
    <string name="kg_login_submit_button" msgid="5355904582674054702">"Sign in"</string>
    <string name="kg_login_invalid_input" msgid="5754664119319872197">"Invalid username or password."</string>
    <string name="kg_login_account_recovery_hint" msgid="5690709132841752974">"Forgot your username or password?\nVisit "<b>"google.com/accounts/recovery"</b>"."</string>
    <string name="kg_login_checking_password" msgid="1052685197710252395">"Checking account…"</string>
    <string name="kg_too_many_failed_pin_attempts_dialog_message" msgid="8276745642049502550">"You have incorrectly typed your PIN <xliff:g id="NUMBER_0">%d</xliff:g> times. \n\nTry again in <xliff:g id="NUMBER_1">%d</xliff:g> seconds."</string>
    <string name="kg_too_many_failed_password_attempts_dialog_message" msgid="7813713389422226531">"You have incorrectly typed your password <xliff:g id="NUMBER_0">%d</xliff:g> times. \n\nTry again in <xliff:g id="NUMBER_1">%d</xliff:g> seconds."</string>
    <string name="kg_too_many_failed_pattern_attempts_dialog_message" msgid="74089475965050805">"You have incorrectly drawn your unlock pattern <xliff:g id="NUMBER_0">%d</xliff:g> times. \n\nTry again in <xliff:g id="NUMBER_1">%d</xliff:g> seconds."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="tablet" msgid="1575557200627128949">"You have incorrectly attempted to unlock the tablet <xliff:g id="NUMBER_0">%d</xliff:g> times. After <xliff:g id="NUMBER_1">%d</xliff:g> more unsuccessful attempts, the tablet will be reset to factory default and all user data will be lost."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="default" msgid="4051015943038199910">"You have incorrectly attempted to unlock the phone <xliff:g id="NUMBER_0">%d</xliff:g> times. After <xliff:g id="NUMBER_1">%d</xliff:g> more unsuccessful attempts, the phone will be reset to factory default and all user data will be lost."</string>
    <string name="kg_failed_attempts_now_wiping" product="tablet" msgid="2072996269148483637">"You have incorrectly attempted to unlock the tablet <xliff:g id="NUMBER">%d</xliff:g> times. The tablet will now be reset to factory default."</string>
    <string name="kg_failed_attempts_now_wiping" product="default" msgid="4817627474419471518">"You have incorrectly attempted to unlock the phone <xliff:g id="NUMBER">%d</xliff:g> times. The phone will now be reset to factory default."</string>
    <string name="kg_failed_attempts_almost_at_login" product="tablet" msgid="3253575572118914370">"You have incorrectly drawn your unlock pattern <xliff:g id="NUMBER_0">%d</xliff:g> times. After <xliff:g id="NUMBER_1">%d</xliff:g> more unsuccessful attempts, you will be asked to unlock your tablet using an email account.\n\n Try again in <xliff:g id="NUMBER_2">%d</xliff:g> seconds."</string>
    <string name="kg_failed_attempts_almost_at_login" product="default" msgid="1437638152015574839">"You have incorrectly drawn your unlock pattern <xliff:g id="NUMBER_0">%d</xliff:g> times. After <xliff:g id="NUMBER_1">%d</xliff:g> more unsuccessful attempts, you will be asked to unlock your phone using an email account.\n\n Try again in <xliff:g id="NUMBER_2">%d</xliff:g> seconds."</string>
    <string name="kg_text_message_separator" product="default" msgid="4160700433287233771">" — "</string>
    <string name="kg_reordering_delete_drop_target_text" msgid="7899202978204438708">"Remove"</string>
    <string name="safe_media_volume_warning" product="default" msgid="7324161939475478066">"Raise volume above recommended level?\nListening at high volume for long periods may damage your hearing."</string>
    <string name="continue_to_enable_accessibility" msgid="1626427372316070258">"Keep holding down two fingers to enable accessibility."</string>
    <string name="accessibility_enabled" msgid="1381972048564547685">"Accessibility enabled."</string>
    <string name="enable_accessibility_canceled" msgid="3833923257966635673">"Accessibility cancelled."</string>
    <string name="user_switched" msgid="3768006783166984410">"Current user <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="owner_name" msgid="2716755460376028154">"Owner"</string>
    <string name="error_message_title" msgid="4510373083082500195">"Error"</string>
    <string name="app_no_restricted_accounts" msgid="5739463249673727736">"This app doesn\'t support accounts for restricted profiles"</string>
    <string name="app_not_found" msgid="3429141853498927379">"No application found to handle this action"</string>
    <string name="revoke" msgid="5404479185228271586">"Revoke"</string>
    <string name="mediasize_iso_a0" msgid="1994474252931294172">"ISO A0"</string>
    <string name="mediasize_iso_a1" msgid="3333060421529791786">"ISO A1"</string>
    <string name="mediasize_iso_a2" msgid="3097535991925798280">"ISO A2"</string>
    <string name="mediasize_iso_a3" msgid="3023213259314236123">"ISO A3"</string>
    <string name="mediasize_iso_a4" msgid="231745325296873764">"ISO A4"</string>
    <string name="mediasize_iso_a5" msgid="3484327407340865411">"ISO A5"</string>
    <string name="mediasize_iso_a6" msgid="4861908487129577530">"ISO A6"</string>
    <string name="mediasize_iso_a7" msgid="5890208588072936130">"ISO A7"</string>
    <string name="mediasize_iso_a8" msgid="4319425041085816612">"ISO A8"</string>
    <string name="mediasize_iso_a9" msgid="4882220529506432008">"ISO A9"</string>
    <string name="mediasize_iso_a10" msgid="2382866026365359391">"ISO A10"</string>
    <string name="mediasize_iso_b0" msgid="3651827147402009675">"ISO B0"</string>
    <string name="mediasize_iso_b1" msgid="6072859628278739957">"ISO B1"</string>
    <string name="mediasize_iso_b2" msgid="1348731852150380378">"ISO B2"</string>
    <string name="mediasize_iso_b3" msgid="2612510181259261379">"ISO B3"</string>
    <string name="mediasize_iso_b4" msgid="695151378838115434">"ISO B4"</string>
    <string name="mediasize_iso_b5" msgid="4863754285582212487">"ISO B5"</string>
    <string name="mediasize_iso_b6" msgid="5305816292139647241">"ISO B6"</string>
    <string name="mediasize_iso_b7" msgid="531673542602786624">"ISO B7"</string>
    <string name="mediasize_iso_b8" msgid="9164474595708850034">"ISO B8"</string>
    <string name="mediasize_iso_b9" msgid="282102976764774160">"ISO B9"</string>
    <string name="mediasize_iso_b10" msgid="4517141714407898976">"ISO B10"</string>
    <string name="mediasize_iso_c0" msgid="3103521357901591100">"ISO C0"</string>
    <string name="mediasize_iso_c1" msgid="1231954105985048595">"ISO C1"</string>
    <string name="mediasize_iso_c2" msgid="927702816980087462">"ISO C2"</string>
    <string name="mediasize_iso_c3" msgid="835154173518304159">"ISO C3"</string>
    <string name="mediasize_iso_c4" msgid="5095951985108194011">"ISO C4"</string>
    <string name="mediasize_iso_c5" msgid="1985397450332305739">"ISO C5"</string>
    <string name="mediasize_iso_c6" msgid="8147421924174693013">"ISO C6"</string>
    <string name="mediasize_iso_c7" msgid="8993994925276122950">"ISO C7"</string>
    <string name="mediasize_iso_c8" msgid="6871178104139598957">"ISO C8"</string>
    <string name="mediasize_iso_c9" msgid="7983532635227561362">"ISO C9"</string>
    <string name="mediasize_iso_c10" msgid="5040764293406765584">"ISO C10"</string>
    <string name="mediasize_na_letter" msgid="2841414839888344296">"Letter"</string>
    <string name="mediasize_na_gvrnmt_letter" msgid="5295836838862962809">"Government Letter"</string>
    <string name="mediasize_na_legal" msgid="8621364037680465666">"Legal"</string>
    <string name="mediasize_na_junior_legal" msgid="3309324162155085904">"Junior Legal"</string>
    <string name="mediasize_na_ledger" msgid="5567030340509075333">"Ledger"</string>
    <string name="mediasize_na_tabloid" msgid="4571735038501661757">"Tabloid"</string>
    <string name="mediasize_na_index_3x5" msgid="5182901917818625126">"Index Card 3 x 5"</string>
    <string name="mediasize_na_index_4x6" msgid="7687620625422312396">"Index Card 4 x 6"</string>
    <string name="mediasize_na_index_5x8" msgid="8834215284646872800">"Index Card 5 x 8"</string>
    <string name="mediasize_na_monarch" msgid="213639906956550754">"Monarch"</string>
    <string name="mediasize_na_quarto" msgid="835778493593023223">"Quarto"</string>
    <string name="mediasize_na_foolscap" msgid="1573911237983677138">"Foolscap"</string>
    <string name="mediasize_chinese_roc_8k" msgid="3626855847189438896">"ROC 8K"</string>
    <string name="mediasize_chinese_roc_16k" msgid="9182191577022943355">"ROC 16K"</string>
    <string name="mediasize_chinese_prc_1" msgid="4793232644980170500">"PRC 1"</string>
    <string name="mediasize_chinese_prc_2" msgid="5404109730975720670">"PRC 2"</string>
    <string name="mediasize_chinese_prc_3" msgid="1335092253339363526">"PRC 3"</string>
    <string name="mediasize_chinese_prc_4" msgid="9167997800486569834">"PRC 4"</string>
    <string name="mediasize_chinese_prc_5" msgid="845875168823541497">"PRC 5"</string>
    <string name="mediasize_chinese_prc_6" msgid="3220325667692648789">"PRC 6"</string>
    <string name="mediasize_chinese_prc_7" msgid="1776792138507038527">"PRC 7"</string>
    <string name="mediasize_chinese_prc_8" msgid="1417176642687456692">"PRC 8"</string>
    <string name="mediasize_chinese_prc_9" msgid="4785983473123798365">"PRC 9"</string>
    <string name="mediasize_chinese_prc_10" msgid="7847982299391851899">"PRC 10"</string>
    <string name="mediasize_chinese_prc_16k" msgid="262793383539980677">"PRC 16K"</string>
    <string name="mediasize_chinese_om_pa_kai" msgid="5256815579447959814">"Pa Kai"</string>
    <string name="mediasize_chinese_om_dai_pa_kai" msgid="7336412963441354407">"Dai Pa Kai"</string>
    <string name="mediasize_chinese_om_jurro_ku_kai" msgid="6324465444100490742">"Jurro Ku Kai"</string>
    <string name="mediasize_japanese_jis_b10" msgid="1787262845627694376">"JIS B10"</string>
    <string name="mediasize_japanese_jis_b9" msgid="3336035783663287470">"JIS B9"</string>
    <string name="mediasize_japanese_jis_b8" msgid="6195398299104345731">"JIS B8"</string>
    <string name="mediasize_japanese_jis_b7" msgid="1674621886902828884">"JIS B7"</string>
    <string name="mediasize_japanese_jis_b6" msgid="4170576286062657435">"JIS B6"</string>
    <string name="mediasize_japanese_jis_b5" msgid="4899297958100032533">"JIS B5"</string>
    <string name="mediasize_japanese_jis_b4" msgid="4213158129126666847">"JIS B4"</string>
    <string name="mediasize_japanese_jis_b3" msgid="8513715307410310696">"JIS B3"</string>
    <string name="mediasize_japanese_jis_b2" msgid="4777690211897131190">"JIS B2"</string>
    <string name="mediasize_japanese_jis_b1" msgid="4608142385457034603">"JIS B1"</string>
    <string name="mediasize_japanese_jis_b0" msgid="7587108366572243991">"JIS B0"</string>
    <string name="mediasize_japanese_jis_exec" msgid="5244075432263649068">"JIS Exec"</string>
    <string name="mediasize_japanese_chou4" msgid="4941652015032631361">"Chou4"</string>
    <string name="mediasize_japanese_chou3" msgid="6387319169263957010">"Chou3"</string>
    <string name="mediasize_japanese_chou2" msgid="1299112025415343982">"Chou2"</string>
    <string name="mediasize_japanese_hagaki" msgid="8070115620644254565">"Hagaki"</string>
    <string name="mediasize_japanese_oufuku" msgid="6049065587307896564">"Oufuku"</string>
    <string name="mediasize_japanese_kahu" msgid="6872696027560065173">"Kahu"</string>
    <string name="mediasize_japanese_kaku2" msgid="2359077233775455405">"Kaku2"</string>
    <string name="mediasize_japanese_you4" msgid="2091777168747058008">"You4"</string>
    <string name="mediasize_unknown_portrait" msgid="3088043641616409762">"Unknown portrait"</string>
    <string name="mediasize_unknown_landscape" msgid="4876995327029361552">"Unknown landscape"</string>
    <string name="write_fail_reason_cancelled" msgid="7091258378121627624">"Cancelled"</string>
    <string name="write_fail_reason_cannot_write" msgid="8132505417935337724">"Error writing content"</string>
    <string name="reason_unknown" msgid="6048913880184628119">"unknown"</string>
    <string name="reason_service_unavailable" msgid="7824008732243903268">"Print service not enabled"</string>
    <string name="print_service_installed_title" msgid="2246317169444081628">"<xliff:g id="NAME">%s</xliff:g> service installed"</string>
    <string name="print_service_installed_message" msgid="5897362931070459152">"Tap to enable"</string>
    <string name="restr_pin_enter_admin_pin" msgid="783643731895143970">"Enter administrator PIN"</string>
    <string name="restr_pin_enter_pin" msgid="3395953421368476103">"Enter PIN"</string>
    <string name="restr_pin_incorrect" msgid="8571512003955077924">"Incorrect"</string>
    <string name="restr_pin_enter_old_pin" msgid="1462206225512910757">"Current PIN:"</string>
    <string name="restr_pin_enter_new_pin" msgid="5959606691619959184">"New PIN"</string>
    <string name="restr_pin_confirm_pin" msgid="8501523829633146239">"Confirm new PIN"</string>
    <string name="restr_pin_create_pin" msgid="8017600000263450337">"Create a PIN for modifying restrictions"</string>
    <string name="restr_pin_error_doesnt_match" msgid="2224214190906994548">"PINs don\'t match. Try again."</string>
    <string name="restr_pin_error_too_short" msgid="8173982756265777792">"PIN is too short. Must be at least 4 digits."</string>
  <plurals name="restr_pin_countdown">
    <item quantity="one" msgid="311050995198548675">"Try again in 1 second"</item>
    <item quantity="other" msgid="4730868920742952817">"Try again in <xliff:g id="COUNT">%d</xliff:g> seconds"</item>
  </plurals>
    <string name="restr_pin_try_later" msgid="973144472490532377">"Try again later"</string>
    <string name="immersive_mode_confirmation" msgid="7227416894979047467">"Swipe down from the top to exit full screen."</string>
</resources>
