<?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;Zonder titel&gt;"</string>
    <string name="ellipsis" msgid="7899829516048813237">"…"</string>
    <string name="ellipsis_two_dots" msgid="1228078994866030736">"‥"</string>
    <string name="emptyPhoneNumber" msgid="7694063042079676517">"(Geen telefoonnummer)"</string>
    <string name="unknownName" msgid="2277556546742746522">"(Onbekend)"</string>
    <string name="defaultVoiceMailAlphaTag" msgid="2660020990097733077">"Voicemail"</string>
    <string name="defaultMsisdnAlphaTag" msgid="2850889754919584674">"MSISDN1"</string>
    <string name="mmiError" msgid="5154499457739052907">"Verbindingsprobleem of ongeldige MMI-code."</string>
    <string name="mmiFdnError" msgid="5224398216385316471">"Bewerking is beperkt tot vaste nummers."</string>
    <string name="serviceEnabled" msgid="8147278346414714315">"Service is ingeschakeld."</string>
    <string name="serviceEnabledFor" msgid="6856228140453471041">"Service is ingeschakeld voor:"</string>
    <string name="serviceDisabled" msgid="1937553226592516411">"Service is uitgeschakeld."</string>
    <string name="serviceRegistered" msgid="6275019082598102493">"De registratie is voltooid."</string>
    <string name="serviceErased" msgid="1288584695297200972">"Wissen uitgevoerd."</string>
    <string name="passwordIncorrect" msgid="7612208839450128715">"Onjuist wachtwoord."</string>
    <string name="mmiComplete" msgid="8232527495411698359">"MMI voltooid."</string>
    <string name="badPin" msgid="9015277645546710014">"De oude pincode die u heeft ingevoerd, is onjuist."</string>
    <string name="badPuk" msgid="5487257647081132201">"De PUK-code die u heeft ingevoerd, is onjuist."</string>
    <string name="mismatchPin" msgid="609379054496863419">"De pincodes die u heeft ingevoerd, komen niet overeen."</string>
    <string name="invalidPin" msgid="3850018445187475377">"Voer een PIN-code van 4 tot 8 cijfers in."</string>
    <string name="invalidPuk" msgid="8761456210898036513">"Typ een PUK-code die 8 cijfers of langer is."</string>
    <string name="needPuk" msgid="919668385956251611">"Uw SIM-kaart is vergrendeld met de PUK-code. Typ de PUK-code om te ontgrendelen."</string>
    <string name="needPuk2" msgid="4526033371987193070">"Voer de PUK2-code in om de SIM-kaart te ontgrendelen."</string>
    <string name="enablePin" msgid="209412020907207950">"Mislukt. Schakel SIM/RUIM-vergrendeling in."</string>
  <plurals name="pinpuk_attempts">
    <item quantity="one" msgid="6596245285809790142">"U heeft nog <xliff:g id="NUMBER">%d</xliff:g> poging over voordat de simkaart wordt vergrendeld."</item>
    <item quantity="other" msgid="7530597808358774740">"U heeft nog <xliff:g id="NUMBER">%d</xliff:g> pogingen over voordat de simkaart wordt vergrendeld."</item>
  </plurals>
    <string name="imei" msgid="2625429890869005782">"IMEI"</string>
    <string name="meid" msgid="4841221237681254195">"MEID"</string>
    <string name="ClipMmi" msgid="6952821216480289285">"Inkomende beller-id"</string>
    <string name="ClirMmi" msgid="7784673673446833091">"Uitgaande beller-id"</string>
    <string name="CfMmi" msgid="5123218989141573515">"Oproep doorschakelen"</string>
    <string name="CwMmi" msgid="9129678056795016867">"Wisselgesprek"</string>
    <string name="BaMmi" msgid="455193067926770581">"Oproep blokkeren"</string>
    <string name="PwdMmi" msgid="7043715687905254199">"Wachtwoordwijziging"</string>
    <string name="PinMmi" msgid="3113117780361190304">"PIN-wijziging"</string>
    <string name="CnipMmi" msgid="3110534680557857162">"Nummer van beller beschikbaar"</string>
    <string name="CnirMmi" msgid="3062102121430548731">"Nummer van beller beperkt"</string>
    <string name="ThreeWCMmi" msgid="9051047170321190368">"Driewegs bellen"</string>
    <string name="RuacMmi" msgid="7827887459138308886">"Ongewenste, vervelende oproepen weigeren"</string>
    <string name="CndMmi" msgid="3116446237081575808">"Weergave van nummer van beller"</string>
    <string name="DndMmi" msgid="1265478932418334331">"Niet storen"</string>
    <string name="CLIRDefaultOnNextCallOn" msgid="429415409145781923">"Beller-id standaard ingesteld op \'beperkt\'. Volgende oproep: beperkt."</string>
    <string name="CLIRDefaultOnNextCallOff" msgid="3092918006077864624">"Beller-id standaard ingesteld op \'beperkt\'. Volgende oproep: onbeperkt."</string>
    <string name="CLIRDefaultOffNextCallOn" msgid="6179425182856418465">"Beller-id standaard ingesteld op \'onbeperkt\'. Volgende oproep: beperkt."</string>
    <string name="CLIRDefaultOffNextCallOff" msgid="2567998633124408552">"Beller-id standaard ingesteld op \'onbeperkt\'. Volgende oproep: onbeperkt."</string>
    <string name="serviceNotProvisioned" msgid="8614830180508686666">"Service niet voorzien."</string>
    <string name="CLIRPermanent" msgid="3377371145926835671">"U kunt de instelling voor de beller-id niet wijzigen."</string>
    <string name="RestrictedChangedTitle" msgid="5592189398956187498">"Beperkte toegang gewijzigd"</string>
    <string name="RestrictedOnData" msgid="8653794784690065540">"Gegevensservice is geblokkeerd."</string>
    <string name="RestrictedOnEmergency" msgid="6581163779072833665">"Alarmservice is geblokkeerd."</string>
    <string name="RestrictedOnNormal" msgid="4953867011389750673">"Spraakservice is geblokkeerd."</string>
    <string name="RestrictedOnAllVoice" msgid="3396963652108151260">"Alle spraakservices zijn geblokkeerd."</string>
    <string name="RestrictedOnSms" msgid="8314352327461638897">"SMS-service is geblokkeerd."</string>
    <string name="RestrictedOnVoiceData" msgid="996636487106171320">"Spraak-/gegevensservices zijn geblokkeerd."</string>
    <string name="RestrictedOnVoiceSms" msgid="1888588152792023873">"Spraak-/SMS-services zijn geblokkeerd."</string>
    <string name="RestrictedOnAll" msgid="5643028264466092821">"Alle spraak-/gegevens-/SMS-services zijn geblokkeerd."</string>
    <string name="serviceClassVoice" msgid="1258393812335258019">"Spraak"</string>
    <string name="serviceClassData" msgid="872456782077937893">"Gegevens"</string>
    <string name="serviceClassFAX" msgid="5566624998840486475">"FAX"</string>
    <string name="serviceClassSMS" msgid="2015460373701527489">"SMS"</string>
    <string name="serviceClassDataAsync" msgid="4523454783498551468">"Asynchroon"</string>
    <string name="serviceClassDataSync" msgid="7530000519646054776">"Synchroniseren"</string>
    <string name="serviceClassPacket" msgid="6991006557993423453">"Pakket"</string>
    <string name="serviceClassPAD" msgid="3235259085648271037">"PAD"</string>
    <string name="roamingText0" msgid="7170335472198694945">"Roamingaanduiding aan"</string>
    <string name="roamingText1" msgid="5314861519752538922">"Roamingaanduiding uit"</string>
    <string name="roamingText2" msgid="8969929049081268115">"Roamingaanduiding knippert"</string>
    <string name="roamingText3" msgid="5148255027043943317">"Uit de buurt"</string>
    <string name="roamingText4" msgid="8808456682550796530">"Buiten het gebouw"</string>
    <string name="roamingText5" msgid="7604063252850354350">"Roaming - Voorkeurssysteem"</string>
    <string name="roamingText6" msgid="2059440825782871513">"Roaming - Beschikbaar systeem"</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 - Volledige servicefunctionaliteit"</string>
    <string name="roamingText10" msgid="3992906999815316417">"Roaming - Gedeeltelijke servicefunctionaliteit"</string>
    <string name="roamingText11" msgid="4154476854426920970">"Roamingbanner aan"</string>
    <string name="roamingText12" msgid="1189071119992726320">"Roamingbanner uit"</string>
    <string name="roamingTextSearching" msgid="8360141885972279963">"Service zoeken"</string>
    <string name="cfTemplateNotForwarded" msgid="1683685883841272560">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: niet doorgeschakeld"</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> na <xliff:g id="TIME_DELAY">{2}</xliff:g> seconden"</string>
    <string name="cfTemplateRegistered" msgid="5073237827620166285">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: niet doorgeschakeld"</string>
    <string name="cfTemplateRegisteredTime" msgid="6781621964320635172">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: niet doorgeschakeld"</string>
    <string name="fcComplete" msgid="3118848230966886575">"Functiecode voltooid."</string>
    <string name="fcError" msgid="3327560126588500777">"Verbindingsprobleem of ongeldige functiecode."</string>
    <string name="httpErrorOk" msgid="1191919378083472204">"OK"</string>
    <string name="httpError" msgid="7956392511146698522">"Er is een netwerkfout opgetreden."</string>
    <string name="httpErrorLookup" msgid="4711687456111963163">"Kan de URL niet vinden."</string>
    <string name="httpErrorUnsupportedAuthScheme" msgid="6299980280442076799">"Het schema voor de siteverificatie wordt niet ondersteund."</string>
    <string name="httpErrorAuth" msgid="1435065629438044534">"Kan niet verifiëren."</string>
    <string name="httpErrorProxyAuth" msgid="1788207010559081331">"Verificatie via de proxyserver is mislukt."</string>
    <string name="httpErrorConnect" msgid="8714273236364640549">"Kan geen verbinding maken met de server."</string>
    <string name="httpErrorIO" msgid="2340558197489302188">"Kan niet communiceren met de server. Probeer het later opnieuw."</string>
    <string name="httpErrorTimeout" msgid="4743403703762883954">"Er is een time-out voor de serververbinding opgetreden."</string>
    <string name="httpErrorRedirectLoop" msgid="8679596090392779516">"De pagina bevat te veel serveromleidingen."</string>
    <string name="httpErrorUnsupportedScheme" msgid="5015730812906192208">"Het protocol wordt niet ondersteund."</string>
    <string name="httpErrorFailedSslHandshake" msgid="96549606000658641">"Er kan geen beveiligde verbinding tot stand worden gebracht."</string>
    <string name="httpErrorBadUrl" msgid="3636929722728881972">"De pagina kan niet worden geopend omdat de URL ongeldig is."</string>
    <string name="httpErrorFile" msgid="2170788515052558676">"Kan het bestand niet openen."</string>
    <string name="httpErrorFileNotFound" msgid="6203856612042655084">"Kan het opgevraagde bestand niet vinden."</string>
    <string name="httpErrorTooManyRequests" msgid="1235396927087188253">"Er worden te veel aanvragen verwerkt. Probeer het later opnieuw."</string>
    <string name="notification_title" msgid="8967710025036163822">"Fout bij aanmelding voor \'<xliff:g id="ACCOUNT">%1$s</xliff:g>\'"</string>
    <string name="contentServiceSync" msgid="8353523060269335667">"Synchroniseren"</string>
    <string name="contentServiceSyncNotificationTitle" msgid="397743349191901458">"Synchroniseren"</string>
    <string name="contentServiceTooManyDeletesNotificationDesc" msgid="8100981435080696431">"Te veel verwijderen voor <xliff:g id="CONTENT_TYPE">%s</xliff:g>."</string>
    <string name="low_memory" product="tablet" msgid="6494019234102154896">"Tabletgeheugen is vol. Verwijder enkele bestanden om ruimte vrij te maken."</string>
    <string name="low_memory" product="default" msgid="3475999286680000541">"Telefoongeheugen is vol. Verwijder enkele bestanden om ruimte vrij te maken."</string>
    <string name="ssl_ca_cert_warning" msgid="5848402127455021714">"Netwerk kan worden gecontroleerd"</string>
    <string name="ssl_ca_cert_noti_by_unknown" msgid="4475437862189850602">"Door een onbekende derde partij"</string>
    <string name="ssl_ca_cert_noti_managed" msgid="4030263497686867141">"Door <xliff:g id="MANAGING_DOMAIN">%s</xliff:g>"</string>
    <string name="me" msgid="6545696007631404292">"Ik"</string>
    <string name="power_dialog" product="tablet" msgid="8545351420865202853">"Tabletopties"</string>
    <string name="power_dialog" product="default" msgid="1319919075463988638">"Telefoonopties"</string>
    <string name="silent_mode" msgid="7167703389802618663">"Stille modus"</string>
    <string name="turn_on_radio" msgid="3912793092339962371">"Draadloos inschakelen"</string>
    <string name="turn_off_radio" msgid="8198784949987062346">"Draadloos uitschakelen"</string>
    <string name="screen_lock" msgid="799094655496098153">"Schermvergrendeling"</string>
    <string name="power_off" msgid="4266614107412865048">"Uitschakelen"</string>
    <string name="silent_mode_silent" msgid="319298163018473078">"Belsoftware uit"</string>
    <string name="silent_mode_vibrate" msgid="7072043388581551395">"Belsoftware op trillen"</string>
    <string name="silent_mode_ring" msgid="8592241816194074353">"Belsoftware aan"</string>
    <string name="shutdown_progress" msgid="2281079257329981203">"Uitschakelen..."</string>
    <string name="shutdown_confirm" product="tablet" msgid="3385745179555731470">"Uw tablet wordt uitgeschakeld."</string>
    <string name="shutdown_confirm" product="default" msgid="649792175242821353">"Uw telefoon wordt uitgeschakeld."</string>
    <string name="shutdown_confirm_question" msgid="2906544768881136183">"Wilt u afsluiten?"</string>
    <string name="reboot_safemode_title" msgid="7054509914500140361">"Opnieuw opstarten in veilige modus"</string>
    <string name="reboot_safemode_confirm" msgid="55293944502784668">"Wilt u opnieuw opstarten in de veilige modus? Als u dit doet, worden alle geïnstalleerde applicaties van derden uitgeschakeld. Ze worden weer ingeschakeld als u weer opnieuw opstart."</string>
    <string name="recent_tasks_title" msgid="3691764623638127888">"Recent"</string>
    <string name="no_recent_tasks" msgid="8794906658732193473">"Geen recente apps."</string>
    <string name="global_actions" product="tablet" msgid="408477140088053665">"Tabletopties"</string>
    <string name="global_actions" product="default" msgid="2406416831541615258">"Telefoonopties"</string>
    <string name="global_action_lock" msgid="2844945191792119712">"Schermvergrendeling"</string>
    <string name="global_action_power_off" msgid="4471879440839879722">"Uitschakelen"</string>
    <string name="global_action_bug_report" msgid="7934010578922304799">"Foutenrapport"</string>
    <string name="bugreport_title" msgid="2667494803742548533">"Foutenrapport genereren"</string>
    <string name="bugreport_message" msgid="398447048750350456">"Hiermee worden gegevens over de huidige status van uw apparaat verzameld en als e-mail verzonden. Wanneer u een foutenrapport start, duurt het even voordat het kan worden verzonden. Even geduld alstublieft."</string>
    <string name="global_action_toggle_silent_mode" msgid="8219525344246810925">"Stille modus"</string>
    <string name="global_action_silent_mode_on_status" msgid="3289841937003758806">"Geluid is UIT"</string>
    <string name="global_action_silent_mode_off_status" msgid="1506046579177066419">"Geluid is AAN"</string>
    <string name="global_actions_toggle_airplane_mode" msgid="5884330306926307456">"Vliegmodus"</string>
    <string name="global_actions_airplane_mode_on_status" msgid="2719557982608919750">"Vliegmodus is AAN"</string>
    <string name="global_actions_airplane_mode_off_status" msgid="5075070442854490296">"Vliegmodus is UIT"</string>
    <string name="status_bar_notification_info_overflow" msgid="5301981741705354993">"999 +"</string>
    <string name="safeMode" msgid="2788228061547930246">"Veilige modus"</string>
    <string name="android_system_label" msgid="6577375335728551336">"Android-systeem"</string>
    <string name="permgrouplab_costMoney" msgid="5429808217861460401">"Services waarvoor u moet betalen"</string>
    <string name="permgroupdesc_costMoney" msgid="3293301903409869495">"Activiteiten uitvoeren waarvoor kosten in rekening kunnen worden gebracht."</string>
    <string name="permgrouplab_messages" msgid="7521249148445456662">"Uw berichten"</string>
    <string name="permgroupdesc_messages" msgid="7821999071003699236">"Sms, e-mail en andere berichten lezen en schrijven."</string>
    <string name="permgrouplab_personalInfo" msgid="3519163141070533474">"Uw persoonlijke informatie"</string>
    <string name="permgroupdesc_personalInfo" msgid="8426453129788861338">"Rechtstreeks toegang krijgen tot informatie over u die is opgeslagen op uw contactkaart."</string>
    <string name="permgrouplab_socialInfo" msgid="5799096623412043791">"Uw sociale informatie"</string>
    <string name="permgroupdesc_socialInfo" msgid="7129842457611643493">"Rechtstreeks toegang krijgen tot informatie over uw contacten en sociale connecties."</string>
    <string name="permgrouplab_location" msgid="635149742436692049">"Uw locatie"</string>
    <string name="permgroupdesc_location" msgid="5704679763124170100">"Uw fysieke locatie bijhouden."</string>
    <string name="permgrouplab_network" msgid="5808983377727109831">"Netwerkcommunicatie"</string>
    <string name="permgroupdesc_network" msgid="4478299413241861987">"Toegang tot verschillende netwerkfuncties."</string>
    <string name="permgrouplab_bluetoothNetwork" msgid="1585403544162128109">"Bluetooth"</string>
    <string name="permgroupdesc_bluetoothNetwork" msgid="5625288577164282391">"Toegang tot apparaten en netwerken via Bluetooth."</string>
    <string name="permgrouplab_audioSettings" msgid="8329261670151871235">"Audio-instellingen"</string>
    <string name="permgroupdesc_audioSettings" msgid="2641515403347568130">"Audio-instellingen wijzigen."</string>
    <string name="permgrouplab_affectsBattery" msgid="6209246653424798033">"De accu beïnvloeden"</string>
    <string name="permgroupdesc_affectsBattery" msgid="6441275320638916947">"Functies gebruiken waardoor de accu snel leeg kan raken."</string>
    <string name="permgrouplab_calendar" msgid="5863508437783683902">"Agenda"</string>
    <string name="permgroupdesc_calendar" msgid="5777534316982184416">"Rechtstreeks toegang krijgen tot agenda en afspraken."</string>
    <string name="permgrouplab_dictionary" msgid="4148597128843641379">"Gebruikerswoordenboek lezen"</string>
    <string name="permgroupdesc_dictionary" msgid="7921166355964764490">"Woorden lezen in het gebruikerswoordenboek."</string>
    <string name="permgrouplab_writeDictionary" msgid="8090237702432576788">"Gebruikerswoordenboek schrijven"</string>
    <string name="permgroupdesc_writeDictionary" msgid="2711561994497361646">"Woorden toevoegen aan het gebruikerswoordenboek."</string>
    <string name="permgrouplab_bookmarks" msgid="1949519673103968229">"Bladwijzers en geschiedenis"</string>
    <string name="permgroupdesc_bookmarks" msgid="4169771606257963028">"Rechtstreeks toegang krijgen tot bladwijzers en browsergeschiedenis."</string>
    <string name="permgrouplab_deviceAlarms" msgid="6117704629728824101">"Alarm"</string>
    <string name="permgroupdesc_deviceAlarms" msgid="4769356362251641175">"De wekker instellen."</string>
    <string name="permgrouplab_voicemail" msgid="4162237145027592133">"Voicemail"</string>
    <string name="permgroupdesc_voicemail" msgid="2498403969862951393">"Rechtstreeks toegang krijgen tot voicemail."</string>
    <string name="permgrouplab_microphone" msgid="171539900250043464">"Microfoon"</string>
    <string name="permgroupdesc_microphone" msgid="7106618286905738408">"Rechtstreeks toegang krijgen tot de microfoon om geluid op te nemen."</string>
    <string name="permgrouplab_camera" msgid="4820372495894586615">"Camera"</string>
    <string name="permgroupdesc_camera" msgid="2933667372289567714">"Rechtstreeks toegang krijgen tot de camera om afbeeldingen of video\'s vast te leggen."</string>
    <string name="permgrouplab_screenlock" msgid="8275500173330718168">"Scherm vergrendelen"</string>
    <string name="permgroupdesc_screenlock" msgid="7067497128925499401">"Mogelijkheid om de werking van het vergrendelingsscherm op uw apparaat te beïnvloeden."</string>
    <string name="permgrouplab_appInfo" msgid="8028789762634147725">"Informatie over uw applicaties"</string>
    <string name="permgroupdesc_appInfo" msgid="3950378538049625907">"Mogelijkheid om het gedrag van andere applicaties op uw apparaat te beïnvloeden."</string>
    <string name="permgrouplab_wallpaper" msgid="3850280158041175998">"Achtergrond"</string>
    <string name="permgroupdesc_wallpaper" msgid="5630417854750540154">"De achtergrondinstellingen van het apparaat wijzigen."</string>
    <string name="permgrouplab_systemClock" msgid="406535759236612992">"Klok"</string>
    <string name="permgroupdesc_systemClock" msgid="3944359833624094992">"De tijd of tijdzone van het apparaat wijzigen."</string>
    <string name="permgrouplab_statusBar" msgid="2095862568113945398">"Statusbalk"</string>
    <string name="permgroupdesc_statusBar" msgid="6242593432226807171">"De instellingen van de apparaatstatusbalk wijzigen."</string>
    <string name="permgrouplab_syncSettings" msgid="3341990986147826541">"Synchronisatie-instellingen"</string>
    <string name="permgroupdesc_syncSettings" msgid="7603195265129031797">"Toegang krijgen tot de synchronisatie-instellingen."</string>
    <string name="permgrouplab_accounts" msgid="3359646291125325519">"Uw accounts"</string>
    <string name="permgroupdesc_accounts" msgid="4948732641827091312">"Toegang tot de beschikbare accounts."</string>
    <string name="permgrouplab_hardwareControls" msgid="7998214968791599326">"Bedieningselementen hardware"</string>
    <string name="permgroupdesc_hardwareControls" msgid="4357057861225462702">"Rechtstreekse toegang tot hardware op de handset."</string>
    <string name="permgrouplab_phoneCalls" msgid="9067173988325865923">"Telefoonoproepen"</string>
    <string name="permgroupdesc_phoneCalls" msgid="7489701620446183770">"Oproepen bijhouden, registreren en verwerken."</string>
    <string name="permgrouplab_systemTools" msgid="4652191644082714048">"Systeemhulpprogramma\'s"</string>
    <string name="permgroupdesc_systemTools" msgid="8162102602190734305">"Toegang tot en beheer van het systeem op lager niveau."</string>
    <string name="permgrouplab_developmentTools" msgid="3446164584710596513">"Ontwikkelingshulpprogramma\'s"</string>
    <string name="permgroupdesc_developmentTools" msgid="7058828032358142018">"Functies die alleen nodig zijn voor app-ontwikkelaars."</string>
    <string name="permgrouplab_display" msgid="4279909676036402636">"Gebruikersinterface van andere applicaties"</string>
    <string name="permgroupdesc_display" msgid="6051002031933013714">"De gebruikersinterface van andere applicaties beïnvloeden."</string>
    <string name="permgrouplab_storage" msgid="1971118770546336966">"Opslagruimte"</string>
    <string name="permgroupdesc_storage" product="nosdcard" msgid="7442318502446874999">"Toegang krijgen tot USB-opslag."</string>
    <string name="permgroupdesc_storage" product="default" msgid="9203302214915355774">"Toegang tot de SD-kaart."</string>
    <string name="permgrouplab_accessibilityFeatures" msgid="7919025602283593907">"Toegankelijkheidsfuncties"</string>
    <string name="permgroupdesc_accessibilityFeatures" msgid="4205196881678144335">"Functies die kunnen worden aangevraagd door ondersteunende technologie."</string>
    <string name="capability_title_canRetrieveWindowContent" msgid="3901717936930170320">"Inhoud van vensters ophalen"</string>
    <string name="capability_desc_canRetrieveWindowContent" msgid="3772225008605310672">"De inhoud inspecteren van een venster waarmee u interactie heeft."</string>
    <string name="capability_title_canRequestTouchExploration" msgid="3108723364676667320">"Verkennen via aanraking inschakelen"</string>
    <string name="capability_desc_canRequestTouchExploration" msgid="5800552516779249356">"Aangeraakte items worden hardop benoemd en het scherm kan worden verkend door middel van aanraking."</string>
    <string name="capability_title_canRequestEnhancedWebAccessibility" msgid="1739881766522594073">"Verbeterde internettoegankelijkheid inschakelen"</string>
    <string name="capability_desc_canRequestEnhancedWebAccessibility" msgid="7881063961507511765">"Er kunnen scripts worden geïnstalleerd om app-inhoud toegankelijker te maken."</string>
    <string name="capability_title_canRequestFilterKeyEvents" msgid="2103440391902412174">"Tekst observeren die u typt"</string>
    <string name="capability_desc_canRequestFilterKeyEvents" msgid="7463135292204152818">"Omvat persoonlijke gegevens zoals creditcardnummers en wachtwoorden."</string>
    <string name="permlab_statusBar" msgid="7417192629601890791">"statusbalk uitschakelen of wijzigen"</string>
    <string name="permdesc_statusBar" msgid="8434669549504290975">"Hiermee kan de app de statusbalk uitschakelen of systeempictogrammen toevoegen en verwijderen."</string>
    <string name="permlab_statusBarService" msgid="7247281911387931485">"statusbalk"</string>
    <string name="permdesc_statusBarService" msgid="716113660795976060">"Hiermee kan de app de statusbalk zijn."</string>
    <string name="permlab_expandStatusBar" msgid="1148198785937489264">"statusbalk uitvouwen/samenvouwen"</string>
    <string name="permdesc_expandStatusBar" msgid="6917549437129401132">"Hiermee kan de app de statusbalk uitvouwen of samenvouwen."</string>
    <string name="permlab_install_shortcut" msgid="4279070216371564234">"snelkoppelingen installeren"</string>
    <string name="permdesc_install_shortcut" msgid="8341295916286736996">"Een app toestaan snelkoppelingen aan het startscherm toe te voegen zonder tussenkomst van de gebruiker."</string>
    <string name="permlab_uninstall_shortcut" msgid="4729634524044003699">"snelkoppelingen verwijderen"</string>
    <string name="permdesc_uninstall_shortcut" msgid="6745743474265057975">"De app toestaan snelkoppelingen van het startscherm te verwijderen zonder tussenkomst van de gebruiker."</string>
    <string name="permlab_processOutgoingCalls" msgid="3906007831192990946">"uitgaande oproepen doorschakelen"</string>
    <string name="permdesc_processOutgoingCalls" msgid="5331318931937402040">"Hiermee kan de app uitgaande oproepen verwerken en het nummer wijzigen dat wordt gebeld. De app kan uitgaande oproepen bijhouden, omleiden of blokkeren."</string>
    <string name="permlab_receiveSms" msgid="8673471768947895082">"tekstberichten (SMS) ontvangen"</string>
    <string name="permdesc_receiveSms" msgid="6424387754228766939">"Hiermee kan de app sms-berichten ontvangen en verwerken. Dit betekent dat de app berichten die naar uw apparaat zijn verzonden, kan bijhouden of verwijderen zonder deze aan u weer te geven."</string>
    <string name="permlab_receiveMms" msgid="1821317344668257098">"tekstberichten (MMS) ontvangen"</string>
    <string name="permdesc_receiveMms" msgid="533019437263212260">"Hiermee kan de app MMS-berichten ontvangen en verwerken. Dit betekent dat de app berichten die naar uw apparaat zijn verzonden, kan bijhouden of verwijderen zonder deze aan u weer te geven."</string>
    <string name="permlab_receiveEmergencyBroadcast" msgid="1803477660846288089">"noodberichten ontvangen"</string>
    <string name="permdesc_receiveEmergencyBroadcast" msgid="848524070262431974">"Hiermee kan de app berichten over noodsituaties ontvangen en verwerken. Deze rechten zijn alleen beschikbaar voor systeemapps."</string>
    <string name="permlab_readCellBroadcasts" msgid="1598328843619646166">"infodienstberichten lezen"</string>
    <string name="permdesc_readCellBroadcasts" msgid="6361972776080458979">"Toestaan dat de app infodienstberichten leest die worden ontvangen op uw apparaat. Infodienstberichten worden verzonden naar bepaalde locaties om u te waarschuwen voor noodsituaties. Schadelijke apps kunnen de prestaties of verwerking van uw apparaat verstoren wanneer een infodienstbericht wordt ontvangen."</string>
    <string name="permlab_sendSms" msgid="5600830612147671529">"SMS-berichten verzenden"</string>
    <string name="permdesc_sendSms" msgid="7094729298204937667">"Hiermee kan de app sms-berichten verzenden. Dit kan tot onverwachte kosten leiden. Schadelijke apps kunnen u geld kosten doordat ze zonder uw bevestiging berichten kunnen verzenden."</string>
    <string name="permlab_sendRespondViaMessageRequest" msgid="8713889105305943200">"gebeurtenissen voor reageren-via-berichten verzenden"</string>
    <string name="permdesc_sendRespondViaMessageRequest" msgid="7107648548468778734">"Hiermee kan de app verzoeken verzenden aan andere bericht-apps om gebeurtenissen voor reageren-via-berichten voor inkomende oproepen te verwerken."</string>
    <string name="permlab_readSms" msgid="8745086572213270480">"uw tekstberichten (SMS of MMS) lezen"</string>
    <string name="permdesc_readSms" product="tablet" msgid="2467981548684735522">"Hiermee kan de app sms-berichten lezen die zijn opgeslagen op uw tablet of simkaart. De app kan alle sms-berichten lezen, ongeacht inhoud of vertrouwelijkheid."</string>
    <string name="permdesc_readSms" product="default" msgid="3695967533457240550">"Hiermee kan de app sms-berichten lezen die zijn opgeslagen op uw telefoon of simkaart. De app kan alle sms-berichten lezen, ongeacht inhoud of vertrouwelijkheid."</string>
    <string name="permlab_writeSms" msgid="3216950472636214774">"uw tekstberichten (SMS of MMS) bewerken"</string>
    <string name="permdesc_writeSms" product="tablet" msgid="5160413947794501538">"Hiermee kan de app naar de op uw tablet of simkaart opgeslagen sms\'jes schrijven. Schadelijke apps kunnen uw berichten mogelijk verwijderen."</string>
    <string name="permdesc_writeSms" product="default" msgid="7268668709052328567">"Hiermee kan de app naar de op uw telefoon of simkaart opgeslagen sms\'jes schrijven. Schadelijke apps kunnen uw berichten mogelijk verwijderen."</string>
    <string name="permlab_receiveWapPush" msgid="5991398711936590410">"tekstberichten (WAP) ontvangen"</string>
    <string name="permdesc_receiveWapPush" msgid="748232190220583385">"Hiermee kan de app WAP-berichten ontvangen en verwerken. Dit betekent dat de app berichten die naar uw apparaat zijn verzonden, kan bijhouden of verwijderen zonder deze aan u weer te geven."</string>
    <string name="permlab_getTasks" msgid="6466095396623933906">"actieve apps ophalen"</string>
    <string name="permdesc_getTasks" msgid="7454215995847658102">"Hiermee kan de app informatie ophalen over actieve en recent uitgevoerde taken. Zo kan de app informatie vinden over welke apps op het apparaat worden gebruikt."</string>
    <string name="permlab_interactAcrossUsers" msgid="7114255281944211682">"interactie tussen gebruikers"</string>
    <string name="permdesc_interactAcrossUsers" msgid="364670963623385786">"Hiermee kan de app acties uitvoeren voor verschillende gebruikers van het apparaat. Schadelijke apps kunnen dit gebruiken om de beveiliging tussen gebruikers te schenden."</string>
    <string name="permlab_interactAcrossUsersFull" msgid="2567734285545074105">"volledige toestemming voor interactie tussen gebruikers"</string>
    <string name="permdesc_interactAcrossUsersFull" msgid="376841368395502366">"Hiermee is alle mogelijke interactie tussen gebruikers toegestaan."</string>
    <string name="permlab_manageUsers" msgid="1676150911672282428">"gebruikers beheren"</string>
    <string name="permdesc_manageUsers" msgid="8409306667645355638">"Toestaan dat apps gebruikers op het apparaat beheren, inclusief het opvragen van gegevens en het maken en verwijderen van gebruikers."</string>
    <string name="permlab_getDetailedTasks" msgid="6229468674753529501">"details van actieve apps ophalen"</string>
    <string name="permdesc_getDetailedTasks" msgid="153824741440717599">"Hiermee kan de app gedetailleerde informatie over huidige en recent uitgevoerde taken ophalen. Schadelijke apps kunnen op deze manier mogelijk privé-informatie over andere apps achterhalen."</string>
    <string name="permlab_reorderTasks" msgid="2018575526934422779">"actieve apps opnieuw rangschikken"</string>
    <string name="permdesc_reorderTasks" msgid="7734217754877439351">"Hiermee kan de app taken naar de voor- en achtergrond verplaatsen. De app kan dit doen zonder om uw bevestiging te vragen."</string>
    <string name="permlab_removeTasks" msgid="6821513401870377403">"actieve apps stoppen"</string>
    <string name="permdesc_removeTasks" msgid="1394714352062635493">"Hiermee kan de app taken verwijderen en apps sluiten. Schadelijke apps kunnen het gedrag van andere apps verstoren."</string>
    <string name="permlab_manageActivityStacks" msgid="7391191384027303065">"activiteitstacks beheren"</string>
    <string name="permdesc_manageActivityStacks" msgid="1615881933034084440">"Hiermee kan de app de activiteitstacks waarin andere apps worden uitgevoerd, toevoegen, verwijderen en aanpassen. Schadelijke apps kunnen de werking van andere apps verstoren."</string>
    <string name="permlab_startAnyActivity" msgid="2918768238045206456">"elke activiteit starten"</string>
    <string name="permdesc_startAnyActivity" msgid="997823695343584001">"Toestaan dat de app elke activiteit start, ongeacht rechtenbeveiliging of geëxporteerde status."</string>
    <string name="permlab_setScreenCompatibility" msgid="6975387118861842061">"schermcompatibiliteit instellen"</string>
    <string name="permdesc_setScreenCompatibility" msgid="692043618693917374">"Toestaan dat de app de schermcompatibiliteitsmodus van andere apps beheert. Schadelijke apps kunnen het gedrag van andere apps verstoren."</string>
    <string name="permlab_setDebugApp" msgid="3022107198686584052">"foutopsporing in apps inschakelen"</string>
    <string name="permdesc_setDebugApp" msgid="4474512416299013256">"Hiermee kan de app de foutopsporing voor een andere app inschakelen. Schadelijke apps kunnen dit gebruiken om andere apps af te sluiten."</string>
    <string name="permlab_changeConfiguration" msgid="4162092185124234480">"weergave-instellingen voor systeem wijzigen"</string>
    <string name="permdesc_changeConfiguration" msgid="4372223873154296076">"Hiermee kan de app de huidige configuratie wijzigen, zoals de landinstelling of de algemene lettergrootte."</string>
    <string name="permlab_enableCarMode" msgid="5684504058192921098">"automodus inschakelen"</string>
    <string name="permdesc_enableCarMode" msgid="4853187425751419467">"Hiermee kan de app de automodus inschakelen."</string>
    <string name="permlab_killBackgroundProcesses" msgid="3914026687420177202">"andere apps sluiten"</string>
    <string name="permdesc_killBackgroundProcesses" msgid="4593353235959733119">"Hiermee kan de app achtergrondprocessen van andere apps beëindigen. Hierdoor kunnen andere apps worden gestopt."</string>
    <string name="permlab_forceStopPackages" msgid="2329627428832067700">"andere apps gedwongen stoppen"</string>
    <string name="permdesc_forceStopPackages" msgid="5253157296183940812">"Hiermee kan de app andere apps stoppen."</string>
    <string name="permlab_forceBack" msgid="652935204072584616">"app gedwongen stoppen"</string>
    <string name="permdesc_forceBack" msgid="3892295830419513623">"Hiermee kan de app elke willekeurige activiteit die op de voorgrond wordt uitgevoerd, sluiten en naar de achtergrond verplaatsen. Nooit vereist voor normale apps."</string>
    <string name="permlab_dump" msgid="1681799862438954752">"interne systeemstatus ophalen"</string>
    <string name="permdesc_dump" msgid="1778299088692290329">"Hiermee kan de app de interne systeemstatus ophalen. Schadelijke apps kunnen een grote hoeveelheid persoonlijke en beveiligde informatie ophalen die ze normaal gesproken nooit nodig hebben."</string>
    <string name="permlab_retrieve_window_content" msgid="8022588608994589938">"scherminhoud ophalen"</string>
    <string name="permdesc_retrieve_window_content" msgid="3193269069469700265">"Hiermee kan de app de inhoud van het actieve venster ophalen. Schadelijke apps kunnen de volledige inhoud van het venster ophalen en alle tekst bekijken, behalve wachtwoorden."</string>
    <string name="permlab_temporary_enable_accessibility" msgid="2312612135127310254">"toegankelijkheid tijdelijk inschakelen"</string>
    <string name="permdesc_temporary_enable_accessibility" msgid="8079456293182975464">"Een app toestaan toegankelijkheid tijdelijk in te schakelen op het apparaat. Schadelijke apps kunnen toegankelijkheid inschakelen zonder toestemming van de gebruiker."</string>
    <string name="permlab_retrieve_window_info" msgid="8532295199112519378">"venstergegevens ophalen"</string>
    <string name="permdesc_retrieve_window_info" msgid="4998836370424186849">"Toestaan dat een app gegevens over vensters kan ophalen uit vensterbeheer. Schadelijke apps kunnen gegevens ophalen die zijn bedoeld voor interne systeemfunctionaliteit."</string>
    <string name="permlab_filter_events" msgid="8675535648807427389">"evenementen filteren"</string>
    <string name="permdesc_filter_events" msgid="8006236315888347680">"Toestaan dat een app een invoerfilter registreert waarmee de streams van alle gebruikersgebeurtenissen worden gefilterd voordat deze worden verzonden. Schadelijke apps kunnen de gebruikersinterface van het systeem beheren zonder tussenkomst van de gebruiker."</string>
    <string name="permlab_magnify_display" msgid="5973626738170618775">"display vergroten"</string>
    <string name="permdesc_magnify_display" msgid="7121235684515003792">"Een app toestaan de inhoud van een display te vergroten. Schadelijke apps kunnen de display-inhoud transformeren op een manier waardoor het apparaat onbruikbaar wordt."</string>
    <string name="permlab_shutdown" msgid="7185747824038909016">"gedeeltelijke uitschakeling"</string>
    <string name="permdesc_shutdown" msgid="7046500838746291775">"Hiermee wordt activiteitenbeheer uitgeschakeld. Er wordt geen volledige uitschakeling uitgevoerd."</string>
    <string name="permlab_stopAppSwitches" msgid="4138608610717425573">"schakelen tussen apps voorkomen"</string>
    <string name="permdesc_stopAppSwitches" msgid="8262195802582255021">"Hiermee wordt voorkomen dat de gebruiker overschakelt naar een andere app."</string>
    <string name="permlab_getTopActivityInfo" msgid="2537922311411546016">"huidige appgegevens ophalen"</string>
    <string name="permdesc_getTopActivityInfo" msgid="2512448855496067131">"De houder kan hiermee persoonlijke gegevens ophalen over de applicatie die momenteel op de voorgrond wordt weergegeven."</string>
    <string name="permlab_runSetActivityWatcher" msgid="892239094867182656">"alle startende apps bijhouden en beheren"</string>
    <string name="permdesc_runSetActivityWatcher" msgid="6003603162578577406">"Hiermee kan de app de manier bijhouden en beheren waarop het systeem activiteiten start. Schadelijke apps kunnen het systeem volledig in gevaar brengen. Deze machtiging is alleen voor ontwikkeling vereist, nooit voor normaal gebruik."</string>
    <string name="permlab_broadcastPackageRemoved" msgid="2576333434893532475">"melding verzenden dat pakket is verwijderd"</string>
    <string name="permdesc_broadcastPackageRemoved" msgid="6621901216207931089">"Hiermee kan de app een melding verzenden dat een app-pakket is verwijderd. Schadelijke apps kunnen dit gebruiken om andere actieve apps af te sluiten."</string>
    <string name="permlab_broadcastSmsReceived" msgid="5689095009030336593">"melding over ontvangen SMS-bericht verzenden"</string>
    <string name="permdesc_broadcastSmsReceived" msgid="4152037720034365492">"Hiermee kan de app een melding verzenden dat een sms\'je is ontvangen. Schadelijke apps kunnen dit gebruiken om inkomende sms\'jes te vervalsen."</string>
    <string name="permlab_broadcastWapPush" msgid="3145347413028582371">"melding over ontvangen WAP-PUSH-bericht verzenden"</string>
    <string name="permdesc_broadcastWapPush" msgid="4783402525039442729">"Hiermee kan de app een melding verzenden dat een WAP PUSH-bericht is ontvangen. Schadelijke apps kunnen dit gebruiken om de ontvangst van MMS-berichten te vervalsen of de inhoud van een webpagina ongemerkt te vervangen door schadelijke varianten."</string>
    <string name="permlab_setProcessLimit" msgid="2451873664363662666">"aantal actieve processen beperken"</string>
    <string name="permdesc_setProcessLimit" msgid="7318061314040879542">"Hiermee kan de app het maximale aantal processen beheren dat kan worden uitgevoerd. Nooit nodig voor normale apps."</string>
    <string name="permlab_setAlwaysFinish" msgid="550958507798796965">"achtergrondapps gedwongen stoppen"</string>
    <string name="permdesc_setAlwaysFinish" msgid="7471310652868841499">"Hiermee kan de app bepalen of activiteiten worden afgerond zodra ze naar de achtergrond worden verplaatst. Dit is nooit nodig voor normale apps."</string>
    <string name="permlab_batteryStats" msgid="2789610673514103364">"accustatistieken lezen"</string>
    <string name="permdesc_batteryStats" msgid="5897346582882915114">"Hiermee kan de app het huidige accugebruik voor gegevens op laag niveau lezen. Een app kan hierdoor mogelijk gedetailleerde informatie achterhalen over de door u gebruikte apps."</string>
    <string name="permlab_updateBatteryStats" msgid="3719689764536379557">"accustatistieken aanpassen"</string>
    <string name="permdesc_updateBatteryStats" msgid="6862817857178025002">"Hiermee kan de app verzamelde accustatistieken wijzigen. Niet voor gebruik door normale apps."</string>
    <string name="permlab_getAppOpsStats" msgid="1508779687436585744">"bewerkingsstatistieken van apps ophalen"</string>
    <string name="permdesc_getAppOpsStats" msgid="6243887041577912877">"Hiermee kan de app verzamelde bewerkingsstatistieken van apps ophalen. Niet voor gebruik door normale apps."</string>
    <string name="permlab_updateAppOpsStats" msgid="8829097373851521505">"bewerkingsstatistieken van apps wijzigen"</string>
    <string name="permdesc_updateAppOpsStats" msgid="50784596594403483">"Hiermee kan de app verzamelde bewerkingsstatistieken van apps wijzigen. Niet voor gebruik door normale apps."</string>
    <string name="permlab_backup" msgid="470013022865453920">"systeemback-up en -herstel beheren"</string>
    <string name="permdesc_backup" msgid="6912230525140589891">"Hiermee kan de app het beheer van het mechanisme voor systeemback-up en -herstel beheren. Niet voor gebruik door normale apps."</string>
    <string name="permlab_confirm_full_backup" msgid="5557071325804469102">"een volledige back-up- of herstelbewerking bevestigen"</string>
    <string name="permdesc_confirm_full_backup" msgid="1748762171637699562">"Hiermee kan de app de gebruikersinterface voor bevestiging van de volledige back-up starten. Mag door geen enkele app worden gebruikt."</string>
    <string name="permlab_internalSystemWindow" msgid="2148563628140193231">"niet-geautoriseerde vensters weergeven"</string>
    <string name="permdesc_internalSystemWindow" msgid="7458387759461466397">"Hiermee kan de app vensters maken die door de interne systeemgebruikersinterface worden gebruikt. Niet voor gebruik door normale apps."</string>
    <string name="permlab_systemAlertWindow" msgid="3543347980839518613">"weergeven over andere apps"</string>
    <string name="permdesc_systemAlertWindow" msgid="8584678381972820118">"Hiermee kan de app tekenen op andere apps of de gebruikersinterface. De app kan uw gebruik van de interface in alle apps verstoren, of wijzigen wat u in andere apps denkt te zien."</string>
    <string name="permlab_setAnimationScale" msgid="2805103241153907174">"algemene animatiesnelheid wijzigen"</string>
    <string name="permdesc_setAnimationScale" msgid="7690063428924343571">"Hiermee kan de app op elk gewenst moment de algemene animatiesnelheid wijzigen (snellere of tragere animaties)."</string>
    <string name="permlab_manageAppTokens" msgid="1286505717050121370">"app-tokens beheren"</string>
    <string name="permdesc_manageAppTokens" msgid="8043431713014395671">"Hiermee kan de app zelf tokens maken en beheren buiten de normale Z-rangschikking om. Dit is in principe nooit nodig voor normale apps."</string>
    <string name="permlab_freezeScreen" msgid="4708181184441880175">"scherm bevriezen"</string>
    <string name="permdesc_freezeScreen" msgid="8558923789222670064">"De app toestaan het scherm tijdelijk te bevriezen voor een volledige schermovergang."</string>
    <string name="permlab_injectEvents" msgid="1378746584023586600">"drukken op toetsen en bedieningselementen"</string>
    <string name="permdesc_injectEvents" product="tablet" msgid="206352565599968632">"Hiermee kan de app de eigen invoergebeurtenissen (zoals toetsaanslagen) aan andere apps doorgeven. Schadelijke apps kunnen dit gebruiken om de tablet over te nemen."</string>
    <string name="permdesc_injectEvents" product="default" msgid="653128057572326253">"Hiermee kan de app de eigen invoergebeurtenissen (toetsaanslagen, enzovoort) aan andere apps doorgeven. Schadelijke apps kunnen dit gebruiken om de telefoon over te nemen."</string>
    <string name="permlab_readInputState" msgid="469428900041249234">"uw invoer en acties vastleggen"</string>
    <string name="permdesc_readInputState" msgid="8387754901688728043">"Hiermee kan de app bijhouden op welke toetsen u drukt, zelfs wanneer u een andere app gebruikt (bijvoorbeeld wanneer u een wachtwoord typt). Dit is niet nodig voor normale apps."</string>
    <string name="permlab_bindInputMethod" msgid="3360064620230515776">"verbinden aan een invoermethode"</string>
    <string name="permdesc_bindInputMethod" msgid="3250440322807286331">"Hiermee kan de houder zich verbinden met de hoofdinterface van een invoermethode. Nooit vereist voor normale apps."</string>
    <string name="permlab_bindAccessibilityService" msgid="5357733942556031593">"koppelen aan een toegankelijkheidsservice"</string>
    <string name="permdesc_bindAccessibilityService" msgid="7034615928609331368">"Hiermee wordt de houder toegestaan verbinding te maken met de hoofdinterface van een toegankelijkheidsservice. Nooit vereist voor normale apps."</string>
    <string name="permlab_bindPrintService" msgid="8462815179572748761">"koppelen aan een afdrukservice"</string>
    <string name="permdesc_bindPrintService" msgid="7960067623209111135">"Hiermee kan de houder verbinding maken met de hoofdinterface van een afdrukservice. Nooit vereist voor normale apps."</string>
    <string name="permlab_bindPrintSpoolerService" msgid="6807762783744125954">"koppelen aan een afdrukspoolerservice"</string>
    <string name="permdesc_bindPrintSpoolerService" msgid="3680552285933318372">"Hiermee kan de houder verbinding maken met de hoofdinterface van een afdrukspoolerservice. Nooit vereist voor normale apps."</string>
    <string name="permlab_bindNfcService" msgid="2752731300419410724">"koppelen aan NFC-service"</string>
    <string name="permdesc_bindNfcService" msgid="6120647629174066862">"Hiermee kan de houder apps koppelen die NFC-kaarten emuleren. Nooit vereist voor normale apps."</string>
    <string name="permlab_bindTextService" msgid="7358378401915287938">"koppelen aan een sms-service"</string>
    <string name="permdesc_bindTextService" msgid="8151968910973998670">"Hiermee kan de gebruiker koppelen met de hoofdinterface van een tekstservice (zoals SpellCheckerService). Dit is niet nodig voor normale apps."</string>
    <string name="permlab_bindVpnService" msgid="4708596021161473255">"koppelen aan een VPN-service"</string>
    <string name="permdesc_bindVpnService" msgid="2067845564581693905">"Staat de houder toe verbinding te maken met de hoofdinterface van een VPN-service. Nooit vereist voor normale apps."</string>
    <string name="permlab_bindWallpaper" msgid="8716400279937856462">"verbinden met een achtergrond"</string>
    <string name="permdesc_bindWallpaper" msgid="7108428692595491668">"Hiermee wordt de houder toegestaan zich te verbinden met de hoofdinterface van een achtergrond. Nooit vereist voor normale apps."</string>
    <string name="permlab_bindRemoteDisplay" msgid="1782923938029941960">"verbinding maken met een extern display"</string>
    <string name="permdesc_bindRemoteDisplay" msgid="1261242718727295981">"Hiermee wordt de houder toegestaan verbinding te maken met de hoofdinterface van een extern display. Nooit vereist voor normale apps."</string>
    <string name="permlab_bindRemoteViews" msgid="5697987759897367099">"verbinden met een widgetservice"</string>
    <string name="permdesc_bindRemoteViews" msgid="4717987810137692572">"Hiermee wordt de houder toegestaan verbinding te maken met de hoofdinterface van een widgetservice. Nooit vereist voor normale apps."</string>
    <string name="permlab_bindDeviceAdmin" msgid="8704986163711455010">"interactie met apparaatbeheer"</string>
    <string name="permdesc_bindDeviceAdmin" msgid="569715419543907930">"Hiermee kan de houder intenties verzenden naar een apparaatbeheerder. Nooit vereist voor normale apps."</string>
    <string name="permlab_manageDeviceAdmins" msgid="4248828900045808722">"een apparaatbeheerder toevoegen of verwijderen"</string>
    <string name="permdesc_manageDeviceAdmins" msgid="5025608167709942485">"Hiermee kan de rechtenhouder actieve apparaatbeheerders toevoegen of verwijderen. Nooit vereist voor normale apps."</string>
    <string name="permlab_setOrientation" msgid="3365947717163866844">"schermstand wijzigen"</string>
    <string name="permdesc_setOrientation" msgid="3046126619316671476">"Hiermee kan de app de rotatie van het scherm op elk moment wijzigen. Nooit vereist voor normale apps."</string>
    <string name="permlab_setPointerSpeed" msgid="9175371613322562934">"aanwijzersnelheid wijzigen"</string>
    <string name="permdesc_setPointerSpeed" msgid="6866563234274104233">"Hiermee kan de app de snelheid van de muis- of trackpadaanwijzer op elk moment wijzigen. Nooit vereist voor normale apps."</string>
    <string name="permlab_setKeyboardLayout" msgid="4778731703600909340">"toetsenbordindeling wijzigen"</string>
    <string name="permdesc_setKeyboardLayout" msgid="8480016771134175879">"Hiermee kan de app de toetsenbordindeling wijzigen. Nooit vereist voor normale apps."</string>
    <string name="permlab_signalPersistentProcesses" msgid="4539002991947376659">"Linux-signalen verzenden naar apps"</string>
    <string name="permdesc_signalPersistentProcesses" msgid="4896992079182649141">"Hiermee kan de app ervoor zorgen dat het geleverde signaal wordt verzonden naar alle persistente processen."</string>
    <string name="permlab_persistentActivity" msgid="8841113627955563938">"app altijd laten uitvoeren"</string>
    <string name="permdesc_persistentActivity" product="tablet" msgid="8525189272329086137">"Hiermee kan de app gedeelten van zichzelf persistent maken in het geheugen. Dit kan de hoeveelheid geheugen beperken die beschikbaar is voor andere apps, waardoor de tablet trager kan worden."</string>
    <string name="permdesc_persistentActivity" product="default" msgid="4384760047508278272">"Hiermee kan de app gedeelten van zichzelf persistent maken in het geheugen. Dit kan de hoeveelheid geheugen beperken die beschikbaar is voor andere apps, waardoor de telefoon trager kan worden."</string>
    <string name="permlab_deletePackages" msgid="184385129537705938">"apps verwijderen"</string>
    <string name="permdesc_deletePackages" msgid="7411480275167205081">"Hiermee kan de app Android-pakketten verwijderen. Schadelijke apps kunnen deze toestemming gebruiken om belangrijke apps te verwijderen."</string>
    <string name="permlab_clearAppUserData" msgid="274109191845842756">"gegevens van andere apps verwijderen"</string>
    <string name="permdesc_clearAppUserData" msgid="4625323684125459488">"Hiermee kan de app gebruikersgegevens wissen."</string>
    <string name="permlab_deleteCacheFiles" msgid="3128665571837408675">"cachegeheugens van andere apps verwijderen"</string>
    <string name="permdesc_deleteCacheFiles" msgid="3812998599006730196">"Hiermee kan de app cachebestanden verwijderen."</string>
    <string name="permlab_getPackageSize" msgid="7472921768357981986">"opslagruimte van app meten"</string>
    <string name="permdesc_getPackageSize" msgid="3921068154420738296">"Hiermee kan de app de bijbehorende code, gegevens en cachegrootten ophalen."</string>
    <string name="permlab_installPackages" msgid="2199128482820306924">"apps rechtstreeks installeren"</string>
    <string name="permdesc_installPackages" msgid="5628530972548071284">"Hiermee kan de app nieuwe of bijgewerkte Android-pakketten installeren. Schadelijke apps kunnen hiermee nieuwe apps toevoegen met willekeurig belangrijke rechten."</string>
    <string name="permlab_clearAppCache" msgid="7487279391723526815">"alle cachegegevens van app verwijderen"</string>
    <string name="permdesc_clearAppCache" product="tablet" msgid="8974640871945434565">"Hiermee kan de app opslagruimte op de tablet vrij maken door bestanden te verwijderen uit de cachemappen van andere apps. Hierdoor worden andere apps mogelijk langzamer gestart, omdat ze gegevens opnieuw moeten ophalen."</string>
    <string name="permdesc_clearAppCache" product="default" msgid="2459441021956436779">"Hiermee kan de app opslagruimte op de telefoon vrij maken door bestanden te verwijderen uit de cachemappen van andere apps. Hierdoor worden andere apps mogelijk langzamer gestart, omdat ze gegevens opnieuw moeten ophalen."</string>
    <string name="permlab_movePackage" msgid="3289890271645921411">"appbronnen verplaatsen"</string>
    <string name="permdesc_movePackage" msgid="319562217778244524">"Hiermee kan de app andere appbronnen verplaatsen van interne naar externe media en andersom."</string>
    <string name="permlab_readLogs" msgid="6615778543198967614">"gevoelige logbestandsgegevens lezen"</string>
    <string name="permdesc_readLogs" product="tablet" msgid="82061313293455151">"Hiermee kan de app de verschillende logbestanden van het systeem lezen. De app kan op deze manier algemene informatie achterhalen over uw tabletgebruik, mogelijk inclusief persoonlijke of privé-informatie."</string>
    <string name="permdesc_readLogs" product="default" msgid="2063438140241560443">"Hiermee kan de app de verschillende logbestanden van het systeem lezen. De app kan op deze manier algemene informatie achterhalen over uw telefoongebruik, mogelijk inclusief persoonlijke of privé-informatie."</string>
    <string name="permlab_anyCodecForPlayback" msgid="715805555823881818">"elke mediadecoder gebruiken voor afspelen"</string>
    <string name="permdesc_anyCodecForPlayback" msgid="8283912488433189010">"Hiermee kan de app alle geïnstalleerde mediadecoders gebruiken om te decoderen voor het afspelen."</string>
    <string name="permlab_manageCaCertificates" msgid="1678391896786882014">"vertrouwde inloggegevens beheren"</string>
    <string name="permdesc_manageCaCertificates" msgid="4015644047196937014">"Hiermee kan de app CA-certificaten installeren en verwijderen als vertrouwde inloggegevens."</string>
    <string name="permlab_diagnostic" msgid="8076743953908000342">"lezen/schrijven naar bronnen van diag"</string>
    <string name="permdesc_diagnostic" msgid="6608295692002452283">"Hiermee kan de app lezen en schrijven naar elke bron die hoort bij de diagnostische groep, zoals bestanden in /dev. Hierdoor kan de systeemstabiliteit en -veiligheid worden beïnvloed. Dit mag ALLEEN worden gebruikt voor hardwarespecifieke diagnostiek door de fabrikant of provider."</string>
    <string name="permlab_changeComponentState" msgid="6335576775711095931">"componenten van apps in- of uitschakelen"</string>
    <string name="permdesc_changeComponentState" product="tablet" msgid="8887435740982237294">"Hiermee kan de app wijzigen of een component van een andere app wel of niet is ingeschakeld. Schadelijke apps kunnen dit gebruiken om belangrijke tabletfuncties uit te schakelen. U moet voorzichtig omgaan met deze rechten, aangezien het mogelijk is dat onderdelen van apps onbruikbaar, inconsistent of instabiel worden."</string>
    <string name="permdesc_changeComponentState" product="default" msgid="1827232484416505615">"Hiermee kan de app wijzigen of een component van een andere app wel of niet is ingeschakeld. Schadelijke apps kunnen dit gebruiken om belangrijke telefoonfuncties uit te schakelen. U moet voorzichtig omgaan met deze rechten, aangezien het mogelijk is dat onderdelen van apps onbruikbaar, inconsistent of instabiel worden."</string>
    <string name="permlab_grantRevokePermissions" msgid="4627315351093508795">"rechten verlenen of intrekken"</string>
    <string name="permdesc_grantRevokePermissions" msgid="4088642654085850662">"Toestaan dat een app specifieke rechten aan zichzelf of andere apps verleent of deze intrekt. Schadelijke apps kunnen dit gebruiken om toegang te krijgen tot functies waartoe u de apps geen toegang heeft gegeven."</string>
    <string name="permlab_setPreferredApplications" msgid="8463181628695396391">"voorkeursapps instellen"</string>
    <string name="permdesc_setPreferredApplications" msgid="4973986762241783712">"Hiermee kan de app uw voorkeursapps aanpassen. Schadelijke apps kunnen de apps die worden uitgevoerd zonder uw medeweten wijzigen om uw bestaande apps te imiteren en privégegevens van u te verzamelen."</string>
    <string name="permlab_writeSettings" msgid="2226195290955224730">"systeeminstellingen aanpassen"</string>
    <string name="permdesc_writeSettings" msgid="7775723441558907181">"Hiermee kan de app de instellingsgegevens van het systeem aanpassen. Schadelijke apps kunnen de configuratie van uw systeem verstoren."</string>
    <string name="permlab_writeSecureSettings" msgid="204676251876718288">"beveiligde systeeminstellingen wijzigen"</string>
    <string name="permdesc_writeSecureSettings" msgid="8159535613020137391">"Hiermee kan de app de gegevens voor beveiligde systeeminstellingen aanpassen. Dit wordt niet gebruikt door normale apps."</string>
    <string name="permlab_writeGservices" msgid="2149426664226152185">"de Google-serviceskaart wijzigen"</string>
    <string name="permdesc_writeGservices" msgid="1287309437638380229">"Hiermee kan de app de Google-serviceskaart wijzigen. Niet voor gebruik door normale apps."</string>
    <string name="permlab_receiveBootCompleted" msgid="5312965565987800025">"uitvoeren bij opstarten"</string>
    <string name="permdesc_receiveBootCompleted" product="tablet" msgid="7390304664116880704">"Hiermee kan de app zichzelf laten starten zodra het systeem is opgestart. Hierdoor kan het langer duren voordat de tablet is opgestart en een app kan altijd actief zijn, wat de tablet kan vertragen."</string>
    <string name="permdesc_receiveBootCompleted" product="default" msgid="513950589102617504">"Hiermee kan de app zichzelf starten zodra het systeem klaar is met opstarten. Hierdoor kan het langer duren voordat de telefoon is opgestart en kan de app de telefoonprocessen vertragen door altijd actief te zijn."</string>
    <string name="permlab_broadcastSticky" msgid="7919126372606881614">"sticky broadcast verzenden"</string>
    <string name="permdesc_broadcastSticky" product="tablet" msgid="7749760494399915651">"Hiermee kan de app sticky broadcasts verzenden die behouden blijven nadat de broadcast is beëindigd. Bij overmatig gebruik kan de tablet traag of instabiel worden omdat er te veel geheugenruimte wordt gebruikt."</string>
    <string name="permdesc_broadcastSticky" product="default" msgid="2825803764232445091">"Hiermee kan de app sticky broadcasts verzenden die behouden blijven nadat de broadcast is beëindigd. Bij overmatig gebruik kan de telefoon traag of instabiel worden omdat er te veel geheugenruimte wordt gebruikt."</string>
    <string name="permlab_readContacts" msgid="8348481131899886131">"uw contacten lezen"</string>
    <string name="permdesc_readContacts" product="tablet" msgid="5294866856941149639">"Hiermee kan de app gegevens lezen over de contacten die zijn opgeslagen op uw tablet, inclusief de frequentie waarmee u heeft gebeld, gemaild of op andere manieren heeft gecommuniceerd met specifieke personen. Met deze toestemming kunnen apps uw contactgegevens opslaan, en schadelijke apps kunnen zonder uw medeweten contactgegevens delen."</string>
    <string name="permdesc_readContacts" product="default" msgid="8440654152457300662">"Hiermee kan de app gegevens lezen over de contacten die zijn opgeslagen op uw telefoon, inclusief de frequentie waarmee u heeft gebeld, gemaild of op andere manieren heeft gecommuniceerd met specifieke personen. Met deze toestemming kunnen apps uw contactgegevens opslaan, en schadelijke apps kunnen zonder uw medeweten contactgegevens delen."</string>
    <string name="permlab_writeContacts" msgid="5107492086416793544">"uw contacten aanpassen"</string>
    <string name="permdesc_writeContacts" product="tablet" msgid="897243932521953602">"Hiermee kan de app gegevens wijzigen over de contacten die zijn opgeslagen op uw tablet, inclusief de frequentie waarmee u heeft gebeld, gemaild of op andere manieren heeft gecommuniceerd met specifieke contacten. Met deze toestemming kunnen apps contactgegevens verwijderen."</string>
    <string name="permdesc_writeContacts" product="default" msgid="589869224625163558">"Hiermee kan de app gegevens wijzigen over de contacten die zijn opgeslagen op uw telefoon, inclusief de frequentie waarmee u heeft gebeld, gemaild of op andere manieren heeft gecommuniceerd met specifieke contacten. Met deze toestemming kunnen apps contactgegevens verwijderen."</string>
    <string name="permlab_readCallLog" msgid="3478133184624102739">"gesprekkenlijst lezen"</string>
    <string name="permdesc_readCallLog" product="tablet" msgid="3700645184870760285">"Hiermee kan de app het gesprekkenlijst van uw tablet lezen, inclusief gegevens over inkomende en uitgaande oproepen. Met deze toestemming kunnen apps uw oproeploggegevens opslaan, en schadelijke apps kunnen logoproepgegevens zonder uw medeweten delen."</string>
    <string name="permdesc_readCallLog" product="default" msgid="5777725796813217244">"Hiermee kan de app het gesprekkenlijst van uw telefoon lezen, inclusief gegevens over inkomende en uitgaande oproepen. Met deze toestemming kunnen apps uw oproeploggegevens opslaan, en schadelijke apps kunnen logoproepgegevens zonder uw medeweten delen."</string>
    <string name="permlab_writeCallLog" msgid="8552045664743499354">"gesprekkenlijst schrijven"</string>
    <string name="permdesc_writeCallLog" product="tablet" msgid="6661806062274119245">"Toestaan dat de app het gesprekkenlijst van uw tablet aanpast, waaronder gegevens over inkomende en uitgaande oproepen. Schadelijke apps kunnen hiermee uw gesprekkenlijst wissen of aanpassen."</string>
    <string name="permdesc_writeCallLog" product="default" msgid="683941736352787842">"Toestaan dat de app het gesprekkenlijst van uw telefoon aanpast, waaronder gegevens over inkomende en uitgaande oproepen. Schadelijke apps kunnen hiermee uw gesprekkenlijst wissen of aanpassen."</string>
    <string name="permlab_readProfile" msgid="4701889852612716678">"uw eigen contactkaart lezen"</string>
    <string name="permdesc_readProfile" product="default" msgid="5462475151849888848">"Hiermee kan de app persoonlijke profielgegevens lezen die op uw apparaat zijn opgeslagen, zoals uw naam en contactgegevens. Dit betekent dat de app u kan identificeren en uw profielgegevens naar anderen kan verzenden."</string>
    <string name="permlab_writeProfile" msgid="907793628777397643">"uw eigen contactkaart aanpassen"</string>
    <string name="permdesc_writeProfile" product="default" msgid="5552084294598465899">"Hiermee kan de app persoonlijke profielgegevens wijzigen of toevoegen die op uw apparaat zijn opgeslagen, zoals uw naam en contactgegevens. Dit betekent dat de app u kan identificeren en uw profielgegevens naar anderen kan verzenden."</string>
    <string name="permlab_readSocialStream" product="default" msgid="1268920956152419170">"uw sociale stream lezen"</string>
    <string name="permdesc_readSocialStream" product="default" msgid="4255706027172050872">"Hiermee kan de app toegang krijgen tot sociale updates van u en uw vrienden en deze synchroniseren. Wees voorzichtig bij het delen van informatie: hiermee kan de app communicatie lezen tussen u en uw vrienden op sociale netwerken, ongeacht de vertrouwelijkheid. Opmerking: deze toestemming kan niet worden afgedwongen voor alle sociale netwerken."</string>
    <string name="permlab_writeSocialStream" product="default" msgid="3504179222493235645">"schrijven naar sociale streams"</string>
    <string name="permdesc_writeSocialStream" product="default" msgid="3086557552204114849">"Hiermee kan de app sociale updates van u en uw vrienden weergeven. Wees voorzichtig bij het delen van informatie: hiermee kan de app berichten produceren die afkomstig lijken te zijn van een vriend. Opmerking: deze toestemming kan niet worden afgedwongen voor alle sociale netwerken."</string>
    <string name="permlab_readCalendar" msgid="5972727560257612398">"agenda-afspraken en vertrouwelijke informatie lezen"</string>
    <string name="permdesc_readCalendar" product="tablet" msgid="4216462049057658723">"Hiermee kan de app alle agenda-afspraken lezen die zijn opgeslagen op uw tablet, inclusief die van vrienden of collega\'s. De app kan uw agenda delen of uw agendagegevens opslaan, ongeacht vertrouwelijkheid of gevoeligheid."</string>
    <string name="permdesc_readCalendar" product="default" msgid="7434548682470851583">"Hiermee kan de app alle agenda-afspraken lezen die zijn opgeslagen op uw telefoon, inclusief die van vrienden of collega\'s. De app kan uw agenda delen of uw agendagegevens opslaan, ongeacht vertrouwelijkheid of gevoeligheid."</string>
    <string name="permlab_writeCalendar" msgid="8438874755193825647">"agenda-afspraken toevoegen of wijzigen en e-mails verzenden aan gasten zonder medeweten van de eigenaren"</string>
    <string name="permdesc_writeCalendar" product="tablet" msgid="6679035520113668528">"Hiermee kan de app afspraken toevoegen, verwijderen en wijzigen die u kunt bewerken op uw tablet, inclusief afspraken van vrienden of collega\'s. Zo kan de app berichten verzenden die afkomstig lijken te zijn van agenda-eigenaren, of afspraken aanpassen zonder medeweten van de eigenaar."</string>
    <string name="permdesc_writeCalendar" product="default" msgid="2324469496327249376">"Hiermee kan de app afspraken toevoegen, verwijderen en wijzigen die u kunt bewerken op uw telefoon, inclusief afspraken van vrienden of collega\'s. Zo kan de app berichten verzenden die afkomstig lijken te zijn van agenda-eigenaren, of afspraken aanpassen zonder medeweten van de eigenaar."</string>
    <string name="permlab_accessMockLocation" msgid="8688334974036823330">"neplocatiebronnen voor test"</string>
    <string name="permdesc_accessMockLocation" msgid="5808711039482051824">"Voorbeeld-locatiebronnen maken voor tests of een nieuwe locatieprovider instellen. Hiermee kan de app de locatie en/of status overschrijven van andere locatiebronnen zoals GPS of locatieproviders."</string>
    <string name="permlab_accessLocationExtraCommands" msgid="2836308076720553837">"toegang tot extra opdrachten van locatieaanbieder"</string>
    <string name="permdesc_accessLocationExtraCommands" msgid="5945166642335800763">"Hiermee krijgt de app toegang tot extra opdrachten voor de locatieprovider. De app kan hiermee de werking van GPS of andere locatiebronnen te verstoren."</string>
    <string name="permlab_installLocationProvider" msgid="6578101199825193873">"toestemming om een locatieprovider te installeren"</string>
    <string name="permdesc_installLocationProvider" msgid="9066146120470591509">"Voorbeeld-locatiebronnen maken voor tests of een nieuwe locatieprovider instellen. Hiermee kan de app de locatie en/of status overschrijven van andere locatiebronnen zoals GPS of locatieproviders."</string>
    <string name="permlab_accessFineLocation" msgid="1191898061965273372">"precieze locatie (GPS- en netwerkgebaseerd)"</string>
    <string name="permdesc_accessFineLocation" msgid="5295047563564981250">"Hiermee kan de app uw precieze locatie bepalen via GPS (Global Positioning System) of netwerklocatiebronnen zoals zendmasten en wifi. Deze locatieservices moeten zijn ingeschakeld en beschikbaar zijn op uw apparaat voordat de app ze kan gebruiken. Apps kunnen dit gebruiken om te bepalen waar u bent en verbruiken mogelijk extra acculading."</string>
    <string name="permlab_accessCoarseLocation" msgid="4887895362354239628">"geschatte locatie (netwerkgebaseerd)"</string>
    <string name="permdesc_accessCoarseLocation" msgid="2538200184373302295">"Hiermee kan de app beschikken over uw geschatte locatie. Deze locatie wordt afgeleid van locatieservices die netwerklocatiebronnen zoals zendmasten en wifi gebruiken. Deze locatieservices moeten zijn ingeschakeld en beschikbaar zijn op uw apparaat voordat de app ze kan gebruiken. Apps kunnen dit gebruiken om ongeveer te bepalen waar u zich bevindt."</string>
    <string name="permlab_accessSurfaceFlinger" msgid="2363969641792388947">"toegang tot SurfaceFlinger"</string>
    <string name="permdesc_accessSurfaceFlinger" msgid="1041619516733293551">"Hiermee kan de app SurfaceFlinger-functies op laag niveau gebruiken."</string>
    <string name="permlab_readFrameBuffer" msgid="6690504248178498136">"framebuffer lezen"</string>
    <string name="permdesc_readFrameBuffer" msgid="4937405521809454680">"Hiermee kan de app de inhoud van de framebuffer lezen."</string>
    <string name="permlab_configureWifiDisplay" msgid="5595661694746742168">"wifi-displays configureren"</string>
    <string name="permdesc_configureWifiDisplay" msgid="7916815158690218065">"De app toestaan wifi-displays te configureren en hiermee verbinding te maken."</string>
    <string name="permlab_controlWifiDisplay" msgid="393641276723695496">"wifi-displays beheren"</string>
    <string name="permdesc_controlWifiDisplay" msgid="4543912292681826986">"De app toestaan minder belangrijke functies van wifi-displays te beheren."</string>
    <string name="permlab_captureAudioOutput" msgid="6857134498402346708">"audio-uitvoer vastleggen"</string>
    <string name="permdesc_captureAudioOutput" msgid="6210597754212208853">"Hiermee kan de app audio-uitvoer vastleggen en verwerken."</string>
    <string name="permlab_captureAudioHotword" msgid="1890553935650349808">"Detectie van hotwords"</string>
    <string name="permdesc_captureAudioHotword" msgid="9151807958153056810">"Hiermee kan de app audio opnemen voor het detecteren van hotwords. Het opnemen kan op de achtergrond plaatsvinden, maar voorkomt niet dat andere audio wordt opgenomen (bijvoorbeeld in Camcorder)."</string>
    <string name="permlab_captureVideoOutput" msgid="2246828773589094023">"video-uitvoer vastleggen"</string>
    <string name="permdesc_captureVideoOutput" msgid="359481658034149860">"Hiermee kan de app video-uitvoer vastleggen en verwerken."</string>
    <string name="permlab_captureSecureVideoOutput" msgid="7815398969303382016">"beveiligde video-uitvoer vastleggen"</string>
    <string name="permdesc_captureSecureVideoOutput" msgid="2779793064709350289">"Hiermee kan de app beveiligde video-uitvoer vastleggen en verwerken."</string>
    <string name="permlab_mediaContentControl" msgid="8749790560720562511">"afspelen van media beheren en toegang tot metadata"</string>
    <string name="permdesc_mediaContentControl" msgid="1637478200272062">"Hiermee kan de app het afspelen van media beheren en de media-informatie opvragen (titel, auteur...)."</string>
    <string name="permlab_modifyAudioSettings" msgid="6095859937069146086">"uw audio-instellingen wijzigen"</string>
    <string name="permdesc_modifyAudioSettings" msgid="3522565366806248517">"Hiermee kan de app algemene audio-instellingen wijzigen zoals het volume en welke luidspreker wordt gebruikt voor de uitvoer."</string>
    <string name="permlab_recordAudio" msgid="3876049771427466323">"audio opnemen"</string>
    <string name="permdesc_recordAudio" msgid="4906839301087980680">"Hiermee kan de app audio opnemen met de microfoon. Met deze toestemming kan de app op elk moment audio opnemen, zonder om uw bevestiging te vragen."</string>
    <string name="permlab_camera" msgid="3616391919559751192">"foto\'s en video\'s maken"</string>
    <string name="permdesc_camera" msgid="8497216524735535009">"Hiermee kan de app foto\'s en video\'s maken met de camera. Met deze toestemming kan de app de camera altijd gebruiken, zonder uw bevestiging."</string>
    <string name="permlab_cameraDisableTransmitLed" msgid="2651072630501126222">"indicatielampje uitschakelen wanneer camera wordt gebruikt"</string>
    <string name="permdesc_cameraDisableTransmitLed" msgid="4764585465480295341">"Staat toe dat een vooraf geïnstalleerde systeemapp het indicatielampje voor cameragebruik uitschakelt."</string>
    <string name="permlab_brick" product="tablet" msgid="2961292205764488304">"tablet permanent uitschakelen"</string>
    <string name="permlab_brick" product="default" msgid="8337817093326370537">"telefoon permanent uitschakelen"</string>
    <string name="permdesc_brick" product="tablet" msgid="4334818808001699530">"Hiermee kan de app de gehele tablet permanent uitschakelen. Dit is erg gevaarlijk."</string>
    <string name="permdesc_brick" product="default" msgid="5788903297627283099">"Hiermee kan de app de gehele telefoon permanent uitschakelen. Dit is erg gevaarlijk."</string>
    <string name="permlab_reboot" product="tablet" msgid="3436634972561795002">"opnieuw opstarten van tablet afdwingen"</string>
    <string name="permlab_reboot" product="default" msgid="2898560872462638242">"telefoon nu opnieuw opstarten"</string>
    <string name="permdesc_reboot" product="tablet" msgid="8172056180063700741">"Hiermee kan de app de tablet opnieuw opstarten."</string>
    <string name="permdesc_reboot" product="default" msgid="5326008124289989969">"Hiermee kan de app de telefoon opnieuw laten opstarten."</string>
    <string name="permlab_mount_unmount_filesystems" product="nosdcard" msgid="2927361537942591841">"bestandssysteem van USB-opslag openen"</string>
    <string name="permlab_mount_unmount_filesystems" product="default" msgid="4402305049890953810">"bestandssysteem van SD-kaart openen"</string>
    <string name="permdesc_mount_unmount_filesystems" msgid="1829290701658992347">"Hiermee kan de app bestandssystemen koppelen en ontkoppelen voor verwisselbare opslagruimte."</string>
    <string name="permlab_mount_format_filesystems" product="nosdcard" msgid="6227819582624904972">"USB-opslag wissen"</string>
    <string name="permlab_mount_format_filesystems" product="default" msgid="262582698639274056">"SD-kaart wissen"</string>
    <string name="permdesc_mount_format_filesystems" msgid="8784268246779198627">"Hiermee kan de app de externe opslag formatteren."</string>
    <string name="permlab_asec_access" msgid="3411338632002193846">"informatie over de interne opslag verkrijgen"</string>
    <string name="permdesc_asec_access" msgid="3094563844593878548">"Hiermee kan de app informatie over de interne opslag verkrijgen."</string>
    <string name="permlab_asec_create" msgid="6414757234789336327">"interne opslag maken"</string>
    <string name="permdesc_asec_create" msgid="4558869273585856876">"Hiermee kan de app interne opslag maken."</string>
    <string name="permlab_asec_destroy" msgid="526928328301618022">"interne opslag vernietigen"</string>
    <string name="permdesc_asec_destroy" msgid="7218749286145526537">"Hiermee kan de app de interne opslag vernietigen."</string>
    <string name="permlab_asec_mount_unmount" msgid="8877998101944999386">"interne opslag koppelen/ontkoppelen"</string>
    <string name="permdesc_asec_mount_unmount" msgid="3451360114902490929">"Hiermee kan de app de interne opslag koppelen/ontkoppelen."</string>
    <string name="permlab_asec_rename" msgid="7496633954080472417">"naam van interne opslag wijzigen"</string>
    <string name="permdesc_asec_rename" msgid="1794757588472127675">"Hiermee kan de app de naam van de interne opslag wijzigen."</string>
    <string name="permlab_vibrate" msgid="7696427026057705834">"trilling beheren"</string>
    <string name="permdesc_vibrate" msgid="6284989245902300945">"Hiermee kan de app de trilstand beheren."</string>
    <string name="permlab_flashlight" msgid="2155920810121984215">"zaklamp bedienen"</string>
    <string name="permdesc_flashlight" msgid="6522284794568368310">"Hiermee kan de app de zaklamp bedienen."</string>
    <string name="permlab_manageUsb" msgid="1113453430645402723">"voorkeuren en rechten voor USB-apparaten beheren"</string>
    <string name="permdesc_manageUsb" msgid="7776155430218239833">"Hiermee kan de app voorkeuren en rechten voor USB-apparaten beheren."</string>
    <string name="permlab_accessMtp" msgid="4953468676795917042">"MTP-protocol implementeren"</string>
    <string name="permdesc_accessMtp" msgid="6532961200486791570">"Staat toegang tot de kernel van de MTP-driver toe voor het implementeren van het MTP-USB-protocol."</string>
    <string name="permlab_hardware_test" msgid="4148290860400659146">"hardware testen"</string>
    <string name="permdesc_hardware_test" msgid="6597964191208016605">"Hiermee kan de app verschillende randapparaten beheren om de hardware te testen."</string>
    <string name="permlab_callPhone" msgid="3925836347681847954">"telefoonnummers rechtstreeks bellen"</string>
    <string name="permdesc_callPhone" msgid="3740797576113760827">"Hiermee kan de app zonder uw tussenkomst telefoonnummers bellen. Dit kan tot onverwachte kosten of oproepen leiden. De app kan hiermee geen noodnummers bellen. Schadelijke apps kunnen u geld kosten door nummers te bellen zonder om uw bevestiging te vragen."</string>
    <string name="permlab_callPrivileged" msgid="4198349211108497879">"alle telefoonnummers rechtstreeks bellen"</string>
    <string name="permdesc_callPrivileged" msgid="1689024901509996810">"Hiermee kan de app elk telefoonnummer bellen zonder uw tussenkomst, inclusief alarmnummers. Schadelijke apps kunnen onnodige en illegale oproepen uitvoeren naar alarmdiensten."</string>
    <string name="permlab_performCdmaProvisioning" product="tablet" msgid="4842576994144604821">"meteen starten met CDMA-tabletinstelling"</string>
    <string name="permlab_performCdmaProvisioning" product="default" msgid="5604848095315421425">"meteen starten met CDMA-telefooninstelling"</string>
    <string name="permdesc_performCdmaProvisioning" msgid="1994193538802314186">"Hiermee kan de app starten met CDMA-provisioning. Schadelijke apps kunnen de CDMA-provisioning onnodig starten."</string>
    <string name="permlab_locationUpdates" msgid="7785408253364335740">"meldingen over locatie-updates beheren"</string>
    <string name="permdesc_locationUpdates" msgid="1120741557891438876">"Hiermee kan de app locatie-updatemeldingen van de radio in- of uitschakelen. Niet voor gebruik door normale apps."</string>
    <string name="permlab_checkinProperties" msgid="7855259461268734914">"toegang tot checkin-eigenschappen"</string>
    <string name="permdesc_checkinProperties" msgid="4024526968630194128">"Hiermee beschikt de app over lees-/schrijftoegang tot eigenschappen die door de checkin-service zijn geüpload. Niet voor gebruik door normale apps."</string>
    <string name="permlab_bindGadget" msgid="776905339015863471">"widgets kiezen"</string>
    <string name="permdesc_bindGadget" msgid="8261326938599049290">"Hiermee kan de app het systeem laten weten welke widgets door welke app kunnen worden gebruikt. Een app met deze rechten kan andere apps toegang verlenen tot persoonlijke gegevens. Dit wordt niet gebruikt door normale apps."</string>
    <string name="permlab_modifyPhoneState" msgid="8423923777659292228">"telefoonstatus wijzigen"</string>
    <string name="permdesc_modifyPhoneState" msgid="1029877529007686732">"Hiermee kan de app de telefoonfuncties van het apparaat beheren. Een app met deze toestemming kan schakelen tussen netwerken, kan de radio van de telefoon in- en uitschakelen en dergelijke acties uitvoeren zonder dat u hiervan op de hoogte wordt gesteld."</string>
    <string name="permlab_readPhoneState" msgid="9178228524507610486">"telefoonstatus en -identiteit lezen"</string>
    <string name="permdesc_readPhoneState" msgid="1639212771826125528">"Hiermee kan de app toegang krijgen tot de telefoonfuncties van het apparaat, Met deze toestemming kan de app het telefoonnummer en de apparaat-ID\'s bepalen, of een oproep actief is, en het andere telefoonnummer waarmee wordt gebeld."</string>
    <string name="permlab_wakeLock" product="tablet" msgid="1531731435011495015">"voorkomen dat tablet overschakelt naar slaapmodus"</string>
    <string name="permlab_wakeLock" product="default" msgid="573480187941496130">"voorkomen dat telefoon overschakelt naar slaapmodus"</string>
    <string name="permdesc_wakeLock" product="tablet" msgid="7311319824400447868">"Hiermee kan de app voorkomen dat de tablet overschakelt naar de slaapmodus."</string>
    <string name="permdesc_wakeLock" product="default" msgid="8559100677372928754">"Hiermee kan de app voorkomen dat de telefoon overschakelt naar de slaapmodus."</string>
    <string name="permlab_transmitIr" msgid="7545858504238530105">"infrarood verzenden"</string>
    <string name="permdesc_transmitIr" product="tablet" msgid="5358308854306529170">"Hiermee kan de app de infraroodzender van de tablet gebruiken."</string>
    <string name="permdesc_transmitIr" product="default" msgid="7957763745020300725">"Hiermee kan de app de infraroodzender van de telefoon gebruiken."</string>
    <string name="permlab_devicePower" product="tablet" msgid="2787034722616350417">"tablet in- of uitschakelen"</string>
    <string name="permlab_devicePower" product="default" msgid="4928622470980943206">"telefoon in- of uitschakelen"</string>
    <string name="permdesc_devicePower" product="tablet" msgid="6689862878984631831">"Hiermee kan de app de tablet in- of uitschakelen."</string>
    <string name="permdesc_devicePower" product="default" msgid="6037057348463131032">"Hiermee kan de app de telefoon in- of uitschakelen."</string>
    <string name="permlab_factoryTest" msgid="3715225492696416187">"uitvoeren in fabriekstestmodus"</string>
    <string name="permdesc_factoryTest" product="tablet" msgid="3952059318359653091">"Uitvoeren als fabrikanttest op laag niveau, waardoor toegang wordt gegeven tot de hardware van de tablet. Alleen beschikbaar als een tablet zich in de fabrikanttestmodus bevindt."</string>
    <string name="permdesc_factoryTest" product="default" msgid="8136644990319244802">"Uitvoeren als fabrikanttest op laag niveau, waardoor toegang wordt gegeven tot de hardware van de telefoon. Alleen beschikbaar als een telefoon zich in de fabrikanttestmodus bevindt."</string>
    <string name="permlab_setWallpaper" msgid="6627192333373465143">"achtergrond instellen"</string>
    <string name="permdesc_setWallpaper" msgid="7373447920977624745">"Hiermee kan de app de systeemachtergrond instellen."</string>
    <string name="permlab_setWallpaperHints" msgid="3278608165977736538">"uw achtergrondformaat aanpassen"</string>
    <string name="permdesc_setWallpaperHints" msgid="8235784384223730091">"Hiermee kan de app de grootte van de achtergrond instellen."</string>
    <string name="permlab_masterClear" msgid="2315750423139697397">"systeem terugzetten op fabrieksinstellingen"</string>
    <string name="permdesc_masterClear" msgid="3665380492633910226">"Hiermee kan de app het systeem terugzetten naar de fabrieksinstellingen, waarbij alle gegevens, configuraties en geïnstalleerde apps worden verwijderd."</string>
    <string name="permlab_setTime" msgid="2021614829591775646">"tijd instellen"</string>
    <string name="permdesc_setTime" product="tablet" msgid="1896341438151152881">"Hiermee kan de app de kloktijd van de tablet wijzigen."</string>
    <string name="permdesc_setTime" product="default" msgid="1855702730738020">"Hiermee kan de app de kloktijd van de telefoon wijzigen."</string>
    <string name="permlab_setTimeZone" msgid="2945079801013077340">"tijdzone instellen"</string>
    <string name="permdesc_setTimeZone" product="tablet" msgid="1676983712315827645">"Hiermee kan de app de tijdzone van de tablet wijzigen."</string>
    <string name="permdesc_setTimeZone" product="default" msgid="4499943488436633398">"Hiermee kan de app de tijdzone van de telefoon wijzigen."</string>
    <string name="permlab_accountManagerService" msgid="4829262349691386986">"fungeren als de AccountManagerService"</string>
    <string name="permdesc_accountManagerService" msgid="1948455552333615954">"Hiermee kan de app AccountAuthenticators aanroepen."</string>
    <string name="permlab_getAccounts" msgid="1086795467760122114">"accounts op het apparaat vinden"</string>
    <string name="permdesc_getAccounts" product="tablet" msgid="2741496534769660027">"Hiermee krijgt de app toegang tot de lijst met accounts die op de tablet bekend zijn. Dit kunnen ook accounts zijn die zijn gemaakt door apps die u heeft geïnstalleerd."</string>
    <string name="permdesc_getAccounts" product="default" msgid="3448316822451807382">"Hiermee krijgt de app toegang tot de lijst met accounts die op de telefoon bekend zijn. Dit kunnen ook accounts zijn die zijn gemaakt door apps die u heeft geïnstalleerd."</string>
    <string name="permlab_authenticateAccounts" msgid="5265908481172736933">"accounts maken en wachtwoorden instellen"</string>
    <string name="permdesc_authenticateAccounts" msgid="5472124296908977260">"Hiermee kan de app de accountverificatiemogelijkheden van AccountManager gebruiken, inclusief het maken van accounts en het ophalen en instellen van de bijbehorende wachtwoorden."</string>
    <string name="permlab_manageAccounts" msgid="4983126304757177305">"accounts toevoegen of verwijderen"</string>
    <string name="permdesc_manageAccounts" msgid="8698295625488292506">"Hiermee kan de app bewerkingen uitvoeren zoals het toevoegen en verwijderen van accounts en het verwijderen van de bijbehorende wachtwoorden."</string>
    <string name="permlab_useCredentials" msgid="235481396163877642">"accounts op het apparaat gebruiken"</string>
    <string name="permdesc_useCredentials" msgid="7984227147403346422">"Hiermee kan de app verificatietokens aanvragen."</string>
    <string name="permlab_accessNetworkState" msgid="4951027964348974773">"netwerkverbindingen weergeven"</string>
    <string name="permdesc_accessNetworkState" msgid="8318964424675960975">"Hiermee kan de app informatie bekijken over netwerkverbindingen, zoals welke netwerken er zijn en welke verbonden zijn."</string>
    <string name="permlab_createNetworkSockets" msgid="8018758136404323658">"volledige netwerktoegang"</string>
    <string name="permdesc_createNetworkSockets" msgid="3403062187779724185">"Hiermee kan de app netwerksockets maken en aangepaste netwerkprotocollen gebruiken. De browser en andere apps bieden mogelijkheden om gegevens via internet te verzenden, dus deze toestemming is niet vereist om gegevens via internet te verzenden."</string>
    <string name="permlab_writeApnSettings" msgid="505660159675751896">"netwerkinstellingen en -verkeer wijzigen/onderscheppen"</string>
    <string name="permdesc_writeApnSettings" msgid="5333798886412714193">"Hiermee kan de app netwerkinstellingen wijzigen en alle netwerkverkeer onderscheppen en controleren om bijvoorbeeld de proxy en poort van een APN te wijzigen. Schadelijke apps kunnen netwerkpakketten controleren, omleiden of aanpassen zonder uw medeweten."</string>
    <string name="permlab_changeNetworkState" msgid="958884291454327309">"netwerkverbinding wijzigen"</string>
    <string name="permdesc_changeNetworkState" msgid="6789123912476416214">"Hiermee kan de app de status van de netwerkverbinding wijzigen."</string>
    <string name="permlab_changeTetherState" msgid="5952584964373017960">"getetherde verbinding wijzigen"</string>
    <string name="permdesc_changeTetherState" msgid="1524441344412319780">"Hiermee kan de app de status van de getetherde netwerkverbinding wijzigen."</string>
    <string name="permlab_changeBackgroundDataSetting" msgid="1400666012671648741">"instelling voor gebruik van achtergrondgegevens van gegevens wijzigen"</string>
    <string name="permdesc_changeBackgroundDataSetting" msgid="5347729578468744379">"Hiermee kan de app de instelling voor gebruik van achtergrondgegevens wijzigen."</string>
    <string name="permlab_accessWifiState" msgid="5202012949247040011">"wifi-verbindingen weergeven"</string>
    <string name="permdesc_accessWifiState" msgid="5002798077387803726">"Hiermee kan de app informatie over wifi-netwerken bekijken, zoals of wifi is ingeschakeld en de naam van apparaten waarmee via wifi verbinding is gemaakt."</string>
    <string name="permlab_changeWifiState" msgid="6550641188749128035">"wifi-verbinding maken en verbreken"</string>
    <string name="permdesc_changeWifiState" msgid="7137950297386127533">"Hiermee kan de app zich koppelen aan en ontkoppelen van wifi-toegangspunten en wijzigingen aanbrengen in de apparaatconfiguratie voor wifi-netwerken."</string>
    <string name="permlab_changeWifiMulticastState" msgid="1368253871483254784">"Wifi Multicast-ontvangst toestaan"</string>
    <string name="permdesc_changeWifiMulticastState" product="tablet" msgid="7969774021256336548">"Hiermee kan de app pakketten ontvangen die via multicastadressen naar alle apparaten in een wifi-netwerk worden verzonden, niet alleen naar uw tablet. Het stroomgebruik ligt hierbij hoger dan in de niet-multicastmodus."</string>
    <string name="permdesc_changeWifiMulticastState" product="default" msgid="6851949706025349926">"Hiermee kan de app pakketten ontvangen die via multicastadressen naar alle apparaten in een wifi-netwerk worden verzonden, niet alleen naar uw telefoon. Het stroomgebruik ligt hierbij hoger dan in de niet-multicastmodus."</string>
    <string name="permlab_bluetoothAdmin" msgid="6006967373935926659">"Bluetooth-instellingen openen"</string>
    <string name="permdesc_bluetoothAdmin" product="tablet" msgid="6921177471748882137">"Hiermee kan de app de lokale Bluetooth-tablet configureren en externe apparaten zoeken en koppelen."</string>
    <string name="permdesc_bluetoothAdmin" product="default" msgid="8931682159331542137">"Hiermee kan de app de lokale Bluetooth-telefoon configureren en externe apparaten zoeken en koppelen."</string>
    <string name="permlab_bluetoothPriv" msgid="4009494246009513828">"Bluetooth-koppeling door app toestaan"</string>
    <string name="permdesc_bluetoothPriv" product="tablet" msgid="8045735193417468857">"De app toestaan te koppelen met externe apparaten zonder tussenkomst van de gebruiker."</string>
    <string name="permdesc_bluetoothPriv" product="default" msgid="8045735193417468857">"De app toestaan te koppelen met externe apparaten zonder tussenkomst van de gebruiker."</string>
    <string name="permlab_accessWimaxState" msgid="4195907010610205703">"WiMAX-verbinding maken en verbreken"</string>
    <string name="permdesc_accessWimaxState" msgid="6360102877261978887">"Hiermee kan de app bepalen of WiMAX is ingeschakeld en informatie bekijken over alle WiMAX-netwerken waarmee verbinding is gemaakt."</string>
    <string name="permlab_changeWimaxState" msgid="2405042267131496579">"WiMAX-status wijzigen"</string>
    <string name="permdesc_changeWimaxState" product="tablet" msgid="3156456504084201805">"Hiermee kan de app de tablet verbinden met WiMAX-netwerken en de verbinding daarmee verbreken."</string>
    <string name="permdesc_changeWimaxState" product="default" msgid="697025043004923798">"Hiermee kan de app de telefoon verbinden met WiMAX-netwerken en de verbinding daarmee verbreken."</string>
    <string name="permlab_bluetooth" msgid="6127769336339276828">"koppelen met Bluetooth-apparaten"</string>
    <string name="permdesc_bluetooth" product="tablet" msgid="3480722181852438628">"Hiermee kan de app de Bluetooth-configuratie van de tablet bekijken en verbindingen met gekoppelde apparaten maken en accepteren."</string>
    <string name="permdesc_bluetooth" product="default" msgid="3207106324452312739">"Hiermee kan de app de Bluetooth-configuratie van de telefoon bekijken en verbindingen met gekoppelde apparaten maken en accepteren."</string>
    <string name="permlab_nfc" msgid="4423351274757876953">"Near Field Communication regelen"</string>
    <string name="permdesc_nfc" msgid="7120611819401789907">"Hiermee kan de app communiceren met NFC-tags (Near Field Communication), kaarten en lezers."</string>
    <string name="permlab_disableKeyguard" msgid="3598496301486439258">"uw schermvergrendeling uitschakelen"</string>
    <string name="permdesc_disableKeyguard" msgid="6034203065077122992">"Hiermee kan de app de toetsenblokkering en bijbehorende wachtwoordbeveiliging uitschakelen. Zo kan de telefoon de toetsenblokkering uitschakelen wanneer er een oproep binnenkomt en de toetsenblokkering weer inschakelen als de oproep is beëindigd."</string>
    <string name="permlab_readSyncSettings" msgid="6201810008230503052">"synchronisatie-instellingen lezen"</string>
    <string name="permdesc_readSyncSettings" msgid="2706745674569678644">"Hiermee kan de app de synchronisatie-instellingen voor een account lezen. Dit kan bijvoorbeeld bepalen of de app Personen wordt gesynchroniseerd met een account."</string>
    <string name="permlab_writeSyncSettings" msgid="5408694875793945314">"synchronisatie in- en uitschakelen"</string>
    <string name="permdesc_writeSyncSettings" msgid="8956262591306369868">"Hiermee kan een app de synchronisatie-instellingen aanpassen voor een account. Deze toestemming kan bijvoorbeeld worden gebruikt om synchronisatie van de app Personen in te schakelen voor een account."</string>
    <string name="permlab_readSyncStats" msgid="7396577451360202448">"synchronisatiestatistieken lezen"</string>
    <string name="permdesc_readSyncStats" msgid="1510143761757606156">"Hiermee kan een app de synchronisatiestatistieken voor een account lezen, inclusief de geschiedenis van synchronisatie-activiteiten en hoeveel gegevens zijn gesynchroniseerd."</string>
    <string name="permlab_subscribedFeedsRead" msgid="4756609637053353318">"geabonneerde feeds lezen"</string>
    <string name="permdesc_subscribedFeedsRead" msgid="5557058907906144505">"Hiermee kan de app details over de huidige gesynchroniseerde feeds achterhalen."</string>
    <string name="permlab_subscribedFeedsWrite" msgid="9015246325408209296">"geabonneerde feeds schrijven"</string>
    <string name="permdesc_subscribedFeedsWrite" msgid="6928930188826089413">"Hiermee kan de app uw momenteel gesynchroniseerde feeds aanpassen. Schadelijke apps kunnen uw gesynchroniseerde feeds wijzigen."</string>
    <string name="permlab_readDictionary" msgid="4107101525746035718">"termen lezen die u heeft toegevoegd aan het woordenboek"</string>
    <string name="permdesc_readDictionary" msgid="659614600338904243">"Hiermee kan de app alle woorden, namen en woordcombinaties lezen die de gebruiker heeft opgeslagen in het gebruikerswoordenboek."</string>
    <string name="permlab_writeDictionary" msgid="2183110402314441106">"woorden toevoegen aan het gebruikerswoordenboek"</string>
    <string name="permdesc_writeDictionary" msgid="8185385716255065291">"Hiermee kan de app nieuwe woorden schrijven naar het gebruikerswoordenboek."</string>
    <string name="permlab_sdcardRead" product="nosdcard" msgid="367275095159405468">"de inhoud van uw USB-opslag lezen"</string>
    <string name="permlab_sdcardRead" product="default" msgid="2188156462934977940">"de inhoud van uw SD-kaart lezen"</string>
    <string name="permdesc_sdcardRead" product="nosdcard" msgid="3446988712598386079">"De app toestaan de inhoud van uw USB-opslag te lezen."</string>
    <string name="permdesc_sdcardRead" product="default" msgid="2607362473654975411">"De app toestaan de inhoud van uw SD-kaart te lezen."</string>
    <string name="permlab_sdcardWrite" product="nosdcard" msgid="8485979062254666748">"de inhoud van uw USB-opslag aanpassen of verwijderen"</string>
    <string name="permlab_sdcardWrite" product="default" msgid="8805693630050458763">"de inhoud van uw SD-kaart aanpassen of verwijderen"</string>
    <string name="permdesc_sdcardWrite" product="nosdcard" msgid="6175406299445710888">"Hiermee kan de app schrijven naar de USB-opslag."</string>
    <string name="permdesc_sdcardWrite" product="default" msgid="4337417790936632090">"Hiermee kan de app schrijven naar de SD-kaart."</string>
    <string name="permlab_mediaStorageWrite" product="default" msgid="6859839199706879015">"inh. mediaopsl. wijz./verw."</string>
    <string name="permdesc_mediaStorageWrite" product="default" msgid="8189160597698529185">"Hiermee kan de app de inhoud van de interne mediaopslag aanpassen."</string>
    <string name="permlab_manageDocs" product="default" msgid="5778318598448849829">"documentopslag beheren"</string>
    <string name="permdesc_manageDocs" product="default" msgid="8704323176914121484">"Hiermee kan de app documentopslag beheren."</string>
    <string name="permlab_sdcardAccessAll" msgid="8150613823900460576">"toegang tot externe opslag van alle gebruikers"</string>
    <string name="permdesc_sdcardAccessAll" msgid="3215208357415891320">"Hiermee krijgt de app toegang tot externe opslag van alle gebruikers."</string>
    <string name="permlab_cache_filesystem" msgid="5656487264819669824">"het cachebestandssysteem openen"</string>
    <string name="permdesc_cache_filesystem" msgid="5578967642265550955">"Hiermee kan de app het cachebestandssysteem lezen en schrijven."</string>
    <string name="permlab_use_sip" msgid="5986952362795870502">"internetoproepen starten/ontvangen"</string>
    <string name="permdesc_use_sip" msgid="4717632000062674294">"Hiermee kan de app de SIP-service gebruiken om internetoproepen te starten/te ontvangen."</string>
    <string name="permlab_bind_call_service" msgid="6724009726671246551">"interactie met scherm in actieve oproep"</string>
    <string name="permdesc_bind_call_service" msgid="8732547662442572435">"Hiermee kan de app bepalen wanneer en hoe de gebruiker het scherm in een actieve oproep te zien krijgt."</string>
    <string name="permlab_readNetworkUsageHistory" msgid="7862593283611493232">"historisch netwerkgebruik lezen"</string>
    <string name="permdesc_readNetworkUsageHistory" msgid="7689060749819126472">"Hiermee kan de app historisch netwerkgebruik voor specifieke netwerken en apps lezen."</string>
    <string name="permlab_manageNetworkPolicy" msgid="2562053592339859990">"netwerkbeleid beheren"</string>
    <string name="permdesc_manageNetworkPolicy" msgid="7537586771559370668">"Hiermee kan de app het netwerkbeleid beheren en app-specifieke regels definiëren."</string>
    <string name="permlab_modifyNetworkAccounting" msgid="5088217309088729650">"verrekening van netwerkgebruik aanpassen"</string>
    <string name="permdesc_modifyNetworkAccounting" msgid="5443412866746198123">"Hiermee kan een app aanpassen hoe het netwerkgebruik wordt toegekend aan apps. Dit wordt niet gebruikt door normale apps."</string>
    <string name="permlab_markNetworkSocket" msgid="3658527214914959749">"socketmarkeringen aanpassen"</string>
    <string name="permdesc_markNetworkSocket" msgid="7655568433696356578">"Hiermee kan de app socketmarkeringen voor routeren aanpassen"</string>
    <string name="permlab_accessNotifications" msgid="7673416487873432268">"toegang tot meldingen"</string>
    <string name="permdesc_accessNotifications" msgid="458457742683431387">"Hiermee kan de app meldingen ophalen, onderzoeken en wissen, waaronder meldingen die zijn verzonden door andere apps."</string>
    <string name="permlab_bindNotificationListenerService" msgid="7057764742211656654">"koppelen aan een listener-service voor meldingen"</string>
    <string name="permdesc_bindNotificationListenerService" msgid="985697918576902986">"Hiermee kan de houder koppelen aan de hoofdinterface van een listener-service voor meldingen. Nooit vereist voor normale apps."</string>
    <string name="permlab_invokeCarrierSetup" msgid="3699600833975117478">"de door de provider geleverde configuratie-app aanroepen"</string>
    <string name="permdesc_invokeCarrierSetup" msgid="4159549152529111920">"Hiermee kan de houder de door de provider geleverde configuratie-app aanroepen. Nooit vereist voor normale apps."</string>
    <string name="permlab_accessNetworkConditions" msgid="8206077447838909516">"controleren op waarnemingen met betrekking tot netwerkomstandigheden"</string>
    <string name="permdesc_accessNetworkConditions" msgid="6899102075825272211">"Hiermee kan een app controleren op waarnemingen met betrekking tot netwerkomstandigheden. Nooit vereist voor normale apps."</string>
    <string name="policylab_limitPassword" msgid="4497420728857585791">"Wachtwoordregels instellen"</string>
    <string name="policydesc_limitPassword" msgid="3252114203919510394">"De lengte en tekens beheren die zijn toegestaan in wachtwoorden voor schermontgrendeling."</string>
    <string name="policylab_watchLogin" msgid="914130646942199503">"Pogingen voor schermontgrendeling bijhouden"</string>
    <string name="policydesc_watchLogin" product="tablet" msgid="3215729294215070072">"Bijhouden hoe vaak onjuiste wachtwoorden worden ingevoerd wanneer het scherm wordt ontgrendeld en de tablet vergrendelen of alle gegevens op de tablet wissen als te veel onjuiste wachtwoorden worden ingevoerd."</string>
    <string name="policydesc_watchLogin" product="default" msgid="5712323091846761073">"Bijhouden hoe vaak onjuiste wachtwoorden worden ingevoerd wanneer het scherm wordt ontgrendeld en de telefoon vergrendelen of alle gegevens op de telefoon wissen als te veel onjuiste wachtwoorden worden ingevoerd."</string>
    <string name="policylab_resetPassword" msgid="2620077191242688955">"Het wachtwoord voor schermontgrendeling wijzigen"</string>
    <string name="policydesc_resetPassword" msgid="605963962301904458">"Het wachtwoord voor schermontgrendeling wijzigen."</string>
    <string name="policylab_forceLock" msgid="2274085384704248431">"Het scherm vergrendelen"</string>
    <string name="policydesc_forceLock" msgid="1141797588403827138">"Beheren hoe en wanneer het scherm wordt vergrendeld."</string>
    <string name="policylab_wipeData" msgid="3910545446758639713">"Alle gegevens wissen"</string>
    <string name="policydesc_wipeData" product="tablet" msgid="4306184096067756876">"De gegevens van de tablet zonder waarschuwing wissen door de fabrieksinstellingen te herstellen."</string>
    <string name="policydesc_wipeData" product="default" msgid="5096895604574188391">"De gegevens van de telefoon zonder waarschuwing wissen door de fabrieksinstellingen te herstellen."</string>
    <string name="policylab_setGlobalProxy" msgid="2784828293747791446">"Algemene proxy voor het apparaat instellen"</string>
    <string name="policydesc_setGlobalProxy" msgid="6387497466660154931">"Stel de algemene proxy voor het apparaat in die moet worden gebruikt terwijl het beleid is geactiveerd. Alleen de eerste apparaatbeheerder stelt de algemene proxy in."</string>
    <string name="policylab_expirePassword" msgid="885279151847254056">"Verval wachtwoord instellen"</string>
    <string name="policydesc_expirePassword" msgid="1729725226314691591">"Beheren hoe vaak het wachtwoord voor schermvergrendeling moet worden gewijzigd."</string>
    <string name="policylab_encryptedStorage" msgid="8901326199909132915">"Codering voor opslag instellen"</string>
    <string name="policydesc_encryptedStorage" msgid="2637732115325316992">"Vereisen dat opgeslagen appgegevens kunnen worden gecodeerd."</string>
    <string name="policylab_disableCamera" msgid="6395301023152297826">"Camera\'s uitschakelen"</string>
    <string name="policydesc_disableCamera" msgid="2306349042834754597">"Het gebruik van alle apparaatcamera\'s voorkomen."</string>
    <string name="policylab_disableKeyguardFeatures" msgid="266329104542638802">"Functies uit in toetsblokk."</string>
    <string name="policydesc_disableKeyguardFeatures" msgid="3467082272186534614">"Gebruik van bepaalde functies voorkomen in toetsblokkering."</string>
  <string-array name="phoneTypes">
    <item msgid="8901098336658710359">"Thuis"</item>
    <item msgid="869923650527136615">"Mobiel"</item>
    <item msgid="7897544654242874543">"Werk"</item>
    <item msgid="1103601433382158155">"Fax werk"</item>
    <item msgid="1735177144948329370">"Fax thuis"</item>
    <item msgid="603878674477207394">"Semafoon"</item>
    <item msgid="1650824275177931637">"Overig"</item>
    <item msgid="9192514806975898961">"Aangepast"</item>
  </string-array>
  <string-array name="emailAddressTypes">
    <item msgid="8073994352956129127">"Thuis"</item>
    <item msgid="7084237356602625604">"Werk"</item>
    <item msgid="1112044410659011023">"Overig"</item>
    <item msgid="2374913952870110618">"Aangepast"</item>
  </string-array>
  <string-array name="postalAddressTypes">
    <item msgid="6880257626740047286">"Thuis"</item>
    <item msgid="5629153956045109251">"Werk"</item>
    <item msgid="4966604264500343469">"Overig"</item>
    <item msgid="4932682847595299369">"Aangepast"</item>
  </string-array>
  <string-array name="imAddressTypes">
    <item msgid="1738585194601476694">"Thuis"</item>
    <item msgid="1359644565647383708">"Werk"</item>
    <item msgid="7868549401053615677">"Overig"</item>
    <item msgid="3145118944639869809">"Aangepast"</item>
  </string-array>
  <string-array name="organizationTypes">
    <item msgid="7546335612189115615">"Werk"</item>
    <item msgid="4378074129049520373">"Overig"</item>
    <item msgid="3455047468583965104">"Aangepast"</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">"Aangepast"</string>
    <string name="phoneTypeHome" msgid="2570923463033985887">"Thuis"</string>
    <string name="phoneTypeMobile" msgid="6501463557754751037">"Mobiel"</string>
    <string name="phoneTypeWork" msgid="8863939667059911633">"Werk"</string>
    <string name="phoneTypeFaxWork" msgid="3517792160008890912">"Fax werk"</string>
    <string name="phoneTypeFaxHome" msgid="2067265972322971467">"Fax thuis"</string>
    <string name="phoneTypePager" msgid="7582359955394921732">"Pager"</string>
    <string name="phoneTypeOther" msgid="1544425847868765990">"Overig"</string>
    <string name="phoneTypeCallback" msgid="2712175203065678206">"Terugbelnummer"</string>
    <string name="phoneTypeCar" msgid="8738360689616716982">"Auto"</string>
    <string name="phoneTypeCompanyMain" msgid="540434356461478916">"Bedrijf, algemeen"</string>
    <string name="phoneTypeIsdn" msgid="8022453193171370337">"ISDN"</string>
    <string name="phoneTypeMain" msgid="6766137010628326916">"Algemeen"</string>
    <string name="phoneTypeOtherFax" msgid="8587657145072446565">"Andere fax"</string>
    <string name="phoneTypeRadio" msgid="4093738079908667513">"Radio"</string>
    <string name="phoneTypeTelex" msgid="3367879952476250512">"Telex"</string>
    <string name="phoneTypeTtyTdd" msgid="8606514378585000044">"Teksttelefoon"</string>
    <string name="phoneTypeWorkMobile" msgid="1311426989184065709">"Mobiel werk"</string>
    <string name="phoneTypeWorkPager" msgid="649938731231157056">"Pager werk"</string>
    <string name="phoneTypeAssistant" msgid="5596772636128562884">"Assistent"</string>
    <string name="phoneTypeMms" msgid="7254492275502768992">"MMS"</string>
    <string name="eventTypeCustom" msgid="7837586198458073404">"Aangepast"</string>
    <string name="eventTypeBirthday" msgid="2813379844211390740">"Verjaardag"</string>
    <string name="eventTypeAnniversary" msgid="3876779744518284000">"Jubileum"</string>
    <string name="eventTypeOther" msgid="7388178939010143077">"Overig"</string>
    <string name="emailTypeCustom" msgid="8525960257804213846">"Aangepast"</string>
    <string name="emailTypeHome" msgid="449227236140433919">"Thuis"</string>
    <string name="emailTypeWork" msgid="3548058059601149973">"Werk"</string>
    <string name="emailTypeOther" msgid="2923008695272639549">"Overig"</string>
    <string name="emailTypeMobile" msgid="119919005321166205">"Mobiel"</string>
    <string name="postalTypeCustom" msgid="8903206903060479902">"Aangepast"</string>
    <string name="postalTypeHome" msgid="8165756977184483097">"Thuis"</string>
    <string name="postalTypeWork" msgid="5268172772387694495">"Werk"</string>
    <string name="postalTypeOther" msgid="2726111966623584341">"Overig"</string>
    <string name="imTypeCustom" msgid="2074028755527826046">"Aangepast"</string>
    <string name="imTypeHome" msgid="6241181032954263892">"Thuis"</string>
    <string name="imTypeWork" msgid="1371489290242433090">"Werk"</string>
    <string name="imTypeOther" msgid="5377007495735915478">"Overig"</string>
    <string name="imProtocolCustom" msgid="6919453836618749992">"Aangepast"</string>
    <string name="imProtocolAim" msgid="7050360612368383417">"AIM"</string>
    <string name="imProtocolMsn" msgid="144556545420769442">"Windows Live"</string>
    <string name="imProtocolYahoo" msgid="8271439408469021273">"Yahoo"</string>
    <string name="imProtocolSkype" msgid="9019296744622832951">"Skype"</string>
    <string name="imProtocolQq" msgid="8887484379494111884">"QQ"</string>
    <string name="imProtocolGoogleTalk" msgid="493902321140277304">"Hangouts"</string>
    <string name="imProtocolIcq" msgid="1574870433606517315">"ICQ"</string>
    <string name="imProtocolJabber" msgid="2279917630875771722">"Jabber"</string>
    <string name="imProtocolNetMeeting" msgid="8287625655986827971">"NetMeeting"</string>
    <string name="orgTypeWork" msgid="29268870505363872">"Werk"</string>
    <string name="orgTypeOther" msgid="3951781131570124082">"Overig"</string>
    <string name="orgTypeCustom" msgid="225523415372088322">"Aangepast"</string>
    <string name="relationTypeCustom" msgid="3542403679827297300">"Aangepast"</string>
    <string name="relationTypeAssistant" msgid="6274334825195379076">"Assistent"</string>
    <string name="relationTypeBrother" msgid="8757913506784067713">"Broer"</string>
    <string name="relationTypeChild" msgid="1890746277276881626">"Kind"</string>
    <string name="relationTypeDomesticPartner" msgid="6904807112121122133">"Levenspartner"</string>
    <string name="relationTypeFather" msgid="5228034687082050725">"Vader"</string>
    <string name="relationTypeFriend" msgid="7313106762483391262">"Vriend"</string>
    <string name="relationTypeManager" msgid="6365677861610137895">"Manager"</string>
    <string name="relationTypeMother" msgid="4578571352962758304">"Moeder"</string>
    <string name="relationTypeParent" msgid="4755635567562925226">"Ouder"</string>
    <string name="relationTypePartner" msgid="7266490285120262781">"Partner"</string>
    <string name="relationTypeReferredBy" msgid="101573059844135524">"Genoemd door"</string>
    <string name="relationTypeRelative" msgid="1799819930085610271">"Familielid"</string>
    <string name="relationTypeSister" msgid="1735983554479076481">"Zus"</string>
    <string name="relationTypeSpouse" msgid="394136939428698117">"Echtgenoot/-genote"</string>
    <string name="sipAddressTypeCustom" msgid="2473580593111590945">"Aangepast"</string>
    <string name="sipAddressTypeHome" msgid="6093598181069359295">"Startpagina"</string>
    <string name="sipAddressTypeWork" msgid="6920725730797099047">"Werk"</string>
    <string name="sipAddressTypeOther" msgid="4408436162950119849">"Overig"</string>
    <string name="keyguard_password_enter_pin_code" msgid="3037685796058495017">"Pincode typen"</string>
    <string name="keyguard_password_enter_puk_code" msgid="4800725266925845333">"Geef de PUK-code en de nieuwe pincode op"</string>
    <string name="keyguard_password_enter_puk_prompt" msgid="1341112146710087048">"PUK-code"</string>
    <string name="keyguard_password_enter_pin_prompt" msgid="8027680321614196258">"Nieuwe pincode"</string>
    <string name="keyguard_password_entry_touch_hint" msgid="7858547464982981384"><font size="17">"Raak aan om wachtwoord in te voeren"</font></string>
    <string name="keyguard_password_enter_password_code" msgid="1054721668279049780">"Typ het wachtwoord om te ontgrendelen"</string>
    <string name="keyguard_password_enter_pin_password_code" msgid="6391755146112503443">"Typ pincode om te ontgrendelen"</string>
    <string name="keyguard_password_wrong_pin_code" msgid="2422225591006134936">"Onjuiste pincode."</string>
    <string name="keyguard_label_text" msgid="861796461028298424">"Druk op \'Menu\' en vervolgens op 0 om te ontgrendelen."</string>
    <string name="emergency_call_dialog_number_for_display" msgid="696192103195090970">"Alarmnummer"</string>
    <string name="lockscreen_carrier_default" msgid="8963839242565653192">"Geen service"</string>
    <string name="lockscreen_screen_locked" msgid="7288443074806832904">"Scherm vergrendeld."</string>
    <string name="lockscreen_instructions_when_pattern_enabled" msgid="46154051614126049">"Druk op \'Menu\' om te ontgrendelen of noodoproep te plaatsen."</string>
    <string name="lockscreen_instructions_when_pattern_disabled" msgid="686260028797158364">"Druk op \'Menu\' om te ontgrendelen."</string>
    <string name="lockscreen_pattern_instructions" msgid="7478703254964810302">"Patroon tekenen om te ontgrendelen"</string>
    <string name="lockscreen_emergency_call" msgid="5347633784401285225">"Noodoproep"</string>
    <string name="lockscreen_return_to_call" msgid="5244259785500040021">"Terug naar gesprek"</string>
    <string name="lockscreen_pattern_correct" msgid="9039008650362261237">"Juist!"</string>
    <string name="lockscreen_pattern_wrong" msgid="4317955014948108794">"Opnieuw proberen"</string>
    <string name="lockscreen_password_wrong" msgid="5737815393253165301">"Nogmaals proberen"</string>
    <string name="faceunlock_multiple_failures" msgid="754137583022792429">"Maximaal aantal pogingen voor Ontgrendelen via gezichtsherkenning overschreden"</string>
    <string name="lockscreen_plugged_in" msgid="8057762828355572315">"Opladen, <xliff:g id="NUMBER">%d</xliff:g><xliff:g id="PERCENT">%%</xliff:g>"</string>
    <string name="lockscreen_charged" msgid="321635745684060624">"Opgeladen"</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">"Sluit de oplader aan."</string>
    <string name="lockscreen_missing_sim_message_short" msgid="5099439277819215399">"Geen simkaart"</string>
    <string name="lockscreen_missing_sim_message" product="tablet" msgid="151659196095791474">"Geen SIM-kaart in tablet."</string>
    <string name="lockscreen_missing_sim_message" product="default" msgid="2186920585695169078">"Geen SIM-kaart in telefoon."</string>
    <string name="lockscreen_missing_sim_instructions" msgid="5372787138023272615">"Plaats een simkaart."</string>
    <string name="lockscreen_missing_sim_instructions_long" msgid="3526573099019319472">"De simkaart ontbreekt of kan niet worden gelezen. Plaats een simkaart."</string>
    <string name="lockscreen_permanent_disabled_sim_message_short" msgid="5096149665138916184">"Onbruikbare simkaart."</string>
    <string name="lockscreen_permanent_disabled_sim_instructions" msgid="910904643433151371">"Uw simkaart is permanent uitgeschakeld.\n Neem contact op met uw mobiele serviceprovider voor een nieuwe simkaart."</string>
    <string name="lockscreen_transport_prev_description" msgid="201594905152746886">"Knop voor vorig nummer"</string>
    <string name="lockscreen_transport_next_description" msgid="6089297650481292363">"Knop voor volgend nummer"</string>
    <string name="lockscreen_transport_pause_description" msgid="7659088786780128001">"Knop voor onderbreken"</string>
    <string name="lockscreen_transport_play_description" msgid="5888422938351019426">"Knop voor afspelen"</string>
    <string name="lockscreen_transport_stop_description" msgid="4562318378766987601">"Knop voor stoppen"</string>
    <string name="emergency_calls_only" msgid="6733978304386365407">"Alleen noodoproepen"</string>
    <string name="lockscreen_network_locked_message" msgid="143389224986028501">"Netwerk vergrendeld"</string>
    <string name="lockscreen_sim_puk_locked_message" msgid="7441797339976230">"SIM-kaart is vergrendeld met PUK-code."</string>
    <string name="lockscreen_sim_puk_locked_instructions" msgid="8127916255245181063">"Raadpleeg de gebruikershandleiding of neem contact op met de klantenservice."</string>
    <string name="lockscreen_sim_locked_message" msgid="8066660129206001039">"SIM-kaart is vergrendeld."</string>
    <string name="lockscreen_sim_unlock_progress_dialog_message" msgid="595323214052881264">"SIM-kaart ontgrendelen..."</string>
    <string name="lockscreen_too_many_failed_attempts_dialog_message" msgid="6481623830344107222">"U heeft uw ontgrendelingspatroon <xliff:g id="NUMBER_0">%d</xliff:g> keer onjuist getekend. \n\nProbeer het over <xliff:g id="NUMBER_1">%d</xliff:g> seconden opnieuw."</string>
    <string name="lockscreen_too_many_failed_password_attempts_dialog_message" msgid="2725973286239344555">"U heeft uw wachtwoord <xliff:g id="NUMBER_0">%d</xliff:g> keer onjuist getypt. \n\nProbeer het over <xliff:g id="NUMBER_1">%d</xliff:g> seconden opnieuw."</string>
    <string name="lockscreen_too_many_failed_pin_attempts_dialog_message" msgid="6216672706545696955">"U heeft uw pincode <xliff:g id="NUMBER_0">%d</xliff:g> keer onjuist getypt. \n\nProbeer het over <xliff:g id="NUMBER_1">%d</xliff:g> seconden opnieuw."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="tablet" msgid="9191611984625460820">"U heeft uw ontgrendelingspatroon <xliff:g id="NUMBER_0">%d</xliff:g> keer onjuist getekend. Na nog eens <xliff:g id="NUMBER_1">%d</xliff:g> mislukte pogingen wordt u gevraagd uw tablet te ontgrendelen met uw aanmeldingsgegevens voor Google.\n\n Probeer het over <xliff:g id="NUMBER_2">%d</xliff:g> seconden opnieuw."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="default" msgid="2590227559763762751">"U heeft uw ontgrendelingspatroon <xliff:g id="NUMBER_0">%d</xliff:g> keer onjuist getekend. Na nog eens <xliff:g id="NUMBER_1">%d</xliff:g> mislukte pogingen wordt u gevraagd uw telefoon te ontgrendelen met uw aanmeldingsgegevens voor Google.\n\n Probeer het over <xliff:g id="NUMBER_2">%d</xliff:g> seconden opnieuw."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="tablet" msgid="6128106399745755604">"U heeft <xliff:g id="NUMBER_0">%d</xliff:g> keer geprobeerd de tablet op een onjuiste manier te ontgrendelen. Na nog eens <xliff:g id="NUMBER_1">%d</xliff:g> mislukte pogingen worden de fabrieksinstellingen hersteld op de tablet en gaan alle gebruikersgegevens verloren."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="default" msgid="8603565142156826565">"U heeft nu <xliff:g id="NUMBER_0">%d</xliff:g> keer geprobeerd de telefoon op een onjuiste manier te ontgrendelen. Na nog eens <xliff:g id="NUMBER_1">%d</xliff:g> mislukte pogingen worden de fabrieksinstellingen hersteld op de telefoon en gaan alle gebruikersgegevens verloren."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="tablet" msgid="280873516493934365">"U heeft <xliff:g id="NUMBER">%d</xliff:g> keer geprobeerd de tablet op een onjuiste manier te ontgrendelen. De fabrieksinstellingen worden nu hersteld op de tablet."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="default" msgid="3025504721764922246">"U heeft <xliff:g id="NUMBER">%d</xliff:g> keer geprobeerd de telefoon op een onjuiste manier te ontgrendelen. De fabrieksinstellingen worden nu hersteld op de telefoon."</string>
    <string name="lockscreen_too_many_failed_attempts_countdown" msgid="6251480343394389665">"Probeer het over <xliff:g id="NUMBER">%d</xliff:g> seconden opnieuw."</string>
    <string name="lockscreen_forgot_pattern_button_text" msgid="2626999449610695930">"Patroon vergeten?"</string>
    <string name="lockscreen_glogin_forgot_pattern" msgid="2588521501166032747">"Account ontgrendelen"</string>
    <string name="lockscreen_glogin_too_many_attempts" msgid="2751368605287288808">"Te veel patroonpogingen"</string>
    <string name="lockscreen_glogin_instructions" msgid="3931816256100707784">"Log in op uw Google-account om te ontgrendelen."</string>
    <string name="lockscreen_glogin_username_hint" msgid="8846881424106484447">"Gebruikersnaam (e-mail)"</string>
    <string name="lockscreen_glogin_password_hint" msgid="5958028383954738528">"Wachtwoord"</string>
    <string name="lockscreen_glogin_submit_button" msgid="7130893694795786300">"Inloggen"</string>
    <string name="lockscreen_glogin_invalid_input" msgid="1364051473347485908">"Gebruikersnaam of wachtwoord ongeldig."</string>
    <string name="lockscreen_glogin_account_recovery_hint" msgid="1696924763690379073">"Bent u uw gebruikersnaam of wachtwoord vergeten?\nGa naar "<b>"https://www.google.com/accounts/recovery"</b>"."</string>
    <string name="lockscreen_glogin_checking_password" msgid="7114627351286933867">"Controleren…"</string>
    <string name="lockscreen_unlock_label" msgid="737440483220667054">"Ontgrendelen"</string>
    <string name="lockscreen_sound_on_label" msgid="9068877576513425970">"Geluid aan"</string>
    <string name="lockscreen_sound_off_label" msgid="996822825154319026">"Geluid uit"</string>
    <string name="lockscreen_access_pattern_start" msgid="3941045502933142847">"Patroon gestart"</string>
    <string name="lockscreen_access_pattern_cleared" msgid="5583479721001639579">"Patroon gewist"</string>
    <string name="lockscreen_access_pattern_cell_added" msgid="6756031208359292487">"Cel toegevoegd"</string>
    <string name="lockscreen_access_pattern_detected" msgid="4988730895554057058">"Patroon voltooid"</string>
    <string name="keyguard_accessibility_widget_changed" msgid="5678624624681400191">"%1$s. Widget %2$d van %3$d."</string>
    <string name="keyguard_accessibility_add_widget" msgid="8273277058724924654">"Widget toevoegen."</string>
    <string name="keyguard_accessibility_widget_empty_slot" msgid="1281505703307930757">"Leeg"</string>
    <string name="keyguard_accessibility_unlock_area_expanded" msgid="2278106022311170299">"Ontgrendelingsgebied uitgevouwen."</string>
    <string name="keyguard_accessibility_unlock_area_collapsed" msgid="6366992066936076396">"Ontgrendelingsgebied samengevouwen."</string>
    <string name="keyguard_accessibility_widget" msgid="6527131039741808240">"Widget <xliff:g id="WIDGET_INDEX">%1$s</xliff:g>."</string>
    <string name="keyguard_accessibility_user_selector" msgid="1226798370913698896">"Gebruikersselectie"</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">"Mediabediening"</string>
    <string name="keyguard_accessibility_widget_reorder_start" msgid="8736853615588828197">"Opnieuw indelen van widget gestart."</string>
    <string name="keyguard_accessibility_widget_reorder_end" msgid="7170190950870468320">"Opnieuw indelen van widget beëindigd."</string>
    <string name="keyguard_accessibility_widget_deleted" msgid="4426204263929224434">"Widget <xliff:g id="WIDGET_INDEX">%1$s</xliff:g> verwijderd."</string>
    <string name="keyguard_accessibility_expand_lock_area" msgid="519859720934178024">"Ontgrendelingsgebied uitvouwen."</string>
    <string name="keyguard_accessibility_slide_unlock" msgid="2959928478764697254">"Ontgrendeling via schuiven."</string>
    <string name="keyguard_accessibility_pattern_unlock" msgid="1490840706075246612">"Ontgrendeling via patroon."</string>
    <string name="keyguard_accessibility_face_unlock" msgid="4817282543351718535">"Ontgrendelen via gezichtsherkenning"</string>
    <string name="keyguard_accessibility_pin_unlock" msgid="2469687111784035046">"Ontgrendeling via pincode."</string>
    <string name="keyguard_accessibility_password_unlock" msgid="7675777623912155089">"Ontgrendeling via wachtwoord."</string>
    <string name="keyguard_accessibility_pattern_area" msgid="7679891324509597904">"Tekengebied voor patroon."</string>
    <string name="keyguard_accessibility_slide_area" msgid="6736064494019979544">"Schuifgebied."</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">"teken"</string>
    <string name="granularity_label_word" msgid="7075570328374918660">"woord"</string>
    <string name="granularity_label_link" msgid="5815508880782488267">"link"</string>
    <string name="granularity_label_line" msgid="5764267235026120888">"lijn"</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">"Fabriekstest mislukt"</string>
    <string name="factorytest_not_system" msgid="4435201656767276723">"De actie FACTORY_TEST wordt alleen ondersteund voor pakketten die zijn geïnstalleerd in /system/app."</string>
    <string name="factorytest_no_action" msgid="872991874799998561">"Er is geen pakket gevonden dat de actie FACTORY_TEST levert."</string>
    <string name="factorytest_reboot" msgid="6320168203050791643">"Opnieuw opstarten"</string>
    <string name="js_dialog_title" msgid="1987483977834603872">"De pagina op \'<xliff:g id="TITLE">%s</xliff:g>\' meldt het volgende:"</string>
    <string name="js_dialog_title_default" msgid="6961903213729667573">"JavaScript"</string>
    <string name="js_dialog_before_unload_title" msgid="2619376555525116593">"Navigatie bevestigen"</string>
    <string name="js_dialog_before_unload_positive_button" msgid="3112752010600484130">"Deze pagina verlaten"</string>
    <string name="js_dialog_before_unload_negative_button" msgid="5614861293026099715">"Op deze pagina blijven"</string>
    <string name="js_dialog_before_unload" msgid="3468816357095378590">"<xliff:g id="MESSAGE">%s</xliff:g>\n\nWeet u zeker dat u deze pagina wilt verlaten?"</string>
    <string name="save_password_label" msgid="6860261758665825069">"Bevestigen"</string>
    <string name="double_tap_toast" msgid="4595046515400268881">"Tip: dubbeltik om in en uit te zoomen."</string>
    <string name="autofill_this_form" msgid="4616758841157816676">"Autom. aanvullen"</string>
    <string name="setup_autofill" msgid="7103495070180590814">"Autom. aanvullen instellen"</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">"Provincie"</string>
    <string name="autofill_postal_code" msgid="4696430407689377108">"Postcode"</string>
    <string name="autofill_state" msgid="6988894195520044613">"Staat"</string>
    <string name="autofill_zip_code" msgid="8697544592627322946">"Postcode"</string>
    <string name="autofill_county" msgid="237073771020362891">"County"</string>
    <string name="autofill_island" msgid="4020100875984667025">"Eiland"</string>
    <string name="autofill_district" msgid="8400735073392267672">"District"</string>
    <string name="autofill_department" msgid="5343279462564453309">"Departement"</string>
    <string name="autofill_prefecture" msgid="2028499485065800419">"Prefectuur"</string>
    <string name="autofill_parish" msgid="8202206105468820057">"Gemeente"</string>
    <string name="autofill_area" msgid="3547409050889952423">"Gebied"</string>
    <string name="autofill_emirate" msgid="2893880978835698818">"Emiraat"</string>
    <string name="permlab_readHistoryBookmarks" msgid="3775265775405106983">"uw webbladwijzers en -geschiedenis lezen"</string>
    <string name="permdesc_readHistoryBookmarks" msgid="8462378226600439658">"Hiermee kan de app de geschiedenis lezen van alle URL\'s die in de systeemeigen browser zijn bezocht, en alle bladwijzers in de systeemeigen browser. Let op: deze toestemming kan niet worden geforceerd door andere browsers of andere apps met internetmogelijkheden."</string>
    <string name="permlab_writeHistoryBookmarks" msgid="3714785165273314490">"webbladwijzers en -geschiedenis schrijven"</string>
    <string name="permdesc_writeHistoryBookmarks" product="tablet" msgid="6825527469145760922">"Hiermee kan de app de webgeschiedenis wijzigen in de systeemeigen browser en de bladwijzers die zijn opgeslagen op uw tablet. Deze toestemming kan niet worden geforceerd door andere browsers of andere apps met internetmogelijkheden.."</string>
    <string name="permdesc_writeHistoryBookmarks" product="default" msgid="8497389531014185509">"Hiermee kan de app de webgeschiedenis wijzigen in de systeemeigen browser en de bladwijzers die zijn opgeslagen op uw telefoon. Deze toestemming kan niet worden geforceerd door andere browsers of andere apps met internetmogelijkheden."</string>
    <string name="permlab_setAlarm" msgid="1379294556362091814">"een alarm instellen"</string>
    <string name="permdesc_setAlarm" msgid="316392039157473848">"Hiermee kan de app een alarm instellen in een geïnstalleerde wekkerapp. Deze functie wordt door sommige wekkerapps niet geïmplementeerd."</string>
    <string name="permlab_addVoicemail" msgid="5525660026090959044">"voicemail toevoegen"</string>
    <string name="permdesc_addVoicemail" msgid="6604508651428252437">"Hiermee kan de app berichten toevoegen aan de inbox van uw voicemail."</string>
    <string name="permlab_writeGeolocationPermissions" msgid="5962224158955273932">"geolocatierechten voor browser aanpassen"</string>
    <string name="permdesc_writeGeolocationPermissions" msgid="1083743234522638747">"Hiermee kan de app de geolocatierechten van de browser aanpassen. Schadelijke apps kunnen dit gebruiken om locatiegegevens te verzenden naar willekeurige websites."</string>
    <string name="permlab_packageVerificationAgent" msgid="5568139100645829117">"pakketten controleren"</string>
    <string name="permdesc_packageVerificationAgent" msgid="8437590190990843381">"Hiermee kan de app controleren of een pakket kan worden geïnstalleerd."</string>
    <string name="permlab_bindPackageVerifier" msgid="4187786793360326654">"koppelen aan pakketcontroleprogramma"</string>
    <string name="permdesc_bindPackageVerifier" msgid="3180741773233862126">"Hiermee kan de houder verzoeken indienen voor pakketcontroles. Nooit vereist voor normale apps."</string>
    <string name="permlab_serialPort" msgid="546083327654631076">"toegang krijgen tot seriële poorten"</string>
    <string name="permdesc_serialPort" msgid="2991639985224598193">"De houder toestaan toegang tot seriële poorten te krijgen met de SerialManager API."</string>
    <string name="permlab_accessContentProvidersExternally" msgid="5077774297943409285">"externe toegang tot inhoudsproviders"</string>
    <string name="permdesc_accessContentProvidersExternally" msgid="4544346486697853685">"Hiermee kan de houder toegang krijgen tot inhoudsproviders via de shell. Nooit vereist voor normale apps."</string>
    <string name="permlab_updateLock" msgid="3527558366616680889">"automatische apparaatupdates afwijzen"</string>
    <string name="permdesc_updateLock" msgid="1655625832166778492">"Toestaan dat de houder informatie aan het systeem levert over welk moment een goed tijdstip is voor een niet-interactieve reboot om het apparaat bij te werken."</string>
    <string name="save_password_message" msgid="767344687139195790">"Wilt u dat de browser dit wachtwoord onthoudt?"</string>
    <string name="save_password_notnow" msgid="6389675316706699758">"Niet nu"</string>
    <string name="save_password_remember" msgid="6491879678996749466">"Onthouden"</string>
    <string name="save_password_never" msgid="8274330296785855105">"Nooit"</string>
    <string name="open_permission_deny" msgid="7374036708316629800">"U heeft geen toestemming om deze pagina te openen."</string>
    <string name="text_copied" msgid="4985729524670131385">"Tekst naar klembord gekopieerd."</string>
    <string name="more_item_label" msgid="4650918923083320495">"Meer"</string>
    <string name="prepend_shortcut_label" msgid="2572214461676015642">"Menu+"</string>
    <string name="menu_space_shortcut_label" msgid="2410328639272162537">"ruimte"</string>
    <string name="menu_enter_shortcut_label" msgid="2743362785111309668">"invoeren"</string>
    <string name="menu_delete_shortcut_label" msgid="3658178007202748164">"verwijderen"</string>
    <string name="search_go" msgid="8298016669822141719">"Zoeken"</string>
    <string name="searchview_description_search" msgid="6749826639098512120">"Zoeken"</string>
    <string name="searchview_description_query" msgid="5911778593125355124">"Zoekopdracht"</string>
    <string name="searchview_description_clear" msgid="1330281990951833033">"Zoekopdracht wissen"</string>
    <string name="searchview_description_submit" msgid="2688450133297983542">"Zoekopdracht verzenden"</string>
    <string name="searchview_description_voice" msgid="2453203695674994440">"Gesproken zoekopdrachten"</string>
    <string name="enable_explore_by_touch_warning_title" msgid="7460694070309730149">"\'Verkennen via aanraking\' aan?"</string>
    <string name="enable_explore_by_touch_warning_message" product="tablet" msgid="8655887539089910577">"<xliff:g id="ACCESSIBILITY_SERVICE_NAME">%1$s</xliff:g> wil \'Verkennen via aanraking\' inschakelen. Wanneer \'Verkennen via aanraking\' is ingeschakeld, kunt u beschrijvingen beluisteren of bekijken van wat er onder uw vinger staat of aanraakbewerkingen uitvoeren op de tablet."</string>
    <string name="enable_explore_by_touch_warning_message" product="default" msgid="2708199672852373195">"<xliff:g id="ACCESSIBILITY_SERVICE_NAME">%1$s</xliff:g> wil \'Verkennen via aanraking\' inschakelen. Wanneer \'Verkennen via aanraking\' is ingeschakeld, kunt u beschrijvingen beluisteren of bekijken van wat er onder uw vinger staat of aanraakbewerkingen uitvoeren op de telefoon."</string>
    <string name="oneMonthDurationPast" msgid="7396384508953779925">"1 maand geleden"</string>
    <string name="beforeOneMonthDurationPast" msgid="909134546836499826">"Meer dan 1 maand geleden"</string>
  <plurals name="num_seconds_ago">
    <item quantity="one" msgid="4869870056547896011">"1 seconde geleden"</item>
    <item quantity="other" msgid="3903706804349556379">"<xliff:g id="COUNT">%d</xliff:g> seconden geleden"</item>
  </plurals>
  <plurals name="num_minutes_ago">
    <item quantity="one" msgid="3306787433088810191">"1 minuut geleden"</item>
    <item quantity="other" msgid="2176942008915455116">"<xliff:g id="COUNT">%d</xliff:g> minuten geleden"</item>
  </plurals>
  <plurals name="num_hours_ago">
    <item quantity="one" msgid="9150797944610821849">"1 uur geleden"</item>
    <item quantity="other" msgid="2467273239587587569">"<xliff:g id="COUNT">%d</xliff:g> uur geleden"</item>
  </plurals>
  <plurals name="last_num_days">
    <item quantity="other" msgid="3069992808164318268">"Afgelopen <xliff:g id="COUNT">%d</xliff:g> dagen"</item>
  </plurals>
    <string name="last_month" msgid="3959346739979055432">"Afgelopen maand"</string>
    <string name="older" msgid="5211975022815554840">"Ouder"</string>
  <plurals name="num_days_ago">
    <item quantity="one" msgid="861358534398115820">"gisteren"</item>
    <item quantity="other" msgid="2479586466153314633">"<xliff:g id="COUNT">%d</xliff:g> dagen geleden"</item>
  </plurals>
  <plurals name="in_num_seconds">
    <item quantity="one" msgid="2729745560954905102">"over 1 seconde"</item>
    <item quantity="other" msgid="1241926116443974687">"over <xliff:g id="COUNT">%d</xliff:g> seconden"</item>
  </plurals>
  <plurals name="in_num_minutes">
    <item quantity="one" msgid="8793095251325200395">"over 1 minuut"</item>
    <item quantity="other" msgid="3330713936399448749">"over <xliff:g id="COUNT">%d</xliff:g> minuten"</item>
  </plurals>
  <plurals name="in_num_hours">
    <item quantity="one" msgid="7164353342477769999">"over 1 uur"</item>
    <item quantity="other" msgid="547290677353727389">"over <xliff:g id="COUNT">%d</xliff:g> uur"</item>
  </plurals>
  <plurals name="in_num_days">
    <item quantity="one" msgid="5413088743009839518">"morgen"</item>
    <item quantity="other" msgid="5109449375100953247">"over <xliff:g id="COUNT">%d</xliff:g> dagen"</item>
  </plurals>
  <plurals name="abbrev_num_seconds_ago">
    <item quantity="one" msgid="1849036840200069118">"1 seconde geleden"</item>
    <item quantity="other" msgid="3699169366650930415">"<xliff:g id="COUNT">%d</xliff:g> seconden geleden"</item>
  </plurals>
  <plurals name="abbrev_num_minutes_ago">
    <item quantity="one" msgid="6361490147113871545">"1 minuut geleden"</item>
    <item quantity="other" msgid="851164968597150710">"<xliff:g id="COUNT">%d</xliff:g> minuten geleden"</item>
  </plurals>
  <plurals name="abbrev_num_hours_ago">
    <item quantity="one" msgid="4796212039724722116">"1 uur geleden"</item>
    <item quantity="other" msgid="6889970745748538901">"<xliff:g id="COUNT">%d</xliff:g> uur geleden"</item>
  </plurals>
  <plurals name="abbrev_num_days_ago">
    <item quantity="one" msgid="8463161711492680309">"gisteren"</item>
    <item quantity="other" msgid="3453342639616481191">"<xliff:g id="COUNT">%d</xliff:g> dagen geleden"</item>
  </plurals>
  <plurals name="abbrev_in_num_seconds">
    <item quantity="one" msgid="5842225370795066299">"over 1 seconde"</item>
    <item quantity="other" msgid="5495880108825805108">"over <xliff:g id="COUNT">%d</xliff:g> seconden"</item>
  </plurals>
  <plurals name="abbrev_in_num_minutes">
    <item quantity="one" msgid="562786149928284878">"over 1 minuut"</item>
    <item quantity="other" msgid="4216113292706568726">"over <xliff:g id="COUNT">%d</xliff:g> minuten"</item>
  </plurals>
  <plurals name="abbrev_in_num_hours">
    <item quantity="one" msgid="3274708118124045246">"over 1 uur"</item>
    <item quantity="other" msgid="3705373766798013406">"over <xliff:g id="COUNT">%d</xliff:g> uur"</item>
  </plurals>
  <plurals name="abbrev_in_num_days">
    <item quantity="one" msgid="2178576254385739855">"morgen"</item>
    <item quantity="other" msgid="2973062968038355991">"over <xliff:g id="COUNT">%d</xliff:g> dagen"</item>
  </plurals>
    <string name="preposition_for_date" msgid="9093949757757445117">"op <xliff:g id="DATE">%s</xliff:g>"</string>
    <string name="preposition_for_time" msgid="5506831244263083793">"om <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">"dag"</string>
    <string name="days" msgid="4774547661021344602">"dagen"</string>
    <string name="hour" msgid="2126771916426189481">"uur"</string>
    <string name="hours" msgid="894424005266852993">"uren"</string>
    <string name="minute" msgid="9148878657703769868">"min"</string>
    <string name="minutes" msgid="5646001005827034509">"minuten"</string>
    <string name="second" msgid="3184235808021478">"sec"</string>
    <string name="seconds" msgid="3161515347216589235">"seconden"</string>
    <string name="week" msgid="5617961537173061583">"week"</string>
    <string name="weeks" msgid="6509623834583944518">"weken"</string>
    <string name="year" msgid="4001118221013892076">"jaar"</string>
    <string name="years" msgid="6881577717993213522">"jaren"</string>
  <plurals name="duration_seconds">
    <item quantity="one" msgid="6962015528372969481">"1 seconde"</item>
    <item quantity="other" msgid="1886107766577166786">"<xliff:g id="COUNT">%d</xliff:g> seconden"</item>
  </plurals>
  <plurals name="duration_minutes">
    <item quantity="one" msgid="4915414002546085617">"1 minuut"</item>
    <item quantity="other" msgid="3165187169224908775">"<xliff:g id="COUNT">%d</xliff:g> minuten"</item>
  </plurals>
  <plurals name="duration_hours">
    <item quantity="one" msgid="8917467491248809972">"1 uur"</item>
    <item quantity="other" msgid="3863962854246773930">"<xliff:g id="COUNT">%d</xliff:g> uur"</item>
  </plurals>
    <string name="VideoView_error_title" msgid="3534509135438353077">"Probleem met video"</string>
    <string name="VideoView_error_text_invalid_progressive_playback" msgid="3186670335938670444">"Deze video kan niet worden gestreamd naar dit apparaat."</string>
    <string name="VideoView_error_text_unknown" msgid="3450439155187810085">"Deze video kan niet worden afgespeeld."</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">"twaalf uur \'s middags"</string>
    <string name="Noon" msgid="3342127745230013127">"Twaalf uur \'s middags"</string>
    <string name="midnight" msgid="7166259508850457595">"middernacht"</string>
    <string name="Midnight" msgid="5630806906897892201">"Middernacht"</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">"Alles selecteren"</string>
    <string name="cut" msgid="3092569408438626261">"Knippen"</string>
    <string name="copy" msgid="2681946229533511987">"Kopiëren"</string>
    <string name="paste" msgid="5629880836805036433">"Plakken"</string>
    <string name="replace" msgid="5781686059063148930">"Vervangen..."</string>
    <string name="delete" msgid="6098684844021697789">"Verwijderen"</string>
    <string name="copyUrl" msgid="2538211579596067402">"URL kopiëren"</string>
    <string name="selectTextMode" msgid="1018691815143165326">"Tekst selecteren"</string>
    <string name="textSelectionCABTitle" msgid="5236850394370820357">"Tekstselectie"</string>
    <string name="addToDictionary" msgid="4352161534510057874">"Toevoegen aan woordenboek"</string>
    <string name="deleteText" msgid="6979668428458199034">"Verwijderen"</string>
    <string name="inputMethod" msgid="1653630062304567879">"Invoermethode"</string>
    <string name="editTextMenuTitle" msgid="4909135564941815494">"Tekstacties"</string>
    <string name="low_internal_storage_view_title" msgid="5576272496365684834">"Opslagruimte is bijna vol"</string>
    <string name="low_internal_storage_view_text" msgid="6640505817617414371">"Bepaalde systeemfuncties werken mogelijk niet"</string>
    <string name="app_running_notification_title" msgid="8718335121060787914">"<xliff:g id="APP_NAME">%1$s</xliff:g> wordt uitgevoerd"</string>
    <string name="app_running_notification_text" msgid="4653586947747330058">"Raak aan voor meer informatie of om de app te stoppen."</string>
    <string name="ok" msgid="5970060430562524910">"OK"</string>
    <string name="cancel" msgid="6442560571259935130">"Annuleren"</string>
    <string name="yes" msgid="5362982303337969312">"OK"</string>
    <string name="no" msgid="5141531044935541497">"Annuleren"</string>
    <string name="dialog_alert_title" msgid="2049658708609043103">"Let op"</string>
    <string name="loading" msgid="7933681260296021180">"Laden..."</string>
    <string name="capital_on" msgid="1544682755514494298">"AAN"</string>
    <string name="capital_off" msgid="6815870386972805832">"UIT"</string>
    <string name="whichApplication" msgid="4533185947064773386">"Actie voltooien met"</string>
    <string name="whichHomeApplication" msgid="4616420172727326782">"Een startscherm-app selecteren"</string>
    <string name="alwaysUse" msgid="4583018368000610438">"Standaard gebruiken voor deze actie."</string>
    <string name="clearDefaultHintMsg" msgid="3252584689512077257">"Standaardinstelling wissen via Systeeminstellingen &gt; Apps &gt; Gedownload."</string>
    <string name="chooseActivity" msgid="7486876147751803333">"Een actie selecteren"</string>
    <string name="chooseUsbActivity" msgid="6894748416073583509">"Een app voor het USB-apparaat selecteren"</string>
    <string name="noApplications" msgid="2991814273936504689">"Geen enkele app kan deze actie uitvoeren."</string>
    <string name="aerr_title" msgid="1905800560317137752"></string>
    <string name="aerr_application" msgid="932628488013092776">"<xliff:g id="APPLICATION">%1$s</xliff:g> is gestopt."</string>
    <string name="aerr_process" msgid="4507058997035697579">"Het proces <xliff:g id="PROCESS">%1$s</xliff:g> is gestopt."</string>
    <string name="anr_title" msgid="4351948481459135709"></string>
    <string name="anr_activity_application" msgid="1904477189057199066">"<xliff:g id="APPLICATION">%2$s</xliff:g> reageert niet.\n\nWilt u deze app sluiten?"</string>
    <string name="anr_activity_process" msgid="5776209883299089767">"Activiteit <xliff:g id="ACTIVITY">%1$s</xliff:g> reageert niet.\n\nWilt u deze activiteit sluiten?"</string>
    <string name="anr_application_process" msgid="8941757607340481057">"<xliff:g id="APPLICATION">%1$s</xliff:g> reageert niet. Wilt u deze app sluiten?"</string>
    <string name="anr_process" msgid="6513209874880517125">"Proces <xliff:g id="PROCESS">%1$s</xliff:g> reageert niet.\n\nWilt u het sluiten?"</string>
    <string name="force_close" msgid="8346072094521265605">"OK"</string>
    <string name="report" msgid="4060218260984795706">"Rapport"</string>
    <string name="wait" msgid="7147118217226317732">"Wachten"</string>
    <string name="webpage_unresponsive" msgid="3272758351138122503">"De pagina reageert niet meer.\n\nWilt u de pagina sluiten?"</string>
    <string name="launch_warning_title" msgid="1547997780506713581">"App verplaatst"</string>
    <string name="launch_warning_replace" msgid="6202498949970281412">"<xliff:g id="APP_NAME">%1$s</xliff:g> is nu actief."</string>
    <string name="launch_warning_original" msgid="188102023021668683">"<xliff:g id="APP_NAME">%1$s</xliff:g> was het eerst gestart."</string>
    <string name="screen_compat_mode_scale" msgid="3202955667675944499">"Schaal"</string>
    <string name="screen_compat_mode_show" msgid="4013878876486655892">"Altijd weergeven"</string>
    <string name="screen_compat_mode_hint" msgid="1064524084543304459">"U kunt dit opnieuw inschakelen via Systeeminstellingen &gt; Apps &gt; Gedownload."</string>
    <string name="smv_application" msgid="3307209192155442829">"De app <xliff:g id="APPLICATION">%1$s</xliff:g> (proces <xliff:g id="PROCESS">%2$s</xliff:g>) heeft het zelf afgedwongen StrictMode-beleid geschonden."</string>
    <string name="smv_process" msgid="5120397012047462446">"Het proces <xliff:g id="PROCESS">%1$s</xliff:g> heeft het zelf afgedwongen StrictMode-beleid geschonden."</string>
    <string name="android_upgrading_title" msgid="1584192285441405746">"Android wordt bijgewerkt..."</string>
    <string name="android_upgrading_apk" msgid="7904042682111526169">"App <xliff:g id="NUMBER_0">%1$d</xliff:g> van <xliff:g id="NUMBER_1">%2$d</xliff:g> optimaliseren."</string>
    <string name="android_upgrading_starting_apps" msgid="451464516346926713">"Apps starten."</string>
    <string name="android_upgrading_complete" msgid="1405954754112999229">"Opstarten afronden."</string>
    <string name="heavy_weight_notification" msgid="9087063985776626166">"<xliff:g id="APP">%1$s</xliff:g> wordt uitgevoerd"</string>
    <string name="heavy_weight_notification_detail" msgid="1721681741617898865">"Raak aan om naar app te schakelen"</string>
    <string name="heavy_weight_switcher_title" msgid="7153167085403298169">"Schakelen tussen apps?"</string>
    <string name="heavy_weight_switcher_text" msgid="7022631924534406403">"Er wordt al een andere app uitgevoerd die moet worden gestopt voordat u een nieuwe app kunt starten."</string>
    <string name="old_app_action" msgid="493129172238566282">"Terug naar <xliff:g id="OLD_APP">%1$s</xliff:g>"</string>
    <string name="old_app_description" msgid="2082094275580358049">"De nieuwe app niet starten."</string>
    <string name="new_app_action" msgid="5472756926945440706">"<xliff:g id="OLD_APP">%1$s</xliff:g> starten"</string>
    <string name="new_app_description" msgid="1932143598371537340">"De oude app stoppen zonder opslaan."</string>
    <string name="sendText" msgid="5209874571959469142">"Een actie voor tekst selecteren"</string>
    <string name="volume_ringtone" msgid="6885421406845734650">"Belvolume"</string>
    <string name="volume_music" msgid="5421651157138628171">"Mediavolume"</string>
    <string name="volume_music_hint_playing_through_bluetooth" msgid="9165984379394601533">"Afspelen via Bluetooth"</string>
    <string name="volume_music_hint_silent_ringtone_selected" msgid="8310739960973156272">"Stille beltoon ingesteld"</string>
    <string name="volume_call" msgid="3941680041282788711">"Volume inkomende oproep"</string>
    <string name="volume_bluetooth_call" msgid="2002891926351151534">"Volume tijdens gesprek in Bluetooth-modus"</string>
    <string name="volume_alarm" msgid="1985191616042689100">"Alarmvolume"</string>
    <string name="volume_notification" msgid="2422265656744276715">"Meldingsvolume"</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">"Beltoonvolume"</string>
    <string name="volume_icon_description_incall" msgid="8890073218154543397">"Belvolume"</string>
    <string name="volume_icon_description_media" msgid="4217311719665194215">"Mediavolume"</string>
    <string name="volume_icon_description_notification" msgid="7044986546477282274">"Meldingsvolume"</string>
    <string name="ringtone_default" msgid="3789758980357696936">"Standaardbeltoon"</string>
    <string name="ringtone_default_with_actual" msgid="8129563480895990372">"Standaardbeltoon (<xliff:g id="ACTUAL_RINGTONE">%1$s</xliff:g>)"</string>
    <string name="ringtone_silent" msgid="7937634392408977062">"Geen"</string>
    <string name="ringtone_picker_title" msgid="3515143939175119094">"Beltonen"</string>
    <string name="ringtone_unknown" msgid="5477919988701784788">"Onbekende beltoon"</string>
  <plurals name="wifi_available">
    <item quantity="one" msgid="6654123987418168693">"Wifi-netwerk beschikbaar"</item>
    <item quantity="other" msgid="4192424489168397386">"Wifi-netwerken beschikbaar"</item>
  </plurals>
  <plurals name="wifi_available_detailed">
    <item quantity="one" msgid="1634101450343277345">"Open wifi-netwerk beschikbaar"</item>
    <item quantity="other" msgid="7915895323644292768">"Open wifi-netwerken beschikbaar"</item>
  </plurals>
    <string name="wifi_available_sign_in" msgid="4029489716605255386">"Inloggen op wifi-netwerk"</string>
    <string name="network_available_sign_in" msgid="8495155593358054676">"Inloggen bij netwerk"</string>
    <!-- no translation found for network_available_sign_in_detailed (8000081941447976118) -->
    <skip />
    <string name="wifi_watchdog_network_disabled" msgid="7904214231651546347">"Kan geen verbinding maken met wifi"</string>
    <string name="wifi_watchdog_network_disabled_detailed" msgid="5548780776418332675">" heeft een slechte internetverbinding."</string>
    <string name="wifi_p2p_dialog_title" msgid="97611782659324517">"Wifi Direct"</string>
    <string name="wifi_p2p_turnon_message" msgid="2909250942299627244">"Wifi Direct starten. Hierdoor wordt de wifi-client/hotspot uitgeschakeld."</string>
    <string name="wifi_p2p_failed_message" msgid="3763669677935623084">"Kan Wifi Direct niet starten."</string>
    <string name="wifi_p2p_enabled_notification_title" msgid="2068321881673734886">"Wifi Direct is actief"</string>
    <string name="wifi_p2p_enabled_notification_message" msgid="1638949953993894335">"Aanraken voor instellingen"</string>
    <string name="accept" msgid="1645267259272829559">"Accepteren"</string>
    <string name="decline" msgid="2112225451706137894">"Weigeren"</string>
    <string name="wifi_p2p_invitation_sent_title" msgid="1318975185112070734">"Uitnodiging verzonden"</string>
    <string name="wifi_p2p_invitation_to_connect_title" msgid="4958803948658533637">"Uitnodiging om te koppelen"</string>
    <string name="wifi_p2p_from_message" msgid="570389174731951769">"Van:"</string>
    <string name="wifi_p2p_to_message" msgid="248968974522044099">"Naar:"</string>
    <string name="wifi_p2p_enter_pin_message" msgid="5920929550367828970">"Voer de gewenste pincode in:"</string>
    <string name="wifi_p2p_show_pin_message" msgid="8530563323880921094">"Pincode"</string>
    <string name="wifi_p2p_frequency_conflict_message" product="tablet" msgid="8012981257742232475">"De verbinding met het wifi-netwerk wordt tijdelijk uitgeschakeld terwijl de telefoon is verbonden met <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_p2p_frequency_conflict_message" product="default" msgid="7363907213787469151">"De verbinding met het wifi-netwerk wordt tijdelijk uitgeschakeld terwijl de telefoon verbonden is met <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="select_character" msgid="3365550120617701745">"Teken invoegen"</string>
    <string name="sms_control_title" msgid="7296612781128917719">"SMS-berichten verzenden"</string>
    <string name="sms_control_message" msgid="3867899169651496433">"&lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; verzendt moment een groot aantal sms-berichten. Wilt u toestaan ​​dat deze app berichten blijft verzenden?"</string>
    <string name="sms_control_yes" msgid="3663725993855816807">"Toestaan"</string>
    <string name="sms_control_no" msgid="625438561395534982">"Weigeren"</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; wil graag een bericht verzenden naar &lt;b&gt;<xliff:g id="DEST_ADDRESS">%2$s</xliff:g>&lt;/b&gt;."</string>
    <string name="sms_short_code_details" msgid="3492025719868078457">"Dit "<font fgcolor="#ffffb060">"kan leiden tot kosten"</font>" in uw mobiele account."</string>
    <string name="sms_premium_short_code_details" msgid="5523826349105123687"><font fgcolor="#ffffb060">"Dit leidt tot kosten in uw mobiele account."</font></string>
    <string name="sms_short_code_confirm_allow" msgid="4458878637111023413">"Verzenden"</string>
    <string name="sms_short_code_confirm_deny" msgid="2927389840209170706">"Annuleren"</string>
    <string name="sms_short_code_remember_choice" msgid="5289538592272218136">"Mijn keuze onthouden"</string>
    <string name="sms_short_code_remember_undo_instruction" msgid="4960944133052287484">"U kunt dit later wijzigen in \'Instellingen\' &gt; \'Apps\'"</string>
    <string name="sms_short_code_confirm_always_allow" msgid="3241181154869493368">"Altijd toestaan"</string>
    <string name="sms_short_code_confirm_never_allow" msgid="446992765774269673">"Nooit toestaan"</string>
    <string name="sim_removed_title" msgid="6227712319223226185">"Simkaart verwijderd"</string>
    <string name="sim_removed_message" msgid="2333164559970958645">"Het mobiele netwerk is niet beschikbaar totdat u het apparaat opnieuw start met een geldige simkaart."</string>
    <string name="sim_done_button" msgid="827949989369963775">"Gereed"</string>
    <string name="sim_added_title" msgid="3719670512889674693">"Simkaart aangesloten"</string>
    <string name="sim_added_message" msgid="6599945301141050216">"Start uw apparaat opnieuw voor toegang tot het mobiele netwerk."</string>
    <string name="sim_restart_button" msgid="4722407842815232347">"Opnieuw starten"</string>
    <string name="time_picker_dialog_title" msgid="8349362623068819295">"Tijd instellen"</string>
    <string name="date_picker_dialog_title" msgid="5879450659453782278">"Datum instellen"</string>
    <string name="date_time_set" msgid="5777075614321087758">"Instellen"</string>
    <string name="date_time_done" msgid="2507683751759308828">"Gereed"</string>
    <string name="perms_new_perm_prefix" msgid="8257740710754301407"><font size="12" fgcolor="#ff33b5e5">"NIEUW: "</font></string>
    <string name="perms_description_app" msgid="5139836143293299417">"Geleverd door <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="no_permissions" msgid="7283357728219338112">"Geen machtigingen vereist"</string>
    <string name="perm_costs_money" msgid="4902470324142151116">"hieraan kunnen kosten zijn verbonden"</string>
    <string name="usb_storage_activity_title" msgid="4465055157209648641">"USB-massaopslag"</string>
    <string name="usb_storage_title" msgid="5901459041398751495">"USB-verbinding"</string>
    <string name="usb_storage_message" product="nosdcard" msgid="3308538094316477839">"U heeft uw telefoon via USB op uw computer aangesloten. Raak de knop hieronder aan als u bestanden tussen uw computer en de USB-opslag van uw Android wilt kopiëren."</string>
    <string name="usb_storage_message" product="default" msgid="805351000446037811">"U heeft uw telefoon via USB op uw computer aangesloten. Raak de onderstaande knop aan als u bestanden tussen uw computer en de SD-kaart van uw Android wilt kopiëren."</string>
    <string name="usb_storage_button_mount" msgid="1052259930369508235">"USB-opslag inschakelen"</string>
    <string name="usb_storage_error_message" product="nosdcard" msgid="3017045217365540658">"Er is een probleem bij het gebruik van uw USB-opslag voor USB-massaopslag."</string>
    <string name="usb_storage_error_message" product="default" msgid="2876018512716970313">"Er is een probleem bij het gebruik van uw SD-kaart voor USB-massaopslag."</string>
    <string name="usb_storage_notification_title" msgid="8175892554757216525">"USB-verbinding"</string>
    <string name="usb_storage_notification_message" msgid="939822783828183763">"Raak aan om bestanden naar/van uw computer te kopiëren."</string>
    <string name="usb_storage_stop_notification_title" msgid="2336058396663516017">"USB-opslag uitschakelen"</string>
    <string name="usb_storage_stop_notification_message" msgid="1656852098555623822">"Raak aan om USB-opslag uit te schakelen."</string>
    <string name="usb_storage_stop_title" msgid="660129851708775853">"USB-opslag in gebruik"</string>
    <string name="usb_storage_stop_message" product="nosdcard" msgid="4264025280777219521">"Voordat u USB-opslag uitschakelt, moet u de USB-opslag van uw Android ontkoppelen van uw computer (\'uitwerpen\')."</string>
    <string name="usb_storage_stop_message" product="default" msgid="8043969782460613114">"Voordat u USB-opslag uitschakelt, moet u de SD-kaart van uw Android ontkoppelen van uw computer (\'uitwerpen\')."</string>
    <string name="usb_storage_stop_button_mount" msgid="7060218034900696029">"USB-opslag uitschakelen"</string>
    <string name="usb_storage_stop_error_message" msgid="1970374898263063836">"Er is een probleem opgetreden tijdens het uitschakelen van de USB-opslag. Controleer of u de USB-host heeft losgekoppeld en probeer het opnieuw."</string>
    <string name="dlg_confirm_kill_storage_users_title" msgid="963039033470478697">"USB-opslag inschakelen"</string>
    <string name="dlg_confirm_kill_storage_users_text" msgid="5100428757107469454">"Als u USB-opslag inschakelt, worden bepaalde apps die u gebruikt, gestopt en zijn deze mogelijk pas weer beschikbaar wanneer u USB-opslag uitschakelt."</string>
    <string name="dlg_error_title" msgid="7323658469626514207">"USB-bewerking mislukt"</string>
    <string name="dlg_ok" msgid="7376953167039865701">"OK"</string>
    <string name="usb_mtp_notification_title" msgid="3699913097391550394">"Gekoppeld als media-apparaat"</string>
    <string name="usb_ptp_notification_title" msgid="1960817192216064833">"Gekoppeld als camera"</string>
    <string name="usb_cd_installer_notification_title" msgid="6774712827892090754">"Gekoppeld als installatieprogramma"</string>
    <string name="usb_accessory_notification_title" msgid="7848236974087653666">"Aangesloten op een USB-accessoire"</string>
    <string name="usb_notification_message" msgid="2290859399983720271">"Raak aan voor andere USB-opties."</string>
    <string name="extmedia_format_title" product="nosdcard" msgid="9020092196061007262">"USB-opslag formatteren?"</string>
    <string name="extmedia_format_title" product="default" msgid="3648415921526526069">"SD-kaart formatteren?"</string>
    <string name="extmedia_format_message" product="nosdcard" msgid="3934016853425761078">"Alle bestanden die in uw USB-opslag zijn opgeslagen, worden gewist. Deze actie kan niet ongedaan worden gemaakt."</string>
    <string name="extmedia_format_message" product="default" msgid="14131895027543830">"Alle gegevens op uw kaart worden gewist."</string>
    <string name="extmedia_format_button_format" msgid="4131064560127478695">"Formatteren"</string>
    <string name="adb_active_notification_title" msgid="6729044778949189918">"USB-foutopsporing verbonden"</string>
    <string name="adb_active_notification_message" msgid="1016654627626476142">"Tik om USB-foutopsporing uit te schakelen."</string>
    <string name="select_input_method" msgid="4653387336791222978">"Invoermethode selecteren"</string>
    <string name="configure_input_methods" msgid="9091652157722495116">"Invoermethoden instellen"</string>
    <string name="use_physical_keyboard" msgid="6203112478095117625">"Fysiek toetsenbord"</string>
    <string name="hardware" msgid="7517821086888990278">"Hardware"</string>
    <string name="select_keyboard_layout_notification_title" msgid="1407367017263030773">"Toetsenbordindeling selecteren"</string>
    <string name="select_keyboard_layout_notification_message" msgid="4465907700449257063">"Tik om een ​​toetsenbordindeling te selecteren."</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>"kandidaten"</u></string>
    <string name="ext_media_checking_notification_title" product="nosdcard" msgid="3449816005351468560">"USB-opslag voorbereiden"</string>
    <string name="ext_media_checking_notification_title" product="default" msgid="5457603418970994050">"SD-kaart voorbereiden"</string>
    <string name="ext_media_checking_notification_message" msgid="8287319882926737053">"Controleren op fouten."</string>
    <string name="ext_media_nofs_notification_title" product="nosdcard" msgid="7788040745686229307">"Lege USB-opslag"</string>
    <string name="ext_media_nofs_notification_title" product="default" msgid="780477838241212997">"Lege SD-kaart"</string>
    <string name="ext_media_nofs_notification_message" product="nosdcard" msgid="7840121067427269500">"USB-opslag is leeg of heeft een niet-ondersteund bestandssysteem."</string>
    <string name="ext_media_nofs_notification_message" product="default" msgid="8641065641786923604">"SD-kaart is leeg of heeft een niet-ondersteund bestandssysteem."</string>
    <string name="ext_media_unmountable_notification_title" product="nosdcard" msgid="2090046769532713563">"USB-opslag beschadigd"</string>
    <string name="ext_media_unmountable_notification_title" product="default" msgid="6410723906019100189">"Beschadigde SD-kaart"</string>
    <string name="ext_media_unmountable_notification_message" product="nosdcard" msgid="1795917578395333280">"USB-opslag is beschadigd. Probeer deze opnieuw te formatteren."</string>
    <string name="ext_media_unmountable_notification_message" product="default" msgid="1753898567525568253">"SD-kaart is beschadigd. Probeer deze opnieuw te formatteren."</string>
    <string name="ext_media_badremoval_notification_title" product="nosdcard" msgid="1661683031330951073">"USB-opslag onverwachts verwijderd"</string>
    <string name="ext_media_badremoval_notification_title" product="default" msgid="6872152882604407837">"SD-kaart onverwachts verwijderd"</string>
    <string name="ext_media_badremoval_notification_message" product="nosdcard" msgid="4329848819865594241">"Ontkoppel de USB-opslag voordat u deze verwijdert om gegevensverlies te voorkomen."</string>
    <string name="ext_media_badremoval_notification_message" product="default" msgid="7260183293747448241">"Ontkoppel de SD-kaart voordat u deze verwijdert om gegevensverlies te voorkomen."</string>
    <string name="ext_media_safe_unmount_notification_title" product="nosdcard" msgid="3967973893270360230">"USB-opslag veilig verwijderen"</string>
    <string name="ext_media_safe_unmount_notification_title" product="default" msgid="6729801130790616200">"De SD-kaart kan veilig worden verwijderd"</string>
    <string name="ext_media_safe_unmount_notification_message" product="nosdcard" msgid="6142195361606493530">"U kunt de USB-opslag veilig verwijderen."</string>
    <string name="ext_media_safe_unmount_notification_message" product="default" msgid="568841278138377604">"U kunt de SD-kaart veilig verwijderen."</string>
    <string name="ext_media_nomedia_notification_title" product="nosdcard" msgid="4486377230140227651">"USB-opslag verwijderd"</string>
    <string name="ext_media_nomedia_notification_title" product="default" msgid="8902518030404381318">"SD-kaart is verwijderd"</string>
    <string name="ext_media_nomedia_notification_message" product="nosdcard" msgid="6921126162580574143">"USB-opslag verwijderd. Plaats nieuw medium."</string>
    <string name="ext_media_nomedia_notification_message" product="default" msgid="3870120652983659641">"SD-kaart verwijderd. Plaats een nieuwe."</string>
    <string name="activity_list_empty" msgid="1675388330786841066">"Geen overeenkomende activiteiten gevonden."</string>
    <string name="permlab_pkgUsageStats" msgid="8787352074326748892">"gebruiksstatistieken van component bijwerken"</string>
    <string name="permdesc_pkgUsageStats" msgid="1106612424254277630">"Hiermee kan de app verzamelde gebruiksstatistieken van componenten wijzigen. Niet voor gebruik door normale apps."</string>
    <string name="permlab_copyProtectedData" msgid="4341036311211406692">"inhoud kopiëren"</string>
    <string name="permdesc_copyProtectedData" msgid="4390697124288317831">"Hiermee kan de app de standaard containerservice aanroepen om inhoud te kopiëren. Niet voor gebruik door normale apps."</string>
    <string name="permlab_route_media_output" msgid="1642024455750414694">"Media-uitvoer aansturen"</string>
    <string name="permdesc_route_media_output" msgid="4932818749547244346">"Hiermee kan een app media-uitvoer naar andere externe apparaten doorsturen."</string>
    <string name="permlab_access_keyguard_secure_storage" msgid="7565552237977815047">"Toegang tot opslag met toetsbeveiliging"</string>
    <string name="permdesc_access_keyguard_secure_storage" msgid="5866245484303285762">"Hiermee krijgt een app toegang tot opslag met toetsbeveiliging."</string>
    <string name="permlab_control_keyguard" msgid="172195184207828387">"Weergeven en verbergen van toetsbeveiliging beheren"</string>
    <string name="permdesc_control_keyguard" msgid="3043732290518629061">"Staat toe dat een app de toetsbeveiliging beheert."</string>
    <string name="tutorial_double_tap_to_zoom_message_short" msgid="4070433208160063538">"Raak twee keer aan voor zoomregeling"</string>
    <string name="gadget_host_error_inflating" msgid="4882004314906466162">"Kan widget niet toevoegen."</string>
    <string name="ime_action_go" msgid="8320845651737369027">"Ga"</string>
    <string name="ime_action_search" msgid="658110271822807811">"Zoeken"</string>
    <string name="ime_action_send" msgid="2316166556349314424">"Verzenden"</string>
    <string name="ime_action_next" msgid="3138843904009813834">"Volgende"</string>
    <string name="ime_action_done" msgid="8971516117910934605">"Gereed"</string>
    <string name="ime_action_previous" msgid="1443550039250105948">"Vorige"</string>
    <string name="ime_action_default" msgid="2840921885558045721">"Uitvoeren"</string>
    <string name="dial_number_using" msgid="5789176425167573586">"Nummer bellen\nmet <xliff:g id="NUMBER">%s</xliff:g>"</string>
    <string name="create_contact_using" msgid="4947405226788104538">"Contact maken\nmet <xliff:g id="NUMBER">%s</xliff:g>"</string>
    <string name="grant_credentials_permission_message_header" msgid="2106103817937859662">"De volgende apps verzoeken om toegang tot uw account, nu en in de toekomst."</string>
    <string name="grant_credentials_permission_message_footer" msgid="3125211343379376561">"Wilt u dit verzoek toestaan?"</string>
    <string name="grant_permissions_header_text" msgid="6874497408201826708">"Verzoek om toegang"</string>
    <string name="allow" msgid="7225948811296386551">"Toestaan"</string>
    <string name="deny" msgid="2081879885755434506">"Weigeren"</string>
    <string name="permission_request_notification_title" msgid="6486759795926237907">"Toestemming gevraagd"</string>
    <string name="permission_request_notification_with_subtitle" msgid="8530393139639560189">"Toestemming gevraagd\nvoor account <xliff:g id="ACCOUNT">%s</xliff:g>."</string>
    <string name="input_method_binding_label" msgid="1283557179944992649">"Invoermethode"</string>
    <string name="sync_binding_label" msgid="3687969138375092423">"Synchroniseren"</string>
    <string name="accessibility_binding_label" msgid="4148120742096474641">"Toegankelijkheid"</string>
    <string name="wallpaper_binding_label" msgid="1240087844304687662">"Achtergrond"</string>
    <string name="chooser_wallpaper" msgid="7873476199295190279">"Achtergrond wijzigen"</string>
    <string name="notification_listener_binding_label" msgid="2014162835481906429">"Listener voor meldingen"</string>
    <string name="vpn_title" msgid="19615213552042827">"VPN is geactiveerd"</string>
    <string name="vpn_title_long" msgid="6400714798049252294">"VPN wordt geactiveerd door <xliff:g id="APP">%s</xliff:g>"</string>
    <string name="vpn_text" msgid="3011306607126450322">"Raak aan om het netwerk te beheren."</string>
    <string name="vpn_text_long" msgid="6407351006249174473">"Verbonden met <xliff:g id="SESSION">%s</xliff:g>. Tik om het netwerk te beheren."</string>
    <string name="vpn_lockdown_connecting" msgid="6443438964440960745">"Always-on VPN-verbinding maken…"</string>
    <string name="vpn_lockdown_connected" msgid="8202679674819213931">"Always-on VPN-verbinding"</string>
    <string name="vpn_lockdown_error" msgid="6009249814034708175">"Fout met Always-on VPN"</string>
    <string name="vpn_lockdown_config" msgid="6415899150671537970">"Aanraken om te configureren"</string>
    <string name="upload_file" msgid="2897957172366730416">"Bestand kiezen"</string>
    <string name="no_file_chosen" msgid="6363648562170759465">"Geen bestand geselecteerd"</string>
    <string name="reset" msgid="2448168080964209908">"Opnieuw instellen"</string>
    <string name="submit" msgid="1602335572089911941">"Verzenden"</string>
    <string name="car_mode_disable_notification_title" msgid="3164768212003864316">"Automodus ingeschakeld"</string>
    <string name="car_mode_disable_notification_message" msgid="8035230537563503262">"Raak aan om de automodus te sluiten."</string>
    <string name="tethered_notification_title" msgid="3146694234398202601">"Tethering of hotspot actief"</string>
    <string name="tethered_notification_message" msgid="6857031760103062982">"Aanraken voor instellen."</string>
    <string name="back_button_label" msgid="2300470004503343439">"Vorige"</string>
    <string name="next_button_label" msgid="1080555104677992408">"Volgende"</string>
    <string name="skip_button_label" msgid="1275362299471631819">"Overslaan"</string>
    <string name="throttle_warning_notification_title" msgid="4890894267454867276">"Hoog mobiel gegevensgebruik"</string>
    <string name="throttle_warning_notification_message" msgid="3340822228599337743">"Raak aan voor meer informatie over mobiel gegevensgebruik."</string>
    <string name="throttled_notification_title" msgid="6269541897729781332">"Mobiele gegevenslimiet overschreden"</string>
    <string name="throttled_notification_message" msgid="5443457321354907181">"Raak aan voor meer informatie over mobiel gegevensgebruik."</string>
    <string name="no_matches" msgid="8129421908915840737">"Geen overeenkomsten"</string>
    <string name="find_on_page" msgid="1946799233822820384">"Zoeken op pagina"</string>
  <plurals name="matches_found">
    <item quantity="one" msgid="8167147081136579439">"1 overeenkomst"</item>
    <item quantity="other" msgid="4641872797067609177">"<xliff:g id="INDEX">%d</xliff:g> van <xliff:g id="TOTAL">%d</xliff:g>"</item>
  </plurals>
    <string name="action_mode_done" msgid="7217581640461922289">"Gereed"</string>
    <string name="progress_unmounting" product="nosdcard" msgid="3923810448507612746">"USB-opslag ontkoppelen..."</string>
    <string name="progress_unmounting" product="default" msgid="1327894998409537190">"SD-kaart ontkoppelen..."</string>
    <string name="progress_erasing" product="nosdcard" msgid="4521573321524340058">"USB-opslag wissen..."</string>
    <string name="progress_erasing" product="default" msgid="6596988875507043042">"SD-kaart wissen..."</string>
    <string name="format_error" product="nosdcard" msgid="6299769563624776948">"Kan USB-opslag niet wissen."</string>
    <string name="format_error" product="default" msgid="7315248696644510935">"Kan SD-kaart niet wissen."</string>
    <string name="media_bad_removal" msgid="7960864061016603281">"SD-kaart is verwijderd voordat deze is ontkoppeld."</string>
    <string name="media_checking" product="nosdcard" msgid="418188720009569693">"USB-opslag wordt momenteel gecontroleerd."</string>
    <string name="media_checking" product="default" msgid="7334762503904827481">"SD-kaart wordt momenteel gecontroleerd."</string>
    <string name="media_removed" msgid="7001526905057952097">"SD-kaart is verwijderd."</string>
    <string name="media_shared" product="nosdcard" msgid="5830814349250834225">"USB-opslag wordt momenteel gebruikt door een computer."</string>
    <string name="media_shared" product="default" msgid="5706130568133540435">"SD-kaart wordt momenteel gebruikt door een computer."</string>
    <string name="media_unknown_state" msgid="729192782197290385">"Extern medium heeft onbekende status."</string>
    <string name="share" msgid="1778686618230011964">"Delen"</string>
    <string name="find" msgid="4808270900322985960">"Vinden"</string>
    <string name="websearch" msgid="4337157977400211589">"Online zoeken"</string>
    <string name="find_next" msgid="5742124618942193978">"Volgende zoeken"</string>
    <string name="find_previous" msgid="2196723669388360506">"Vorige zoeken"</string>
    <string name="gpsNotifTicker" msgid="5622683912616496172">"Locatieverzoek van <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="gpsNotifTitle" msgid="5446858717157416839">"Locatieverzoek"</string>
    <string name="gpsNotifMessage" msgid="1374718023224000702">"Aangevraagd door <xliff:g id="NAME">%1$s</xliff:g> (<xliff:g id="SERVICE">%2$s</xliff:g>)"</string>
    <string name="gpsVerifYes" msgid="2346566072867213563">"Ja"</string>
    <string name="gpsVerifNo" msgid="1146564937346454865">"Nee"</string>
    <string name="sync_too_many_deletes" msgid="5296321850662746890">"Verwijderingslimiet overschreden"</string>
    <string name="sync_too_many_deletes_desc" msgid="496551671008694245">"Er zijn <xliff:g id="NUMBER_OF_DELETED_ITEMS">%1$d</xliff:g> verwijderde items voor <xliff:g id="TYPE_OF_SYNC">%2$s</xliff:g> , account <xliff:g id="ACCOUNT_NAME">%3$s</xliff:g> . Wat wilt u doen?"</string>
    <string name="sync_really_delete" msgid="2572600103122596243">"De items verwijderen."</string>
    <string name="sync_undo_deletes" msgid="2941317360600338602">"Verwijderingen ongedaan maken"</string>
    <string name="sync_do_nothing" msgid="3743764740430821845">"Nu niets doen."</string>
    <string name="choose_account_label" msgid="5655203089746423927">"Een account selecteren"</string>
    <string name="add_account_label" msgid="2935267344849993553">"Een account toevoegen"</string>
    <string name="add_account_button_label" msgid="3611982894853435874">"Account toevoegen"</string>
    <string name="number_picker_increment_button" msgid="2412072272832284313">"Verhogen"</string>
    <string name="number_picker_decrement_button" msgid="476050778386779067">"Verlagen"</string>
    <string name="number_picker_increment_scroll_mode" msgid="3073101067441638428">"<xliff:g id="VALUE">%s</xliff:g> blijven aanraken."</string>
    <string name="number_picker_increment_scroll_action" msgid="9101473045891835490">"Veeg omhoog om te verhogen en omlaag om te verlagen."</string>
    <string name="time_picker_increment_minute_button" msgid="8865885114028614321">"Hogere waarde voor minuten"</string>
    <string name="time_picker_decrement_minute_button" msgid="6246834937080684791">"Lagere waarde voor minuten"</string>
    <string name="time_picker_increment_hour_button" msgid="3652056055810223139">"Hogere waarde voor uren"</string>
    <string name="time_picker_decrement_hour_button" msgid="1377479863429214792">"Lagere waarde voor uren"</string>
    <string name="time_picker_increment_set_pm_button" msgid="4147590696151230863">"PM instellen"</string>
    <string name="time_picker_decrement_set_am_button" msgid="8302140353539486752">"AM instellen"</string>
    <string name="date_picker_increment_month_button" msgid="5369998479067934110">"Hogere waarde voor maand"</string>
    <string name="date_picker_decrement_month_button" msgid="1832698995541726019">"Lagere waarde voor maand"</string>
    <string name="date_picker_increment_day_button" msgid="7130465412308173903">"Hogere waarde voor dag"</string>
    <string name="date_picker_decrement_day_button" msgid="4131881521818750031">"Lagere waarde voor dag"</string>
    <string name="date_picker_increment_year_button" msgid="6318697384310808899">"Hogere waarde voor jaar"</string>
    <string name="date_picker_decrement_year_button" msgid="4482021813491121717">"Lagere waarde voor jaar"</string>
    <string name="keyboardview_keycode_alt" msgid="4856868820040051939">"Alt"</string>
    <string name="keyboardview_keycode_cancel" msgid="1203984017245783244">"Annuleren"</string>
    <string name="keyboardview_keycode_delete" msgid="3337914833206635744">"Delete"</string>
    <string name="keyboardview_keycode_done" msgid="1992571118466679775">"Gereed"</string>
    <string name="keyboardview_keycode_mode_change" msgid="4547387741906537519">"Modus wijzigen"</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">"Een app selecteren"</string>
    <string name="activitychooserview_choose_application_error" msgid="8624618365481126668">"Kan <xliff:g id="APPLICATION_NAME">%s</xliff:g> niet starten"</string>
    <string name="shareactionprovider_share_with" msgid="806688056141131819">"Delen met"</string>
    <string name="shareactionprovider_share_with_application" msgid="5627411384638389738">"Delen met <xliff:g id="APPLICATION_NAME">%s</xliff:g>"</string>
    <string name="content_description_sliding_handle" msgid="415975056159262248">"Schuifgreep. Tikken en blijven aanraken."</string>
    <string name="description_direction_up" msgid="7169032478259485180">"Veeg omhoog voor <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
    <string name="description_direction_down" msgid="5087739728639014595">"Veeg omlaag voor <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
    <string name="description_direction_left" msgid="7207478719805562165">"Veeg naar links voor <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
    <string name="description_direction_right" msgid="8034433242579600980">"Veeg naar rechts voor <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
    <string name="description_target_unlock" msgid="2228524900439801453">"Ontgrendelen"</string>
    <string name="description_target_camera" msgid="969071997552486814">"Camera"</string>
    <string name="description_target_silent" msgid="893551287746522182">"Stil"</string>
    <string name="description_target_soundon" msgid="30052466675500172">"Geluid aan"</string>
    <string name="description_target_search" msgid="3091587249776033139">"Zoeken"</string>
    <string name="description_target_unlock_tablet" msgid="3833195335629795055">"Vegen om te ontgrendelen"</string>
    <string name="keyboard_headset_required_to_hear_password" msgid="7011927352267668657">"Sluit een headset aan om wachtwoordtoetsen te laten voorlezen."</string>
    <string name="keyboard_password_character_no_headset" msgid="2859873770886153678">"Stip."</string>
    <string name="action_bar_home_description" msgid="5293600496601490216">"Navigeren naar startpositie"</string>
    <string name="action_bar_up_description" msgid="2237496562952152589">"Omhoog navigeren"</string>
    <string name="action_menu_overflow_description" msgid="2295659037509008453">"Meer opties"</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">"Interne opslag"</string>
    <string name="storage_sd_card" msgid="3282948861378286745">"SD-kaart"</string>
    <string name="storage_usb" msgid="3017954059538517278">"USB-opslag"</string>
    <string name="extract_edit_menu_button" msgid="8940478730496610137">"Bewerken"</string>
    <string name="data_usage_warning_title" msgid="1955638862122232342">"Waarschuwing v. gegevensgebruik"</string>
    <string name="data_usage_warning_body" msgid="2814673551471969954">"Aanraken: gebruik/inst. bekijken"</string>
    <string name="data_usage_3g_limit_title" msgid="7093334419518706686">"2G-/3G-gegevens uitgeschakeld"</string>
    <string name="data_usage_4g_limit_title" msgid="7636489436819470761">"4G-gegevens uitgeschakeld"</string>
    <string name="data_usage_mobile_limit_title" msgid="7869402519391631884">"Mobiele gegevens uitgeschakeld"</string>
    <string name="data_usage_wifi_limit_title" msgid="8992154736441284865">"Wifi-data uitgeschakeld"</string>
    <string name="data_usage_limit_body" msgid="3317964706973601386">"Raak aan om in te schakelen."</string>
    <string name="data_usage_3g_limit_snoozed_title" msgid="7026739121138005231">"Gegevenslimiet 2G-3G overschreden"</string>
    <string name="data_usage_4g_limit_snoozed_title" msgid="1106562779311209039">"Gegevenslimiet 4G overschreden"</string>
    <string name="data_usage_mobile_limit_snoozed_title" msgid="279240572165412168">"Mobiele datalimiet overschreden"</string>
    <string name="data_usage_wifi_limit_snoozed_title" msgid="8743856006384825974">"Wifi-datalimiet overschreden"</string>
    <string name="data_usage_limit_snoozed_body" msgid="7035490278298441767">"<xliff:g id="SIZE">%s</xliff:g> meer dan limiet."</string>
    <string name="data_usage_restricted_title" msgid="5965157361036321914">"Achtergrondgegevens beperkt"</string>
    <string name="data_usage_restricted_body" msgid="6741521330997452990">"Raak aan voor opheffen beperking"</string>
    <string name="ssl_certificate" msgid="6510040486049237639">"Beveiligingscertificaat"</string>
    <string name="ssl_certificate_is_valid" msgid="6825263250774569373">"Dit certificaat is geldig."</string>
    <string name="issued_to" msgid="454239480274921032">"Uitgegeven voor:"</string>
    <string name="common_name" msgid="2233209299434172646">"Algemene naam:"</string>
    <string name="org_name" msgid="6973561190762085236">"Organisatie:"</string>
    <string name="org_unit" msgid="7265981890422070383">"Organisatie-eenheid:"</string>
    <string name="issued_by" msgid="2647584988057481566">"Uitgegeven door:"</string>
    <string name="validity_period" msgid="8818886137545983110">"Geldigheid:"</string>
    <string name="issued_on" msgid="5895017404361397232">"Uitgegeven op:"</string>
    <string name="expires_on" msgid="3676242949915959821">"Verloopt op:"</string>
    <string name="serial_number" msgid="758814067660862493">"Serienummer:"</string>
    <string name="fingerprints" msgid="4516019619850763049">"Vingerafdrukken:"</string>
    <string name="sha256_fingerprint" msgid="4391271286477279263">"SHA-256-vingerafdruk"</string>
    <string name="sha1_fingerprint" msgid="7930330235269404581">"SHA-1-vingerafdruk:"</string>
    <string name="activity_chooser_view_see_all" msgid="4292569383976636200">"Alles weergeven"</string>
    <string name="activity_chooser_view_dialog_title_default" msgid="4710013864974040615">"Een activiteit kiezen"</string>
    <string name="share_action_provider_share_with" msgid="5247684435979149216">"Delen met"</string>
    <string name="list_delimeter" msgid="3975117572185494152">", "</string>
    <string name="sending" msgid="3245653681008218030">"Verzenden..."</string>
    <string name="launchBrowserDefault" msgid="2057951947297614725">"Browser starten?"</string>
    <string name="SetupCallDefault" msgid="5834948469253758575">"Oproep accepteren?"</string>
    <string name="activity_resolver_use_always" msgid="8017770747801494933">"Altijd"</string>
    <string name="activity_resolver_use_once" msgid="2404644797149173758">"Eén keer"</string>
    <string name="default_audio_route_name" product="tablet" msgid="4617053898167127471">"Tablet"</string>
    <string name="default_audio_route_name" product="default" msgid="4239291273420140123">"Telefoon"</string>
    <string name="default_audio_route_name_headphones" msgid="8119971843803439110">"Hoofdtelefoon"</string>
    <string name="default_audio_route_name_dock_speakers" msgid="6240602982276591864">"Dockluidsprekers"</string>
    <string name="default_media_route_name_hdmi" msgid="2450970399023478055">"HDMI"</string>
    <string name="default_audio_route_category_name" msgid="3722811174003886946">"Systeem"</string>
    <string name="bluetooth_a2dp_audio_route_name" msgid="8575624030406771015">"Bluetooth-audio"</string>
    <string name="wireless_display_route_description" msgid="9070346425023979651">"Draadloze weergave"</string>
    <string name="media_route_button_content_description" msgid="5758553567065145276">"Media-uitvoer"</string>
    <string name="media_route_chooser_title" msgid="1751618554539087622">"Verbinding maken met apparaat"</string>
    <string name="media_route_chooser_title_for_remote_display" msgid="3395541745872017583">"Scherm sturen naar apparaat"</string>
    <string name="media_route_chooser_searching" msgid="4776236202610828706">"Zoeken naar apparaten…"</string>
    <string name="media_route_chooser_extended_settings" msgid="87015534236701604">"Instellingen"</string>
    <string name="media_route_controller_disconnect" msgid="8966120286374158649">"Verbinding verbreken"</string>
    <string name="media_route_status_scanning" msgid="7279908761758293783">"Scannen..."</string>
    <string name="media_route_status_connecting" msgid="6422571716007825440">"Verbinden..."</string>
    <string name="media_route_status_available" msgid="6983258067194649391">"Beschikbaar"</string>
    <string name="media_route_status_not_available" msgid="6739899962681886401">"Niet beschikbaar"</string>
    <string name="media_route_status_in_use" msgid="4533786031090198063">"In gebruik"</string>
    <string name="display_manager_built_in_display_name" msgid="2583134294292563941">"Ingebouwd scherm"</string>
    <string name="display_manager_hdmi_display_name" msgid="1555264559227470109">"HDMI-scherm"</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">", beveiligd"</string>
    <string name="wifi_display_notification_connecting_title" msgid="2838646471050359706">"Scherm sturen"</string>
    <string name="wifi_display_notification_connecting_message" msgid="5837350993752841389">"Verbinden met <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_display_notification_connected_title" msgid="8567308065912676285">"Scherm sturen"</string>
    <string name="wifi_display_notification_connected_message" msgid="2587209325701109715">"Verbonden met <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_display_notification_disconnect" msgid="6183754463561153372">"Verbinding verbreken"</string>
    <string name="kg_emergency_call_label" msgid="684946192523830531">"Noodoproep"</string>
    <string name="kg_forgot_pattern_button_text" msgid="8852021467868220608">"Patroon vergeten"</string>
    <string name="kg_wrong_pattern" msgid="1850806070801358830">"Onjuist patroon"</string>
    <string name="kg_wrong_password" msgid="2333281762128113157">"Onjuist wachtwoord"</string>
    <string name="kg_wrong_pin" msgid="1131306510833563801">"Onjuiste pincode"</string>
    <string name="kg_too_many_failed_attempts_countdown" msgid="6358110221603297548">"Probeer het over <xliff:g id="NUMBER">%1$d</xliff:g> seconden opnieuw."</string>
    <string name="kg_pattern_instructions" msgid="398978611683075868">"Teken uw patroon"</string>
    <string name="kg_sim_pin_instructions" msgid="2319508550934557331">"Geef de pincode van de simkaart op"</string>
    <string name="kg_pin_instructions" msgid="2377242233495111557">"Pincode opgeven"</string>
    <string name="kg_password_instructions" msgid="5753646556186936819">"Wachtwoord invoeren"</string>
    <string name="kg_puk_enter_puk_hint" msgid="453227143861735537">"De simkaart is nu uitgeschakeld. Geef de PUK-code op om door te gaan. Neem contact op met de provider voor informatie."</string>
    <string name="kg_puk_enter_pin_hint" msgid="7871604527429602024">"Gewenste pincode opgeven"</string>
    <string name="kg_enter_confirm_pin_hint" msgid="325676184762529976">"Gewenste pincode bevestigen"</string>
    <string name="kg_sim_unlock_progress_dialog_message" msgid="8950398016976865762">"Simkaart ontgrendelen..."</string>
    <string name="kg_password_wrong_pin_code" msgid="1139324887413846912">"Onjuiste pincode."</string>
    <string name="kg_invalid_sim_pin_hint" msgid="8795159358110620001">"Voer een pincode van 4 tot 8 cijfers in."</string>
    <string name="kg_invalid_sim_puk_hint" msgid="7553388325654369575">"De PUK-code is minimaal acht nummers lang."</string>
    <string name="kg_invalid_puk" msgid="3638289409676051243">"Geef de juiste PUK-code opnieuw op. Bij herhaalde pogingen wordt de simkaart permanent uitgeschakeld."</string>
    <string name="kg_invalid_confirm_pin_hint" product="default" msgid="7003469261464593516">"Pincodes komen niet overeen"</string>
    <string name="kg_login_too_many_attempts" msgid="6486842094005698475">"Te veel patroonpogingen"</string>
    <string name="kg_login_instructions" msgid="1100551261265506448">"Als u wilt ontgrendelen, moet u inloggen op uw Google-account."</string>
    <string name="kg_login_username_hint" msgid="5718534272070920364">"Gebruikersnaam (e-mail)"</string>
    <string name="kg_login_password_hint" msgid="9057289103827298549">"Wachtwoord"</string>
    <string name="kg_login_submit_button" msgid="5355904582674054702">"Inloggen"</string>
    <string name="kg_login_invalid_input" msgid="5754664119319872197">"Ongeldige gebruikersnaam of wachtwoord."</string>
    <string name="kg_login_account_recovery_hint" msgid="5690709132841752974">"Bent u uw gebruikersnaam of wachtwoord vergeten?\nGa naar "<b>"google.com/accounts/recovery"</b>"."</string>
    <string name="kg_login_checking_password" msgid="1052685197710252395">"Account controleren…"</string>
    <string name="kg_too_many_failed_pin_attempts_dialog_message" msgid="8276745642049502550">"U heeft uw pincode <xliff:g id="NUMBER_0">%d</xliff:g> keer onjuist getypt. \n\nProbeer het over <xliff:g id="NUMBER_1">%d</xliff:g> seconden opnieuw."</string>
    <string name="kg_too_many_failed_password_attempts_dialog_message" msgid="7813713389422226531">"U heeft uw wachtwoord <xliff:g id="NUMBER_0">%d</xliff:g> keer onjuist getypt. \n\nProbeer het over <xliff:g id="NUMBER_1">%d</xliff:g> seconden opnieuw."</string>
    <string name="kg_too_many_failed_pattern_attempts_dialog_message" msgid="74089475965050805">"U heeft uw ontgrendelingspatroon <xliff:g id="NUMBER_0">%d</xliff:g> keer onjuist getekend. \n\nProbeer het over <xliff:g id="NUMBER_1">%d</xliff:g> seconden opnieuw."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="tablet" msgid="1575557200627128949">"U heeft <xliff:g id="NUMBER_0">%d</xliff:g> keer geprobeerd de tablet op een onjuiste manier te ontgrendelen. Na nog eens <xliff:g id="NUMBER_1">%d</xliff:g> mislukte pogingen worden de fabrieksinstellingen hersteld op de tablet en gaan alle gebruikersgegevens verloren."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="default" msgid="4051015943038199910">"U heeft nu <xliff:g id="NUMBER_0">%d</xliff:g> keer geprobeerd de telefoon op een onjuiste manier te ontgrendelen. Na nog eens <xliff:g id="NUMBER_1">%d</xliff:g> mislukte pogingen worden de fabrieksinstellingen hersteld op de telefoon en gaan alle gebruikersgegevens verloren."</string>
    <string name="kg_failed_attempts_now_wiping" product="tablet" msgid="2072996269148483637">"U heeft <xliff:g id="NUMBER">%d</xliff:g> keer geprobeerd de tablet op een onjuiste manier te ontgrendelen. De fabrieksinstellingen worden nu hersteld op de tablet."</string>
    <string name="kg_failed_attempts_now_wiping" product="default" msgid="4817627474419471518">"U heeft <xliff:g id="NUMBER">%d</xliff:g> keer geprobeerd de telefoon op een onjuiste manier te ontgrendelen. De fabrieksinstellingen worden nu hersteld op de telefoon."</string>
    <string name="kg_failed_attempts_almost_at_login" product="tablet" msgid="3253575572118914370">"U heeft uw ontgrendelingspatroon <xliff:g id="NUMBER_0">%d</xliff:g> keer onjuist getekend. Na nog eens <xliff:g id="NUMBER_1">%d</xliff:g> mislukte pogingen wordt u gevraagd uw tablet te ontgrendelen via een e-mailaccount.\n\n Probeer het over <xliff:g id="NUMBER_2">%d</xliff:g> seconden opnieuw."</string>
    <string name="kg_failed_attempts_almost_at_login" product="default" msgid="1437638152015574839">"U heeft uw ontgrendelingspatroon <xliff:g id="NUMBER_0">%d</xliff:g> keer onjuist getekend. Na nog eens <xliff:g id="NUMBER_1">%d</xliff:g> mislukte pogingen wordt u gevraagd uw telefoon te ontgrendelen via een e-mailaccount.\n\n Probeer het over <xliff:g id="NUMBER_2">%d</xliff:g> seconden opnieuw."</string>
    <string name="kg_text_message_separator" product="default" msgid="4160700433287233771">" — "</string>
    <string name="kg_reordering_delete_drop_target_text" msgid="7899202978204438708">"Verwijderen"</string>
    <string name="safe_media_volume_warning" product="default" msgid="7324161939475478066">"Wilt u het volume verhogen tot boven het aanbevolen geluidsniveau?\nTe lang luisteren op een te hoog volume kan leiden tot gehoorbeschadiging."</string>
    <string name="continue_to_enable_accessibility" msgid="1626427372316070258">"Blijf het scherm met twee vingers aanraken om toegankelijkheid in te schakelen."</string>
    <string name="accessibility_enabled" msgid="1381972048564547685">"Toegankelijkheid ingeschakeld."</string>
    <string name="enable_accessibility_canceled" msgid="3833923257966635673">"Toegankelijkheid geannuleerd."</string>
    <string name="user_switched" msgid="3768006783166984410">"Huidige gebruiker <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="owner_name" msgid="2716755460376028154">"Eigenaar"</string>
    <string name="error_message_title" msgid="4510373083082500195">"Fout"</string>
    <string name="app_no_restricted_accounts" msgid="5739463249673727736">"Deze app biedt geen ondersteuning voor accounts voor beperkte profielen"</string>
    <string name="app_not_found" msgid="3429141853498927379">"Er is geen app gevonden om deze actie uit te voeren"</string>
    <string name="revoke" msgid="5404479185228271586">"Intrekken"</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">"Indexkaart 3 x 5 inch"</string>
    <string name="mediasize_na_index_4x6" msgid="7687620625422312396">"Indexkaart 4 x 6 inch"</string>
    <string name="mediasize_na_index_5x8" msgid="8834215284646872800">"Indexkaart 5 x 8 inch"</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">"Onbekend portret"</string>
    <string name="mediasize_unknown_landscape" msgid="4876995327029361552">"Onbekend landschap"</string>
    <string name="write_fail_reason_cancelled" msgid="7091258378121627624">"Geannuleerd"</string>
    <string name="write_fail_reason_cannot_write" msgid="8132505417935337724">"Fout bij schrijven van inhoud"</string>
    <string name="reason_unknown" msgid="6048913880184628119">"onbekend"</string>
    <string name="reason_service_unavailable" msgid="7824008732243903268">"Afdrukservice niet ingeschakeld"</string>
    <string name="print_service_installed_title" msgid="2246317169444081628">"<xliff:g id="NAME">%s</xliff:g>-service geïnstalleerd"</string>
    <string name="print_service_installed_message" msgid="5897362931070459152">"Tik om in te schakelen"</string>
    <string name="restr_pin_enter_admin_pin" msgid="783643731895143970">"Pincode voor beheerder opgeven"</string>
    <string name="restr_pin_enter_pin" msgid="3395953421368476103">"Geef de pincode op"</string>
    <string name="restr_pin_incorrect" msgid="8571512003955077924">"Onjuist"</string>
    <string name="restr_pin_enter_old_pin" msgid="1462206225512910757">"Huidige pincode"</string>
    <string name="restr_pin_enter_new_pin" msgid="5959606691619959184">"Nieuwe pincode"</string>
    <string name="restr_pin_confirm_pin" msgid="8501523829633146239">"Nieuwe pincode bevestigen"</string>
    <string name="restr_pin_create_pin" msgid="8017600000263450337">"Maak een pincode voor het aanpassen van beperkingen"</string>
    <string name="restr_pin_error_doesnt_match" msgid="2224214190906994548">"De pincodes komen niet overeen. Probeer het opnieuw."</string>
    <string name="restr_pin_error_too_short" msgid="8173982756265777792">"Pincode is te kort. Moet ten minste vier cijfers lang zijn."</string>
  <plurals name="restr_pin_countdown">
    <item quantity="one" msgid="311050995198548675">"Probeer het over één seconde opnieuw"</item>
    <item quantity="other" msgid="4730868920742952817">"Probeer het over <xliff:g id="COUNT">%d</xliff:g> seconden opnieuw"</item>
  </plurals>
    <string name="restr_pin_try_later" msgid="973144472490532377">"Probeer het later opnieuw"</string>
    <string name="immersive_mode_confirmation" msgid="7227416894979047467">"Veeg omlaag vanaf de bovenkant om het volledige scherm te sluiten."</string>
</resources>
