<?xml version="1.0" encoding="utf-8"?>
<resources>
	<string name="role_admin">Administratör</string>
	<string name="role_editor">Redaktör</string>
	<string name="role_author">Författare</string>
	<string name="role_contributor">Medarbetare</string>
	<string name="role_follower">Prenumerant</string>
	<string name="role_viewer">Läsare</string>
	<string name="error_post_my_profile_no_connection">Ingen nätverksanslutning, kunde inte spara din profil</string>
	<string name="alignment_none">Ingen</string>
	<string name="alignment_left">Vänster</string>
	<string name="alignment_right">Höger</string>
	<string name="site_settings_list_editor_action_mode_title">Vald %1$d</string>
	<string name="error_fetch_users_list">Kunde inte hämta webbplatsens användare</string>
	<string name="plans_manage">Uppgradera ditt paket på\nWordPress.com/plans</string>
	<string name="people_empty_list_filtered_viewers">Du har inga läsare än.</string>
	<string name="people_fetching">Hämtar användare...</string>
	<string name="title_follower">Följare</string>
	<string name="title_email_follower">Följare via e-post</string>
	<string name="people_empty_list_filtered_email_followers">Du har inga följare via e-post än.</string>
	<string name="people_empty_list_filtered_followers">Du har inga följare än.</string>
	<string name="people_empty_list_filtered_users">Du har inga användare än.</string>
	<string name="people_dropdown_item_email_followers">Följare via e-post</string>
	<string name="people_dropdown_item_viewers">Läsare</string>
	<string name="people_dropdown_item_followers">Följare</string>
	<string name="people_dropdown_item_team">Team</string>
	<string name="invite_message_usernames_limit">Bjud in upp till 10 e-postadresser eller användare på WordPress.com. De som behöver ett användarnamn får instruktioner skickade till dem.</string>
	<string name="viewer_remove_confirmation_message">Om du tar bort denna läsare kommer hen inte kunna besöka denna webbplats.\n\nÄr du säker på att du vill ta bort denna läsare?</string>
	<string name="follower_remove_confirmation_message">Om följaren tas bort kommer hen inte längre få notiser från denna webbplats såvida de inte följer webbplatsen på nytt.\n\nVill du fortfarande ta bort denna följare?</string>
	<string name="follower_subscribed_since">Sedan %1$s</string>
	<string name="reader_label_view_gallery">Visa galleri</string>
	<string name="error_remove_follower">Kunde inte ta bort följare</string>
	<string name="error_remove_viewer">Kunde inte ta bort läsare</string>
	<string name="error_fetch_email_followers_list">Kunde inte hämta följare via e-post</string>
	<string name="error_fetch_followers_list">Kunde inte hämta följare</string>
	<string name="editor_failed_uploads_switch_html">Vissa mediauppladdningar har misslyckats. Du kan inte skifta till HTML-läget\n        i detta tillstånd. Vill du ta bort alla misslyckade uppladdningar och fortsätta?</string>
	<string name="format_bar_description_html">HTML-läge</string>
	<string name="visual_editor">Visuell redigerare</string>
	<string name="image_thumbnail">Miniatyrbild</string>
	<string name="format_bar_description_ul">Oordnad lista</string>
	<string name="format_bar_description_ol">Ordnad lista</string>
	<string name="format_bar_description_more">Infoga mer</string>
	<string name="format_bar_description_media">Infoga media</string>
	<string name="format_bar_description_strike">Genomstrykning</string>
	<string name="format_bar_description_quote">Citatblock</string>
	<string name="format_bar_description_link">Infoga länk</string>
	<string name="format_bar_description_italic">Kursiv</string>
	<string name="format_bar_description_underline">Understreck</string>
	<string name="image_settings_save_toast">Ändringar sparade</string>
	<string name="image_caption">Bildtext</string>
	<string name="image_alt_text">Alt-text</string>
	<string name="image_link_to">Länka till</string>
	<string name="image_width">Bredd</string>
	<string name="format_bar_description_bold">Fetstil</string>
	<string name="image_settings_dismiss_dialog_title">Förkasta ändringar som inte sparats?</string>
	<string name="stop_upload_dialog_title">Stoppa uppladdning?</string>
	<string name="stop_upload_button">Stoppa uppladdning</string>
	<string name="alert_error_adding_media">Ett fel uppstod när media skulle infogas</string>
	<string name="alert_action_while_uploading">Du laddar för närvarande upp media. Vänligen vänta till det är klart.</string>
	<string name="alert_insert_image_html_mode">Media kan inte infogas direkt i HTML-läget. Vänligen växla tillbaka till det visuella läget.</string>
	<string name="uploading_gallery_placeholder">Laddar upp galleri...</string>
	<string name="invite_error_some_failed">Inbjudan skickades men fel uppstod!</string>
	<string name="invite_error_for_username">%1$s: %2$s</string>
	<string name="invite_sent">Inbjudan skickad</string>
	<string name="tap_to_try_again">Tryck för att försöka igen!</string>
	<string name="invite_error_sending">Ett fel uppstod när inbjudan skulle skickas!</string>
	<string name="invite_error_invalid_usernames_multiple">Kan inte skicka: Det finns ogiltiga användarnamn eller e-postadresser</string>
	<string name="invite_error_invalid_usernames_one">Kan inte skicka: Ett användarnamn eller en e-postadress är ogiltig</string>
	<string name="invite_error_no_usernames">Ange minst ett användarnamn</string>
	<string name="invite_message_info">(Valfritt) Du kan lägga till ett anpassat meddelande med upp till 500 tecken som kommer att ingå i inbjudan till användare.</string>
	<string name="invite_message_remaining_other">%d tecken återstår</string>
	<string name="invite_message_remaining_one">1 tecken återstår</string>
	<string name="invite_message_remaining_zero">0 tecken återstår</string>
	<string name="invite_invalid_email">E-postadressen "%s" är ogiltig</string>
	<string name="invite_message_title">Anpassat meddelande</string>
	<string name="invite_already_a_member">Det finns redan en medlem med användarnamnet "%s"</string>
	<string name="invite_username_not_found">Det gick inte att hitta en användare med användarnamnet "%s"</string>
	<string name="invite">Bjud in</string>
	<string name="invite_names_title">Användarnamn eller e‑postmeddelanden</string>
	<string name="signup_succeed_signin_failed">Ditt konto har skapats men ett fel uppstod medan du loggades\n in. Försök att logga in med ditt nya användarnamn och lösenord.</string>
	<string name="send_link">Skicka länk</string>
	<string name="my_site_header_external">Externt</string>
	<string name="invite_people">Bjud in personer</string>
	<string name="label_clear_search_history">Rensa sökhistoriken</string>
	<string name="dlg_confirm_clear_search_history">Rensa sökhistoriken?</string>
	<string name="reader_empty_posts_in_search_description">Inga inlägg hittade för %s på ditt språk</string>
	<string name="reader_label_post_search_running">Söker...</string>
	<string name="reader_label_related_posts">Relaterad läsning</string>
	<string name="reader_empty_posts_in_search_title">Hittade inga inlägg</string>
	<string name="reader_label_post_search_explainer">Sök alla offentliga WordPress.com-bloggar</string>
	<string name="reader_hint_post_search">Sök på WordPress.com</string>
	<string name="reader_title_related_post_detail">Relaterade inlägg</string>
	<string name="reader_title_search_results">Sök efter%s</string>
	<string name="preview_screen_links_disabled">Länkar har avaktiverats på förhandsvisningsskärmen</string>
	<string name="draft_explainer">Det här inlägget är ett utkast som inte har publicerats</string>
	<string name="send">Skicka</string>
	<string name="user_remove_confirmation_message">Om du tar bort %1$s kommer användaren inte längre kunna besöka webbplatsen, men eventuellt innehåll som skapats av %1$s kommer att finnas kvar.\n\nVill du fortfarande ta bort denna användare?</string>
	<string name="person_removed">%1$s borttagen</string>
	<string name="person_remove_confirmation_title">Ta bort %1$s</string>
	<string name="reader_empty_posts_in_custom_list">Webbplatserna i denna lista har inte publicerat några inlägg på senare tid</string>
	<string name="people">Människor</string>
	<string name="edit_user">Redigera användare</string>
	<string name="role">Roll</string>
	<string name="error_remove_user">Kunde inte ta bort användare</string>
	<string name="error_fetch_viewers_list">Kunde inte hämta webbplatsens läsare</string>
	<string name="error_update_role">Kunde inte uppdatera användarroll</string>
	<string name="gravatar_camera_and_media_permission_required">Behörigheter krävs för att välja eller ta ett foto</string>
	<string name="error_updating_gravatar">Det gick inte att uppdatera din Gravatar</string>
	<string name="error_locating_image">Det gick inte att hitta den beskurna bilden</string>
	<string name="error_refreshing_gravatar">Det gick inte att ladda om din Gravatar</string>
	<string name="gravatar_tip">Nyhet! Tryck på din Gravatar för att ändra den!</string>
	<string name="error_cropping_image">Det gick inte att beskära bilden</string>
	<string name="launch_your_email_app">Starta din e‑postapp</string>
	<string name="checking_email">Kontrollerar e-post</string>
	<string name="not_on_wordpress_com">Inte på WordPress.com?</string>
	<string name="magic_link_unavailable_error_message">Inte tillgänglig för närvarande. Ange ditt lösenord</string>
	<string name="check_your_email">Kolla din e-post</string>
	<string name="get_a_link_sent_to_your_email_to_sign_in_instantly">Få en länk skickad till din e-post för att omedelbart logga in</string>
	<string name="logging_in">Loggar in</string>
	<string name="enter_your_password_instead">Ange ditt lösenord istället</string>
	<string name="web_address_dialog_hint">Visas offentligt när du kommenterar.</string>
	<string name="jetpack_not_connected_message">Jetpack-tillägget är installerat men inte anslutet till WordPress.com. Vill du ansluta Jetpack?</string>
	<string name="username_email">E-post eller användarnamn</string>
	<string name="jetpack_not_connected">Jetpack-tillägget är inte anslutet</string>
	<string name="new_editor_reflection_error">Den visuella redigeraren är inte kompatibel med din enhet. Den\n inaktiverades automatiskt.</string>
	<string name="stats_insights_latest_post_no_title">(ingen rubrik)</string>
	<string name="capture_or_pick_photo">Ta eller välj ett foto</string>
	<string name="plans_post_purchase_text_themes">Du har nu obegränsad tillgång till Premium-teman. Förhandsgranska valfritt tema på din webbplats för att komma igång.</string>
	<string name="plans_post_purchase_button_themes">Visa teman</string>
	<string name="plans_post_purchase_title_themes">Hitta ett perfekt premium-tema</string>
	<string name="plans_post_purchase_button_video">Skapa nytt inlägg</string>
	<string name="plans_post_purchase_text_video">Du kan ladda upp och spara videoklipp på din webbplats med VideoPress och ditt utökade utrymme för media.</string>
	<string name="plans_post_purchase_title_video">Ge inlägg mer liv med video</string>
	<string name="plans_post_purchase_button_customize">Anpassa min webbplats</string>
	<string name="plans_post_purchase_text_customize">Du har nu tillgång till anpassade typsnitt, anpassade färger, samt möjligheten att skriva anpassad CSS.</string>
	<string name="plans_post_purchase_text_intro">Din webbplats tackar dig. Nu kan du utforska din webbplats nya funktioner och välja var du vill börja.</string>
	<string name="plans_post_purchase_title_customize">Anpassa typsnitt &amp; färger</string>
	<string name="plans_post_purchase_title_intro">Allt klart, snyggt jobbat!</string>
	<string name="export_your_content_message">Dina inlägg, sidor och inställningar kommer att skickas via e-post till %s.</string>
	<string name="plan">Paket</string>
	<string name="plans">Paket</string>
	<string name="plans_loading_error">Kunde inte ladda in paket</string>
	<string name="export_your_content">Exportera ditt innehåll</string>
	<string name="exporting_content_progress">Exporterar innehåll...</string>
	<string name="export_email_sent">Exporte-post skickat!</string>
	<string name="premium_upgrades_message">Du har aktiva premium-uppgraderingar på din webbplats. Vänligen avsluta dina uppgraderingar innan du tar bort din webbplats.</string>
	<string name="show_purchases">Visa köp</string>
	<string name="checking_purchases">Kollar köp</string>
	<string name="premium_upgrades_title">Premium-uppgraderingar</string>
	<string name="purchases_request_error">Något gick fel. Kunde inte hämta köp.</string>
	<string name="delete_site_progress">Raderar webbplats...</string>
	<string name="delete_site_summary">Denna handling kan inte ångras. När du raderar din webbplats raderas allt innehåll, alla författare, och alla domäner från din webbplats.</string>
	<string name="delete_site_hint">Radera webbplats</string>
	<string name="export_site_hint">Exportera din webbplats till XML-fil</string>
	<string name="are_you_sure">Är du säker?</string>
	<string name="export_site_summary">Om du är säker, vänligen se till att du tar dig tid att exportera ditt innehåll nu. Ditt innehåll kan inte återskapas i framtiden.</string>
	<string name="keep_your_content">Spara ditt innehåll</string>
	<string name="domain_removal_hint">Domänerna som inte kommer att fungera efter att du raderat din webbplats</string>
	<string name="domain_removal_summary">Var försiktig! Om du raderar din webbplats kommer du också ta bort domän/domänerna nedan.</string>
	<string name="primary_domain">Primärdomän</string>
	<string name="domain_removal">Ta bort domän</string>
	<string name="error_deleting_site_summary">Det uppstod ett fel när din webbplats skulle tas bort. Vänligen kontakta supporten för mer hjälp.</string>
	<string name="error_deleting_site">Kunde inte ta bort webbplats</string>
	<string name="confirm_delete_site_prompt">Vänligen skriv %1$s i fältet nedan för att godkänna. Din webbplats kommer sedan vara borta för alltid.</string>
	<string name="site_settings_export_content_title">Exportera innehåll</string>
	<string name="contact_support">Kontakta support</string>
	<string name="confirm_delete_site">Godkänn webbplatsborttagning</string>
	<string name="start_over_text">Om du vill ha en webbplats, men inte vill ha någon av inläggen eller sidorna du har nu, kan vårt supportteam ta bort dina inlägg, sidor, mediaobjekt och kommentarer åt dig.\n\nDetta låter dig behålla din webbplats och URL men ger dig möjligheten att börja om på nytt i ditt skapande. Kontakta oss för att ta bort allt ditt nuvarande innehåll.</string>
	<string name="site_settings_start_over_hint">Börja om med webbplatsen</string>
	<string name="let_us_help">Låt oss hjälpa</string>
	<string name="me_btn_app_settings">Appinställningar</string>
	<string name="start_over">Börja om</string>
	<string name="editor_remove_failed_uploads">Ta bort misslyckade uppladdningar</string>
	<string name="editor_toast_failed_uploads">En del mediauppladdningar har misslyckats. Du kan inte spara eller publicera\n ditt inlägg i dess nuvarande form. Vill du ta bort all media som inte gick att ladda upp?</string>
	<string name="comments_empty_list_filtered_trashed">Inga bortkastade kommentarer</string>
	<string name="site_settings_advanced_header">Avancerat</string>
	<string name="comments_empty_list_filtered_pending">Inga väntande kommentarer</string>
	<string name="comments_empty_list_filtered_approved">Inga godkända kommentarer</string>
	<string name="button_done">Klar</string>
	<string name="button_skip">Hoppa över</string>
	<string name="site_timeout_error">Kunde inte ansluta till WordPress-webbplatsen eftersom servern inte svarade.</string>
	<string name="xmlrpc_malformed_response_error">Kunde inte ansluta. WordPress-installationen svarade med ett ogiltigt XML-RPC-dokument.</string>
	<string name="xmlrpc_missing_method_error">Kunde inte ansluta. Obligatoriska XML-RPC-metoder saknas på servern.</string>
	<string name="post_format_status">Status</string>
	<string name="post_format_video">Videoklipp</string>
	<string name="alignment_center">Centrerat</string>
	<string name="theme_free">Free</string>
	<string name="theme_all">Alla</string>
	<string name="theme_premium">Premium</string>
	<string name="post_format_chat">Chatt</string>
	<string name="post_format_gallery">Galleri</string>
	<string name="post_format_image">Bild</string>
	<string name="post_format_link">Länk</string>
	<string name="post_format_quote">Citat</string>
	<string name="post_format_standard">Standard</string>
	<string name="notif_events">Information om kurser och evenemang på WordPress.com (online och fysiska möten).</string>
	<string name="post_format_aside">Notering</string>
	<string name="post_format_audio">Ljud</string>
	<string name="notif_surveys">Möjligheter att delta i WordPress.coms studier och undersökningar.</string>
	<string name="notif_tips">Tips för att få ut så mycket som möjligt av WordPress.com.</string>
	<string name="notif_community">Community</string>
	<string name="replies_to_my_comments">Svar på mina kommentarer</string>
	<string name="notif_suggestions">Förslag</string>
	<string name="notif_research">Forskning</string>
	<string name="site_achievements">Webbplats-troféer</string>
	<string name="username_mentions">Omnämnande av användarnamn</string>
	<string name="likes_on_my_posts">Gilla-markeringar för mina inlägg</string>
	<string name="site_follows">Webbplatsföljare</string>
	<string name="likes_on_my_comments">Gillar mina kommentarer</string>
	<string name="comments_on_my_site">Kommentarer på min webbplats</string>
	<string name="site_settings_list_editor_summary_other">%d poster</string>
	<string name="site_settings_list_editor_summary_one">1 post</string>
	<string name="approve_auto_if_previously_approved">Kända användares kommentarer</string>
	<string name="approve_auto">Alla användare</string>
	<string name="approve_manual">Inga kommentarer</string>
	<string name="site_settings_paging_summary_other">%d kommentarer per sida</string>
	<string name="site_settings_paging_summary_one">1 kommentar per sida</string>
	<string name="site_settings_multiple_links_summary_other">Kräv godkännande för fler än %d länkar</string>
	<string name="site_settings_multiple_links_summary_one">Kräv godkännande för fler än 1 länk</string>
	<string name="site_settings_multiple_links_summary_zero">Kräv godkännande för fler än 0 länkar</string>
	<string name="detail_approve_auto">Godkänn allas kommentarer automatiskt.</string>
	<string name="detail_approve_auto_if_previously_approved">Godkänn automatiskt om användaren har en tidigare godkänd kommentar</string>
	<string name="detail_approve_manual">Kräv manuellt godkännande för alla kommentarer.</string>
	<string name="filter_trashed_posts">Borttagen</string>
	<string name="days_quantity_one">1 dag</string>
	<string name="days_quantity_other">%d dagar</string>
	<string name="filter_published_posts">Publicerad</string>
	<string name="filter_draft_posts">Utkast</string>
	<string name="filter_scheduled_posts">Schemalagd</string>
	<string name="pending_email_change_snackbar">Klicka på verifieringslänken i e-postmeddelandet som skickades till %1$s för att bekräfta din nya adress</string>
	<string name="primary_site">Primär webbplats</string>
	<string name="web_address">Webbadress</string>
	<string name="editor_toast_uploading_please_wait">Mediefiler laddas upp för tillfället. Vänta tills de är färdiguppladdade.</string>
	<string name="error_refresh_comments_showing_older">Kommentarer kan inte uppdateras just nu – visar äldre kommentarer</string>
	<string name="editor_post_settings_set_featured_image">Ange utvald bild</string>
	<string name="editor_post_settings_featured_image">Utvald bild</string>
	<string name="new_editor_promo_desc">I WordPress-appen för Android ingår nu en ny, fantastisk, visuell\n redigerare. Prova gärna genom att skapa ett nytt inlägg.</string>
	<string name="new_editor_promo_title">Helt ny redigerare</string>
	<string name="new_editor_promo_button_label">Tack!</string>
	<string name="visual_editor_enabled">Visuell redigerare aktiverad</string>
	<string name="editor_content_placeholder">Berätta din historia här...</string>
	<string name="editor_page_title_placeholder">Sidans rubrik</string>
	<string name="editor_post_title_placeholder">Inläggets rubrik</string>
	<string name="email_address">E-postadress</string>
	<string name="preference_show_visual_editor">Visa visuell redigerare</string>
	<string name="dlg_sure_to_delete_comments">Radera dessa kommentarer premanent?</string>
	<string name="preference_editor">Redigerare</string>
	<string name="dlg_sure_to_delete_comment">Radera denna kommentar premanent?</string>
	<string name="mnu_comment_delete_permanently">Ta bort</string>
	<string name="comment_deleted_permanently">Kommentar raderad</string>
	<string name="mnu_comment_untrash">Återställ</string>
	<string name="comments_empty_list_filtered_spam">Inga skräppost-kommentarer</string>
	<string name="could_not_load_page">Kunde inte ladda sida</string>
	<string name="comment_status_all">Alla</string>
	<string name="interface_language">Gränssnittspråk</string>
	<string name="off">Av</string>
	<string name="about_the_app">Om appen</string>
	<string name="error_post_account_settings">Kunde inte spara dina kontoinställningar</string>
	<string name="error_post_my_profile">Kunde inte spara din profil</string>
	<string name="error_fetch_account_settings">Kunde inte hämta dina kontoinställningar</string>
	<string name="error_fetch_my_profile">Kunde inte hämta din profil</string>
	<string name="stats_widget_promo_ok_btn_label">Ok, klart</string>
	<string name="stats_widget_promo_desc">Lägg till denna widget på startskärmen för att med ett enda klick få tillgång till din statistik.</string>
	<string name="stats_widget_promo_title">Startskärmens statuswidget</string>
	<string name="site_settings_unknown_language_code_error">Språkkoden känns inte igen</string>
	<string name="site_settings_threading_dialog_description">Tillåt att kommentarer staplas i trådar.</string>
	<string name="site_settings_threading_dialog_header">Trådar upp till</string>
	<string name="remove">Ta bort</string>
	<string name="search">Sök</string>
	<string name="add_category">Lägg till kategori</string>
	<string name="disabled">Inaktiverad</string>
	<string name="site_settings_image_original_size">Originalstorlek</string>
	<string name="privacy_private">Din webbplats är bara synlig för dig själv och användare som du godkänner</string>
	<string name="privacy_public_not_indexed">Din webbplats är synlig för alla, men begär att sökmotorerna inte ska indexera den</string>
	<string name="privacy_public">Din webbplats är synlig för alla och kan indexeras av sökmotorer</string>
	<string name="about_me_hint">Ett par ord om dig själv…</string>
	<string name="public_display_name_hint">Om det inte anges något annat kommer visningsnamnet som standard att vara ditt användarnamn</string>
	<string name="about_me">Om mig</string>
	<string name="public_display_name">Offentligt visningsnamn</string>
	<string name="my_profile">Min profil</string>
	<string name="first_name">Förnamn</string>
	<string name="last_name">Efternamn</string>
	<string name="site_privacy_public_desc">Tillåt att sökmotorer indexerar denna webbplats</string>
	<string name="site_privacy_hidden_desc">Be att sökmotorer inte indexerar denna webbplats</string>
	<string name="site_privacy_private_desc">Jag vill att min webbplats ska vara privat och endast tillgänglig för användare som jag själv väljer</string>
	<string name="cd_related_post_preview_image">Relaterat inlägg förhandsgranskningsbild</string>
	<string name="error_post_remote_site_settings">Kunde inte spara webbplatsinfo</string>
	<string name="error_fetch_remote_site_settings">Kunde inte hämta webbplatsinfo</string>
	<string name="error_media_upload_connection">Ett anslutningsfel uppstod vid uppladdning av media</string>
	<string name="site_settings_disconnected_toast">Frånkopplad, redigering inaktiverad.</string>
	<string name="site_settings_unsupported_version_error">WordPress-versionen stöds ej</string>
	<string name="site_settings_multiple_links_dialog_description">Kräv godkännande för kommentarer som innehåller fler än detta antal länkar.</string>
	<string name="site_settings_close_after_dialog_switch_text">Stäng automatiskt</string>
	<string name="site_settings_close_after_dialog_description">Stäng kommentarer om inlägg automatiskt.</string>
	<string name="site_settings_paging_dialog_description">Dela upp kommentarstrådar i flera sidor.</string>
	<string name="site_settings_paging_dialog_header">Kommentarer per sida</string>
	<string name="site_settings_close_after_dialog_title">Stäng kommentarer</string>
	<string name="site_settings_blacklist_description">När en kommentar innehåller något av dessa ord i innehåll, namn, URL, e-postadress eller IP markeras den som skräppost. Du kan ange delar av ord, så "press" kommer att matcha "Wordpress".</string>
	<string name="site_settings_hold_for_moderation_description">När en kommentar innehåller något av dessa ord i innehåll, namn, URL, e-postadress eller IP stannar den i granskningskön Du kan ange delar av ord, så "press" kommer att matcha "Wordpress".</string>
	<string name="site_settings_list_editor_input_hint">Ange ett ord eller en fras</string>
	<string name="site_settings_list_editor_no_items_text">Inga objekt</string>
	<string name="site_settings_learn_more_caption">Du kan åsidosätta dessa inställningar för enskilda inlägg.</string>
	<string name="site_settings_rp_preview3_site">i "Uppgradera"</string>
	<string name="site_settings_rp_preview3_title">Uppgraderingsfokus: VideoPress för bröllop</string>
	<string name="site_settings_rp_preview2_site">i "Appar"</string>
	<string name="site_settings_rp_preview2_title">WordPress för Android får en ansiktslyftning</string>
	<string name="site_settings_rp_preview1_site">i "Mobilt"</string>
	<string name="site_settings_rp_preview1_title">Stor iPhone/iPad-uppdatering finns nu tillgänglig</string>
	<string name="site_settings_rp_show_images_title">Visa bilder</string>
	<string name="site_settings_rp_show_header_title">Visa sidhuvud</string>
	<string name="site_settings_rp_switch_summary">Relaterade inlägg visar relevant innehåll från din webbplats nedanför dina inlägg.</string>
	<string name="site_settings_rp_switch_title">Visa relaterade inlägg</string>
	<string name="site_settings_delete_site_hint">Tar bort dina webbplatsdata från appen</string>
	<string name="site_settings_blacklist_hint">Kommentarer som matchar ett filter markeras som skräppost</string>
	<string name="site_settings_moderation_hold_hint">Kommentarer som matchar ett filter placeras i granskningskön</string>
	<string name="site_settings_multiple_links_hint">Ignorera länkbegränsningen för kända användare</string>
	<string name="site_settings_whitelist_hint">Kommentarens författare måste ha en tidigare godkänd kommentar</string>
	<string name="site_settings_user_account_required_hint">Användare måste vara registrerade och inloggade för att kunna kommentera</string>
	<string name="site_settings_identity_required_hint">Kommentarens författare måste fylla i namn och e-postadress</string>
	<string name="site_settings_manual_approval_hint">Kommentarer måste godkännas manuellt</string>
	<string name="site_settings_paging_hint">Visa kommentarer i stycken av en viss storlek</string>
	<string name="site_settings_threading_hint">Tillåt staplade kommentarer till ett visst djup</string>
	<string name="site_settings_sort_by_hint">Avgör i vilken ordning kommentarer visas</string>
	<string name="site_settings_close_after_hint">Tillåt inte kommentarer efter den angivna tiden</string>
	<string name="site_settings_receive_pingbacks_hint">Tillåt länknotiser från andra bloggar</string>
	<string name="site_settings_send_pingbacks_hint">Försök meddela alla bloggar som länkats i inlägget</string>
	<string name="site_settings_allow_comments_hint">Tillåt att läsare publicerar kommentarer</string>
	<string name="site_settings_discussion_hint">Visa och ändra dina webbplatsers diskussionsinställningar</string>
	<string name="site_settings_more_hint">Visa alla tillgängliga diskussionsinställningar</string>
	<string name="site_settings_related_posts_hint">Visa eller dölj relaterade inlägg i läsaren</string>
	<string name="site_settings_upload_and_link_image_hint">Aktivera för att alltid ladda upp bilden i fullstorlek</string>
	<string name="site_settings_image_width_hint">Ändrar bildstorlek i inlägg till denna bredd</string>
	<string name="site_settings_format_hint">Anger nytt inläggsformat</string>
	<string name="site_settings_category_hint">Anger ny inläggskategori</string>
	<string name="site_settings_location_hint">Lägg automatiskt till platsdata i dina inlägg</string>
	<string name="site_settings_password_hint">Ändra ditt lösenord</string>
	<string name="site_settings_username_hint">Nuvarande användarkonto</string>
	<string name="site_settings_language_hint">Det språk som den här bloggen huvudsakligen är skrivet på</string>
	<string name="site_settings_privacy_hint">Kontrollerar vem som kan se din webbplats</string>
	<string name="site_settings_address_hint">Ändring av din adress stöds för närvarande inte</string>
	<string name="site_settings_tagline_hint">En kort beskrivning eller snärtig mening som beskriver din blogg</string>
	<string name="site_settings_title_hint">Beskriv med några få ord vad denna webbplats handlar om</string>
	<string name="site_settings_whitelist_known_summary">Kommentarer från kända användare</string>
	<string name="site_settings_whitelist_all_summary">Kommentarer från alla användare</string>
	<string name="site_settings_threading_summary">%d nivåer</string>
	<string name="site_settings_privacy_private_summary">Privat</string>
	<string name="site_settings_privacy_hidden_summary">Dold</string>
	<string name="site_settings_delete_site_title">Radera webbplats</string>
	<string name="site_settings_privacy_public_summary">Offentlig</string>
	<string name="site_settings_blacklist_title">Svartlista</string>
	<string name="site_settings_moderation_hold_title">Vänta på granskning</string>
	<string name="site_settings_multiple_links_title">Länkar i kommentarer</string>
	<string name="site_settings_whitelist_title">Godkänn automatiskt</string>
	<string name="site_settings_threading_title">Trådning</string>
	<string name="site_settings_paging_title">Paginering</string>
	<string name="site_settings_sort_by_title">Sortera efter</string>
	<string name="site_settings_account_required_title">Användare måste vara inloggade</string>
	<string name="site_settings_identity_required_title">Måste inkludera namn och e-postadress</string>
	<string name="site_settings_receive_pingbacks_title">Ta emot pingbacks</string>
	<string name="site_settings_send_pingbacks_title">Skicka pingbacks</string>
	<string name="site_settings_allow_comments_title">Tillåt kommentarer</string>
	<string name="site_settings_default_format_title">Standardformat</string>
	<string name="site_settings_default_category_title">Standardkategori</string>
	<string name="site_settings_location_title">Aktivera plats</string>
	<string name="site_settings_address_title">Adress</string>
	<string name="site_settings_title_title">Webbplatsens titel</string>
	<string name="site_settings_tagline_title">Slogan</string>
	<string name="site_settings_this_device_header">Denna enhet</string>
	<string name="site_settings_discussion_new_posts_header">Standard för nya inlägg</string>
	<string name="site_settings_account_header">Konto</string>
	<string name="site_settings_writing_header">Skriva</string>
	<string name="newest_first">Nyast först</string>
	<string name="site_settings_general_header">Allmänt</string>
	<string name="discussion">Diskussion</string>
	<string name="privacy">Integritet</string>
	<string name="related_posts">Relaterade inlägg</string>
	<string name="comments">Kommentarer</string>
	<string name="close_after">Stäng efter</string>
	<string name="oldest_first">Äldst först</string>
	<string name="media_error_no_permission_upload">Du har inte tillåtelse att ladda upp media till webbplatsen</string>
	<string name="never">Aldrig</string>
	<string name="unknown">Okänd</string>
	<string name="reader_err_get_post_not_found">Detta inlägg finns inte längre</string>
	<string name="reader_err_get_post_not_authorized">Du har inte behörighet att se detta inlägg</string>
	<string name="reader_err_get_post_generic">Kunde inte hämta detta inlägg</string>
	<string name="blog_name_no_spaced_allowed">En webbadress kan inte innehålla mellanslag</string>
	<string name="invalid_username_no_spaces">Ett användarnamn kan inte innehålla mellanslag</string>
	<string name="reader_empty_followed_blogs_no_recent_posts_description">De webbplatser du följer har inte publicerat något nyligen</string>
	<string name="reader_empty_followed_blogs_no_recent_posts_title">Inga nya inlägg</string>
	<string name="media_details_copy_url_toast">URL kopierad till urklipp</string>
	<string name="edit_media">Redigera media</string>
	<string name="media_details_copy_url">Kopiera URL</string>
	<string name="media_details_label_date_uploaded">Uppladdad</string>
	<string name="media_details_label_date_added">Lade till</string>
	<string name="selected_theme">Valt tema</string>
	<string name="could_not_load_theme">Kunde inte ladda tema</string>
	<string name="theme_activation_error">Något gick fel. Kunde inte aktivera tema</string>
	<string name="theme_by_author_prompt_append"> av %1$s</string>
	<string name="theme_prompt">Tack för att du väljer %1$s</string>
	<string name="theme_try_and_customize">Testa &amp; anpassa</string>
	<string name="theme_view">Visa</string>
	<string name="theme_details">Information</string>
	<string name="theme_support">Support</string>
	<string name="theme_done">KLART</string>
	<string name="theme_manage_site">HANTERA WEBBPLATS</string>
	<string name="title_activity_theme_support">Teman</string>
	<string name="theme_activate">Aktivera</string>
	<string name="date_range_start_date">Startdatum</string>
	<string name="date_range_end_date">Slutdatum</string>
	<string name="current_theme">Nuvarande tema</string>
	<string name="customize">Anpassa</string>
	<string name="details">Information</string>
	<string name="support">Support</string>
	<string name="active">Aktiv</string>
	<string name="stats_referrers_spam_generic_error">Något gick fel under processen. Skräppoststatus ändrades inte.</string>
	<string name="stats_referrers_marking_not_spam">Markerar som inte skräppost</string>
	<string name="stats_referrers_unspam">Inte skräppost</string>
	<string name="stats_referrers_marking_spam">Markerar som skräppost</string>
	<string name="theme_auth_error_authenticate">Kunde inte hämta teman: kunde inte autentisera användare</string>
	<string name="post_published">Inlägg publicerat</string>
	<string name="page_published">Sida publicerad</string>
	<string name="post_updated">Inlägg uppdaterat</string>
	<string name="page_updated">Sida uppdaterad</string>
	<string name="stats_referrers_spam">Skräppost</string>
	<string name="theme_no_search_result_found">Tyvärr hittades inga teman.</string>
	<string name="media_file_name">Filnamn: %s</string>
	<string name="media_uploaded_on">Laddades upp den: %s</string>
	<string name="media_dimensions">Storlek: %s</string>
	<string name="upload_queued">Köad</string>
	<string name="media_file_type">Filtyp: %s</string>
	<string name="reader_label_gap_marker">Ladda fler inlägg</string>
	<string name="notifications_no_search_results">Inga webbplatser matchade "%s"</string>
	<string name="search_sites">Sök webbplatser</string>
	<string name="notifications_empty_view_reader">Visa Läsare</string>
	<string name="unread">Olästa</string>
	<string name="notifications_empty_action_followers_likes">Se till att synas: kommentera inlägg som du läst.</string>
	<string name="notifications_empty_action_comments">Gå med i en diskussion: kommentera inlägg från bloggar som du följer.</string>
	<string name="notifications_empty_action_unread">Starta upp diskussionen igen: skriv ett nytt inlägg.</string>
	<string name="notifications_empty_action_all">Aktivera dig! Kommentera inlägg från bloggar som du följer.</string>
	<string name="notifications_empty_likes">Inga nya gillar att visa ... ännu.</string>
	<string name="notifications_empty_followers">Inga nya följare att visa ... ännu.</string>
	<string name="notifications_empty_comments">Inga nya kommentarer … ännu.</string>
	<string name="notifications_empty_unread">Du har läst allt!</string>
	<string name="stats_widget_error_jetpack_no_blogid">Gå till statistik i appen och försök att lägga till denna widget senare</string>
	<string name="stats_widget_error_readd_widget">Ta bort denna widget och lägg till den igen</string>
	<string name="stats_widget_error_no_visible_blog">Statistik kunde inte visas utan en synlig blogg</string>
	<string name="stats_widget_error_no_permissions">Ditt konto hos WordPress.com kan inte visa statistik för denna blogg</string>
	<string name="stats_widget_error_no_account">Logga in på WordPress</string>
	<string name="stats_widget_error_generic">Statistik kunde inte laddas</string>
	<string name="stats_widget_loading_data">Laddar data…</string>
	<string name="stats_widget_name_for_blog">Dagens statistik för %1$s</string>
	<string name="stats_widget_name">WordPress dagens status</string>
	<string name="add_location_permission_required">Behörighet krävs för att lägga till plats</string>
	<string name="add_media_permission_required">Behörighet krävs för att lägga till media</string>
	<string name="access_media_permission_required">Behörighet krävs för åtkomst till media</string>
	<string name="stats_enable_rest_api_in_jetpack">Aktivera JSON API-modulen i Jetpack för att visa din statistik.</string>
	<string name="error_open_list_from_notification">Detta inlägg eller sida har publicerats på en annan webbplats</string>
	<string name="reader_short_comment_count_multi">%s kommentarer</string>
	<string name="reader_short_comment_count_one">1 kommentar</string>
	<string name="reader_label_submit_comment">SKICKA</string>
	<string name="reader_hint_comment_on_post">Svara inlägget...</string>
	<string name="reader_discover_visit_blog">Besök %s</string>
	<string name="reader_discover_attribution_blog">Först publicerat på %s</string>
	<string name="reader_discover_attribution_author">Först publicerat av %s</string>
	<string name="reader_discover_attribution_author_and_blog">Först publicerat av %1$s på %2$s</string>
	<string name="reader_short_like_count_multi">%s gillar</string>
	<string name="reader_short_like_count_one">1 gillar</string>
	<string name="reader_label_follow_count">%,d följare</string>
	<string name="reader_short_like_count_none">Gilla</string>
	<string name="reader_menu_tags">Redigera etiketter och bloggar</string>
	<string name="reader_title_post_detail">Läsare-inlägg</string>
	<string name="local_draft_explainer">Det här inlägget är ett lokalt utkast som inte har publicerats</string>
	<string name="local_changes_explainer">Det här inlägget har lokala ändringar som inte har publicerats</string>
	<string name="notifications_push_summary">Inställningar för notiser som visas på din enhet.</string>
	<string name="notifications_email_summary">Inställningar för notiser som skickas till den e-post som är knutet till ditt konto.</string>
	<string name="notifications_tab_summary">Inställningar för notiser som visas under fliken Notiser.</string>
	<string name="notifications_disabled">App-notiser har inaktiverats. Tryck här för att aktivera dem i Inställningar.</string>
	<string name="notification_types">Notistyper</string>
	<string name="error_loading_notifications">Det gick inte att läsa in notisinställningar</string>
	<string name="replies_to_your_comments">Svar på dina kommentarer</string>
	<string name="comment_likes">Gillar för kommentarer</string>
	<string name="app_notifications">App-notiser</string>
	<string name="notifications_tab">Fliken Notiser</string>
	<string name="email">E-post</string>
	<string name="notifications_comments_other_blogs">Kommentarer på andra webbplatser</string>
	<string name="notifications_wpcom_updates">WordPress.com-nyheter</string>
	<string name="notifications_other">Andra</string>
	<string name="notifications_account_emails">E-post från WordPress.com</string>
	<string name="notifications_account_emails_summary">Vi skickar dig alltid viktiga e-postmeddelanden om ditt konto, men du kan även få värdefullt extramaterial.</string>
	<string name="notifications_sights_and_sounds">Bilder och ljud</string>
	<string name="your_sites">Dina webbplatser</string>
	<string name="stats_insights_latest_post_trend">Det har gått %1$s sedan %2$s publicerades. Så här har det gått för inlägget hittills…</string>
	<string name="stats_insights_latest_post_summary">Sammanfattning av senaste inlägg</string>
	<string name="button_revert">Återställ</string>
	<string name="days_ago">%d dagar sedan</string>
	<string name="yesterday">I går</string>
	<string name="connectionbar_no_connection">Ingen anslutning</string>
	<string name="page_trashed">Sidan placerad i papperskorgen</string>
	<string name="post_deleted">Inlägg raderat</string>
	<string name="post_trashed">Inlägget placerat i papperskorgen</string>
	<string name="stats_no_activity_this_period">Ingen aktivitet denna period</string>
	<string name="trashed">Borttagen</string>
	<string name="button_back">Tillbaka</string>
	<string name="page_deleted">Sidan borttagen</string>
	<string name="button_stats">Statistik</string>
	<string name="button_trash">Ta bort</string>
	<string name="button_preview">Förhandsgranska</string>
	<string name="button_view">Visa</string>
	<string name="button_edit">Redigera</string>
	<string name="button_publish">Publicera</string>
	<string name="my_site_no_sites_view_subtitle">Vill du lägga till en?</string>
	<string name="my_site_no_sites_view_title">Du har inga WordPress-webbplatser än.</string>
	<string name="my_site_no_sites_view_drake">Illustration</string>
	<string name="reader_toast_err_follow_blog_not_authorized">Du har inte behörighet för åtkomst till denna blogg</string>
	<string name="reader_toast_err_follow_blog_not_found">Denna blogg kunde inte hittas</string>
	<string name="undo">Ångra</string>
	<string name="tabbar_accessibility_label_my_site">Min sida</string>
	<string name="tabbar_accessibility_label_me">Jag</string>
	<string name="passcodelock_prompt_message">Ange din PIN</string>
	<string name="editor_toast_changes_saved">Ändringar sparades</string>
	<string name="push_auth_expired">Begäran har löpt ut. Logga in på WordPress.com för att försöka igen.</string>
	<string name="stats_insights_best_ever">Flest visningar någonsin</string>
	<string name="ignore">Ignorera </string>
	<string name="stats_insights_most_popular_percent_views">%1$d%% av visningar</string>
	<string name="stats_insights_most_popular_hour">Mest populära timme</string>
	<string name="stats_insights_most_popular_day">Mest populära dag</string>
	<string name="stats_insights_popular">Mest populära dag och timme</string>
	<string name="stats_insights_today">Dagens statistik </string>
	<string name="stats_insights_all_time">Alla inlägg, visningar och besökare</string>
	<string name="stats_insights">Insikter</string>
	<string name="stats_sign_in_jetpack_different_com_account">Om du vill visa din statistik, logga in på det WordPress.com användarkonto som du använde för att ansluta till Jetpack.</string>
	<string name="stats_other_recent_stats_moved_label">Letar du efter din övriga senaste statistik? Vi har flyttat den till Insikter-sidan.</string>
	<string name="me_disconnect_from_wordpress_com">Koppla från WordPress.com </string>
	<string name="me_connect_to_wordpress_com">Anslut till WordPress.com</string>
	<string name="me_btn_login_logout">Logga in/Logga ut</string>
	<string name="account_settings">Kontoinställningar</string>
	<string name="me_btn_support">Hjälp &amp; support</string>
	<string name="site_picker_cant_hide_current_site">"%s" kunde inte döljas eftersom den är den nuvarande webbplatsen</string>
	<string name="site_picker_create_dotcom">Skapa en webbplats på WordPress.com</string>
	<string name="site_picker_add_site">Lägg till webbplats</string>
	<string name="site_picker_add_self_hosted">Lägg till webbplats på egen server</string>
	<string name="site_picker_edit_visibility">Visa/dölj webbplatser</string>
	<string name="my_site_btn_view_admin">Visa admin</string>
	<string name="my_site_btn_view_site">Visa webbplats</string>
	<string name="site_picker_title">Välj webbplats</string>
	<string name="my_site_btn_switch_site">Byt webbplats</string>
	<string name="my_site_btn_blog_posts">Blogginlägg</string>
	<string name="my_site_btn_site_settings">Inställningar </string>
	<string name="my_site_header_look_and_feel">Utseende och känsla</string>
	<string name="my_site_header_publish">Publicera</string>
	<string name="my_site_header_configuration">Konfiguration</string>
	<string name="reader_label_new_posts_subtitle">Knacka för att visa dem</string>
	<string name="notifications_account_required">Logga in på WordPress.com för att få notifikationer </string>
	<string name="stats_unknown_author">Okänd författare</string>
	<string name="image_added">Bild tillagd</string>
	<string name="signout">Koppla från</string>
	<string name="deselect_all">Avmarkera alla </string>
	<string name="show">Visa</string>
	<string name="hide">Dölj</string>
	<string name="select_all">Välj alla</string>
	<string name="sign_out_wpcom_confirm">Att koppla bort ditt konto kommer att innebära att alla @%s’s WordPress.com data från denna enhet, inklusive lokala utkast och lokala förändringar kommer försvinna.</string>
	<string name="select_from_new_picker">Flerval med den nya väljaren</string>
	<string name="stats_generic_error">Nödvändig statistik kunde inte laddas in. </string>
	<string name="no_device_videos">Inga videor</string>
	<string name="no_blog_images">Inga bilder</string>
	<string name="no_blog_videos">Inga videor</string>
	<string name="no_device_images">Inga bilder</string>
	<string name="error_loading_blog_images">Kunde inte hämta bilder </string>
	<string name="error_loading_blog_videos">Kunde inte hämta bilder </string>
	<string name="error_loading_images">Det gick inte att ladda in bilderna</string>
	<string name="error_loading_videos">Det gick inte att ladda in videor</string>
	<string name="loading_blog_images">Hämtar bilder</string>
	<string name="loading_blog_videos">Hämtar videor</string>
	<string name="no_media_sources">Kunde inte hämta media </string>
	<string name="loading_videos">Laddar videos </string>
	<string name="loading_images">Laddar bilder</string>
	<string name="no_media">Ingen media</string>
	<string name="device">Enhet</string>
	<string name="language">Språk</string>
	<string name="add_to_post">Lägg till i inlägg</string>
	<string name="media_picker_title">Välj media</string>
	<string name="take_photo">Ta ett foto</string>
	<string name="take_video">Spela in video</string>
	<string name="tab_title_device_images">Bilder på enhet</string>
	<string name="tab_title_device_videos">Videoklipp på enhet</string>
	<string name="tab_title_site_images">Bilder på webbplats</string>
	<string name="tab_title_site_videos">Videoklipp på webbplats</string>
	<string name="media_details_label_file_name">Filnamn</string>
	<string name="media_details_label_file_type">Filtyp</string>
	<string name="error_publish_no_network">Kunde inte publicera eftersom det into fanns någon nätanslutning. Sparat som utkast.</string>
	<string name="editor_toast_invalid_path">Ogiltig sökväg till fil</string>
	<string name="verification_code">Verifieringskod</string>
	<string name="invalid_verification_code">Ogiltig verifieringskod</string>
	<string name="verify">Verifiera</string>
	<string name="two_step_footer_label">Skriv koden från din Authenticator-app.</string>
	<string name="two_step_footer_button">Skicka kod via SMS</string>
	<string name="two_step_sms_sent">Kolla dina SMS för att se verifieringskoden.</string>
	<string name="sign_in_jetpack">Logga in på ditt WordPress.com-konto för att ansluta till Jetpack.</string>
	<string name="auth_required">Logga in igen för att fortsätta.</string>
	<string name="reader_empty_posts_request_failed">Kunde inte hämta inlägg</string>
	<string name="publisher">Publicerat av:</string>
	<string name="error_notification_open">Kunde inte öppna notis</string>
	<string name="stats_followers_total_email_paged">Visar %1$d - %2$d av %3$s följare via e-post</string>
	<string name="stats_search_terms_unknown_search_terms">Okända söktermer</string>
	<string name="stats_followers_total_wpcom_paged">Visar %1$d - %2$d av %3$s följare på WordPress.com</string>
	<string name="stats_empty_search_terms_desc">Lär dig mer om din söktrafik genom att granska orden dina besökare sökte efter för att hitta din webbplats.</string>
	<string name="stats_empty_search_terms">Inga söktermer</string>
	<string name="stats_entry_search_terms">Sökterm</string>
	<string name="stats_view_authors">Författare</string>
	<string name="stats_view_search_terms">Söktermer</string>
	<string name="comments_fetching">Hämtar kommentarer...</string>
	<string name="pages_fetching">Hämtar sidor...</string>
	<string name="toast_err_post_uploading">Kunde inte öppna inlägg eftersom det laddas upp</string>
	<string name="posts_fetching">Hämtar inlägg...</string>
	<string name="media_fetching">Hämtar media...</string>
	<string name="post_uploading">Laddar upp</string>
	<string name="stats_total">Totalt</string>
	<string name="stats_overall">Övergripande</string>
	<string name="stats_period">Period</string>
	<string name="logs_copied_to_clipboard">App-loggar har kopierats till urklipp</string>
	<string name="reader_label_new_posts">Nya inlägg</string>
	<string name="reader_empty_posts_in_blog">Denna blogg är tom</string>
	<string name="stats_average_per_day">Medel per dag</string>
	<string name="stats_recent_weeks">Senaste veckorna</string>
	<string name="error_copy_to_clipboard">Ett fel uppstod när text skulle kopieras till urklipp</string>
	<string name="reader_page_recommended_blogs">Webbplatser du kanske gillar</string>
	<string name="stats_months_and_years">Månader och år</string>
	<string name="themes_fetching">Hämtar teman...</string>
	<string name="stats_for">Statistik för %s</string>
	<string name="stats_other_recent_stats_label">Annan ny statistik</string>
	<string name="stats_view_all">Visa alla</string>
	<string name="stats_view">Visa</string>
	<string name="stats_followers_months">%1$d månader</string>
	<string name="stats_followers_a_year">Ett år</string>
	<string name="stats_followers_years">%1$d år</string>
	<string name="stats_followers_a_month">En månad</string>
	<string name="stats_followers_minutes">%1$d minuter</string>
	<string name="stats_followers_an_hour_ago">en timme sedan</string>
	<string name="stats_followers_hours">%1$d timmar</string>
	<string name="stats_followers_a_day">En dag</string>
	<string name="stats_followers_days">%1$d dagar</string>
	<string name="stats_followers_a_minute_ago">en minut sedan</string>
	<string name="stats_followers_seconds_ago">sekunder sedan</string>
	<string name="stats_followers_total_email">Totalt antal följare via e-post: %1$s</string>
	<string name="stats_followers_wpcom_selector">WordPress.com</string>
	<string name="stats_followers_email_selector">E-post</string>
	<string name="stats_followers_total_wpcom">Totalt antal följare på WordPress.com: %1$s</string>
	<string name="stats_comments_total_comments_followers">Totalt antal inlägg med följare av kommentarer: %1$s</string>
	<string name="stats_comments_by_authors">Efter författare</string>
	<string name="stats_comments_by_posts_and_pages">Efter inlägg &amp; sidor</string>
	<string name="stats_empty_followers_desc">Håll koll på ditt totala antal följare och hur länge var och en har följt din webbplats.</string>
	<string name="stats_empty_followers">Inga följare</string>
	<string name="stats_empty_publicize_desc">Håll koll på dina följare från andra sociala nätverk genom att använda Offentliggör.</string>
	<string name="stats_empty_publicize">Inga följare via Publicize</string>
	<string name="stats_empty_video">Inga videoklipp spelade</string>
	<string name="stats_empty_video_desc">Om du har laddat upp videoklipp med VideoPress kan du se hur många gånger de har spelats upp.</string>
	<string name="stats_empty_comments_desc">Om du tillåter kommentarer på din webbplats kan du se vilka dina främsta debattörer är och upptäcka vilket innehåll som skapar de bästa diskussionerna. Baserat på de senaste 1 000 kommentarerna.</string>
	<string name="stats_empty_tags_and_categories_desc">Få en överblick över de mest populära ämnena på din webbplats baserat på dina bästa inlägg och sidor från den senaste veckan.</string>
	<string name="stats_empty_top_authors_desc">Se hur många visningar varje författares inlägg eller sidor har och se i detalj vilket innehåll som är mest populärt.</string>
	<string name="stats_empty_tags_and_categories">Inga taggade inlägg eller sidor visade</string>
	<string name="stats_empty_clicks_desc">När ditt innehåll har länkar till andra webbplatser kan du se vilka dina besökare klickar på mest.</string>
	<string name="stats_empty_referrers_desc">Lär dig mer om din webbplats synlighet genom att se vilka webbplatser och sökmotorer som skickar dig mest besökare.</string>
	<string name="stats_empty_clicks_title">Inga klick</string>
	<string name="stats_empty_referrers_title">Inga hänvisningar</string>
	<string name="stats_empty_top_posts_title">Inga inlägg eller sidor visade</string>
	<string name="stats_empty_top_posts_desc">Upptäck vilket innehåll som har visats flest gånger och se detaljerad information över hur inlägg och sidor attraherar besökare över en längre tid.</string>
	<string name="stats_totals_followers">Sedan</string>
	<string name="stats_empty_geoviews">Inga länder</string>
	<string name="stats_empty_geoviews_desc">Utforska listan för att se vilka länder och regioner som besöker din webbplats mest.</string>
	<string name="stats_entry_video_plays">Videoklipp</string>
	<string name="stats_entry_top_commenter">Författare</string>
	<string name="stats_entry_publicize">Tjänst</string>
	<string name="stats_entry_followers">Följare</string>
	<string name="stats_totals_publicize">Följare</string>
	<string name="stats_entry_clicks_link">Länk</string>
	<string name="stats_view_top_posts_and_pages">Inlägg &amp; sidor</string>
	<string name="stats_view_videos">Videoklipp</string>
	<string name="stats_view_publicize">Publicize</string>
	<string name="stats_view_followers">Följare</string>
	<string name="stats_view_countries">Länder</string>
	<string name="stats_likes">Gillar</string>
	<string name="stats_pagination_label">Sida %1$s av %2$s</string>
	<string name="stats_timeframe_years">År</string>
	<string name="stats_views">Visningar</string>
	<string name="stats_visitors">Besökare</string>
	<string name="ssl_certificate_details">Detaljer</string>
	<string name="delete_sure_post">Radera detta inlägg</string>
	<string name="delete_sure">Radera detta utkast</string>
	<string name="delete_sure_page">Radera denna sida</string>
	<string name="confirm_delete_multi_media">Radera valda  poster?</string>
	<string name="confirm_delete_media">Radera vald post?</string>
	<string name="cab_selected">%d valda</string>
	<string name="media_gallery_date_range">Visa media från %1$s till %2$s</string>
	<string name="sure_to_remove_account">Ta bort denna webbplats?</string>
	<string name="reader_empty_followed_blogs_title">Du följer inga webbplatser än</string>
	<string name="reader_empty_posts_liked">Du har inte gillat några inlägg</string>
	<string name="faq_button">Vanliga frågor</string>
	<string name="browse_our_faq_button">Bläddra bland vanliga frågor</string>
	<string name="nux_help_description">Besök hjälpsektionen för att få svar på vanliga frågor eller besök forumet för att ställa nya frågor</string>
	<string name="agree_terms_of_service">Genom att skapa ett konto godkänner du dom fascinerande %1$sAnvändarvillkoren%2$s</string>
	<string name="create_new_blog_wpcom">Skapa en blogg på WordPress.com</string>
	<string name="new_blog_wpcom_created">Blogg på WordPress.com skapad!</string>
	<string name="reader_empty_comments">Inga kommentarer än</string>
	<string name="reader_empty_posts_in_tag">Inga inlägg med denna etikett</string>
	<string name="reader_label_comment_count_multi">%,d kommentarer</string>
	<string name="reader_label_view_original">Visa originalartikel</string>
	<string name="reader_label_like">Gilla</string>
	<string name="reader_label_liked_by">Gillat av</string>
	<string name="reader_label_comment_count_single">En kommentar</string>
	<string name="reader_label_comments_closed">Kommentarer inaktiverade</string>
	<string name="reader_label_comments_on">Kommentarer till</string>
	<string name="reader_title_photo_viewer">%1$d av %2$d</string>
	<string name="error_publish_empty_post">Det går inte att publicera ett tomt inlägg</string>
	<string name="error_refresh_unauthorized_posts">Du saknar behörighet för att visa eller redigera inlägg</string>
	<string name="error_refresh_unauthorized_pages">Du saknar behörighet för att visa eller redigera sidor</string>
	<string name="error_refresh_unauthorized_comments">Du saknar behörighet för att visa eller redigera kommentarer</string>
	<string name="older_month">Äldre än en månad</string>
	<string name="more">Mer</string>
	<string name="older_two_days">Äldre än 2 dagar</string>
	<string name="older_last_week">Äldre än en vecka</string>
	<string name="stats_no_blog">Statistiken för efterfrågad blogg kunde inte laddas</string>
	<string name="select_a_blog">Välj en WordPress-webbplats</string>
	<string name="sending_content">Laddar upp %s innehåll</string>
	<string name="uploading_total">Laddar upp %1$d av %2$d</string>
	<string name="mnu_comment_liked">Gillat</string>
	<string name="comment">Kommentar</string>
	<string name="comment_trashed">Kommentar förkastad</string>
	<string name="posts_empty_list">Inga inlägg än. Varför inte skapa ett?</string>
	<string name="comment_reply_to_user">Svar till %s</string>
	<string name="pages_empty_list">Inga sidor än. Varför inte skapa en?</string>
	<string name="media_empty_list_custom_date">Ingen media för detta tidsintervall</string>
	<string name="posting_post">Postar "%s"</string>
	<string name="signing_out">Loggar ut...</string>
	<string name="reader_toast_err_generic">Kunde inte genomföra denna åtgärd</string>
	<string name="reader_toast_err_block_blog">Kunde inte blockera denna blogg</string>
	<string name="reader_toast_blog_blocked">Inlägg från denna blogg kommer inte längre att visas</string>
	<string name="reader_menu_block_blog">Blockera denna blogg</string>
	<string name="contact_us">Kontakta oss</string>
	<string name="hs__conversation_detail_error">Beskriv problemet du upplever</string>
	<string name="hs__new_conversation_header">Supportchatt</string>
	<string name="hs__conversation_header">Supportchatt</string>
	<string name="hs__username_blank_error">Ange ett giltigt namn</string>
	<string name="hs__invalid_email_error">Ange en giltig e-postadress</string>
	<string name="add_location">Lägg till plats</string>
	<string name="current_location">Nuvarande plats</string>
	<string name="search_location">Sök</string>
	<string name="edit_location">Redigera</string>
	<string name="search_current_location">Hitta</string>
	<string name="preference_send_usage_stats">Skicka statistik</string>
	<string name="preference_send_usage_stats_summary">Skicka automatiskt användarstatistik för att hjälpa oss förbättra WordPress för Android</string>
	<string name="update_verb">Uppdatera</string>
	<string name="schedule_verb">Tidinställ</string>
	<string name="reader_title_blog_preview">Läsare-blogg</string>
	<string name="reader_title_tag_preview">Läsare-etikett</string>
	<string name="reader_title_subs">Taggar &amp; bloggar</string>
	<string name="reader_page_followed_tags">Följda taggar</string>
	<string name="reader_page_followed_blogs">Följda webbplatser</string>
	<string name="reader_hint_add_tag_or_url">Ange en URL eller tagg att följa</string>
	<string name="reader_label_followed_blog">Bloggen följs</string>
	<string name="reader_label_tag_preview">Inlägg taggade %s</string>
	<string name="reader_toast_err_get_blog_info">Kunde inte visa denna blogg</string>
	<string name="reader_toast_err_already_follow_blog">Du följer redan denna blogg</string>
	<string name="reader_toast_err_follow_blog">Kunde inte följa denna blogg</string>
	<string name="reader_toast_err_unfollow_blog">Kunde inte sluta följa denna blogg</string>
	<string name="reader_empty_recommended_blogs">Inga rekommenderade bloggar</string>
	<string name="saving">Sparar...</string>
	<string name="media_empty_list">Ingen media</string>
	<string name="ptr_tip_message">Tips: Dra ned för att uppdatera</string>
	<string name="help">Hjälp</string>
	<string name="forgot_password">Glömt ditt lösenord?</string>
	<string name="forums">Forum</string>
	<string name="help_center">Hjälpcenter</string>
	<string name="ssl_certificate_error">Ogiltigt SSL-ceritfikat</string>
	<string name="ssl_certificate_ask_trust">Om du vanligtvis kan nå denna webbplats utan problem kan felet betyda att någon försöker efterlikna webbplatsen och du borde inte fortsätta. Vill du lita på certifikatet ändå?</string>
	<string name="out_of_memory">Slut på minne för enheten</string>
	<string name="no_network_message">Inget nätverk tillgängligt</string>
	<string name="could_not_remove_account">Det gick inte att ta bort webbplatsen</string>
	<string name="gallery_error">Medieobjektet kunde inte hämtas</string>
	<string name="blog_not_found">Ett fel uppstod vid anslutning till bloggen</string>
	<string name="wait_until_upload_completes">Vänta tills uppladdningen är klar</string>
	<string name="theme_fetch_failed">Misslyckades hämta teman</string>
	<string name="theme_set_failed">Kunde inte ställa in tema</string>
	<string name="theme_auth_error_message">Se till att du har behörighet att ställa in teman</string>
	<string name="comments_empty_list">Inga kommentarer</string>
	<string name="mnu_comment_unspam">Inte skräppost</string>
	<string name="no_site_error">Det gick inte att ansluta till WordPress-webbplatsen</string>
	<string name="adding_cat_failed">Misslyckades lägga till kategori</string>
	<string name="adding_cat_success">Kategorin tillagd</string>
	<string name="cat_name_required">Kategorinamn måste anges</string>
	<string name="category_automatically_renamed">Kategorinamn %1$s är ogiltigt. Har ändrats till %2$s.</string>
	<string name="no_account">Inget WordPress-konto hittat, skapa ett konto och försök igen</string>
	<string name="sdcard_message">Ett SD-kort är nödvändigt för att ladda upp media</string>
	<string name="stats_empty_comments">Inga kommentarer ännu</string>
	<string name="stats_bar_graph_empty">Ingen statistik tillgänglig</string>
	<string name="invalid_url_message">Kontrollera att URL:en är giltig</string>
	<string name="reply_failed">Svara misslyckades</string>
	<string name="notifications_empty_list">Inga notifieringar</string>
	<string name="error_delete_post">Ett fel uppstod vid raderande av %s</string>
	<string name="error_refresh_posts">Inläggen kunde inte uppdateras just nu</string>
	<string name="error_refresh_pages">Sidorna kunde inte uppdateras just nu</string>
	<string name="error_refresh_notifications">Notifieringar kunde inte uppdateras just nu</string>
	<string name="error_refresh_comments">Kommentarerna kan inte uppdateras just nu</string>
	<string name="error_refresh_stats">Statistiken kunde inte uppdateras just nu</string>
	<string name="error_generic">Ett fel uppstod</string>
	<string name="error_moderate_comment">Ett fel uppstod under modereringen</string>
	<string name="error_edit_comment">Ett fel uppstod under redigeringen av kommentaren</string>
	<string name="error_upload">Ett fel uppstod vid uppladdning av %s</string>
	<string name="error_load_comment">Kunde inte ladda kommentaren</string>
	<string name="error_downloading_image">Fel vid nedladdning av bild</string>
	<string name="passcode_wrong_passcode">Fel PIN</string>
	<string name="invalid_email_message">Din epostadress är ogilltig</string>
	<string name="invalid_password_message">Lösenord måste innehålla minst 4 tecken</string>
	<string name="invalid_username_too_short">Användarnamn måste vara längre än 4 tecken</string>
	<string name="invalid_username_too_long">Användarnamn måste vara kortare än 61 tecken</string>
	<string name="username_only_lowercase_letters_and_numbers">Användarnamn får bara innehålla små bokstäver (a-z) och siffror</string>
	<string name="username_required">Ange ett användarnamn</string>
	<string name="username_not_allowed">Användarnamnet är inte tillåtet</string>
	<string name="username_must_be_at_least_four_characters">Användarnamnet måste vara minst 4 tecken</string>
	<string name="username_contains_invalid_characters">Användarnamn får inte innehålla tecknet "_"</string>
	<string name="username_must_include_letters">Användarnamn måste innehålla minst en bokstav (a-z)</string>
	<string name="email_invalid">Ange en giltig epostadress</string>
	<string name="email_not_allowed">Epostadressen är ogiltig</string>
	<string name="username_exists">Användarnamnet används redan</string>
	<string name="email_exists">Epostadressen används redan</string>
	<string name="username_reserved_but_may_be_available">Användarnamnet är för tillfället reserverat men kanske blir tillgängligt om några dagar</string>
	<string name="blog_name_required">Ange webbplatsadress</string>
	<string name="blog_name_not_allowed">Webbplatsadressen är inte tillåten</string>
	<string name="blog_name_must_be_at_least_four_characters">Webbplatsadressen måste vara minst 4 tecken</string>
	<string name="blog_name_must_be_less_than_sixty_four_characters">Webbplatsadressen måste vara kortare än 64 tecken</string>
	<string name="blog_name_contains_invalid_characters">Webbplatsadressen får inte innehålla tecknet "_"</string>
	<string name="blog_name_cant_be_used">Du kan inte använda den webbplatsadressen</string>
	<string name="blog_name_only_lowercase_letters_and_numbers">Webbplatsadressen kan bara innehålla små bokstäver (a-z) och siffror</string>
	<string name="blog_name_exists">Webbplatsen finns redan</string>
	<string name="blog_name_reserved">Webbplatsen är reserverad</string>
	<string name="blog_name_reserved_but_may_be_available">Webbplatsen är reserverad men kan bli tillgänglig om ett par dagar</string>
	<string name="username_or_password_incorrect">Användarnamnet eller lösenordet som angavs är felaktigt</string>
	<string name="nux_cannot_log_in">Vi kan inte logga in dig</string>
	<string name="xmlrpc_error">Kunde inte ansluta. Skriv in hela adressen till xmlrpc.php-filen på din webbplats och försök igen.</string>
	<string name="select_categories">Välj kategorier</string>
	<string name="account_details">Kontodetaljer</string>
	<string name="edit_post">Redigera inlägg</string>
	<string name="add_comment">Lägg till kommentar</string>
	<string name="connection_error">Kommunikationsfel</string>
	<string name="cancel_edit">Avbryt redigering</string>
	<string name="scaled_image_error">Skriv en giltig bredd för skalning</string>
	<string name="post_not_found">Ett fel uppstod vid inläsning av inlägget. Uppdatera dina inlägg och försök igen.</string>
	<string name="learn_more">Läs mer</string>
	<string name="media_gallery_settings_title">Galleriinställningar</string>
	<string name="media_gallery_image_order">Bildordning</string>
	<string name="media_gallery_num_columns">Antal kolumner</string>
	<string name="media_gallery_type_thumbnail_grid">Rutnät av miniatyrer</string>
	<string name="media_gallery_edit">Redigera galleri</string>
	<string name="media_error_no_permission">Du har inte behörighet att visa mediebiblioteket</string>
	<string name="cannot_delete_multi_media_items">En del medieobjekt kunde inte tas bort just nu. Försök igen senare.</string>
	<string name="themes_live_preview">Live förhandsgranskning</string>
	<string name="theme_current_theme">Nuvarande tema</string>
	<string name="theme_premium_theme">Premium-tema</string>
	<string name="link_enter_url_text">Länktext (valfritt)</string>
	<string name="create_a_link">Skapa länk</string>
	<string name="page_settings">Sidinställningar</string>
	<string name="local_draft">Lokalt utkast</string>
	<string name="upload_failed">Uppladdning misslyckades</string>
	<string name="horizontal_alignment">Vågrät justering</string>
	<string name="file_not_found">Kunde inte hitta mediafilen att ladda upp. Har den tagits bort eller flyttats?</string>
	<string name="post_settings">Inläggsinställningar</string>
	<string name="delete_post">Radera inlägg</string>
	<string name="delete_page">Radera sida</string>
	<string name="comment_status_approved">Godkänd</string>
	<string name="comment_status_unapproved">Väntande</string>
	<string name="comment_status_spam">Skräppost</string>
	<string name="comment_status_trash">Kastad</string>
	<string name="edit_comment">Redigera kommentar</string>
	<string name="mnu_comment_approve">Godkänn</string>
	<string name="mnu_comment_unapprove">Godkänn ej</string>
	<string name="mnu_comment_spam">Skräppost</string>
	<string name="mnu_comment_trash">Skräp</string>
	<string name="dlg_approving_comments">Godkänner</string>
	<string name="dlg_unapproving_comments">Förkastar</string>
	<string name="dlg_spamming_comments">Markera som skräppost</string>
	<string name="dlg_trashing_comments">Skicka till papperskorg</string>
	<string name="dlg_confirm_trash_comments">Kasta?</string>
	<string name="trash_yes">Kasta</string>
	<string name="trash_no">Kasta inte</string>
	<string name="trash">Kasta bort</string>
	<string name="author_name">Författarnamn</string>
	<string name="author_email">Författarepostadress</string>
	<string name="author_url">Författar-URL</string>
	<string name="hint_comment_content">Kommentar</string>
	<string name="saving_changes">Spara ändringarna</string>
	<string name="sure_to_cancel_edit_comment">Avbryt redigeringen av denna kommentar?</string>
	<string name="content_required">Kommentar krävs</string>
	<string name="toast_comment_unedited">Kommentaren har inte ändrats</string>
	<string name="remove_account">Ta bort webbplatsen</string>
	<string name="blog_removed_successfully">Webbplatsen har tagits bort</string>
	<string name="delete_draft">Radera utkast</string>
	<string name="preview_page">Förhandsgranska sida</string>
	<string name="preview_post">Förhandsgranska inlägg</string>
	<string name="comment_added">Kommentaren tillagd</string>
	<string name="post_not_published">Inläggets status är inte publicerat</string>
	<string name="page_not_published">Sidans status är inte publicerat</string>
	<string name="view_in_browser">Visa i webbläsare</string>
	<string name="add_new_category">Lägg till ny kategori</string>
	<string name="category_name">Kategorinamn</string>
	<string name="category_slug">Kategorins permalänk (valfritt)</string>
	<string name="category_desc">Kategoribeskrivning (valfri)</string>
	<string name="category_parent">Kategorins förälder (valfritt):</string>
	<string name="share_action_post">Nytt inlägg</string>
	<string name="share_action_media">Mediabibliotek</string>
	<string name="file_error_create">Kunde inte skapa temporär mediafil för uppladdning. Se till att det finns tillräckligt med utrymme på din enhet.</string>
	<string name="location_not_found">Okänd plats</string>
	<string name="open_source_licenses">Öppen källkodslicens</string>
	<string name="invalid_site_url_message">Kontrollera att webbplatsens URL är giltig</string>
	<string name="pending_review">Avvaktar granskning</string>
	<string name="http_credentials">HTTP-autentiseringsuppgifter (valfritt)</string>
	<string name="http_authorization_required">Autentisering krävs</string>
	<string name="post_format">Inläggsformat</string>
	<string name="notifications_empty_all">Inga notiser … ännu.</string>
	<string name="new_post">Nytt inlägg</string>
	<string name="new_media">Ny media</string>
	<string name="view_site">Visa webbplats</string>
	<string name="privacy_policy">Integritetspolicy</string>
	<string name="local_changes">Lokala ändringar</string>
	<string name="image_settings">Bildinställningar</string>
	<string name="add_account_blog_url">Bloggadress</string>
	<string name="wordpress_blog">WordPress-blogg</string>
	<string name="error_blog_hidden">Den här bloggen är dold och kunde inte laddas. Aktivera den igen i inställningarna och försök igen.</string>
	<string name="fatal_db_error">Ett fel uppstod vid skapandet av app-databasen. Försök återinstallera appen.</string>
	<string name="jetpack_message_not_admin">Jetpack tillägget krävs för statistik. Kontakta administratören.</string>
	<string name="reader_title_applog">Programlogg</string>
	<string name="reader_share_link">Dela länk</string>
	<string name="reader_toast_err_add_tag">Kunde inte lägga till etiketten</string>
	<string name="reader_toast_err_remove_tag">Kunde inte ta bort etiketten</string>
	<string name="required_field">Obligatoriskt fält</string>
	<string name="email_hint">Epostadress</string>
	<string name="site_address">Adress till din WordPress-installation (URL)</string>
	<string name="email_cant_be_used_to_signup">Du kan inte använda den e-postadressen för att registrera dig. Vi har problem med att de blockerar viss av våra e-post. Använd en annan e-postleverantör.</string>
	<string name="email_reserved">E-postadressen har redan använts. Kolla efter ett aktiveringsmail i din inbox. Om du inte aktiverar kan du försöka igen om några dagar.</string>
	<string name="blog_name_must_include_letters">Webbplatsadressen måste innehålla minst 1 bokstav (a-z)</string>
	<string name="blog_name_invalid">Ogiltig webbplatsadress</string>
	<string name="blog_title_invalid">Ogiltig webbplatstitel</string>
	<string name="deleting_page">Tar bort sida</string>
	<string name="deleting_post">Tar bort inlägg</string>
	<string name="share_url_post">Dela inlägg</string>
	<string name="share_url_page">Dela sida</string>
	<string name="share_link">Dela länk</string>
	<string name="creating_your_account">Skapar ditt konto</string>
	<string name="creating_your_site">Skapar din webbplats</string>
	<string name="reader_empty_posts_in_tag_updating">Hämtar inlägg...</string>
	<string name="error_refresh_media">Ett fel uppstod när mediabiblioteket skulle uppdateras. Försök igen senare.</string>
	<string name="reader_likes_you_and_multi">Du och %,d andra gillar detta</string>
	<string name="reader_likes_multi">%,d gillar detta</string>
	<string name="reader_toast_err_get_comment">Kunde inte hämta denna kommentar</string>
	<string name="reader_label_reply">Svara</string>
	<string name="video">Video</string>
	<string name="download">Laddar ner media</string>
	<string name="comment_spammed">Kommentar markerad som skräppost</string>
	<string name="cant_share_no_visible_blog">Du kan inte dela på WordPress utan att ha en synlig blogg</string>
	<string name="select_time">Välj tid</string>
	<string name="reader_likes_you_and_one">Du och en annan gillar detta</string>
	<string name="reader_empty_followed_blogs_description">Inget att oroa sig för, peka på ikonen uppe till höger för att börja utforska!</string>
	<string name="select_date">Välj datum</string>
	<string name="pick_photo">Välj bild</string>
	<string name="account_two_step_auth_enabled">Detta konto har två-stegsautentisering påslaget. Gå till dina säkerhetsinställningar på WordPress.com och skapa ett unikt lösenord för appen.</string>
	<string name="pick_video">Välj video</string>
	<string name="reader_toast_err_get_post">Kunde inte hämta detta inlägg</string>
	<string name="validating_user_data">Validerar användarinformation</string>
	<string name="validating_site_data">Validerar webbplats</string>
	<string name="password_invalid">Du måste använda ett säkrare lösenord. Se till att det består av minst 7 tecken och blanda versaler, gemener, siffror, och specialtecken.</string>
	<string name="nux_tap_continue">Fortsätt</string>
	<string name="nux_welcome_create_account">Skapa konto</string>
	<string name="signing_in">Loggar in...</string>
	<string name="nux_add_selfhosted_blog">Lägg till egen installation</string>
	<string name="nux_oops_not_selfhosted_blog">Logga in på WordPress.com</string>
	<string name="media_add_popup_title">Lägg till i mediebiblioteket</string>
	<string name="media_add_new_media_gallery">Skapa galleri</string>
	<string name="empty_list_default">Listan är tom</string>
	<string name="select_from_media_library">Välj från mediebiblioteket</string>
	<string name="jetpack_message">Jetpack-tillägget behövs för att visa statistik. Vill du installera Jetpack?</string>
	<string name="jetpack_not_found">Jetpack-tillägget kunde inte hittas</string>
	<string name="reader_untitled_post">(Ingen titel)</string>
	<string name="reader_share_subject">Delad från %s</string>
	<string name="reader_btn_share">Dela</string>
	<string name="reader_btn_follow">Följ</string>
	<string name="reader_btn_unfollow">Följer</string>
	<string name="reader_hint_comment_on_comment">Svara kommentaren...</string>
	<string name="reader_label_added_tag">Lade till %s</string>
	<string name="reader_label_removed_tag">Tog bort %s</string>
	<string name="reader_likes_one">En person gillar detta</string>
	<string name="reader_likes_only_you">Du gillar detta</string>
	<string name="reader_toast_err_comment_failed">Kunde inte kommentera</string>
	<string name="reader_toast_err_tag_exists">Du följer redan detta ämne</string>
	<string name="reader_toast_err_tag_invalid">Ogiltigt ämne</string>
	<string name="reader_toast_err_share_intent">Kunde inte dela</string>
	<string name="reader_toast_err_view_image">Kunde inte visa bild</string>
	<string name="reader_toast_err_url_intent">Kunde inte öppna %s</string>
	<string name="reader_empty_followed_tags">Du följer inga ämnen</string>
	<string name="create_account_wpcom">Skapa ett konto på WordPress.com</string>
	<string name="button_next">Nästa</string>
	<string name="connecting_wpcom">Ansluter till WordPress.com</string>
	<string name="username_invalid">Ogiltigt användarnamn</string>
	<string name="limit_reached">Gräns nådd. Du kan försöka igen om 1 minut. Att försöka igen innan kommer bara öka tiden du måste vänta innan förbudet är upphävt. Vänligen kontakta support om du tror detta är ett fel.</string>
	<string name="nux_tutorial_get_started_title">Kom igång!</string>
	<string name="themes">Teman</string>
	<string name="all">Alla</string>
	<string name="images">Bilder</string>
	<string name="unattached">Obundna</string>
	<string name="custom_date">Anpassat datum</string>
	<string name="media_add_popup_capture_photo">Ta foto</string>
	<string name="media_add_popup_capture_video">Spela in video</string>
	<string name="media_gallery_image_order_random">Slumpmässig</string>
	<string name="media_gallery_image_order_reverse">Omvänd</string>
	<string name="media_gallery_type">Stil</string>
	<string name="media_gallery_type_squares">Kvadrater</string>
	<string name="media_gallery_type_tiled">Mosaik</string>
	<string name="media_gallery_type_circles">Cirklar</string>
	<string name="media_gallery_type_slideshow">Bildspel</string>
	<string name="media_edit_title_text">Rubrik</string>
	<string name="media_edit_caption_text">Bildtext</string>
	<string name="media_edit_description_text">Beskrivning</string>
	<string name="media_edit_title_hint">Skriv en rubrik här</string>
	<string name="media_edit_caption_hint">Skriv en bildtext här</string>
	<string name="media_edit_description_hint">Skriv en beskrivning här</string>
	<string name="media_edit_success">Uppdaterad</string>
	<string name="media_edit_failure">Kunde inte uppdatera</string>
	<string name="themes_details_label">Detaljer</string>
	<string name="themes_features_label">Funktioner</string>
	<string name="theme_activate_button">Aktivera</string>
	<string name="theme_activating_button">Aktiverar</string>
	<string name="theme_set_success">Temat aktiverat!</string>
	<string name="theme_auth_error_title">Kunde inte hämta teman</string>
	<string name="post_excerpt">Utdrag</string>
	<string name="share_action_title">Lägg till...</string>
	<string name="share_action">Dela</string>
	<string name="stats">Statistik</string>
	<string name="stats_view_visitors_and_views">Besökare och visningar</string>
	<string name="stats_view_clicks">Klick</string>
	<string name="stats_view_tags_and_categories">Etiketter och kategorier</string>
	<string name="stats_view_referrers">Hänvisningar</string>
	<string name="stats_timeframe_today">I dag</string>
	<string name="stats_timeframe_yesterday">I går</string>
	<string name="stats_timeframe_days">Dagar</string>
	<string name="stats_timeframe_weeks">Veckor</string>
	<string name="stats_timeframe_months">Månader</string>
	<string name="stats_entry_country">Land</string>
	<string name="stats_entry_posts_and_pages">Rubrik</string>
	<string name="stats_entry_tags_and_categories">Ämne</string>
	<string name="stats_entry_authors">Författare</string>
	<string name="stats_entry_referrers">Hänvisning</string>
	<string name="stats_totals_views">Visningar</string>
	<string name="stats_totals_clicks">Klick</string>
	<string name="stats_totals_plays">Spelningar</string>
	<string name="passcode_manage">Ändra PIN-kodlås</string>
	<string name="passcode_enter_passcode">Skriv din PIN-kod</string>
	<string name="passcode_enter_old_passcode">Skriv din gamla PIN-kod</string>
	<string name="passcode_re_enter_passcode">Skriv din PIN-kod igen</string>
	<string name="passcode_change_passcode">Ändra PIN-kod</string>
	<string name="passcode_set">PIN-kod inställd</string>
	<string name="passcode_preference_title">PIN-kodlås</string>
	<string name="passcode_turn_off">Stäng av PIN-kodlås</string>
	<string name="passcode_turn_on">Slå på PIN-kodlås</string>
	<string name="upload">Ladda upp</string>
	<string name="discard">Kasta bort</string>
	<string name="sign_in">Logga in</string>
	<string name="notifications">Notifieringar</string>
	<string name="note_reply_successful">Svar publicerat</string>
	<string name="follows">Följer</string>
	<string name="new_notifications">%d nya notifieringar</string>
	<string name="more_notifications">och %d mer.</string>
	<string name="loading">Laddar...</string>
	<string name="httpuser">HTTP-användarnamn</string>
	<string name="httppassword">HTTP-lösenord</string>
	<string name="error_media_upload">Ett fel uppstod vid uppladdning av media</string>
	<string name="post_content">Innehåll (knacka för att lägga till text och media)</string>
	<string name="publish_date">Publicera</string>
	<string name="content_description_add_media">Lägg till media</string>
	<string name="incorrect_credentials">Felaktigt användarnamn eller lösenord.</string>
	<string name="password">Lösenord</string>
	<string name="username">Användarnamn</string>
	<string name="reader">Läsare</string>
	<string name="featured">Använd som utvald bild</string>
	<string name="featured_in_post">Inkludera bild i inlägget</string>
	<string name="no_network_title">Inget nätverk tillgängligt</string>
	<string name="pages">Sidor</string>
	<string name="caption">Bildtext (valfritt)</string>
	<string name="width">Bredd</string>
	<string name="posts">Inlägg</string>
	<string name="anonymous">Anonym</string>
	<string name="page">Sida</string>
	<string name="post">Inlägg</string>
	<string name="blogusername">användarnamn</string>
	<string name="ok">OK</string>
	<string name="upload_scaled_image">Ladda upp och länka till skalad bild</string>
	<string name="scaled_image">Välj bredd för bild</string>
	<string name="scheduled">Tidsinställt</string>
	<string name="link_enter_url">URL</string>
	<string name="uploading">Laddar upp...</string>
	<string name="version">Version</string>
	<string name="tos">Allmänna villkor</string>
	<string name="app_title">WordPress for Android</string>
	<string name="max_thumbnail_px_width">Förvald bildbredd</string>
	<string name="image_alignment">Justering</string>
	<string name="refresh">Uppdatera</string>
	<string name="untitled">Utan titel</string>
	<string name="edit">Redigera</string>
	<string name="post_id">Inlägg</string>
	<string name="page_id">Sida</string>
	<string name="post_password">Lösenord (valfritt)</string>
	<string name="immediately">Omedelbart</string>
	<string name="quickpress_add_alert_title">Ange genvägsnamn</string>
	<string name="today">Idag</string>
	<string name="settings">Inställningar</string>
	<string name="share_url">Dela URL</string>
	<string name="quickpress_window_title">Välj blogg för QuickPress-genväg</string>
	<string name="quickpress_add_error">Genvägsnamn kan inte vara tomt</string>
	<string name="publish_post">Publicera</string>
	<string name="draft">Utkast</string>
	<string name="post_private">Privat</string>
	<string name="upload_full_size_image">Ladda upp och länka till originalbild</string>
	<string name="title">Titel</string>
	<string name="tags_separate_with_commas">Etiketter (separera etiketter med kommatecken)</string>
	<string name="categories">Kategorier</string>
	<string name="dlg_deleting_comments">Raderar kommentarer</string>
	<string name="notification_blink">Blinka notifieringslampa</string>
	<string name="notification_sound">Notifieringsljud</string>
	<string name="notification_vibrate">Vibrera</string>
	<string name="status">Status</string>
	<string name="location">Plats</string>
	<string name="sdcard_title">SD-kort krävs</string>
	<string name="select_video">Välj en video från galleriet</string>
	<string name="media">Media</string>
	<string name="delete">Radera</string>
	<string name="none">Ingen</string>
	<string name="blogs">Bloggar</string>
	<string name="select_photo">Välj en bild från galleri</string>
	<string name="error">Fel</string>
	<string name="cancel">Avbryt</string>
	<string name="save">Spara</string>
	<string name="add">Lägg till</string>
	<string name="category_refresh_error">Fel vid uppdatering av kategorier</string>
	<string name="preview">Förhandsgranska</string>
	<string name="on">om</string>
	<string name="reply">Svara</string>
	<string name="notification_settings">Notisinställningar</string>
	<string name="yes">Ja</string>
	<string name="no">Nej</string>
</resources>
