<?xml version="1.0" encoding="utf-8"?>
<resources>
	<string name="role_viewer">Lezer</string>
	<string name="site_settings_list_editor_action_mode_title">Geselecteerde %1$d</string>
	<string name="error_fetch_users_list">Site-gebruikers ophalen mislukt</string>
	<string name="plans_manage">Beheer je abonnement op\nWordPress.com/plans</string>
	<string name="people_empty_list_filtered_viewers">Je hebt nog geen volgers.</string>
	<string name="people_empty_list_filtered_email_followers">Je hebt nog geen e-mailvolgers.</string>
	<string name="people_empty_list_filtered_followers">Je hebt nog geen volgers.</string>
	<string name="people_empty_list_filtered_users">Je hebt nog geen gebruikers.</string>
	<string name="people_dropdown_item_viewers">Lezers</string>
	<string name="invite_message_usernames_limit">Nodig tot wel 10 e-mailadressen en/of WordPress.com-gebruikersnamen uit. Naar degenen die een gebruikersnaam nodig hebben, worden instructies gestuurd over hoe ze er een aanmaken.</string>
	<string name="viewer_remove_confirmation_message">Als je deze lezer verwijdert, kan hij of zij deze site niet bezoeken.\n\nWil je deze lezer toch verwijderen?</string>
	<string name="follower_remove_confirmation_message">Als deze volger wordt verwijderd, kan hij of zij geen meldingen meer ontvangen over deze site tot hij of zij opnieuw gaat volgen.\n\nWil je deze volger toch verwijderen?</string>
	<string name="error_remove_follower">Volger verwijderen mislukt</string>
	<string name="error_remove_viewer">Lezer verwijderen mislukt</string>
	<string name="error_fetch_email_followers_list">E-mailvolgers site ophalen mislukt</string>
	<string name="error_fetch_followers_list">Sitevolgers ophalen mislukt</string>
	<string name="editor_failed_uploads_switch_html">Enkele media konden niet worden geüpload. Je kunt niet overschakelen naar HTML.\n in deze staat. Alle mislukte uploads verwijderen en doorgaan?</string>
	<string name="format_bar_description_html">HTML</string>
	<string name="visual_editor">Visual Editor</string>
	<string name="image_thumbnail">Miniatuurweergave afbeelding</string>
	<string name="format_bar_description_ul">Ongeordende lijst</string>
	<string name="format_bar_description_ol">Geordende lijst</string>
	<string name="format_bar_description_more">Meer invoeren</string>
	<string name="format_bar_description_media">Media invoeren</string>
	<string name="format_bar_description_strike">Doorstrepen</string>
	<string name="format_bar_description_quote">Citaat blokkeren</string>
	<string name="format_bar_description_link">Link invoeren</string>
	<string name="format_bar_description_italic">Cursief</string>
	<string name="format_bar_description_underline">Onderstrepen</string>
	<string name="image_settings_save_toast">Wijzigingen opgeslagen</string>
	<string name="image_caption">Bijschrift</string>
	<string name="image_alt_text">Alt. tekst</string>
	<string name="image_link_to">Link naar</string>
	<string name="image_width">Breedte</string>
	<string name="format_bar_description_bold">Vetgedrukt</string>
	<string name="image_settings_dismiss_dialog_title">Niet-opgeslagen wijzigingen verwijderen?</string>
	<string name="stop_upload_dialog_title">Stoppen met uploaden?</string>
	<string name="stop_upload_button">Stoppen met upload</string>
	<string name="alert_error_adding_media">Er is een fout opgetreden bij het invoeren van media</string>
	<string name="alert_action_while_uploading">Je bent media aan het uploaden. Wacht totdat dit is afgerond.</string>
	<string name="alert_insert_image_html_mode">Kan media niet direct invoeren in HTML. Schakel terug naar de visuele modus.</string>
	<string name="uploading_gallery_placeholder">Galerij wordt geüpload …</string>
	<string name="invite_sent">Uitnodiging verzonden</string>
	<string name="tap_to_try_again">Tik om het opnieuw te proberen!</string>
	<string name="invite_error_for_username">%1$s: %2$s</string>
	<string name="invite_message_info">(Optioneel) Je kunt een aangepast bericht invoeren van maximaal 500 tekens, dat wordt toegevoegd aan de uitnodiging van de gebruiker(s).</string>
	<string name="invite_message_remaining_other">%d tekens resterend</string>
	<string name="invite_message_remaining_one">1 teken resterend</string>
	<string name="invite_message_remaining_zero">0 tekens resterend</string>
	<string name="invite_invalid_email">Het e-mailadres \'%s\' is ongeldig</string>
	<string name="invite_message_title">Aangepast bericht</string>
	<string name="invite_already_a_member">Er is al een lid met de gebruikersnaam \'%s\'</string>
	<string name="invite_username_not_found">Geen gebruiker gevonden met gebruikersnaam \'%s\'</string>
	<string name="invite">Uitnodigen</string>
	<string name="invite_names_title">Gebruikersnamen of e-mails</string>
	<string name="signup_succeed_signin_failed">Je account is aangemaakt maar er is een fout opgetreden bij het\n aanmelden. Probeer je aan te melden met je nieuwe gebruikersnaam en wachtwoord.</string>
	<string name="send_link">Stuur link</string>
	<string name="my_site_header_external">Extern</string>
	<string name="invite_people">Mensen uitnodigen</string>
	<string name="label_clear_search_history">Zoekgeschiedenis wissen</string>
	<string name="dlg_confirm_clear_search_history">Zoekgeschiedenis wissen?</string>
	<string name="reader_empty_posts_in_search_description">Geen berichten gevonden voor %s in je taal.</string>
	<string name="reader_label_post_search_running">Zoeken ...</string>
	<string name="reader_label_related_posts">Gerelateerd leesmateriaal</string>
	<string name="reader_empty_posts_in_search_title">Geen berichten gevonden.</string>
	<string name="reader_label_post_search_explainer">Zoek alle openbare WordPress.com-blogs</string>
	<string name="reader_hint_post_search">Zoek op WordPress.com</string>
	<string name="reader_title_related_post_detail">Gerelateerd bericht</string>
	<string name="reader_title_search_results">Zoeken naar %s</string>
	<string name="preview_screen_links_disabled">Links uitgeschakeld op voorbeeldscherm</string>
	<string name="draft_explainer">Dit bericht is een concept dat niet is gepubliceerd</string>
	<string name="send">Verzenden</string>
	<string name="person_remove_confirmation_title">Verwijder %1$s</string>
	<string name="reader_empty_posts_in_custom_list">De sites in deze lijst hebben recent niets geplaatst</string>
	<string name="people">Mensen</string>
	<string name="edit_user">Gebruiker bewerken</string>
	<string name="role">Rol</string>
	<string name="error_remove_user">Gebruiker verwijderen mislukt</string>
	<string name="error_update_role">Gebruikersrol updaten mislukt</string>
	<string name="gravatar_camera_and_media_permission_required">Machtigingen vereist om een foto te selecteren of te nemen</string>
	<string name="error_updating_gravatar">Fout bij het updaten van je Gravatar</string>
	<string name="error_locating_image">Fout bij het vinden van de bij te snijden afbeelding</string>
	<string name="error_refreshing_gravatar">Fout bij het opnieuw laden van je Gravatar</string>
	<string name="gravatar_tip">Nieuw! Tik op je Gravatar om deze te wijzigen!</string>
	<string name="error_cropping_image">Fout bij het bijsnijden van de afbeelding</string>
	<string name="launch_your_email_app">Start je e-mailapp op</string>
	<string name="checking_email">E-mail wordt gecontroleerd</string>
	<string name="not_on_wordpress_com">Niet op WordPress.com?</string>
	<string name="magic_link_unavailable_error_message">Momenteel niet beschikbaar. Voer je wachtwoord in</string>
	<string name="check_your_email">Controleer je e-mail</string>
	<string name="get_a_link_sent_to_your_email_to_sign_in_instantly">Ontvang een link die wordt verzonden naar je e-mail om je meteen aan te melden.</string>
	<string name="logging_in">Inloggen</string>
	<string name="enter_your_password_instead">Voer je wachtwoord in</string>
	<string name="web_address_dialog_hint">Wordt openbaar getoond als je reageert.</string>
	<string name="jetpack_not_connected_message">De Jetpack-plugin is geïnstalleerd, maar niet verbonden met WordPress.com. Wil je Jetpack verbinden?</string>
	<string name="username_email">E-mail of gebruikersnaam</string>
	<string name="jetpack_not_connected">Jetpack-plugin niet verbonden</string>
	<string name="new_editor_reflection_error">Visual Editor is niet compatibel met uw apparaat. Het is\n automatisch uitgeschakeld.</string>
	<string name="stats_insights_latest_post_no_title">(geen titel)</string>
	<string name="capture_or_pick_photo">Neem of selecteer foto</string>
	<string name="plans_post_purchase_text_themes">Je hebt nu onbeperkt toegang tot premium thema\'s. Bekijk een voorbeeld van ieder gewenst thema op je site om te beginnen.</string>
	<string name="plans_post_purchase_button_themes">Door thema\'s bladeren</string>
	<string name="plans_post_purchase_title_themes">Vind een perfect premium thema</string>
	<string name="plans_post_purchase_button_video">Stel nieuw bericht op</string>
	<string name="plans_post_purchase_text_video">Met VideoPress en de uitbreiding van je media-opslag kun je video\'s uploaden en hosten op je site.</string>
	<string name="plans_post_purchase_title_video">Breng berichten tot leven met videobeelden</string>
	<string name="plans_post_purchase_button_customize">Mijn site aanpassen</string>
	<string name="plans_post_purchase_text_customize">Je hebt nu toegang tot bewerkingsfuncties voor aangepaste lettertypes, kleuren en CSS.</string>
	<string name="plans_post_purchase_text_intro">Je site maakt salto\'s uit vreugde! Ontdek nu de nieuwe functies van je site en kies waar je wilt beginnen.</string>
	<string name="plans_post_purchase_title_customize">Lettertypes en kleuren aanpassen</string>
	<string name="plans_post_purchase_title_intro">Hij is nu van jou, heel veel plezier!</string>
	<string name="plan">Abonnement</string>
	<string name="plans">Plans</string>
	<string name="plans_loading_error">Kan abonnementen niet laden.</string>
	<string name="export_your_content_message">Je berichten, pagina\'s en instellingen worden naar je e-mailadres, %s, verzonden.</string>
	<string name="export_your_content">Exporteer je content</string>
	<string name="export_email_sent">Exporteer verzonden e-mail!</string>
	<string name="exporting_content_progress">Content exporteren...</string>
	<string name="premium_upgrades_message">Je hebt actieve Premium-upgrades op je site. Annuleer je upgrades voordat je je site verwijdert.</string>
	<string name="checking_purchases">Aankopen worden gecontroleerd</string>
	<string name="show_purchases">Geef aankopen weer</string>
	<string name="premium_upgrades_title">Premium-upgrades</string>
	<string name="purchases_request_error">Er is iets fout gegaan. Kon aankopen niet aanvragen.</string>
	<string name="delete_site_progress">Site verwijderen...</string>
	<string name="delete_site_summary">Deze actie kan niet ongedaan worden gemaakt. Door de site te verwijderen worden alle content, bijdragers en domeinen van de site verwijderd.</string>
	<string name="delete_site_hint">Site verwijderen</string>
	<string name="export_site_hint">Exporteer je site naar een XML-bestand</string>
	<string name="are_you_sure">Weet je het zeker?</string>
	<string name="export_site_summary">Als je het zeker weet, neem dan nu de tijd om je content te exporteren. Deze kan later niet meer worden hersteld.</string>
	<string name="keep_your_content">Je content behouden</string>
	<string name="domain_removal_hint">Domeinen die niet werken wanneer je je site verwijdert</string>
	<string name="domain_removal_summary">Voorzichtig! Door je site te verwijderen, worden ook je onderstaande domeinen verwijderd.</string>
	<string name="primary_domain">Primair domein</string>
	<string name="domain_removal">Verwijdering domein</string>
	<string name="error_deleting_site_summary">Er is een fout opgetreden bij het verwijderen van je site. Neem contact op met ondersteuning voor meer hulp</string>
	<string name="error_deleting_site">Fout bij verwijderen site</string>
	<string name="confirm_delete_site_prompt">Voer %1$s in het onderstaande veld in om dit te bevestigen. Je site wordt dan voorgoed verwijderd.</string>
	<string name="site_settings_export_content_title">Content exporteren</string>
	<string name="confirm_delete_site">Site verwijderen bevestigen</string>
	<string name="contact_support">Neem contact op met ondersteuning</string>
	<string name="start_over_text">Als je een site wilt, maar niet de berichten en pagina\'s die je nu hebt, kan ons ondersteuningsteam je berichten, pagina\'s, media en reacties voor je verwijderen.\n\nHiermee blijft je site en URL actief maar kan je van vooraf aan beginnen met het maken van content. Neem contact met ons op als je je huidige content wilt verwijderen.</string>
	<string name="site_settings_start_over_hint">Begin opnieuw met je site</string>
	<string name="let_us_help">Laat ons je helpen</string>
	<string name="start_over">Begin opnieuw</string>
	<string name="me_btn_app_settings">App-instellingen</string>
	<string name="editor_remove_failed_uploads">Mislukte uploads verwijderen</string>
	<string name="editor_toast_failed_uploads">Enkele media konden niet worden geüpload. Het opslaan of publiceren\n van je bericht is niet mogelijk in deze staat. Wil je alle mislukte uploads verwijderen?</string>
	<string name="site_settings_advanced_header">Geavanceerd</string>
	<string name="comments_empty_list_filtered_trashed">Geen verwijderde reacties</string>
	<string name="comments_empty_list_filtered_pending">Geen reacties in behandeling</string>
	<string name="comments_empty_list_filtered_approved">Geen goedgekeurde reacties</string>
	<string name="button_done">Klaar</string>
	<string name="button_skip">Overslaan</string>
	<string name="site_timeout_error">Kon geen verbinding maken met de WordPress-site wegens een time-out.</string>
	<string name="xmlrpc_malformed_response_error">Kon geen verbinding maken. De WordPress-installatie heeft gereageerd met een ongeldig XML-RPC-document.</string>
	<string name="xmlrpc_missing_method_error">Kon geen verbinding maken. Vereiste XML-RPC-methoden ontbreken op de server.</string>
	<string name="post_format_status">Status</string>
	<string name="post_format_video">Video</string>
	<string name="theme_free">Gratis</string>
	<string name="theme_all">Alle</string>
	<string name="theme_premium">Premium</string>
	<string name="post_format_chat">Chat</string>
	<string name="post_format_gallery">Galerij</string>
	<string name="post_format_image">Afbeelding</string>
	<string name="post_format_link">Link</string>
	<string name="post_format_quote">Citeren</string>
	<string name="post_format_standard">Standaard</string>
	<string name="notif_events">Informatie over cursussen en evenementen van WordPress.com (online en op locatie).</string>
	<string name="post_format_aside">Aside</string>
	<string name="post_format_audio">Audio</string>
	<string name="notif_surveys">Mogelijkheden om deel te nemen aan onderzoeken en enquêtes van WordPress.com.</string>
	<string name="notif_tips">Tips om WordPress.com optimaal te benutten.</string>
	<string name="notif_community">Community</string>
	<string name="replies_to_my_comments">Antwoorden op mijn reacties</string>
	<string name="notif_suggestions">Suggesties</string>
	<string name="notif_research">Onderzoek</string>
	<string name="site_achievements">Prestaties voor de site</string>
	<string name="username_mentions">Vermeldingen van gebruikersnaam</string>
	<string name="likes_on_my_posts">Likes voor mijn berichten</string>
	<string name="site_follows">Volgers van site</string>
	<string name="likes_on_my_comments">Likes voor mijn reacties</string>
	<string name="comments_on_my_site">Reacties op mijn site</string>
	<string name="site_settings_list_editor_summary_other">%d items</string>
	<string name="site_settings_list_editor_summary_one">1 item</string>
	<string name="approve_auto_if_previously_approved">Reacties van bekende gebruikers</string>
	<string name="approve_auto">Alle gebruikers</string>
	<string name="approve_manual">Geen reacties</string>
	<string name="site_settings_paging_summary_other">%d reacties per pagina</string>
	<string name="site_settings_paging_summary_one">1 reactie per pagina</string>
	<string name="site_settings_multiple_links_summary_other">Vereis goedkeuring voor meer dan %d links</string>
	<string name="site_settings_multiple_links_summary_one">Vereis goedkeuring voor meer dan 1 link</string>
	<string name="site_settings_multiple_links_summary_zero">Vereis goedkeuring voor meer dan 0 links</string>
	<string name="detail_approve_auto">Keur de reacties van iedereen automatisch goed.</string>
	<string name="detail_approve_auto_if_previously_approved">Keur de reactie automatisch goed indien de gebruiker eerder een goedgekeurde reactie heeft geplaatst</string>
	<string name="detail_approve_manual">Vereist handmatige goedkeuring voor de reacties van iedereen.</string>
	<string name="filter_trashed_posts">Verwijderd</string>
	<string name="days_quantity_one">1 dag</string>
	<string name="days_quantity_other">%d dagen</string>
	<string name="filter_published_posts">Gepubliceerd</string>
	<string name="filter_draft_posts">Concepten</string>
	<string name="filter_scheduled_posts">Gepland</string>
	<string name="pending_email_change_snackbar">Klik op de link in de verificatiemail die verzonden is naar %1$s om je nieuwe adres te bevestigen</string>
	<string name="primary_site">Primaire site</string>
	<string name="web_address">Webadres</string>
	<string name="editor_toast_uploading_please_wait">Je bent media aan het uploaden. Wacht totdat dit is afgerond.</string>
	<string name="error_refresh_comments_showing_older">Reacties konden momenteel niet worden vernieuwd - oudere reacties worden weergegeven</string>
	<string name="editor_post_settings_set_featured_image">Stel aanbevolen afbeelding in</string>
	<string name="editor_post_settings_featured_image">Aanbevolen afbeelding</string>
	<string name="new_editor_promo_desc">De WordPress-app voor Android bevat een prachtige nieuwe visual\n editor. Probeer hem uit door een nieuw bericht te maken.</string>
	<string name="new_editor_promo_title">Volledig nieuwe editor</string>
	<string name="new_editor_promo_button_label">Geweldig, bedankt!</string>
	<string name="visual_editor_enabled">Visual Editor ingeschakeld</string>
	<string name="editor_content_placeholder">Deel hier je verhaal...</string>
	<string name="editor_page_title_placeholder">Paginatitel</string>
	<string name="editor_post_title_placeholder">Berichttitel</string>
	<string name="email_address">E-mailadres</string>
	<string name="preference_show_visual_editor">Visual Editor weergeven</string>
	<string name="dlg_sure_to_delete_comments">Deze reacties permanent verwijderen?</string>
	<string name="preference_editor">Editor</string>
	<string name="dlg_sure_to_delete_comment">Deze reactie permanent verwijderen?</string>
	<string name="mnu_comment_delete_permanently">Verwijderen</string>
	<string name="comment_deleted_permanently">Reactie verwijderd</string>
	<string name="mnu_comment_untrash">Herstellen</string>
	<string name="comments_empty_list_filtered_spam">Geen spamreacties</string>
	<string name="could_not_load_page">Kan pagina niet laden</string>
	<string name="comment_status_all">Alle</string>
	<string name="interface_language">Interface-taal</string>
	<string name="off">Uit</string>
	<string name="about_the_app">Over de app</string>
	<string name="error_post_account_settings">Opslaan van je accountinstellingen mislukt</string>
	<string name="error_post_my_profile">Opslaan van je profiel mislukt</string>
	<string name="error_fetch_account_settings">Ophalen van je accountinstellingen mislukt</string>
	<string name="error_fetch_my_profile">Ophalen van je profiel mislukt</string>
	<string name="stats_widget_promo_ok_btn_label">OK, duidelijk</string>
	<string name="stats_widget_promo_desc">Voeg de widget toe aan je startscherm om in één klik toegang te krijgen tot je Statistieken.</string>
	<string name="stats_widget_promo_title">Startscherm Statistieken Widget</string>
	<string name="site_settings_unknown_language_code_error">Taalcode niet herkend</string>
	<string name="site_settings_threading_dialog_description">Geneste reacties in threads toestaan.</string>
	<string name="site_settings_threading_dialog_header">Thread omhoog naar</string>
	<string name="remove">Verwijderen</string>
	<string name="search">Zoeken</string>
	<string name="add_category">Categorie toevoegen</string>
	<string name="disabled">Uitgeschakeld</string>
	<string name="site_settings_image_original_size">Oorspronkelijke grootte</string>
	<string name="privacy_private">Je site is alleen zichtbaar voor jou en gebruikers die je goedkeurt</string>
	<string name="privacy_public_not_indexed">Je site kan door iedereen worden bekeken, maar wordt niet geïndexeerd door zoekmachines</string>
	<string name="privacy_public">Je site kan door iedereen worden bekeken en kan worden geïndexeerd door zoekmachines</string>
	<string name="about_me_hint">Enkele woorden over jou…</string>
	<string name="public_display_name_hint">De weergavenaam is standaard je gebruikersnaam, tenzij hij anders is ingesteld</string>
	<string name="about_me">Over mij</string>
	<string name="public_display_name">Openbare weergavenaam</string>
	<string name="my_profile">Mijn Profiel</string>
	<string name="first_name">Voornaam</string>
	<string name="last_name">Achternaam</string>
	<string name="site_privacy_public_desc">Laat zoekmachines deze site indexeren</string>
	<string name="site_privacy_hidden_desc">Laat zoekmachines deze site niet indexeren</string>
	<string name="site_privacy_private_desc">Ik wil dat mijn site privé blijft en dat ik zelf kies voor wie hij zichtbaar is</string>
	<string name="cd_related_post_preview_image">Voorbeeldafbeelding van gerelateerd bericht bekijken</string>
	<string name="error_post_remote_site_settings">Kan site-informatie niet opslaan</string>
	<string name="error_fetch_remote_site_settings">Kan site-informatie niet ophalen</string>
	<string name="error_media_upload_connection">Er is een verbindingsfout opgetreden bij het uploaden van media</string>
	<string name="site_settings_disconnected_toast">Niet verbonden, bijwerken uitgeschakeld.</string>
	<string name="site_settings_unsupported_version_error">Niet-ondersteunde versie van WordPress</string>
	<string name="site_settings_multiple_links_dialog_description">Vereist goedkeuring voor reacties die meer dan dit aantal koppelingen bevatten.</string>
	<string name="site_settings_close_after_dialog_switch_text">Automatisch afsluiten</string>
	<string name="site_settings_close_after_dialog_description">Sluit reacties op artikelen automatisch af.</string>
	<string name="site_settings_paging_dialog_description">Deel reacties in threads op in meerdere pagina\'s.</string>
	<string name="site_settings_paging_dialog_header">Reacties per pagina</string>
	<string name="site_settings_close_after_dialog_title">Reacties afsluiten</string>
	<string name="site_settings_blacklist_description">Wanneer een reactie een van deze woorden bevat in de inhoud, naam, URL, e-mailadres of IP-adres, wordt het gemarkeerd als spam. Ook delen van woorden worden gevonden, dus "press" levert ook "WordPress" op als resultaat.</string>
	<string name="site_settings_hold_for_moderation_description">Wanneer een reactie een van deze woorden bevat in de inhoud, naam, URL, het e-mailadres of IP-adres, wordt hij in de wachtrij voor moderatie gezet. Ook delen van woorden worden gevonden, dus "press" levert ook "WordPress" op als resultaat.</string>
	<string name="site_settings_list_editor_input_hint">Voer een woord of zinsdeel in</string>
	<string name="site_settings_list_editor_no_items_text">Geen items</string>
	<string name="site_settings_learn_more_caption">Je kunt deze instellingen ongedaan maken voor individuele berichten.</string>
	<string name="site_settings_rp_preview3_site">in "Upgrade"</string>
	<string name="site_settings_rp_preview3_title">Upgradefocus: VideoPress voor bruiloften</string>
	<string name="site_settings_rp_preview2_site">in "Apps"</string>
	<string name="site_settings_rp_preview2_title">De WordPress voor Android-app krijgt een grote update</string>
	<string name="site_settings_rp_preview1_site">in "Mobiel"</string>
	<string name="site_settings_rp_preview1_title">Grote update voor iPhone/iPad nu beschikbaar</string>
	<string name="site_settings_rp_show_images_title">Afbeeldingen weergeven</string>
	<string name="site_settings_rp_show_header_title">Koptekst weergeven</string>
	<string name="site_settings_rp_switch_summary">Gerelateerde berichten geeft relevante content van je site weer onder je berichten.</string>
	<string name="site_settings_rp_switch_title">Gerelateerde berichten weergeven</string>
	<string name="site_settings_delete_site_hint">Verwijder je sitegegevens van de app</string>
	<string name="site_settings_blacklist_hint">Reacties die overeenkomen met een filter worden als spam gemarkeerd</string>
	<string name="site_settings_moderation_hold_hint">Reacties die overeenkomen met een filter worden in de wachtrij voor moderatie gezet</string>
	<string name="site_settings_multiple_links_hint">Negeert koppelingslimiet van bekende gebruikers</string>
	<string name="site_settings_whitelist_hint">De reactie-auteur moet eerder een goedgekeurde reactie hebben geplaatst</string>
	<string name="site_settings_user_account_required_hint">Gebruikers moeten geregistreerd en ingelogd zijn om een reactie te plaatsen</string>
	<string name="site_settings_identity_required_hint">De reactie-auteur moet zijn of haar naam en e-mailadres invullen</string>
	<string name="site_settings_manual_approval_hint">Reacties moeten handmatig worden goedgekeurd</string>
	<string name="site_settings_paging_hint">Geef reacties weer in delen van een specifieke grootte</string>
	<string name="site_settings_threading_hint">Geneste reacties toestaan tot een bepaalde diepte</string>
	<string name="site_settings_sort_by_hint">Bepaalt de volgorde waarin reacties worden weergegeven</string>
	<string name="site_settings_close_after_hint">Reacties niet meer toestaan na bepaalde tijd</string>
	<string name="site_settings_receive_pingbacks_hint">Koppelingsmeldingen van andere blogs toestaan</string>
	<string name="site_settings_send_pingbacks_hint">Probeer een melding te maken op alle blogs waaraan het artikel is gekoppeld</string>
	<string name="site_settings_allow_comments_hint">Toestaan dat lezers reacties plaatsen</string>
	<string name="site_settings_discussion_hint">Geef discussie-instellingen van je site weer en wijzig ze</string>
	<string name="site_settings_more_hint">Geef alle beschikbare discussie-instellingen weer</string>
	<string name="site_settings_related_posts_hint">Toon of verberg alle gerelateerde berichten in de reader</string>
	<string name="site_settings_upload_and_link_image_hint">Inschakelen dat de afbeelding altijd op volledige grootte wordt geüpload</string>
	<string name="site_settings_image_width_hint">De afmeting van afbeeldingen in berichten wijzigen naar deze breedte</string>
	<string name="site_settings_format_hint">Een nieuwe post format instellen</string>
	<string name="site_settings_category_hint">Een nieuwe berichtcategorie instellen</string>
	<string name="site_settings_location_hint">Automatisch locatiegegevens aan je berichten toevoegen</string>
	<string name="site_settings_password_hint">Wijzig je wachtwoord</string>
	<string name="site_settings_username_hint">Huidig gebruikersaccount</string>
	<string name="site_settings_language_hint">Taal waarin deze blog voornamelijk is geschreven</string>
	<string name="site_settings_privacy_hint">Beheert wie je site kan zien</string>
	<string name="site_settings_address_hint">Het wijzigen van je adres wordt momenteel niet ondersteund</string>
	<string name="site_settings_tagline_hint">Een korte beschrijving of een pakkende zin om je blog te omschrijven</string>
	<string name="site_settings_title_hint">Leg in een paar woorden uit waar deze site over gaat</string>
	<string name="site_settings_whitelist_known_summary">Reacties van bekende gebruikers</string>
	<string name="site_settings_whitelist_all_summary">Reacties van alle gebruikers</string>
	<string name="site_settings_threading_summary">%d niveaus</string>
	<string name="site_settings_privacy_private_summary">Privé</string>
	<string name="site_settings_privacy_hidden_summary">Verborgen</string>
	<string name="site_settings_delete_site_title">Site verwijderen</string>
	<string name="site_settings_privacy_public_summary">Openbaar</string>
	<string name="site_settings_blacklist_title">Blacklist</string>
	<string name="site_settings_moderation_hold_title">In de wacht zetten voor moderatie</string>
	<string name="site_settings_multiple_links_title">Koppelingen in reacties</string>
	<string name="site_settings_whitelist_title">Automatisch goedkeuren</string>
	<string name="site_settings_threading_title">Weergave threads</string>
	<string name="site_settings_paging_title">Weergave pagina\'s</string>
	<string name="site_settings_sort_by_title">Sorteren op</string>
	<string name="site_settings_account_required_title">Gebruikers moeten aangemeld zijn</string>
	<string name="site_settings_identity_required_title">Moet naam en e-mail bevatten</string>
	<string name="site_settings_receive_pingbacks_title">Pingbacks ontvangen</string>
	<string name="site_settings_send_pingbacks_title">Pingbacks verzenden</string>
	<string name="site_settings_allow_comments_title">Reacties toestaan</string>
	<string name="site_settings_default_format_title">Standaard indeling</string>
	<string name="site_settings_default_category_title">Standaard categorie</string>
	<string name="site_settings_location_title">Locatie inschakelen</string>
	<string name="site_settings_address_title">Adres</string>
	<string name="site_settings_title_title">Sitetitel</string>
	<string name="site_settings_tagline_title">Slogan</string>
	<string name="site_settings_this_device_header">Dit apparaat</string>
	<string name="site_settings_discussion_new_posts_header">Standaardinstellingen voor nieuwe berichten</string>
	<string name="site_settings_account_header">Account</string>
	<string name="site_settings_writing_header">Schrijven</string>
	<string name="newest_first">Nieuwste eerst</string>
	<string name="site_settings_general_header">Algemeen</string>
	<string name="discussion">Reacties</string>
	<string name="privacy">Privacy</string>
	<string name="related_posts">Gerelateerde berichten</string>
	<string name="comments">Commentaar</string>
	<string name="close_after">Hierna sluiten</string>
	<string name="oldest_first">Oudste eerst</string>
	<string name="media_error_no_permission_upload">Je hebt geen toestemming om media naar de site te uploaden</string>
	<string name="never">Nooit</string>
	<string name="unknown">Onbekend</string>
	<string name="reader_err_get_post_not_found">Dit bericht bestaat niet meer</string>
	<string name="reader_err_get_post_not_authorized">Je hebt geen rechten om dit bericht te lezen</string>
	<string name="reader_err_get_post_generic">Kan dit bericht niet ophalen</string>
	<string name="blog_name_no_spaced_allowed">Het adres van de site mag geen spaties bevatten</string>
	<string name="invalid_username_no_spaces">De gebruikersnaam mag geen spaties bevatten</string>
	<string name="reader_empty_followed_blogs_no_recent_posts_description">De sites die je volgt hebben recent niets geplaatst</string>
	<string name="reader_empty_followed_blogs_no_recent_posts_title">Geen recente berichten</string>
	<string name="media_details_copy_url_toast">URL gekopieerd naar klembord</string>
	<string name="edit_media">Media bewerken</string>
	<string name="media_details_copy_url">URL kopiëren</string>
	<string name="media_details_label_date_uploaded">Geüpload</string>
	<string name="media_details_label_date_added">Toegevoegd</string>
	<string name="selected_theme">Geselecteerd thema</string>
	<string name="could_not_load_theme">Kan thema niet laden</string>
	<string name="theme_activation_error">Er is iets fout gegaan. Kan thema niet activeren</string>
	<string name="theme_by_author_prompt_append"> door %1$s</string>
	<string name="theme_prompt">Bedankt dat je hebt gekozen voor %1$s</string>
	<string name="theme_try_and_customize">Uitproberen en aanpassen</string>
	<string name="theme_view">Weergeven</string>
	<string name="theme_details">Details</string>
	<string name="theme_support">Ondersteuning</string>
	<string name="theme_done">GEREED</string>
	<string name="theme_manage_site">SITE BEHEREN</string>
	<string name="title_activity_theme_support">Thema\'s</string>
	<string name="theme_activate">Activeren</string>
	<string name="date_range_start_date">Startdatum</string>
	<string name="date_range_end_date">Einddatum</string>
	<string name="current_theme">Huidig thema</string>
	<string name="customize">Aanpassen</string>
	<string name="details">Details</string>
	<string name="support">Ondersteuning</string>
	<string name="active">Actief</string>
	<string name="stats_referrers_spam_generic_error">Er is iets fout gegaan tijdens deze handeling. De status van de spam is ongewijzigd gebleven.</string>
	<string name="stats_referrers_marking_not_spam">Markeren als geen spam</string>
	<string name="stats_referrers_unspam">Geen spam</string>
	<string name="stats_referrers_marking_spam">Markeren als spam</string>
	<string name="theme_auth_error_authenticate">Fout bij het ophalen van thema\'s: authenticatie van gebruiker mislukt</string>
	<string name="post_published">Bericht gepubliceerd</string>
	<string name="page_published">Pagina gepubliceerd</string>
	<string name="post_updated">Bericht bijgewerkt</string>
	<string name="page_updated">Pagina bijgewerkt</string>
	<string name="stats_referrers_spam">Spam</string>
	<string name="theme_no_search_result_found">Helaas, geen thema\'s gevonden.</string>
	<string name="media_file_name">Bestandsnaam: %s</string>
	<string name="media_uploaded_on">Geüpload op: %s</string>
	<string name="media_dimensions">Afmetingen: %s</string>
	<string name="upload_queued">In wachtrij geplaatst</string>
	<string name="media_file_type">Bestandstype: %s</string>
	<string name="reader_label_gap_marker">Meer berichten laden</string>
	<string name="notifications_no_search_results">Geen sites overeengekomen met \'%s\'</string>
	<string name="search_sites">Zoek sites</string>
	<string name="notifications_empty_view_reader">Reader weergeven</string>
	<string name="unread">Ongelezen</string>
	<string name="notifications_empty_action_followers_likes">Trek de aandacht: reageer op berichten die je hebt gelezen.</string>
	<string name="notifications_empty_action_comments">Deelnemen aan een gesprek: reageer op berichten uit blogs die je volgt.</string>
	<string name="notifications_empty_action_unread">Breng het gesprek weer op gang: schrijf een nieuw bericht.</string>
	<string name="notifications_empty_action_all">Ga aan de slag! Reageer op berichten uit blogs die je volgt.</string>
	<string name="notifications_empty_likes">Er zijn nog geen nieuwe likes.</string>
	<string name="notifications_empty_followers">Er zijn nog geen nieuwe volgers.</string>
	<string name="notifications_empty_comments">Nog geen nieuwe reacties.</string>
	<string name="notifications_empty_unread">Je bent helemaal bij!</string>
	<string name="stats_widget_error_jetpack_no_blogid">Bekijk de statistieken in de app en probeer later de widget toe te voegen</string>
	<string name="stats_widget_error_readd_widget">Verwijder de widget en voeg deze opnieuw in</string>
	<string name="stats_widget_error_no_visible_blog">Je hebt geen toegang tot de statistieken zonder een zichtbare blog</string>
	<string name="stats_widget_error_no_permissions">Je account van WordPress.com heeft geen toegang tot de statistieken van deze blog</string>
	<string name="stats_widget_error_no_account">Login bij WordPress</string>
	<string name="stats_widget_error_generic">Statistieken kunnen niet worden geladen</string>
	<string name="stats_widget_loading_data">Gegevens laden…</string>
	<string name="stats_widget_name_for_blog">Huidige statistieken voor %1$s</string>
	<string name="stats_widget_name">Huidige statistieken van WordPress</string>
	<string name="add_location_permission_required">Toestemming vereist om locatie toe te voegen</string>
	<string name="add_media_permission_required">Toestemming vereist om media toe te voegen</string>
	<string name="access_media_permission_required">Toestemming vereist om media toe te voegen</string>
	<string name="stats_enable_rest_api_in_jetpack">Om je statistieken te bekijken moet je de JSON API module in Jetpack activeren.</string>
	<string name="error_open_list_from_notification">Dit bericht of deze pagina is gepubliceerd op een andere site</string>
	<string name="reader_short_comment_count_multi">%s Reacties</string>
	<string name="reader_short_comment_count_one">1 Reactie</string>
	<string name="reader_label_submit_comment">VERSTUUR</string>
	<string name="reader_hint_comment_on_post">Reageer op bericht…</string>
	<string name="reader_discover_visit_blog">%s bezoeken</string>
	<string name="reader_discover_attribution_blog">Oorspronkelijk geplaatst op %s</string>
	<string name="reader_discover_attribution_author">Oorspronkelijk geplaatst door %s</string>
	<string name="reader_discover_attribution_author_and_blog">Oorspronkelijk geplaatst door %1$s op %2$s</string>
	<string name="reader_short_like_count_multi">%s likes</string>
	<string name="reader_short_like_count_one">1 like</string>
	<string name="reader_label_follow_count">%,d volgers</string>
	<string name="reader_short_like_count_none">Like</string>
	<string name="reader_menu_tags">Tags en blogs bijwerken</string>
	<string name="reader_title_post_detail">Reader-bericht</string>
	<string name="local_draft_explainer">Dit bericht is een lokaal concept dat niet is gepubliceerd</string>
	<string name="local_changes_explainer">Dit bericht bevat lokale wijzigingen die niet zijn gepubliceerd</string>
	<string name="notifications_push_summary">Instellingen voor meldingen die op je apparaat verschijnen.</string>
	<string name="notifications_email_summary">Instellingen voor meldingen die worden verstuurd naar het e-mailadres dat bij je account hoort.</string>
	<string name="notifications_tab_summary">Instellingen voor meldingen die verschijnen in het tabblad Meldingen.</string>
	<string name="notifications_disabled">Appmeldingen zijn uitgeschakeld. Tik hier om ze in te schakelen in Instellingen.</string>
	<string name="notification_types">Soorten meldingen</string>
	<string name="error_loading_notifications">Kan meldingsinstellingen niet laden</string>
	<string name="replies_to_your_comments">Antwoorden op je reacties</string>
	<string name="comment_likes">Likes voor reactie</string>
	<string name="app_notifications">Appmeldingen</string>
	<string name="notifications_tab">Tabblad Meldingen</string>
	<string name="email">E-mailadres</string>
	<string name="notifications_comments_other_blogs">Reacties op andere sites</string>
	<string name="notifications_other">Anders</string>
	<string name="notifications_wpcom_updates">Nieuws WordPress.com</string>
	<string name="notifications_account_emails">E-mail van WordPress.com</string>
	<string name="notifications_account_emails_summary">We sturen altijd belangrijke e-mails met betrekking tot je account, maar je kunt ook aanvullende nuttige berichten ontvangen.</string>
	<string name="notifications_sights_and_sounds">Beelden en geluiden</string>
	<string name="your_sites">Jouw sites</string>
	<string name="stats_insights_latest_post_trend">Het is %1$s geleden sinds %2$s is gepubliceerd. Hier zie je hoe het bericht het tot nu toe heeft gedaan ...</string>
	<string name="stats_insights_latest_post_summary">Samenvatting laatste bericht</string>
	<string name="button_revert">Terugzetten</string>
	<string name="days_ago">%d dagen geleden</string>
	<string name="yesterday">Gisteren</string>
	<string name="connectionbar_no_connection">Geen verbinging</string>
	<string name="button_publish">Publiceren</string>
	<string name="post_deleted">Bericht verwijderd</string>
	<string name="post_trashed">Bericht naar de prullenbak verplaatst</string>
	<string name="page_trashed">Pagina naar de prullenbak verplaatst.</string>
	<string name="button_back">Terug</string>
	<string name="page_deleted">Pagina verwijderd</string>
	<string name="button_stats">Statistieken</string>
	<string name="button_trash">Prullenbak</string>
	<string name="button_edit">Bewerken</string>
	<string name="stats_no_activity_this_period">Geen activiteit deze periode</string>
	<string name="trashed">Verwijderd</string>
	<string name="button_preview">Voorbeeld</string>
	<string name="button_view">Bekijk</string>
	<string name="my_site_no_sites_view_subtitle">Wil je er één toevoegen?</string>
	<string name="my_site_no_sites_view_title">Je hebt nog geen WordPress-sites.</string>
	<string name="my_site_no_sites_view_drake">Illustratie</string>
	<string name="reader_toast_err_follow_blog_not_authorized">Je hebt geen rechten om dit blog te openen</string>
	<string name="reader_toast_err_follow_blog_not_found">Dit blog kon niet worden gevonden</string>
	<string name="undo">Ongedaan maken</string>
	<string name="tabbar_accessibility_label_my_site">Mijn site</string>
	<string name="tabbar_accessibility_label_me">Ik</string>
	<string name="passcodelock_prompt_message">Je PIN invullen.</string>
	<string name="editor_toast_changes_saved">De wijzigingen zijn opgeslagen.</string>
	<string name="push_auth_expired">Je verzoek is verlopen. Je bij WordPress.com aanmelden en opnieuw proberen.</string>
	<string name="stats_insights_best_ever">Best bekeken ooit</string>
	<string name="stats_insights_most_popular_percent_views">%1$d%% van weergaven</string>
	<string name="ignore">Negeren</string>
	<string name="stats_insights_most_popular_hour">De meest populaire tijd.</string>
	<string name="stats_insights_most_popular_day">De meest populaire dag.</string>
	<string name="stats_insights_today">De statistieken van vandaag.</string>
	<string name="stats_insights_popular">De meest populaire dag en tijd.</string>
	<string name="stats_insights_all_time">Alle berichten, weergaven en bezoekers</string>
	<string name="stats_insights">Inzichten</string>
	<string name="stats_sign_in_jetpack_different_com_account">Om de statistieken te bekijken moet je bij je WordPress.com account aanmelden en deze verbinden met Jetpack.</string>
	<string name="stats_other_recent_stats_moved_label">Op zoek naar je andere recente statistieken? We hebben ze verplaatst naar de pagina Inzichten.</string>
	<string name="me_disconnect_from_wordpress_com">Loskoppelen van WordPress.com</string>
	<string name="me_connect_to_wordpress_com">Verbinden met WordPress.com</string>
	<string name="me_btn_login_logout">Inloggen/uitloggen</string>
	<string name="site_picker_cant_hide_current_site">"%s" was niet verborgen omdat het de huidige site is</string>
	<string name="me_btn_support">Help &amp; Support</string>
	<string name="account_settings">Accountinstellingen</string>
	<string name="site_picker_create_dotcom">WordPress.com site maken</string>
	<string name="site_picker_edit_visibility">Sites tonen/verbergen</string>
	<string name="site_picker_add_self_hosted">Een zelf-gehoste site toevoegen</string>
	<string name="site_picker_add_site">Site toevoegen</string>
	<string name="my_site_btn_switch_site">Site wisselen</string>
	<string name="site_picker_title">Site kiezen</string>
	<string name="my_site_btn_view_admin">Beheer bekijken</string>
	<string name="my_site_btn_view_site">Bekijk site</string>
	<string name="my_site_header_publish">Publiceren</string>
	<string name="my_site_header_look_and_feel">Look and feel</string>
	<string name="my_site_btn_blog_posts">Blogberichten</string>
	<string name="my_site_btn_site_settings">Instellingen</string>
	<string name="reader_label_new_posts_subtitle">Tik om ze te tonen</string>
	<string name="my_site_header_configuration">Configuratie</string>
	<string name="notifications_account_required">Meld je aan bij WordPress.com voor meldingen</string>
	<string name="stats_unknown_author">Onbekende auteur</string>
	<string name="signout">Verbinding verbreken</string>
	<string name="image_added">Afbeelding toegevoegd</string>
	<string name="sign_out_wpcom_confirm">Als je je account loskoppelt, worden alle WordPress.com gegevens van @%s verwijderd van dit apparaat, inclusief lokale concepten en lokale wijzigingen.</string>
	<string name="select_all">Alles selecteren</string>
	<string name="hide">Verbergen</string>
	<string name="show">Tonen</string>
	<string name="deselect_all">Alles deselecteren</string>
	<string name="select_from_new_picker">Meerdere selecteren met de nieuwe picker </string>
	<string name="stats_generic_error">Benodigde statistieken konden niet geladen worden</string>
	<string name="no_media_sources">Media ophalen mislukt</string>
	<string name="loading_blog_videos">Video\'s ophalen</string>
	<string name="loading_blog_images">Afbeeldingen ophalen</string>
	<string name="error_loading_images">Fout bij het laden van afbeeldingen</string>
	<string name="error_loading_videos">Fout bij het laden van video\'s</string>
	<string name="error_loading_blog_images">Ophalen van afbeeldingen mislukt</string>
	<string name="error_loading_blog_videos">Ophalen van video\'s mislukt</string>
	<string name="no_device_videos">Geen video\'s </string>
	<string name="no_blog_images">Geen afbeeldingen</string>
	<string name="no_blog_videos">Geen video\'s</string>
	<string name="no_device_images">Geen afbeeldingen</string>
	<string name="loading_images">Afbeeldingen laden</string>
	<string name="no_media">Geen media</string>
	<string name="loading_videos">Video\'s laden</string>
	<string name="device">Apparaat</string>
	<string name="language">Taal</string>
	<string name="add_to_post">Toevoegen aan bericht</string>
	<string name="media_picker_title">Media selecteren</string>
	<string name="take_photo">Een foto maken</string>
	<string name="take_video">Een video maken</string>
	<string name="tab_title_device_images">Apparaatafbeeldingen</string>
	<string name="tab_title_device_videos">Apparaatvideo\'s</string>
	<string name="tab_title_site_images">Siteafbeeldingen</string>
	<string name="tab_title_site_videos">Sitevideo\'s</string>
	<string name="error_publish_no_network">Kan niet publiceren als er geen verbinding is. Opgeslagen als concept.</string>
	<string name="editor_toast_invalid_path">Ongeldig bestandspad</string>
	<string name="verification_code">Verificatiecode</string>
	<string name="invalid_verification_code">Ongeldige verificatiecode</string>
	<string name="verify">Verifiëren</string>
	<string name="two_step_footer_label">Voer de code in vanuit je Authenticator-app.</string>
	<string name="two_step_footer_button">Verzend code via sms</string>
	<string name="two_step_sms_sent">Kijk in je sms\'jes voor de verificatiecode.</string>
	<string name="sign_in_jetpack">Meld je aan bij je WordPress.com account om verbinding te maken met Jetpack.</string>
	<string name="auth_required">Meld je opnieuw aan om door te gaan.</string>
	<string name="media_details_label_file_name">Bestandsnaam</string>
	<string name="media_details_label_file_type">Bestandstype</string>
	<string name="posts_fetching">Fetching posts…</string>
	<string name="media_fetching">Fetching media…</string>
	<string name="pages_fetching">Fetching pages…</string>
	<string name="toast_err_post_uploading">Unable to open post while it\'s uploading</string>
	<string name="stats_view_search_terms">Zoektermen</string>
	<string name="comments_fetching">Fetching comments…</string>
	<string name="stats_empty_search_terms">Geen zoektermen geregistreerd</string>
	<string name="stats_entry_search_terms">Search Term</string>
	<string name="stats_view_authors">Auteurs</string>
	<string name="stats_search_terms_unknown_search_terms">Onbekende zoektermen</string>
	<string name="stats_followers_total_wpcom_paged">Showing %1$d - %2$d of %3$s WordPress.com Followers</string>
	<string name="stats_empty_search_terms_desc">Ontdek meer informatie over je zoekverkeer door de termen te bekijken waarmee je bezoekers hebben gezocht naar je site.</string>
	<string name="reader_empty_posts_request_failed">Unable to retrieve posts</string>
	<string name="publisher">Publisher:</string>
	<string name="error_notification_open">Could not open notification</string>
	<string name="stats_followers_total_email_paged">Showing %1$d - %2$d of %3$s Email Followers</string>
	<string name="stats_months_and_years">Maanden en jaren</string>
	<string name="stats_recent_weeks">Laatste weken</string>
	<string name="error_copy_to_clipboard">Er is een fout opgetreden tijdens het kopiëren van de tekst naar het klembord</string>
	<string name="reader_label_new_posts">Nieuwe berichten</string>
	<string name="reader_empty_posts_in_blog">Deze blog is leeg</string>
	<string name="stats_average_per_day">Gemiddelde per dag</string>
	<string name="stats_period">Periode</string>
	<string name="logs_copied_to_clipboard">Applicatielogs zijn gekopieerd naar het klembord</string>
	<string name="stats_total">Totaal</string>
	<string name="stats_overall">Totaal</string>
	<string name="post_uploading">Uploaden</string>
	<string name="reader_page_recommended_blogs">Sites die je misschien ook leuk vindt</string>
	<string name="stats_comments_total_comments_followers">Totaalaantal berichten met reactievolgers: %1$s</string>
	<string name="stats_visitors">Bezoekers</string>
	<string name="stats_likes">Waarderingen</string>
	<string name="stats_pagination_label">Pagina %1$s van %2$s</string>
	<string name="stats_timeframe_years">Jaren</string>
	<string name="stats_views">Weergaven</string>
	<string name="stats_view_followers">Volgers</string>
	<string name="stats_view_countries">Landen</string>
	<string name="stats_view_top_posts_and_pages">Berichten &amp; pagina\'s</string>
	<string name="stats_view_videos">Video\'s</string>
	<string name="stats_view_publicize">Publiceren</string>
	<string name="stats_totals_publicize">Volgers</string>
	<string name="stats_entry_clicks_link">Link</string>
	<string name="stats_entry_followers">Volger</string>
	<string name="stats_entry_publicize">Service</string>
	<string name="stats_entry_video_plays">Video</string>
	<string name="stats_entry_top_commenter">Auteur</string>
	<string name="stats_empty_geoviews_desc">Bekijk de lijst en ontdek welke landen en regio\'s het meeste verkeer naar je site genereren.</string>
	<string name="stats_totals_followers">Sinds</string>
	<string name="stats_empty_geoviews">Geen landen geregistreerd</string>
	<string name="stats_empty_top_posts_title">Geen berichten of pagina\'s weergegeven</string>
	<string name="stats_empty_top_posts_desc">Ontdek wat je meest bekeken content is en zie hoe afzonderlijke berichten en pagina\'s het doen in de loop der tijd.</string>
	<string name="stats_empty_referrers_title">Geen geregistreerde referrers</string>
	<string name="stats_empty_clicks_title">Geen klikken geregistreerd</string>
	<string name="stats_empty_referrers_desc">Ontdek meer over de zichtbaarheid van je site door naar de websites en zoekmachines te kijken die het meeste verkeer jouw kant opsturen.</string>
	<string name="stats_empty_clicks_desc">Als je content links naar andere sites bevat, zie je welke links je bezoekers het meest aanklikken.</string>
	<string name="stats_empty_tags_and_categories">Geen getagde berichten of pagina\'s weergegeven</string>
	<string name="stats_empty_top_authors_desc">Houd de weergaves van de berichten van elke bijdrager bij en zoom in om de populairste content van elke auteur te ontdekken.</string>
	<string name="stats_empty_tags_and_categories_desc">Bekijk een overzicht van de populairste onderwerpen op je site zoals die weerspiegeld worden in je topberichten van de afgelopen week.</string>
	<string name="stats_empty_comments_desc">Als je reacties toestaat op je site, kun je de personen met de meeste reacties bijhouden en ontdekken welke content zorgt voor de levendigste gesprekken, op basis van de meest recente 1000 reacties.</string>
	<string name="stats_empty_video">Geen afgespeelde video\'s</string>
	<string name="stats_empty_video_desc">Als je video\'s hebt geüpload met behulp van VideoPress, kun je zien hoe vaak ze zijn bekeken.</string>
	<string name="stats_empty_publicize">Geen Publicize-volgers geregistreerd</string>
	<string name="stats_empty_publicize_desc">Houd je volgers van verschillende sociale netwerkservices bij met behulp van Publicize.</string>
	<string name="stats_empty_followers">Geen volgers</string>
	<string name="stats_comments_by_authors">Op auteurs</string>
	<string name="stats_comments_by_posts_and_pages">Op berichten en pagina\'s</string>
	<string name="stats_empty_followers_desc">Houd je totaal aantal volgers bij en hoe lang elke volger je site al volgt.</string>
	<string name="stats_followers_total_wpcom">Totaal aantal WordPress.com volgers: %1$s</string>
	<string name="stats_followers_total_email">Totaal aantal e-mailvolgers: %1$s</string>
	<string name="stats_followers_wpcom_selector">WordPress.com</string>
	<string name="stats_followers_email_selector">E-mail</string>
	<string name="stats_followers_a_minute_ago">een minuut geleden</string>
	<string name="stats_followers_seconds_ago">seconden geleden</string>
	<string name="stats_followers_a_day">Per dag</string>
	<string name="stats_followers_days">%1$d dagen</string>
	<string name="stats_followers_hours">%1$d uren</string>
	<string name="stats_followers_an_hour_ago">een uur geleden</string>
	<string name="stats_followers_minutes">%1$d minuten</string>
	<string name="stats_followers_months">%1$d maanden</string>
	<string name="stats_followers_a_year">Per jaar</string>
	<string name="stats_followers_years">%1$d jaren</string>
	<string name="stats_followers_a_month">Per maand</string>
	<string name="stats_view_all">Alles weergeven</string>
	<string name="stats_view">Weergave</string>
	<string name="stats_other_recent_stats_label">Andere recente statistieken</string>
	<string name="themes_fetching">Thema\'s ophalen …</string>
	<string name="stats_for">Statistieken voor %s</string>
	<string name="ssl_certificate_details">Details</string>
	<string name="sure_to_remove_account">Deze site verwijderen?</string>
	<string name="delete_sure_post">Dit bericht verwijderen</string>
	<string name="delete_sure">Dit concept verwijderen</string>
	<string name="delete_sure_page">Deze pagina verwijderen</string>
	<string name="confirm_delete_multi_media">Geselecteerde items verwijderen?</string>
	<string name="confirm_delete_media">Geselecteerd item verwijderen?</string>
	<string name="cab_selected">%d geselecteerd</string>
	<string name="media_gallery_date_range">Media van %1$s tot %2$s weergeven</string>
	<string name="faq_button">FAQ</string>
	<string name="browse_our_faq_button">Bekijk onze FAQ</string>
	<string name="reader_label_comment_count_single">Eén reactie</string>
	<string name="reader_empty_posts_liked">Je hebt nog geen enkel bericht geliked</string>
	<string name="nux_help_description">Bezoek het help centrum voor antwoorden op algemene vragen or bezoek de forums om nieuwe te stellen</string>
	<string name="agree_terms_of_service">Door het aanmaken van een account ga je akkoord met de fascinerende %1$sTerms of Service%2$s</string>
	<string name="create_new_blog_wpcom">Creëer WordPress.com blog</string>
	<string name="new_blog_wpcom_created">WordPress.com blog gecreëerd!</string>
	<string name="reader_empty_posts_in_tag">Geen berichten met deze tag</string>
	<string name="reader_label_view_original">Bekijk oorspronkelijk artikel</string>
	<string name="reader_label_like">Like</string>
	<string name="reader_label_comments_on">Reacties op</string>
	<string name="error_refresh_unauthorized_posts">Je hebt geen rechten om berichten te bekijken of te bewerken</string>
	<string name="reader_title_photo_viewer">%1$d van %2$d</string>
	<string name="error_refresh_unauthorized_pages">Je hebt geen rechten om pagina\'s te bekijken of te bewerken</string>
	<string name="error_publish_empty_post">Kan een leeg bericht niet publiceren</string>
	<string name="signing_out">Uitloggen…</string>
	<string name="comment">Reactie</string>
	<string name="comment_trashed">Reactie verwijderd</string>
	<string name="older_month">Ouder dan een maand</string>
	<string name="more">Meer</string>
	<string name="older_two_days">Ouder dan 2 dagen</string>
	<string name="older_last_week">Ouder dan een week</string>
	<string name="select_a_blog">Selecteer een WordPress site</string>
	<string name="comment_reply_to_user">Antwoord op %s</string>
	<string name="stats_no_blog">Statistieken konden niet worden geladen voor het vereiste blog</string>
	<string name="sending_content">Uploaden %s inhoud</string>
	<string name="mnu_comment_liked">Liked</string>
	<string name="uploading_total">Uploaden %1$d van %2$d</string>
	<string name="media_empty_list_custom_date">Geen media in dit tijdsinterval</string>
	<string name="posting_post">Publiceren "%s"</string>
	<string name="pages_empty_list">Nog geen pagina\'s. Waarom maak je er niet een?</string>
	<string name="posts_empty_list">Nog geen berichten. Waarom maak je er niet een?</string>
	<string name="reader_empty_comments">Nog geen reacties</string>
	<string name="reader_label_comment_count_multi">%,d reacties</string>
	<string name="reader_label_comments_closed">Reacties zijn gesloten</string>
	<string name="error_refresh_unauthorized_comments">Je hebt geen rechten om reacties te bekijken of te bewerken</string>
	<string name="reader_empty_followed_blogs_title">Je volgt nog geen sites</string>
	<string name="reader_menu_block_blog">Blokkeer deze blog</string>
	<string name="reader_toast_err_generic">Deze actie kan niet uitgevoerd worden</string>
	<string name="reader_toast_err_block_blog">Blokkeren van deze blog is mislukt</string>
	<string name="reader_toast_blog_blocked">Berichten van deze blog zullen niet meer getoond worden</string>
	<string name="contact_us">Contact</string>
	<string name="hs__new_conversation_header">Ondersteuning chat</string>
	<string name="hs__conversation_header">Ondersteuning chat</string>
	<string name="hs__conversation_detail_error">Beschrijf het probleem dat je ziet</string>
	<string name="hs__username_blank_error">Voer een geldige naam in</string>
	<string name="hs__invalid_email_error">Voer een geldig e-mailadres in</string>
	<string name="add_location">Locatie toevoegen</string>
	<string name="current_location">Huidige Locatie</string>
	<string name="search_location">Zoeken</string>
	<string name="edit_location">Bewerken</string>
	<string name="search_current_location">Locatie bepalen</string>
	<string name="preference_send_usage_stats">Verstuur statistieken</string>
	<string name="preference_send_usage_stats_summary">Stuur automatisch gebruiksstatistieken om ons te helpen WordPress voor Android te verbeteren</string>
	<string name="update_verb">Bijwerken</string>
	<string name="schedule_verb">Inplannen</string>
	<string name="reader_title_subs">Tags &amp; Blogs</string>
	<string name="reader_page_followed_tags">Gevolgde tags</string>
	<string name="reader_hint_add_tag_or_url">Voer een tag of URL in om te volgen</string>
	<string name="reader_label_followed_blog">Blog gevolgd</string>
	<string name="reader_label_tag_preview">Posts getagd %s</string>
	<string name="reader_toast_err_get_blog_info">Kan deze blog niet tonen</string>
	<string name="reader_toast_err_already_follow_blog">Je volgt deze blog al</string>
	<string name="reader_toast_err_follow_blog">Kan deze blog niet volgen</string>
	<string name="reader_toast_err_unfollow_blog">Kan deze blog niet ontvolgen</string>
	<string name="reader_empty_recommended_blogs">Geen aanbevolen blogs</string>
	<string name="reader_title_blog_preview">Reader-blog</string>
	<string name="reader_title_tag_preview">Reader-tag</string>
	<string name="reader_page_followed_blogs">Gevolgde sites</string>
	<string name="saving">Aan het opslaan...</string>
	<string name="media_empty_list">Geen media</string>
	<string name="ptr_tip_message">Tip: schuif omlaag om te vernieuwen</string>
	<string name="help">Help</string>
	<string name="forgot_password">Wachtwoord vergeten?</string>
	<string name="forums">Forums</string>
	<string name="help_center">Helpcentrum</string>
	<string name="ssl_certificate_error">Ongeldig SSL-certificaat</string>
	<string name="ssl_certificate_ask_trust">Als je normaal gesproken zonder problemen verbinding maakt met deze site kan deze fout betekenen dat iemand zich probeert voor te doen als deze site. Ga niet verder als dat zo is. Wil je het certificaat toch vertrouwen?</string>
	<string name="could_not_remove_account">Kon site niet verwijderen</string>
	<string name="out_of_memory">Apparaatgeheugen vol</string>
	<string name="no_network_message">Er is geen netwerk beschikbaar</string>
	<string name="no_site_error">Kan niet verbinden met de WordPress-site</string>
	<string name="adding_cat_failed">Toevoegen van categorie mislukt</string>
	<string name="adding_cat_success">Categorie toegevoegd</string>
	<string name="cat_name_required">Het veld Categorienaam is verplicht</string>
	<string name="category_automatically_renamed">Categorienaam %1$s is ongeldig. De categorie is hernoemd naar %2$s.</string>
	<string name="no_account">Geen WordPress-account gevonden. Voeg een account toe en probeer het opnieuw</string>
	<string name="sdcard_message">Er moet een SD-kaart zijn gekoppeld om media te uploaden</string>
	<string name="stats_empty_comments">Er zijn nog geen reacties</string>
	<string name="error_load_comment">Kan de reactie niet laden</string>
	<string name="error_downloading_image">Fout bij downloaden van afbeelding</string>
	<string name="passcode_wrong_passcode">Verkeerde PIN</string>
	<string name="invalid_email_message">Je e-mailadres is niet geldig</string>
	<string name="invalid_password_message">Wachtwoord moet minstens 4 tekens bevatten</string>
	<string name="invalid_username_too_short">Gebruikersnaam moet langer dan 4 tekens zijn</string>
	<string name="invalid_username_too_long">Gebruikersnaam moet korter dan 61 tekens zijn</string>
	<string name="username_only_lowercase_letters_and_numbers">Gebruikersnaam kan alleen kleine letters (a-z) en cijfers bevatten</string>
	<string name="username_required">Voer een gebruikersnaam in</string>
	<string name="username_not_allowed">Gebruikersnaam niet toegestaan</string>
	<string name="theme_fetch_failed">Fout bij het ophalen van thema\'s</string>
	<string name="theme_set_failed">Fout bij het instellen van het thema</string>
	<string name="theme_auth_error_message">Controleer of je rechten hebt om thema\'s in te stellen</string>
	<string name="comments_empty_list">Geen reacties</string>
	<string name="mnu_comment_unspam">Geen spam</string>
	<string name="gallery_error">Media-item kan niet worden opgehaald</string>
	<string name="blog_not_found">Er heeft zich een fout voorgedaan tijdens het openen van dit blog</string>
	<string name="wait_until_upload_completes">Wacht tot de upload is voltooid</string>
	<string name="stats_bar_graph_empty">Geen statistieken beschikbaar</string>
	<string name="reply_failed">Reactie mislukt</string>
	<string name="notifications_empty_list">Geen notificaties</string>
	<string name="error_delete_post">Er heeft zich een fout voorgedaan bij het verwijderen van %s</string>
	<string name="error_refresh_posts">Berichten kunnen momenteel niet worden ververst</string>
	<string name="error_refresh_pages">Pagina\'s kunnen momenteel niet worden ververst</string>
	<string name="error_refresh_notifications">Notificaties kunnen momenteel niet worden ververst</string>
	<string name="error_refresh_comments">Reacties kunnen momenteel niet worden ververst</string>
	<string name="error_refresh_stats">Statistieken kunnen momenteel niet worden ververst</string>
	<string name="error_generic">Er heeft zich een fout voorgedaan</string>
	<string name="error_moderate_comment">Er heeft zich een fout voorgedaan tijdens het modereren</string>
	<string name="error_edit_comment">Er heeft zich een fout voorgedaan tijdens het bewerken van de reactie</string>
	<string name="blog_name_cant_be_used">Dit site-adres kan niet worden gebruikt</string>
	<string name="blog_name_only_lowercase_letters_and_numbers">Het site-adres kan alleen uit kleine letters (a-z) en cijfers bestaan</string>
	<string name="blog_name_exists">Die site bestaat al</string>
	<string name="blog_name_reserved">Die site is gereserveerd</string>
	<string name="username_must_be_at_least_four_characters">Gebruikersnaam moet tenminste 4 tekens lang zijn</string>
	<string name="username_contains_invalid_characters">Gebruikersnaam kan niet het teken \'_\' bevatten</string>
	<string name="error_upload">Er heeft zich een fout voorgedaan bij het uploaden van %s</string>
	<string name="username_must_include_letters">Gebruikersnaam moet ten minste 1 letter (a-z) bevatten</string>
	<string name="email_invalid">Voer een geldig e-mailadres in</string>
	<string name="email_not_allowed">Dat e-mailadres is niet toegestaan</string>
	<string name="username_exists">Die gebruikersnaam bestaat al</string>
	<string name="email_exists">Dat e-mailadres is al in gebruik</string>
	<string name="username_reserved_but_may_be_available">Die gebruikersnaam is momenteel gereserveerd, maar is over een paar dagen misschien wel beschikbaar.</string>
	<string name="blog_name_required">Voer een site-adres in</string>
	<string name="blog_name_not_allowed">Dat site-adres is niet toegestaan</string>
	<string name="blog_name_must_be_at_least_four_characters">Site-adres moet minimaal 4 tekens lang zijn</string>
	<string name="blog_name_must_be_less_than_sixty_four_characters">Het site-adres moet korter zijn dan 64 tekens</string>
	<string name="blog_name_contains_invalid_characters">Site-adres kan niet het teken \'_\' bevatten</string>
	<string name="blog_name_reserved_but_may_be_available">Die site is momenteel gereserveerd, maar is mogelijk binnen een paar dagen beschikbaar</string>
	<string name="username_or_password_incorrect">De gebruikersnaam of het wachtwoord is niet correct</string>
	<string name="nux_cannot_log_in">We kunnen je niet aanmelden</string>
	<string name="invalid_url_message">Controleer of de ingevoerde URL geldig is</string>
	<string name="blog_removed_successfully">Site is verwijderd</string>
	<string name="remove_account">Site verwijderen</string>
	<string name="xmlrpc_error">Verbinding mislukt. Voer het volledig pad in naar xmlrpc.php op je site en probeer het opnieuw.</string>
	<string name="select_categories">Categorieën selecteren</string>
	<string name="account_details">Accountgegevens</string>
	<string name="edit_post">Bericht bewerken</string>
	<string name="add_comment">Reactie toevoegen</string>
	<string name="connection_error">Verbindingsfout</string>
	<string name="cancel_edit">Bewerken annuleren</string>
	<string name="scaled_image_error">Voer een geldige waarde in voor geschaalde breedte</string>
	<string name="post_not_found">Er heeft zich een fout voorgedaan bij het laden van het bericht. Ververs je berichten en probeer het opnieuw.</string>
	<string name="learn_more">Meer informatie</string>
	<string name="media_gallery_settings_title">Galerij-instellingen</string>
	<string name="media_gallery_image_order">Afbeeldingsvolgorde</string>
	<string name="media_gallery_num_columns">Aantal kolommen</string>
	<string name="media_gallery_type_thumbnail_grid">Miniatuurraster</string>
	<string name="media_gallery_edit">Galerij bewerken</string>
	<string name="media_error_no_permission">Je hebt geen rechten om de mediabibliotheek te bekijken</string>
	<string name="cannot_delete_multi_media_items">Sommige media kan niet worden verwijderd. Probeer het later opnieuw.</string>
	<string name="themes_live_preview">Live voorbeeld</string>
	<string name="theme_current_theme">Huidig thema</string>
	<string name="theme_premium_theme">Premium thema</string>
	<string name="link_enter_url_text">Linktekst (optioneel)</string>
	<string name="create_a_link">Een link maken</string>
	<string name="page_settings">Pagina-instellingen</string>
	<string name="local_draft">Lokaal concept</string>
	<string name="upload_failed">Uploaden mislukt</string>
	<string name="horizontal_alignment">Horizontale uitlijning</string>
	<string name="file_not_found">Kan het mediabestand voor upload niet vinden. Is het verplaatst of verwijderd?</string>
	<string name="post_settings">Berichtinstellingen</string>
	<string name="delete_post">Bericht verwijderen</string>
	<string name="delete_page">Pagina verwijderen</string>
	<string name="comment_status_approved">Goedgekeurd</string>
	<string name="comment_status_unapproved">In afwachting</string>
	<string name="comment_status_spam">Spam</string>
	<string name="comment_status_trash">Weggegooid</string>
	<string name="edit_comment">Reactie bewerken</string>
	<string name="mnu_comment_approve">Goedkeuren</string>
	<string name="mnu_comment_unapprove">Afkeuren</string>
	<string name="mnu_comment_spam">Spam</string>
	<string name="mnu_comment_trash">Prullenbak</string>
	<string name="dlg_approving_comments">Aan het goedkeuren</string>
	<string name="dlg_unapproving_comments">Aan het afkeuren</string>
	<string name="dlg_spamming_comments">Aan het markeren als spam</string>
	<string name="dlg_trashing_comments">Aan het verplaatsen naar de prullenbak</string>
	<string name="dlg_confirm_trash_comments">Verplaatsen naar de prullenbak?</string>
	<string name="trash_yes">Verwijderen</string>
	<string name="trash_no">Niet verwijderen</string>
	<string name="trash">Prullenbak</string>
	<string name="author_name">Naam auteur</string>
	<string name="author_email">E-mail auteur</string>
	<string name="author_url">URL auteur</string>
	<string name="hint_comment_content">Reactie</string>
	<string name="saving_changes">Wijzigingen aan het opslaan</string>
	<string name="sure_to_cancel_edit_comment">Bewerken van deze reactie annuleren?</string>
	<string name="content_required">Reactie is vereist</string>
	<string name="toast_comment_unedited">Reactie is niet gewijzigd</string>
	<string name="delete_draft">Concept verwijderen</string>
	<string name="preview_page">Voorbeeld van pagina bekijken</string>
	<string name="preview_post">Voorbeeld van bericht bekijken</string>
	<string name="comment_added">Reactie toegevoegd</string>
	<string name="post_not_published">Berichtstatus is niet gepubliceerd</string>
	<string name="page_not_published">Paginastatus is niet gepubliceerd</string>
	<string name="view_in_browser">Weergeven in browser</string>
	<string name="add_new_category">Nieuwe categorie toevoegen</string>
	<string name="category_name">Naam categorie</string>
	<string name="category_slug">Tijdelijke aanduiding categorie (optioneel)</string>
	<string name="category_desc">Beschrijving categorie (optioneel)</string>
	<string name="category_parent">Bovenliggende categorie (optioneel)</string>
	<string name="share_action_post">Nieuw bericht</string>
	<string name="share_action_media">Mediabibliotheek</string>
	<string name="file_error_create">Kan geen tijdelijk bestand maken voor het uploaden van media. Controleer of er genoeg vrije ruimte is op je apparaat.</string>
	<string name="location_not_found">Onbekende locatie</string>
	<string name="open_source_licenses">Open-sourcelicenties</string>
	<string name="pending_review">In afwachting van controle</string>
	<string name="http_credentials">HTTP-verificatiegegevens (optioneel)</string>
	<string name="http_authorization_required">Autorisatie vereist</string>
	<string name="post_format">Berichtindeling</string>
	<string name="new_post">Nieuw bericht</string>
	<string name="new_media">Nieuwe media</string>
	<string name="view_site">Site weergeven</string>
	<string name="privacy_policy">Privacybeleid</string>
	<string name="local_changes">Lokale wijzigingen</string>
	<string name="image_settings">Afbeeldingsinstellingen</string>
	<string name="add_account_blog_url">Blogadres</string>
	<string name="wordpress_blog">WordPress-blog</string>
	<string name="error_blog_hidden">Dit blog is verborgen en kan niet worden geladen. Schakel het blog in instellingen in en probeer het opnieuw.</string>
	<string name="fatal_db_error">Er heeft zich een fout voorgedaan bij het aanmaken van de database van de app. Probeer de app opnieuw te installeren.</string>
	<string name="jetpack_message_not_admin">De Jetpack-plugin is vereist voor statistieken. Neem contact op met de sitebeheerder.</string>
	<string name="reader_title_applog">Applicatielogboek</string>
	<string name="reader_share_link">Link delen</string>
	<string name="reader_toast_err_add_tag">Deze tag kan niet worden toegevoegd</string>
	<string name="reader_toast_err_remove_tag">Deze tag kan niet worden verwijderd</string>
	<string name="required_field">Vereist veld</string>
	<string name="email_hint">E-mailadres</string>
	<string name="site_address">Je zelf-gehoste adres (URL)</string>
	<string name="email_cant_be_used_to_signup">Je kunt dat e-mailadres niet gebruiken om je aan te melden, omdat ze een aantal van onze e-mailberichten blokkeren. Probeer een andere e-mailaanbieder.</string>
	<string name="email_reserved">Dat e-mailadres is al in gebruik. Zoek in je inbox naar een activeringsmail. Als je niet activeert, kun je het over een paar dagen opnieuw proberen.</string>
	<string name="blog_name_must_include_letters">Site-adres moet ten minste 1 letter (a-z) bevatten</string>
	<string name="blog_name_invalid">Ongeldig site-adres</string>
	<string name="blog_title_invalid">Ongeldige sitetitel</string>
	<string name="notifications_empty_all">Nog geen meldingen.</string>
	<string name="invalid_site_url_message">Controleer of de ingevoerde site-URL geldig is</string>
	<string name="share_url_page">Deel pagina</string>
	<string name="share_url_post">Deel bericht</string>
	<string name="deleting_page">Verwijderen van pagina</string>
	<string name="deleting_post">Verwijderen van bericht</string>
	<string name="share_link">Deel link</string>
	<string name="creating_your_account">Je account aanmaken</string>
	<string name="creating_your_site">Je site aanmaken</string>
	<string name="reader_empty_posts_in_tag_updating">Berichten ophalen...</string>
	<string name="error_refresh_media">Er is iets verkeerd gegaan met het vernieuwen van de mediabibliotheek. Probeer het later nog eens.</string>
	<string name="reader_likes_you_and_multi">Jij en %,d anderen vinden dit leuk</string>
	<string name="reader_likes_multi">%,d mensen vinden dit leuk</string>
	<string name="reader_toast_err_get_comment">Deze reactie kon niet opgehaald worden</string>
	<string name="reader_label_reply">Beantwoord</string>
	<string name="video">Video</string>
	<string name="download">Downloaden van media</string>
	<string name="comment_spammed">Reactie als spam gemarkeerd</string>
	<string name="cant_share_no_visible_blog">Je kan niet delen naar WordPress zonder een zichtbare blog</string>
	<string name="pick_photo">Selecteer foto</string>
	<string name="account_two_step_auth_enabled">Voor deze account is authenticatie in twee stappen actief. Bekijk je beveiligingsinstellingen op WordPress.com en genereer een applicatie-specifiek wachtwoord.</string>
	<string name="pick_video">Selecteer video</string>
	<string name="reader_toast_err_get_post">Niet in staat om dit bericht op te halen</string>
	<string name="validating_user_data">Gebruikersgegevens valideren</string>
	<string name="validating_site_data">Sitegegevens valideren</string>
	<string name="select_time">Selecteer tijd</string>
	<string name="reader_likes_you_and_one">Jij en één andere vinden dit leuk</string>
	<string name="select_date">Selecteer datum</string>
	<string name="reader_empty_followed_blogs_description">Geen zorgen, tap het tag icoon om te beginnen.</string>
	<string name="nux_oops_not_selfhosted_blog">Log in op WordPress.com</string>
	<string name="password_invalid">Je hebt een veiliger wachtwoord nodig. Let erop dat je 7 of meer karakters gebruikt, gebruik hoofd- en kleine letters, nummers of speciale karakters.</string>
	<string name="nux_tap_continue">Ga door</string>
	<string name="nux_welcome_create_account">Maak account aan</string>
	<string name="nux_add_selfhosted_blog">Voeg zelf gehoste site toe</string>
	<string name="signing_in">Inloggen…</string>
	<string name="select_from_media_library">Selecteer uit de mediabibliotheek</string>
	<string name="media_add_popup_title">Toevoegen aan mediabibliotheek</string>
	<string name="reader_untitled_post">(geen titel)</string>
	<string name="reader_btn_share">Delen</string>
	<string name="reader_btn_follow">Volg</string>
	<string name="reader_label_added_tag">%s toegevoegd</string>
	<string name="reader_label_removed_tag">%s verwijderd</string>
	<string name="reader_toast_err_url_intent">Onmogelijk %s te openen</string>
	<string name="create_account_wpcom">Maak een account op Wordpress.com aan</string>
	<string name="connecting_wpcom">Verbinden met Wordpress.com</string>
	<string name="reader_toast_err_share_intent">Onmogelijk te delen</string>
	<string name="reader_toast_err_view_image">Onmogelijk afbeelding te bekijken</string>
	<string name="reader_empty_followed_tags">Je volgt geen enkele tags</string>
	<string name="jetpack_message">De Jetpack plugin is nodig voor statistieken. Wil je Jetpack installeren?</string>
	<string name="empty_list_default">Deze lijst is leeg</string>
	<string name="media_add_new_media_gallery">Een nieuwe galerij aanmaken</string>
	<string name="jetpack_not_found">Jetpack plugin niet gevonden</string>
	<string name="reader_share_subject">gedeeld van %s</string>
	<string name="reader_likes_one">1 persoon vindt dit leuk</string>
	<string name="reader_likes_only_you">Je vindt dit leuk</string>
	<string name="reader_toast_err_comment_failed">Je reactie kon niet gepost worden</string>
	<string name="reader_toast_err_tag_exists">Je volgt deze tag al</string>
	<string name="reader_toast_err_tag_invalid">Dat is geen geldige tag</string>
	<string name="nux_tutorial_get_started_title">Begin!</string>
	<string name="username_invalid">Ongeldige gebruikersnaam</string>
	<string name="reader_btn_unfollow">Volgend</string>
	<string name="limit_reached">Limiet bereikt. Je kan het na 1 minuut nogmaals proberen. Als je het eerder probeert dan zul je langer moeten wachten totdat de ban wordt opgeheven. Neem contact op met de helpdesk wanneer je denk dat dit niet klopt.</string>
	<string name="reader_hint_comment_on_comment">Beantwoord reactie...</string>
	<string name="button_next">Volgende</string>
	<string name="images">Afbeeldingen</string>
	<string name="media_add_popup_capture_photo">Maak een nieuwe foto</string>
	<string name="media_add_popup_capture_video">Maak een nieuwe video</string>
	<string name="all">Alle</string>
	<string name="unattached">Niet gekoppeld</string>
	<string name="custom_date">Aan te passen datum</string>
	<string name="media_gallery_type_slideshow">Diavoorstelling</string>
	<string name="media_edit_title_text">Titel</string>
	<string name="media_edit_caption_text">Onderschrift</string>
	<string name="theme_activating_button">Activeren</string>
	<string name="theme_set_success">Thema succesvol ingesteld!</string>
	<string name="theme_auth_error_title">Kon geen thema\'s ophalen</string>
	<string name="post_excerpt">Samenvatting</string>
	<string name="share_action_title">Voeg toe aan ...</string>
	<string name="themes">Thema\'s</string>
	<string name="media_gallery_image_order_random">Willekeurig</string>
	<string name="media_gallery_image_order_reverse">Omgekeerd</string>
	<string name="media_gallery_type">Type</string>
	<string name="media_gallery_type_squares">Vierkanten</string>
	<string name="media_gallery_type_circles">Circels</string>
	<string name="themes_details_label">Details</string>
	<string name="themes_features_label">Functies</string>
	<string name="theme_activate_button">Activeren</string>
	<string name="share_action">Deel</string>
	<string name="stats">Statistieken</string>
	<string name="stats_view_visitors_and_views">Bezoekers en views</string>
	<string name="stats_view_clicks">Kliks</string>
	<string name="stats_view_tags_and_categories">Tags en categorieën </string>
	<string name="stats_entry_country">Land</string>
	<string name="stats_entry_posts_and_pages">Titel</string>
	<string name="stats_entry_tags_and_categories">Onderwerp</string>
	<string name="stats_entry_authors">Auteur</string>
	<string name="stats_entry_referrers">Referrer</string>
	<string name="stats_totals_views">Views</string>
	<string name="stats_totals_clicks">Kliks</string>
	<string name="stats_totals_plays">Afgespeeld</string>
	<string name="passcode_preference_title">PIN slot</string>
	<string name="passcode_turn_off">Zet PIN slot uit</string>
	<string name="passcode_manage">Beheer PIN slot</string>
	<string name="passcode_enter_passcode">Voer je PIN in</string>
	<string name="passcode_enter_old_passcode">Voer je oude PIN in</string>
	<string name="passcode_re_enter_passcode">Voer je PIN opnieuw in</string>
	<string name="passcode_change_passcode">Verander PIN</string>
	<string name="passcode_set">PIN ingesteld</string>
	<string name="media_edit_description_text">Beschrijving</string>
	<string name="media_edit_title_hint">Voer hier een titel in</string>
	<string name="media_edit_caption_hint">Voer hier een onderschrift in</string>
	<string name="media_edit_description_hint">Voer hier een beschrijving in</string>
	<string name="media_edit_success">Bijgewerkt</string>
	<string name="media_edit_failure">Bijwerken mislukt</string>
	<string name="stats_timeframe_days">Dagen</string>
	<string name="stats_timeframe_weeks">Weken</string>
	<string name="stats_timeframe_months">Maanden</string>
	<string name="stats_timeframe_yesterday">Gisteren</string>
	<string name="stats_view_referrers">Top auteurs</string>
	<string name="stats_timeframe_today">Vandaag</string>
	<string name="media_gallery_type_tiled">Tegels</string>
	<string name="passcode_turn_on">Zet PIN slot aan</string>
	<string name="discard">Verwijder</string>
	<string name="upload">Upload</string>
	<string name="sign_in">Inloggen</string>
	<string name="notifications">Notificaties</string>
	<string name="note_reply_successful">Reactie gepubliceerd</string>
	<string name="new_notifications">%d nieuwe notificaties</string>
	<string name="more_notifications">en %d extra.</string>
	<string name="follows">Volgt</string>
	<string name="loading">Laden...</string>
	<string name="httpuser">HTTP gebruikersnaam</string>
	<string name="httppassword">HTTP wachtwoord</string>
	<string name="error_media_upload">Er is een fout opgetreden tijdens het uploaden van media</string>
	<string name="publish_date">Publiceer</string>
	<string name="content_description_add_media">Media toevoegen</string>
	<string name="post_content">Inhoud (Druk om tekst en media toe te voegen)</string>
	<string name="incorrect_credentials">Incorrecte gebruikersnaam en wachtwoord.</string>
	<string name="password">Wachtwoord</string>
	<string name="username">Gebruikersnaam</string>
	<string name="reader">Reader</string>
	<string name="featured">Gebruiken als uitgelichte afbeelding</string>
	<string name="featured_in_post">Plaats afbeelding in bericht</string>
	<string name="no_network_title">Geen netwerk beschikbaar</string>
	<string name="post">Bericht</string>
	<string name="pages">Pagina\'s</string>
	<string name="caption">Onderschrift (optioneel)</string>
	<string name="width">Breedte</string>
	<string name="posts">Berichten</string>
	<string name="anonymous">Anoniem</string>
	<string name="page">Pagina</string>
	<string name="blogusername">blogusername</string>
	<string name="ok">Ok</string>
	<string name="upload_scaled_image">Upload en link naar afbeelding</string>
	<string name="scaled_image">Breedte geschaalde afbeelding</string>
	<string name="scheduled">Gepland</string>
	<string name="link_enter_url">URL</string>
	<string name="uploading">Uploaden …</string>
	<string name="version">Versie</string>
	<string name="tos">Eindgebruikersovereenkomst</string>
	<string name="app_title">WordPress voor Android</string>
	<string name="max_thumbnail_px_width">Standaardbreedte van afbeelding</string>
	<string name="image_alignment">Uitlijning </string>
	<string name="refresh">Vernieuw</string>
	<string name="untitled">Zonder titel</string>
	<string name="edit">Bewerk</string>
	<string name="post_id">Bericht</string>
	<string name="page_id">Pagina</string>
	<string name="post_password">Wachtwoord (optioneel) </string>
	<string name="immediately">Direct</string>
	<string name="quickpress_add_alert_title">Geef een snelkoppelingsnaam</string>
	<string name="today">Vandaag</string>
	<string name="settings">Instellingen</string>
	<string name="share_url">Deel URL</string>
	<string name="quickpress_window_title">Selecteer een blog voor de QuickPress snelkoppeling</string>
	<string name="quickpress_add_error">Snelkoppelingsnaam kan niet leeg zijn.</string>
	<string name="publish_post">Publiceer</string>
	<string name="post_private">Privé</string>
	<string name="draft">Concept</string>
	<string name="upload_full_size_image">Upload en link naar de volledige afbeelding</string>
	<string name="title">Titel</string>
	<string name="tags_separate_with_commas">Tags (gescheiden door komma\'s)</string>
	<string name="categories">Categorieën </string>
	<string name="dlg_deleting_comments">Reacties verwijderen</string>
	<string name="notification_vibrate">Vibreren </string>
	<string name="notification_blink">Flikker het notificatie licht</string>
	<string name="notification_sound">Meldingsgeluid</string>
	<string name="status">Status</string>
	<string name="location">Locatie</string>
	<string name="sdcard_title">SD kaart is vereist </string>
	<string name="select_video">Selecteer een video van je galerij </string>
	<string name="media">Media</string>
	<string name="delete">Verwijderen</string>
	<string name="none">Geen</string>
	<string name="blogs">Blogs</string>
	<string name="select_photo">Selecteer een foto van je galerij.</string>
	<string name="no">Nee</string>
	<string name="yes">Ja</string>
	<string name="reply">Beantwoord</string>
	<string name="on">aan</string>
	<string name="add">Voeg toe</string>
	<string name="error">Fout</string>
	<string name="cancel">Annuleer </string>
	<string name="save">Bewaar</string>
	<string name="category_refresh_error">Categorie vernieuwen fout</string>
	<string name="preview">Voorbeeld</string>
	<string name="notification_settings">Meldingsinstellingen</string>
</resources>
