<?xml version="1.0" encoding="utf-8"?>
<resources>
	<string name="error_fetch_users_list">Non è possibile recuperare gli utenti del sito</string>
	<string name="plans_manage">Gestisci il tuo piano su\nWordPress.com/plans</string>
	<string name="title_follower">Follower</string>
	<string name="title_email_follower">Email al follower</string>
	<string name="people_empty_list_filtered_viewers">Non hai ancora visitatori.</string>
	<string name="people_empty_list_filtered_email_followers">Non hai ancora follower via email.</string>
	<string name="people_empty_list_filtered_followers">Non hai ancora follower.</string>
	<string name="people_empty_list_filtered_users">Non hai ancora utenti.</string>
	<string name="people_dropdown_item_email_followers">Follower via email</string>
	<string name="people_dropdown_item_viewers">Visitatori</string>
	<string name="people_dropdown_item_followers">Follower</string>
	<string name="people_dropdown_item_team">Team</string>
	<string name="invite_message_usernames_limit">Invita fino a 10 indirizzi email e/o nome utente di WordPress.com. A coloro che che non hanno un nome utente, saranno spedite le istruzioni su come crearne uno.</string>
	<string name="viewer_remove_confirmation_message">Se rimuovi questo visitatore, lui o lei non avrà più la possibilità di visitare questo sito.\n\nVuoi ancora rimuovere questo visitatore?</string>
	<string name="follower_remove_confirmation_message">Se rimosso, questo follower smetterà di ricevere notifiche da questo sito, a meno che non si iscriva di nuovo.\n\nVuoi ancora di rimuovere questo follower?</string>
	<string name="follower_subscribed_since">Dal %1$s</string>
	<string name="reader_label_view_gallery">Visualizza galleria</string>
	<string name="error_remove_follower">Non è possibile rimuovere il follower</string>
	<string name="error_remove_viewer">Non è possibile rimuovere il visitatore</string>
	<string name="error_fetch_email_followers_list">Non è possibile recuperare l\'email dei follower del sito</string>
	<string name="error_fetch_followers_list">Non è possibile recuperare i follower del sito</string>
	<string name="editor_failed_uploads_switch_html">Il caricamento di alcuni elementi multimediali non è andato a buon fine. Non puoi passare alla modalità HTML\n        in questo momento. Vuoi rimuovere i caricamenti falliti e proseguire?</string>
	<string name="format_bar_description_html">Modalità HTML</string>
	<string name="visual_editor">Editor visuale</string>
	<string name="image_thumbnail">Immagine in minaitura</string>
	<string name="format_bar_description_ol">Lista numerata</string>
	<string name="format_bar_description_ul">Lista puntata</string>
	<string name="format_bar_description_more">Inserire di più</string>
	<string name="format_bar_description_media">Inserire l\'elemento multimediale</string>
	<string name="format_bar_description_link">Inserisci link</string>
	<string name="format_bar_description_strike">Barrato</string>
	<string name="format_bar_description_quote">Citazione</string>
	<string name="format_bar_description_italic">Corsivo</string>
	<string name="format_bar_description_underline">Sottolineato</string>
	<string name="image_link_to">Link a</string>
	<string name="image_alt_text">Testo alternativo</string>
	<string name="image_settings_save_toast">Modifiche salvate</string>
	<string name="image_caption">Didascalia</string>
	<string name="image_width">Larghezza</string>
	<string name="format_bar_description_bold">Grassetto</string>
	<string name="image_settings_dismiss_dialog_title">Elimina le modifiche non salvate?</string>
	<string name="stop_upload_button">Ferma il caricamento</string>
	<string name="stop_upload_dialog_title">Ferma il caricamento?</string>
	<string name="alert_error_adding_media">Durante l\'inserimento di un elemento multimediale si è verificato un errore.</string>
	<string name="alert_action_while_uploading">Stai attualmente caricando un elemento multimediale. Attendi il suo completamento.</string>
	<string name="alert_insert_image_html_mode">Impossibile inserire direttamente elementi multimediali in modalità HTML.Passa alla modalità visuale.</string>
	<string name="uploading_gallery_placeholder">Caricamento della galleria…</string>
	<string name="tap_to_try_again">Tocca per provare di nuovo!</string>
	<string name="invite_error_for_username">%1$s: %2$s</string>
	<string name="invite_sent">Invito inviato con successo</string>
	<string name="invite_error_some_failed">L\'invito è stato inviato ma c\'è stato qualche problema!</string>
	<string name="invite_error_sending">Si è verificato un errore nel tentativo di inviare l\'invito!</string>
	<string name="invite_error_invalid_usernames_multiple">Non è possibile inviare l\'email: ci sono dei nomi utente o degli indirizzi non validi.</string>
	<string name="invite_error_invalid_usernames_one">Non è possibile inviare l\'email: c\'è un nomi utente o un indirizzo non valido. </string>
	<string name="invite_error_no_usernames">Aggiungi almeno un nome utente</string>
	<string name="invite_message_info">(Opzionale) Puoi inserire un messaggio personalizzato sino a 500 caratteri che verrà inserito nell\'invito a/agli utente/i.</string>
	<string name="invite_message_remaining_other">%d caratteri rimanenti</string>
	<string name="invite_message_remaining_one">1 carattere rimanente</string>
	<string name="invite_message_remaining_zero">0 caratteri rimanenti</string>
	<string name="invite_invalid_email">L\'indirizzo email \'%s\' non è valido</string>
	<string name="invite_message_title">Messaggio personalizzato</string>
	<string name="invite_already_a_member">Vi è già un membro con il nome utente \'%s\'</string>
	<string name="invite_username_not_found">Nessun utente trovato per il nome utente \'%s\'</string>
	<string name="invite">Invita</string>
	<string name="invite_names_title">Nomi utente o email</string>
	<string name="send_link">Invia link</string>
	<string name="my_site_header_external">Esterno</string>
	<string name="invite_people">Invita delle persone</string>
	<string name="signup_succeed_signin_failed">Il tuo account è stato creato ma si è verificato un errore quando abbiamo provato ad autenticarti.\n       Provata ad entrare col i tuo nome utente e la password appena creati.</string>
	<string name="label_clear_search_history">Pulisci lo storico della ricerca</string>
	<string name="dlg_confirm_clear_search_history">Pulire lo storico della ricerca?</string>
	<string name="reader_empty_posts_in_search_description">Nessun articolo trovato riguardo %s per la tua lingua</string>
	<string name="reader_label_post_search_running">Ricerca in corso...</string>
	<string name="reader_label_related_posts">Letture correlate</string>
	<string name="reader_empty_posts_in_search_title">Nessun articolo trovato</string>
	<string name="reader_label_post_search_explainer">Cerca in tutti i blog pubblici di WordPress.com</string>
	<string name="reader_hint_post_search">Cerca in WordPress.com</string>
	<string name="reader_title_related_post_detail">Articoli correlati</string>
	<string name="reader_title_search_results">Cerca %s</string>
	<string name="preview_screen_links_disabled">I link sono disabilitati nella schermata di anteprima</string>
	<string name="draft_explainer">Questo articolo è un bozza che non è stata ancora pubblicata</string>
	<string name="send">Invia</string>
	<string name="user_remove_confirmation_message">Se rimuovi %1$s, questo utente non sarà più in grado di accedere a questo sito ma qualsiasi contenuto creato da %1$s rimarrà disponibile sul sito.\n\nVuoi davvero rimuovere questo utente?</string>
	<string name="person_removed">\@%1$s è stato rimosso correttamente</string>
	<string name="person_remove_confirmation_title">Rimuovere %1$s</string>
	<string name="reader_empty_posts_in_custom_list">I siti in questo elenco non hanno pubblicato nullla di recente</string>
	<string name="people">Persone</string>
	<string name="edit_user">Modifica utente</string>
	<string name="role">Ruolo</string>
	<string name="error_remove_user">Impossibile rimuovere l\'utente</string>
	<string name="error_update_role">Impossibile aggiornare il ruolo utente</string>
	<string name="error_fetch_viewers_list">Non è possibile recuperare i visitatori del sito</string>
	<string name="gravatar_camera_and_media_permission_required">Autorizzazioni necessarie al fine di selezionare o catturare una foto</string>
	<string name="error_updating_gravatar">Errore nell\'aggiornamento del tuo Gravatar</string>
	<string name="error_refreshing_gravatar">Errore nel ricaricamento del tuo Gravatar</string>
	<string name="error_locating_image">Errore nella localizzazione dell\'immagine ritagliata</string>
	<string name="gravatar_tip">Novità! Fai un tap sul tuo Gravatar per modificarlo!</string>
	<string name="error_cropping_image">Errore nel ritaglio dell\'immagine</string>
	<string name="launch_your_email_app">Esegui la tua app email</string>
	<string name="checking_email">Verifica della email</string>
	<string name="not_on_wordpress_com">Non sei su WordPress.com?</string>
	<string name="check_your_email">Controlla la tua email</string>
	<string name="magic_link_unavailable_error_message">Attualmente non disponibile. Inserisci la tua password</string>
	<string name="logging_in">Sto entrando</string>
	<string name="get_a_link_sent_to_your_email_to_sign_in_instantly">Ottieni un link inviato alla tua email per autenticarti istantaneamente</string>
	<string name="enter_your_password_instead">Oppure inserisci la tua password</string>
	<string name="web_address_dialog_hint">Mostrato pubblicamente quando si commenta.</string>
	<string name="jetpack_not_connected_message">Il plugin Jetpack è installato ma non è connesso a WordPress.com. Desideri connettere Jetpack?</string>
	<string name="username_email">Email o nome utente</string>
	<string name="jetpack_not_connected">Il plugin Jetpack non è connesso</string>
	<string name="new_editor_reflection_error">L\'editor visuale non è compatibile con il tuo device. &amp;Egrave; stato automaticamente disabilitato.</string>
	<string name="stats_insights_latest_post_no_title">(nessun titolo)</string>
	<string name="capture_or_pick_photo">Catturare o selezionare una foto</string>
	<string name="plans_post_purchase_button_themes">Sfoglia i temi</string>
	<string name="plans_post_purchase_text_themes">Ora hai accesso illimitato ai temi premium. Per cominciare, guarda un\'anteprima di ogni tema sul tuo sito.</string>
	<string name="plans_post_purchase_title_themes">Trova il tema premium perfetto</string>
	<string name="plans_post_purchase_button_video">Comincia un nuovo articolo</string>
	<string name="plans_post_purchase_text_video">Potrai effettuare il caricamento dei video nel tuo sito con VideoPress e nel tuo spazio di archiviazione esteso.</string>
	<string name="plans_post_purchase_title_video">Anima gli articoli con i video</string>
	<string name="plans_post_purchase_button_customize">Personalizza il mio sito</string>
	<string name="plans_post_purchase_text_customize">Ora hai accesso a font e colori personalizzati e le possibilità di editare un CSS personalizzato.</string>
	<string name="plans_post_purchase_title_customize">Personalizza font e colori</string>
	<string name="plans_post_purchase_text_intro">Il tuo sito sta facendo salti di gioia! Ora esplora le nuove funzionalità del tuo sito e scegli da dove vuoi cominciare.</string>
	<string name="plans_post_purchase_title_intro">È tutto tuo, ben fatto!</string>
	<string name="plan">Piano</string>
	<string name="plans">Piani</string>
	<string name="export_your_content_message">I tuoi articoli, pagine e impostazioni ti saranno inviate via e-mail all\'indirizzo %s.</string>
	<string name="plans_loading_error">Non è stato possibile caricare i piani</string>
	<string name="export_your_content">Esporta i contenuti</string>
	<string name="exporting_content_progress">Esportazione dei contenuti in corso ...</string>
	<string name="export_email_sent">Email di esportazione inviata!</string>
	<string name="show_purchases">Mostra gli acquisti</string>
	<string name="premium_upgrades_message">Sul tuo sito sono attivi alcuni aggiornamenti premium. Cancella gli aggiornamenti prima di cancellare il sito.</string>
	<string name="checking_purchases">Controllo degli acquisti</string>
	<string name="premium_upgrades_title">Aggiornamenti alla versione Premium</string>
	<string name="purchases_request_error">Qualcosa è andato storto. Non è stato possibile richiedere gli acquisti.</string>
	<string name="delete_site_progress">Cancellazione del sito in corso ...</string>
	<string name="delete_site_summary">Questa azione è irreversibile. Cancellando il tuo sito rimuoverai tutti i contenuti, collaboratori, e domini.</string>
	<string name="delete_site_hint">Elimina il sito</string>
	<string name="export_site_hint">Esporta il sito in un file XML</string>
	<string name="are_you_sure">Sei sicuro?</string>
	<string name="export_site_summary">Se sei sicuro, esporta prima i contenuti perchè non potranno più essere recuperati.</string>
	<string name="keep_your_content">Mantieni il tuo contenuto</string>
	<string name="domain_removal_hint">I domini non funzioneranno più una volta che avrai rimosso il sito</string>
	<string name="domain_removal_summary">Attenzione! Cancellando il sito rimuoverai anche i domini sottoelencati.</string>
	<string name="primary_domain">Dominio principale</string>
	<string name="domain_removal">Rimozione del dominio</string>
	<string name="error_deleting_site_summary">C\'è stato un errore durante la cancellazione del sito. Contatta il forum di supporto per ulteriore assistenza</string>
	<string name="error_deleting_site">Errore durante la cancellazione del sito</string>
	<string name="confirm_delete_site_prompt">Digita %1$s nel campo sotto alla conferma. Dopo il sito sarà cancellato per sempre.</string>
	<string name="site_settings_export_content_title">Esporta il contenuto</string>
	<string name="contact_support">Contatta il supporto</string>
	<string name="confirm_delete_site">Conferma la cancellazione del sito</string>
	<string name="start_over_text">Se vuoi mantenere il sito ma non vuoi più tenere nessuno degli articoli e delle pagine che ci sono ora, la nostra squadra di supporto può cancellare per te articoli, pagine, media e commenti.\n\n Questo terrà attivi sito e URL, e ti permetterà di creare contenuti nuovi. Contattaci per chiederci di cancellare i contenuti attuali.</string>
	<string name="let_us_help">Lascia che ti aiutiamo</string>
	<string name="site_settings_start_over_hint">Ricomincia da capo il tuo sito</string>
	<string name="me_btn_app_settings">Impostazioni dell\'applicazione</string>
	<string name="start_over">Ricomincia</string>
	<string name="editor_remove_failed_uploads">Rimuovi i caricamenti falliti</string>
	<string name="editor_toast_failed_uploads">Il caricamento di qualche media è fallito. Tu puoi non salvare oppure pubblicare \n il tuo articolo così. Vuoi rimuovere i file dei media il cui caricamento è fallito?</string>
	<string name="comments_empty_list_filtered_trashed">Nessun commento nel cestino</string>
	<string name="site_settings_advanced_header">Avanzato</string>
	<string name="comments_empty_list_filtered_pending">Nessun commento in sospeso</string>
	<string name="comments_empty_list_filtered_approved">Nessun commento approvato</string>
	<string name="button_done">Fatto</string>
	<string name="button_skip">Salta</string>
	<string name="site_timeout_error">Non è stato possibile connettersi al sito WordPress a causa di un errore di timeout.</string>
	<string name="xmlrpc_malformed_response_error">Non è possibile connettersi. L\'installazione WordPress risponde con un documento XML-RPC non valido.</string>
	<string name="xmlrpc_missing_method_error">Non è possibile connettersi. Sul server mancano i necessari metodi XML-RPC</string>
	<string name="post_format_status">Stato</string>
	<string name="post_format_video">Video</string>
	<string name="theme_free">Gratuito</string>
	<string name="theme_all">Tutti</string>
	<string name="theme_premium">Premium</string>
	<string name="post_format_chat">Chat</string>
	<string name="post_format_gallery">Galleria</string>
	<string name="post_format_image">Immagine</string>
	<string name="post_format_link">Link</string>
	<string name="post_format_quote">Citazione</string>
	<string name="post_format_standard">Standard</string>
	<string name="notif_events">Informazioni sui corsi e sugli eventi di WordPress.com (online e di persona).</string>
	<string name="post_format_aside">Digressione</string>
	<string name="post_format_audio">Audio</string>
	<string name="notif_surveys">Opportunità di partecipare ai sondaggi e alle ricerche di WordPress.com.</string>
	<string name="notif_tips">Suggerimenti per utilizzare al meglio WordPress.com.</string>
	<string name="notif_community">Comunità</string>
	<string name="replies_to_my_comments">Risposte ai miei commenti</string>
	<string name="notif_suggestions">Suggerimenti</string>
	<string name="notif_research">Ricerca</string>
	<string name="site_achievements">Obiettivi del sito</string>
	<string name="username_mentions">Riferimenti al nome utente</string>
	<string name="likes_on_my_posts">Mi piace per i miei articoli</string>
	<string name="site_follows">Segui del sito</string>
	<string name="likes_on_my_comments">Mi piace per i miei commenti</string>
	<string name="comments_on_my_site">Commenti sul mio sito</string>
	<string name="site_settings_list_editor_summary_other">%d elementi</string>
	<string name="site_settings_list_editor_summary_one">1 elemento</string>
	<string name="approve_auto">Tutti gli utenti</string>
	<string name="approve_auto_if_previously_approved">Commenti di utenti conosciuti</string>
	<string name="approve_manual">Nessun commento</string>
	<string name="site_settings_paging_summary_other">%d commenti per pagina</string>
	<string name="site_settings_paging_summary_one">1 commento per pagina</string>
	<string name="site_settings_multiple_links_summary_other">Richiedi l\'approvazione per più di %d link</string>
	<string name="site_settings_multiple_links_summary_one">Richiedi l\'approvazione per più di 1 link</string>
	<string name="site_settings_multiple_links_summary_zero">Richiedi l\'approvazione per più di 0 link</string>
	<string name="detail_approve_auto">Approva automaticamente i commenti di tutti gli utenti.</string>
	<string name="detail_approve_auto_if_previously_approved">Approva automaticamente se l\'utente ha approvato un commento in precedenza</string>
	<string name="detail_approve_manual">Richiedi l\'approvazione manuale per i commenti di tutti gli utenti.</string>
	<string name="days_quantity_other">%d giorni</string>
	<string name="days_quantity_one">1 giorno</string>
	<string name="filter_trashed_posts">Eliminati</string>
	<string name="filter_published_posts">Pubblicati</string>
	<string name="filter_draft_posts">Bozze</string>
	<string name="filter_scheduled_posts">Programmati</string>
	<string name="pending_email_change_snackbar">Fai clic sul link di verifica nell\'e-mail inviata a %1$s per confermare il tuo nuovo indirizzo</string>
	<string name="primary_site">Sito principale</string>
	<string name="web_address">Indirizzo web</string>
	<string name="editor_toast_uploading_please_wait">Al momento stai caricando file multimediali. Attendi il termine dell\'operazione.</string>
	<string name="error_refresh_comments_showing_older">Impossibile aggiornare i commenti in questo momento, vengono visualizzati i commenti precedenti</string>
	<string name="editor_post_settings_set_featured_image">Imposta immagine in primo piano</string>
	<string name="editor_post_settings_featured_image">Immagine in evidenza</string>
	<string name="new_editor_promo_desc">L\'app WordPress per Android ora include un nuovo bellissimo editor\n visuale. Provalo creando un nuovo articolo.</string>
	<string name="new_editor_promo_title">Un editor completamente nuovo</string>
	<string name="new_editor_promo_button_label">Fantastico, grazie!</string>
	<string name="visual_editor_enabled">Editor visuale abilitato</string>
	<string name="editor_content_placeholder">Condividi la tua storia qui...</string>
	<string name="editor_page_title_placeholder">Titolo della pagina</string>
	<string name="editor_post_title_placeholder">Titolo dell\'articolo</string>
	<string name="email_address">Indirizzo e-mail</string>
	<string name="preference_show_visual_editor">Mostra editor visuale</string>
	<string name="dlg_sure_to_delete_comments">Eliminare in modo permanente questi commenti?</string>
	<string name="preference_editor">Editor</string>
	<string name="dlg_sure_to_delete_comment">Eliminare in modo permanente questo commento?</string>
	<string name="mnu_comment_delete_permanently">Elimina</string>
	<string name="mnu_comment_untrash">Ripristina</string>
	<string name="comment_deleted_permanently">Commento eliminato</string>
	<string name="comments_empty_list_filtered_spam">Nessun commento spam</string>
	<string name="could_not_load_page">Impossibile caricare la pagina</string>
	<string name="comment_status_all">Tutti</string>
	<string name="interface_language">Lingua dell\'interfaccia</string>
	<string name="off">Disattivata</string>
	<string name="about_the_app">Info sull\'app</string>
	<string name="error_post_account_settings">Impossibile salvare le impostazioni del tuo account</string>
	<string name="error_post_my_profile">Impossibile salvare il profilo</string>
	<string name="error_fetch_account_settings">Impossibile recuperare le impostazioni dell\'account</string>
	<string name="error_fetch_my_profile">Impossibile recuperare il profilo</string>
	<string name="stats_widget_promo_ok_btn_label">OK</string>
	<string name="stats_widget_promo_desc">Aggiungi il widget alla schermata Home per accedere alle tue statistiche con un clic.</string>
	<string name="stats_widget_promo_title">Widget delle statistiche della schermata Home</string>
	<string name="site_settings_unknown_language_code_error">Codice lingua non riconosciuto</string>
	<string name="site_settings_threading_dialog_description">Consenti di nidificare i commenti in thread.</string>
	<string name="site_settings_threading_dialog_header">Thread fino a</string>
	<string name="remove">Rimuovi</string>
	<string name="search">Cerca</string>
	<string name="add_category">Aggiungi categoria</string>
	<string name="disabled">Disattivata</string>
	<string name="site_settings_image_original_size">Dimensioni originali</string>
	<string name="privacy_private">Il tuo sito è visibile solo a te e agli utenti che approvi</string>
	<string name="privacy_public_not_indexed">Il tuo sito è visibile a chiunque, ma chiede ai motori di ricerca di non indicizzarlo</string>
	<string name="privacy_public">Il tuo sito è visibile a chiunque e può essere indicizzato dai motori di ricerca</string>
	<string name="about_me_hint">Alcune informazioni su di te…</string>
	<string name="public_display_name_hint">Se non viene impostato, il nome visualizzato coinciderà con il nome utente per impostazione predefinita</string>
	<string name="about_me">Informazioni su di me</string>
	<string name="public_display_name">Nome visualizzato (pubblico)</string>
	<string name="my_profile">Il mio profilo</string>
	<string name="first_name">Nome</string>
	<string name="last_name">Cognome</string>
	<string name="site_privacy_public_desc">Permetti ai motori di ricerca di indicizzare questo sito</string>
	<string name="site_privacy_hidden_desc">Scoraggia i motori di ricerca ad effettuare l\'indicizzazione di questo sito</string>
	<string name="site_privacy_private_desc">Vorrei che il mio sito fosse privato, visibile solo agli utenti scelti da me</string>
	<string name="cd_related_post_preview_image">Immagine di anteprima dell\'articolo correlato</string>
	<string name="error_post_remote_site_settings">Impossibile salvare le informazioni del sito</string>
	<string name="error_fetch_remote_site_settings">Impossibile recuperare le informazioni del sito</string>
	<string name="error_media_upload_connection">Si è verificato un errore di connessione durante il caricamento dei contenuti multimediali</string>
	<string name="site_settings_disconnected_toast">Disconnesso. Modifica disabilitata.</string>
	<string name="site_settings_unsupported_version_error">Versione di WordPress non supportata</string>
	<string name="site_settings_multiple_links_dialog_description">Richiedi l\'approvazione per i commenti che includono un numero di link superiore a quello specificato.</string>
	<string name="site_settings_close_after_dialog_switch_text">Chiudi automaticamente</string>
	<string name="site_settings_close_after_dialog_description">Chiudi automaticamente i commenti sugli articoli.</string>
	<string name="site_settings_paging_dialog_description">Suddividi il flusso dei commenti in più pagine.</string>
	<string name="site_settings_paging_dialog_header">Commenti per pagina</string>
	<string name="site_settings_close_after_dialog_title">Chiudi commenti</string>
	<string name="site_settings_blacklist_description">Quando un commento contiene una di queste parole nel testo, nel nome, nell\'URL, nell\'e-mail o nell\'IP, verrà contrassegnato come spam. Puoi inserire parzialmente le parole, per cui "press" corrisponderà a "WordPress".</string>
	<string name="site_settings_hold_for_moderation_description">Quando un commento contiene una di queste parole nel testo, nel nome, nell\'URL, nell\'e-mail o nell\'IP, verrà inserito nella coda di moderazione. Puoi inserire parzialmente le parole, per cui "press" corrisponderà a "WordPress".</string>
	<string name="site_settings_list_editor_input_hint">Inserisci una parola o una frase</string>
	<string name="site_settings_list_editor_no_items_text">Nessun elemento</string>
	<string name="site_settings_learn_more_caption">Puoi sovrascrivere queste impostazioni per i singoli articoli.</string>
	<string name="site_settings_rp_preview3_site">in "Upgrade"</string>
	<string name="site_settings_rp_preview3_title">Punti principali dell\'aggiornamento: VideoPress per matrimoni</string>
	<string name="site_settings_rp_preview2_site">in "App"</string>
	<string name="site_settings_rp_preview2_title">Grande rinnovamento di WordPress per l\'app Android</string>
	<string name="site_settings_rp_preview1_site">in "Mobile"</string>
	<string name="site_settings_rp_preview1_title">Grande aggiornamento per iPhone/iPad ora disponibile</string>
	<string name="site_settings_rp_show_images_title">Mostra le immagini</string>
	<string name="site_settings_rp_show_header_title">Mostra l\'intestazione</string>
	<string name="site_settings_rp_switch_summary">Articoli correlati visualizza contenuti pertinenti del tuo sito sotto i tuoi articoli.</string>
	<string name="site_settings_rp_switch_title">Mostra gli articoli correlati</string>
	<string name="site_settings_delete_site_hint">Rimuovi i dati del sito dall\'app</string>
	<string name="site_settings_blacklist_hint">I commenti che corrispondono a un filtro vengono contrassegnati come spam</string>
	<string name="site_settings_moderation_hold_hint">I commenti che corrispondono a un filtro vengono inseriti nella coda di moderazione</string>
	<string name="site_settings_multiple_links_hint">Ignora limite di link da utenti conosciuti</string>
	<string name="site_settings_whitelist_hint">L\'autore del commento deve avere un commento già approvato in precedenza</string>
	<string name="site_settings_user_account_required_hint">Gli utenti devono essere registrati ed aver effettuato l\'accesso per poter inviare commenti</string>
	<string name="site_settings_identity_required_hint">L\'autore del commento deve inserire nome e indirizzo e-mail</string>
	<string name="site_settings_manual_approval_hint">I commenti devono essere approvati manualmente</string>
	<string name="site_settings_paging_hint">Visualizza commenti in parti di dimensioni specifiche</string>
	<string name="site_settings_threading_hint">Consenti commenti nidificati per una data profondità</string>
	<string name="site_settings_sort_by_hint">Determina l\'ordine in cui i commenti vengono visualizzati</string>
	<string name="site_settings_close_after_hint">Rifiuta i commenti dopo l\'orario specificato</string>
	<string name="site_settings_receive_pingbacks_hint">Consenti notifiche link da altri blog</string>
	<string name="site_settings_send_pingbacks_hint">Tenta di notificare tutti i blog che hanno un link nell\'articolo</string>
	<string name="site_settings_allow_comments_hint">Consenti ai lettori di pubblicare commenti</string>
	<string name="site_settings_discussion_hint">Visualizza e modifica le impostazioni di discussione del sito</string>
	<string name="site_settings_more_hint">Visualizza tutte le impostazioni di discussione disponibili</string>
	<string name="site_settings_related_posts_hint">Mostra o nascondi gli articoli correlati nel lettore</string>
	<string name="site_settings_upload_and_link_image_hint">Consenti sempre di caricare l\'immagine completa</string>
	<string name="site_settings_image_width_hint">Ridimensiona le immagini negli articoli secondo questa larghezza</string>
	<string name="site_settings_format_hint">Imposta nuovo formato articolo</string>
	<string name="site_settings_category_hint">Imposta nuova categoria articolo</string>
	<string name="site_settings_location_hint">Aggiungi automaticamente i dati sulla posizione agli articoli</string>
	<string name="site_settings_password_hint">Modifica la password</string>
	<string name="site_settings_username_hint">Account utente attuale</string>
	<string name="site_settings_language_hint">Lingua in cui questo blog è scritto prevalentemente</string>
	<string name="site_settings_privacy_hint">Controlla chi può vedere questo sito</string>
	<string name="site_settings_address_hint">La modifica dell\'indirizzo non è attualmente supportata</string>
	<string name="site_settings_tagline_hint">Una breve descrizione o una frase accattivante per descrivere il tuo blog</string>
	<string name="site_settings_title_hint">Spiega in poche parole l\'argomento del sito</string>
	<string name="site_settings_whitelist_known_summary">Commenti da utenti conosciuti</string>
	<string name="site_settings_whitelist_all_summary">Commenti da tutti gli utenti</string>
	<string name="site_settings_threading_summary">%d livelli</string>
	<string name="site_settings_privacy_private_summary">Privato</string>
	<string name="site_settings_privacy_hidden_summary">Nascosto</string>
	<string name="site_settings_delete_site_title">Elimina sito</string>
	<string name="site_settings_privacy_public_summary">Pubblico</string>
	<string name="site_settings_blacklist_title">Blacklist</string>
	<string name="site_settings_moderation_hold_title">Sottoponi a moderazione</string>
	<string name="site_settings_multiple_links_title">Link nei commenti</string>
	<string name="site_settings_whitelist_title">Approva automaticamente</string>
	<string name="site_settings_paging_title">Paginazione</string>
	<string name="site_settings_threading_title">Flusso</string>
	<string name="site_settings_sort_by_title">Ordina per</string>
	<string name="site_settings_account_required_title">Gli utenti devono essere registrati</string>
	<string name="site_settings_identity_required_title">Devono includere nome ed e-mail</string>
	<string name="site_settings_receive_pingbacks_title">Ricevi pingback</string>
	<string name="site_settings_send_pingbacks_title">Invia pingback</string>
	<string name="site_settings_allow_comments_title">Consenti commenti</string>
	<string name="site_settings_default_format_title">Formato predefinito</string>
	<string name="site_settings_default_category_title">Categoria predefinita</string>
	<string name="site_settings_location_title">Abilita posizione</string>
	<string name="site_settings_address_title">Indirizzo</string>
	<string name="site_settings_title_title">Titolo sito</string>
	<string name="site_settings_tagline_title">Tagline</string>
	<string name="site_settings_this_device_header">Questo dispositivo</string>
	<string name="site_settings_discussion_new_posts_header">Impostazioni predefinite per nuovi articoli</string>
	<string name="site_settings_account_header">Account</string>
	<string name="site_settings_writing_header">Scrittura</string>
	<string name="newest_first">Prima i più recenti</string>
	<string name="site_settings_general_header">Generali</string>
	<string name="discussion">Discussione</string>
	<string name="privacy">Privacy</string>
	<string name="related_posts">Articoli correlati</string>
	<string name="comments">Commenti</string>
	<string name="close_after">Chiudi dopo</string>
	<string name="oldest_first">Prima i meno recenti</string>
	<string name="media_error_no_permission_upload">Non disponi delle autorizzazioni per caricare contenuti multimediali sul sito</string>
	<string name="never">Mai</string>
	<string name="unknown">Sconosciuto</string>
	<string name="reader_err_get_post_not_found">Questo articolo non esiste più</string>
	<string name="reader_err_get_post_not_authorized">Non disponi del permesso per visualizzare questo articolo</string>
	<string name="reader_err_get_post_generic">Impossibile recuperare questo articolo</string>
	<string name="blog_name_no_spaced_allowed">L\'indirizzo del sito non può contenere spazi</string>
	<string name="invalid_username_no_spaces">Il nome utente non può contenere spazi</string>
	<string name="reader_empty_followed_blogs_no_recent_posts_description">I siti che segui non hanno pubblicato nulla recentemente</string>
	<string name="reader_empty_followed_blogs_no_recent_posts_title">Nessun articolo recente</string>
	<string name="media_details_copy_url_toast">URL copiata negli appunti</string>
	<string name="edit_media">Modifica media</string>
	<string name="media_details_copy_url">Copia URL</string>
	<string name="media_details_label_date_uploaded">Caricato</string>
	<string name="media_details_label_date_added">Aggiunto</string>
	<string name="selected_theme">Tema selezionato</string>
	<string name="could_not_load_theme">Impossibile caricare il tema</string>
	<string name="theme_activation_error">Qualche cosa è andato storto. Impossibile attivare il tema.</string>
	<string name="theme_by_author_prompt_append">di %1$s</string>
	<string name="theme_prompt">Grazie per aver scelto %1$s</string>
	<string name="theme_try_and_customize">Prova e personalizza</string>
	<string name="theme_view">Visualizza</string>
	<string name="theme_details">Dettagli</string>
	<string name="theme_support">Supporto</string>
	<string name="theme_done">FATTO</string>
	<string name="theme_manage_site">GESTISCI SITO</string>
	<string name="title_activity_theme_support">Temi</string>
	<string name="theme_activate">Attiva</string>
	<string name="date_range_start_date">Data di inizio</string>
	<string name="date_range_end_date">Data di fine</string>
	<string name="current_theme">Tema corrente</string>
	<string name="customize">Personalizza</string>
	<string name="details">Dettagli</string>
	<string name="support">Supporto</string>
	<string name="active">Attivo</string>
	<string name="stats_referrers_spam_generic_error">Qualche cosa è andato storto durante l\'operazione. Lo stato dello spam non è cambiato.</string>
	<string name="stats_referrers_marking_not_spam">Contrassegna come non spam</string>
	<string name="stats_referrers_unspam">Non spam</string>
	<string name="stats_referrers_marking_spam">Contrassegna come spam</string>
	<string name="theme_auth_error_authenticate">Impossibile recuperare il tema: autenticazione utente fallita</string>
	<string name="post_published">Articolo pubblicato</string>
	<string name="page_published">Pagina pubblicata</string>
	<string name="post_updated">Articolo aggiornato</string>
	<string name="page_updated">Pagina aggiornata</string>
	<string name="stats_referrers_spam">Spam</string>
	<string name="theme_no_search_result_found">Nessun tema trovato.</string>
	<string name="media_file_name">Nome del file: %s</string>
	<string name="media_uploaded_on">Aggiornato il: %s</string>
	<string name="media_dimensions">Dimensioni: %s</string>
	<string name="upload_queued">Accodato</string>
	<string name="media_file_type">Tipo di file: %s</string>
	<string name="reader_label_gap_marker">Carica altri articoli</string>
	<string name="notifications_no_search_results">Nessun sito corrisponde a \'%s\'</string>
	<string name="search_sites">Ricerca siti</string>
	<string name="notifications_empty_view_reader">Visualizza nel Reader</string>
	<string name="unread">Non letto</string>
	<string name="notifications_empty_action_followers_likes">Ottieni notifiche: commenti ad articoli che hai letto.</string>
	<string name="notifications_empty_action_comments">Unisciti ad una conversazione: commenti su articoli di blog che segui.</string>
	<string name="notifications_empty_action_unread">Ravviva la conversazione: scrivi un nuovo articolo.</string>
	<string name="notifications_empty_action_all">Sii attivo! Commenta articoli dei blog che segui.</string>
	<string name="notifications_empty_likes">Nessun nuovo mi piace da mostrare... per ora.</string>
	<string name="notifications_empty_followers">Nessun nuovo utente ti segue... per ora.</string>
	<string name="notifications_empty_comments">Nessun nuovo commento... per ora.</string>
	<string name="notifications_empty_unread">Nessun articolo non letto!</string>
	<string name="stats_widget_error_jetpack_no_blogid">Accedi alla Statistiche nella app e quindi successivamente prova ad aggiungere il widget</string>
	<string name="stats_widget_error_readd_widget">Rimuovi il widget e aggiungilo nuovamente</string>
	<string name="stats_widget_error_no_visible_blog">Le statistiche non sono accessibili senza un blog visibile</string>
	<string name="stats_widget_error_no_permissions">Il tuo account WordPress.com non può accedere alle Statistiche di questo blog</string>
	<string name="stats_widget_error_no_account">Effettua il login su WordPress</string>
	<string name="stats_widget_error_generic">Le Statistiche non possno essere caricate</string>
	<string name="stats_widget_loading_data">Caricamento dati...</string>
	<string name="stats_widget_name_for_blog">Statistiche di oggi per %1$s</string>
	<string name="stats_widget_name">Statistiche di oggi di WordPress</string>
	<string name="add_location_permission_required">Per aggiungere una località occorre disporre dei permessi appositi</string>
	<string name="add_media_permission_required">Autorizzazioni richieste per aggiungere file multimediali</string>
	<string name="access_media_permission_required">Autorizzazioni richieste per accedere a file multimediali</string>
	<string name="stats_enable_rest_api_in_jetpack">Per visualizzare le tue statistiche, abilita il modulo JSON API di Jetpack.</string>
	<string name="error_open_list_from_notification">Questo articolo o questa pagina sono state pubblicate su un altro sito</string>
	<string name="reader_short_comment_count_multi">%s commenti</string>
	<string name="reader_short_comment_count_one">1 Commento</string>
	<string name="reader_label_submit_comment">SPEDISCI</string>
	<string name="reader_hint_comment_on_post">Rispondi all’articolo…</string>
	<string name="reader_discover_visit_blog">Visite %s</string>
	<string name="reader_discover_attribution_blog">Pubblicato originariamente su %s</string>
	<string name="reader_discover_attribution_author">Pubblicato originariamente da %s</string>
	<string name="reader_discover_attribution_author_and_blog">Pubblicato oginariamente da %1$s su %2$s</string>
	<string name="reader_short_like_count_multi">%s Mi piace </string>
	<string name="reader_short_like_count_one">1 Mi piace</string>
	<string name="reader_label_follow_count">%,d ti seguono</string>
	<string name="reader_short_like_count_none">Mi piace</string>
	<string name="reader_menu_tags">Modifica tag e blog</string>
	<string name="reader_title_post_detail">Reader articoli</string>
	<string name="local_draft_explainer">Questo articolo è una bozza locale che non è stata pubblicata</string>
	<string name="local_changes_explainer">Questo articolo contiene modifiche locali che non sono state pubblicate</string>
	<string name="notifications_push_summary">Impostazioni per le notifiche visualizzate sul dispositivo.</string>
	<string name="notifications_email_summary">Impostazioni per le notifiche inviate all\'e-mail associata al tuo account.</string>
	<string name="notifications_tab_summary">Impostazioni per le notifiche visualizzate nella scheda Notifiche.</string>
	<string name="notifications_disabled">Le notifiche della app sono state disattivate. Tocca qui per attivarle in Impostazioni.</string>
	<string name="notification_types">Tipi di notifiche</string>
	<string name="error_loading_notifications">Impossibile caricare le impostazioni delle notifiche</string>
	<string name="replies_to_your_comments">Risposte ai tuoi commenti</string>
	<string name="comment_likes">Mi piace dei commenti</string>
	<string name="notifications_tab">Scheda Notifiche</string>
	<string name="email">E-mail</string>
	<string name="app_notifications">Notifiche della app</string>
	<string name="notifications_comments_other_blogs">Commenti su altri siti</string>
	<string name="notifications_wpcom_updates">Aggiornamenti di WordPress.com</string>
	<string name="notifications_other">Altro</string>
	<string name="notifications_account_emails">Email da WordPress.com</string>
	<string name="notifications_account_emails_summary">Invieremo sempre e-mail importanti riguardanti il tuo account, ma potrai ricevere anche informazioni extra utili.</string>
	<string name="notifications_sights_and_sounds">Immagini e suoni</string>
	<string name="your_sites">I tuoi siti</string>
	<string name="stats_insights_latest_post_trend">Sono passati %1$s dalla pubblicazione di %2$s. Ecco com\'è andato finora l\'articolo...</string>
	<string name="stats_insights_latest_post_summary">Riassunto ultimo articolo</string>
	<string name="button_revert">Riconverti</string>
	<string name="days_ago">%d giorni fa</string>
	<string name="yesterday">Ieri</string>
	<string name="connectionbar_no_connection">Nessuna connessione</string>
	<string name="page_trashed">Pagina inviata al cestino</string>
	<string name="post_deleted">Articolo cancellato</string>
	<string name="post_trashed">Articolo inviato al cestino</string>
	<string name="stats_no_activity_this_period">Nessuna attivata in questo periodo</string>
	<string name="trashed">Cestinato</string>
	<string name="button_back">Indietro</string>
	<string name="page_deleted">Pagina cancellata</string>
	<string name="button_stats">Statistiche</string>
	<string name="button_trash">Cestino</string>
	<string name="button_preview">Anteprima</string>
	<string name="button_view">Visualizza</string>
	<string name="button_edit">Modifica</string>
	<string name="button_publish">Pubblica</string>
	<string name="my_site_no_sites_view_subtitle">Vuoi aggiungerne uno?</string>
	<string name="my_site_no_sites_view_title">No hai ancora nessun sito WordPress</string>
	<string name="my_site_no_sites_view_drake">Illustrazione</string>
	<string name="reader_toast_err_follow_blog_not_authorized">Non sei autorizzato ad accedere a questo blog</string>
	<string name="reader_toast_err_follow_blog_not_found">impossibile trovare questo blog</string>
	<string name="undo">Annulla</string>
	<string name="tabbar_accessibility_label_my_site">Il mio sito</string>
	<string name="tabbar_accessibility_label_me">Io</string>
	<string name="editor_toast_changes_saved">Cambiamenti salvati</string>
	<string name="passcodelock_prompt_message">Inserisci il tuo PIN</string>
	<string name="push_auth_expired">La richiesta è scaduta. Accedi a WordPress.com per riprovare.</string>
	<string name="stats_insights_best_ever">Le migliore visualizzazioni di sempre</string>
	<string name="stats_insights_most_popular_percent_views">%1$d%% di visite</string>
	<string name="ignore">Ignora</string>
	<string name="stats_insights_most_popular_hour">Ora più popolare.</string>
	<string name="stats_insights_most_popular_day">Giorno più popolare.</string>
	<string name="stats_insights_popular">Giorno e ora più popolari.</string>
	<string name="stats_insights_today">Statistiche odierne.</string>
	<string name="stats_insights_all_time">Articoli, visualizzazioni e visitatori dall\'inizio</string>
	<string name="stats_insights">Approfondimenti</string>
	<string name="stats_sign_in_jetpack_different_com_account">Per vedere le tue statistiche, accedi con l\'account WordPress.com che hai usato per connettere Jetpack.</string>
	<string name="stats_other_recent_stats_moved_label">Stai cercando le tue altre statististiche recenti? Le abbiamo spostaste nella pagina insights.</string>
	<string name="me_disconnect_from_wordpress_com">Disconnettiti da WordPress.com</string>
	<string name="me_btn_login_logout">Login/Logout</string>
	<string name="me_connect_to_wordpress_com">Connettiti a WordPress.com</string>
	<string name="site_picker_cant_hide_current_site">"%s" non è stato nascosto perchè è il sito corrente</string>
	<string name="me_btn_support">Aiuto e supporto</string>
	<string name="account_settings">Impostazioni account</string>
	<string name="site_picker_create_dotcom">Crea un sito su WordPress.com</string>
	<string name="site_picker_edit_visibility">Mostra/nascondi siti</string>
	<string name="site_picker_add_self_hosted">Aggiungi un sito self-hosted</string>
	<string name="site_picker_add_site">Aggiungi sito</string>
	<string name="my_site_btn_view_site">Visualizza il sito</string>
	<string name="my_site_btn_switch_site">Cambia sito</string>
	<string name="site_picker_title">Seleziona un sito</string>
	<string name="my_site_btn_view_admin">Visualizza l\'amministrazione</string>
	<string name="my_site_header_look_and_feel">Aspetto</string>
	<string name="my_site_header_publish">Pubblica</string>
	<string name="my_site_btn_site_settings">Impostazioni</string>
	<string name="my_site_btn_blog_posts">Articoli blog</string>
	<string name="reader_label_new_posts_subtitle">Tocca per visualizzarli</string>
	<string name="my_site_header_configuration">Configurazione</string>
	<string name="notifications_account_required">Collegati a WordPress.com per le notifiche</string>
	<string name="stats_unknown_author">Autore sconosciuto</string>
	<string name="signout">Disconnettiti</string>
	<string name="image_added">Immagine aggiunta</string>
	<string name="sign_out_wpcom_confirm">Disconnettendo il tuo account tutti i dati @%s WordPress.com da questa periferica, comprese le bozze locali e le modifiche locali.</string>
	<string name="hide">Nascondi</string>
	<string name="select_all">Seleziona tutto</string>
	<string name="deselect_all">Deseleziona tutto</string>
	<string name="show">Mostra</string>
	<string name="select_from_new_picker">Scegli più voci con il nuovo selezionatore</string>
	<string name="loading_blog_images">Recupero immagini</string>
	<string name="loading_blog_videos">Recupero video</string>
	<string name="no_media_sources">Impossibile recuperare elementi media</string>
	<string name="error_loading_blog_videos">Impossibile recuperare i video</string>
	<string name="error_loading_images">Errore nel caricamento delle immagini</string>
	<string name="error_loading_videos">Errore nel caricamento dei video</string>
	<string name="no_device_videos">Nessun video</string>
	<string name="no_blog_images">Nessuna immagine</string>
	<string name="no_blog_videos">Nessun video</string>
	<string name="no_device_images">Nessuna immagine</string>
	<string name="error_loading_blog_images">Impossibile recuperare le immagini</string>
	<string name="stats_generic_error">Le statistiche richieste non possono venir caricate</string>
	<string name="no_media">Nessun elemento media</string>
	<string name="loading_videos">Caricamento video</string>
	<string name="loading_images">Caricamento immagini</string>
	<string name="tab_title_device_videos">Video dispositivo</string>
	<string name="device">Dispositivo</string>
	<string name="tab_title_device_images">Immagini dispositivo</string>
	<string name="language">Lingua</string>
	<string name="add_to_post">Aggiungi ad articolo</string>
	<string name="media_picker_title">Seleziona media</string>
	<string name="take_photo">Fai una foto</string>
	<string name="take_video">Fai un video</string>
	<string name="tab_title_site_images">Immagini sito</string>
	<string name="tab_title_site_videos">Video sito</string>
	<string name="error_publish_no_network">Impossibile pubblicare perchè non c\'è una connessione. Salva come bozza.</string>
	<string name="editor_toast_invalid_path">Percorso file non valido</string>
	<string name="verification_code">Codice di verifica</string>
	<string name="invalid_verification_code">Codice di verifica non valido</string>
	<string name="verify">Verifica</string>
	<string name="two_step_footer_label">Inserisci il codice dalla tua app di autenticazione.</string>
	<string name="two_step_footer_button">Invia codice come messaggio di testo</string>
	<string name="two_step_sms_sent">Verifica i messaggi di testo per il codice di verifica.</string>
	<string name="sign_in_jetpack">Autentificati al tuo account WordPress.com  per connetterti a Jetpack.</string>
	<string name="auth_required">Autentificati nuovamente per continuare.</string>
	<string name="media_details_label_file_name">Nome file</string>
	<string name="media_details_label_file_type">Tipo file</string>
	<string name="media_fetching">Recupero file multimediali in corso…</string>
	<string name="posts_fetching">Recupero degli articoli in corso...</string>
	<string name="toast_err_post_uploading">Impossibile aprire l\'articolo durante il suo caricamento</string>
	<string name="pages_fetching">Recupero pagine in corso…</string>
	<string name="comments_fetching">Recupero commenti in corso...</string>
	<string name="stats_empty_search_terms_desc">Ottieni maggiori informazioni sul tuo traffico di ricerca scoprendo i termini utilizzati dai visitatori per trovare il tuo sito.</string>
	<string name="stats_followers_total_wpcom_paged">Mostra %1$d - %2$d di %3$s follower WordPress.com</string>
	<string name="stats_followers_total_email_paged">Mostra %1$d - %2$d di %3$s follower e-mail</string>
	<string name="error_notification_open">Impossibile aprire la notifica</string>
	<string name="publisher">Editore:</string>
	<string name="stats_view_authors">Autori</string>
	<string name="stats_view_search_terms">Termini di ricerca</string>
	<string name="stats_entry_search_terms">Termine di ricerca</string>
	<string name="stats_empty_search_terms">Nessun termine di ricerca registrato</string>
	<string name="stats_search_terms_unknown_search_terms">Termini di ricerca sconosciuti</string>
	<string name="reader_empty_posts_request_failed">Impossibile recuperare gli articoli</string>
	<string name="stats_months_and_years">Mesi ed anni</string>
	<string name="stats_recent_weeks">Settimane recenti</string>
	<string name="error_copy_to_clipboard">Si è verificato un errore durante la copia del testo negli appunti</string>
	<string name="stats_total">Totale</string>
	<string name="stats_overall">Tutto</string>
	<string name="stats_period">Periodo</string>
	<string name="logs_copied_to_clipboard">I log dell\'applicazione sono stati copiati negli appunti</string>
	<string name="reader_label_new_posts">Nuovi articoli</string>
	<string name="reader_empty_posts_in_blog">Il blog è vuoto</string>
	<string name="stats_average_per_day">Media giornaliera</string>
	<string name="post_uploading">Caricamento</string>
	<string name="reader_page_recommended_blogs">Siti che potrebbero piacerti</string>
	<string name="stats_comments_total_comments_followers">Totale articoli con commento dei follower: %1$s</string>
	<string name="stats_likes">Mi piace</string>
	<string name="stats_views">Visite</string>
	<string name="stats_view_publicize">Pubblicizza</string>
	<string name="stats_view_followers">Follower</string>
	<string name="stats_view_top_posts_and_pages">Articoli e pagine</string>
	<string name="stats_entry_followers">Follower</string>
	<string name="stats_totals_publicize">Follower</string>
	<string name="stats_empty_geoviews_desc">Esplora l\'elenco per scoprire quali Paesi e quali aree geografiche generano maggiore traffico verso il tuo sito.</string>
	<string name="stats_empty_geoviews">Nessun Paese registrato</string>
	<string name="stats_empty_top_posts_desc">Scopri quali sono i tuoi contenuti più visualizzati e controlla l\'andamento nel tempo di ogni articolo o pagina.</string>
	<string name="stats_empty_top_posts_title">Nessuna visita su articoli o pagine</string>
	<string name="stats_empty_referrers_desc">Scopri di più sulla visibilità del tuo sito individuando i siti web e i motori di ricerca che indirizzano la maggior parte del traffico sul tuo sito</string>
	<string name="stats_empty_clicks_desc">Se i tuoi contenuti includono link ad altri siti, scoprirai su quali link i visitatori fanno clic più spesso.</string>
	<string name="stats_empty_tags_and_categories">Articoli senza tag o pagine non visualizzate</string>
	<string name="stats_empty_tags_and_categories_desc">Ottieni una panoramica degli argomenti più popolari sul tuo sito, in base ai tuoi articoli migliori della settimana precedente.</string>
	<string name="stats_empty_top_authors_desc">Traccia le visualizzazioni degli articoli di ogni collaboratore e scopri i contenuti più popolari per ogni autore.</string>
	<string name="stats_empty_video">Nessun video riprodotto</string>
	<string name="stats_empty_comments_desc">Se sul tuo sito è possibile lasciare dei commenti, traccia i tuoi commentatori principali e scopri quali contenuti hanno generato le conversazioni più attive in base ai 1.000 commenti più recenti.</string>
	<string name="stats_empty_publicize">Nessun follower di Pubblicizza registrato</string>
	<string name="stats_empty_publicize_desc">Tieni traccia dei tuoi follower dai vari servizi di social networking utilizzando Pubblicizza.</string>
	<string name="stats_empty_followers">Nessun follower</string>
	<string name="stats_comments_by_authors">Per autori</string>
	<string name="stats_empty_followers_desc">Tieni traccia del numero totale di follower e da quanto tempo ognuno di essi segue il tuo sito web.</string>
	<string name="stats_followers_email_selector">E-mail</string>
	<string name="stats_followers_total_wpcom">Follower WordPress.com totali: %1$s</string>
	<string name="stats_followers_total_email">Follower e-mail totali: %1$s</string>
	<string name="stats_followers_wpcom_selector">wordpress.com</string>
	<string name="stats_view">Vista</string>
	<string name="stats_followers_seconds_ago">pochi secondi fa</string>
	<string name="stats_visitors">Visitatori</string>
	<string name="stats_pagination_label">Pagina %1$s di %2$s</string>
	<string name="stats_timeframe_years">Anni</string>
	<string name="stats_view_countries">Paesi</string>
	<string name="stats_view_videos">Video</string>
	<string name="stats_entry_clicks_link">Link</string>
	<string name="stats_entry_publicize">Servizio</string>
	<string name="stats_entry_top_commenter">Autore</string>
	<string name="stats_entry_video_plays">Video</string>
	<string name="stats_totals_followers">Da</string>
	<string name="stats_empty_referrers_title">Nessun referrer registrato</string>
	<string name="stats_empty_clicks_title">Nessun clic registrato</string>
	<string name="stats_empty_video_desc">Se hai caricato video tramite VideoPress, scopri quante volte vengono visualizzati.</string>
	<string name="stats_comments_by_posts_and_pages">Per articoli e pagine</string>
	<string name="stats_followers_days">%1$d giorni</string>
	<string name="stats_followers_a_minute_ago">un minuto fa</string>
	<string name="stats_followers_a_day">Un giorno</string>
	<string name="stats_followers_hours">%1$d ore</string>
	<string name="stats_followers_minutes">%1$d minuti</string>
	<string name="stats_followers_an_hour_ago">un\'ora fa</string>
	<string name="stats_followers_a_month">Un mese</string>
	<string name="stats_followers_years">%1$d anni</string>
	<string name="stats_followers_a_year">Un anno</string>
	<string name="stats_followers_months">%1$d mesi</string>
	<string name="stats_view_all">Visualizza tutte</string>
	<string name="stats_other_recent_stats_label">Altre statistiche recenti</string>
	<string name="stats_for">Statistiche per %s</string>
	<string name="themes_fetching">Recupero temi…</string>
	<string name="ssl_certificate_details">Dettagli</string>
	<string name="sure_to_remove_account">Rimuovere questo sito?</string>
	<string name="delete_sure_post">Cancella questo articolo</string>
	<string name="delete_sure">Cancella questa bozza</string>
	<string name="delete_sure_page">Cancella questa pagina</string>
	<string name="confirm_delete_multi_media">Cancellare gli elementi selezionati?</string>
	<string name="confirm_delete_media">Cancellare l\'elemento selezionato?</string>
	<string name="cab_selected">%d selezionati</string>
	<string name="media_gallery_date_range">Visualizzazione elementi media da %1$s a %2$s</string>
	<string name="faq_button">FAQ</string>
	<string name="reader_empty_comments">Ancora nessun commento</string>
	<string name="reader_label_comment_count_multi">%,d commenti</string>
	<string name="reader_label_like">Like</string>
	<string name="reader_empty_posts_liked">Non hai ancora fatto un like ad un articolo</string>
	<string name="browse_our_faq_button">Scorri le nostre FAQ</string>
	<string name="nux_help_description">Visita il nostro centro assistenza per ottenere le risposte alle domande più frequenti o visita il forum per porne di nuove</string>
	<string name="agree_terms_of_service">Creando un account accetti le affascinanti %1$sConizioni di Servizio%2$s</string>
	<string name="create_new_blog_wpcom">Crea un blog su WordPress.com</string>
	<string name="new_blog_wpcom_created">Il blog su WordPress.com è stato creato!</string>
	<string name="reader_empty_posts_in_tag">Nessun articolo con questo tag</string>
	<string name="reader_label_view_original">Visualizza l\'articolo originale</string>
	<string name="reader_label_comment_count_single">Un commento</string>
	<string name="reader_label_comments_closed">I commenti sono chiusi</string>
	<string name="reader_label_comments_on">Commenti su</string>
	<string name="reader_title_photo_viewer">%1$d di %2$d</string>
	<string name="error_publish_empty_post">Non è possibile pubblicare un articolo vuoto</string>
	<string name="error_refresh_unauthorized_posts">Non disponi del permesso di visualizzare o modificare gli articoli</string>
	<string name="error_refresh_unauthorized_pages">Non disponi del permesso di visualizzare o modificare le pagine</string>
	<string name="error_refresh_unauthorized_comments">Non disponi del permesso di visualizzare o modificare i commenti</string>
	<string name="older_month">Più vecchio di un mese</string>
	<string name="more">Altro</string>
	<string name="older_two_days">Più vecchio di 2 giorni</string>
	<string name="older_last_week">Più vecchio di una settimana</string>
	<string name="stats_no_blog">Non è possibile caricare le statistiche per il blog indicato</string>
	<string name="select_a_blog">Seleziona un sito WordPress</string>
	<string name="sending_content">Caricamento del contenuto %s</string>
	<string name="uploading_total">Caricamento %1$d di %2$d</string>
	<string name="mnu_comment_liked">Like</string>
	<string name="comment">Commento</string>
	<string name="comment_trashed">Commento cestinato</string>
	<string name="posts_empty_list">Ancora nessun articolo. Perché non crearne uno?</string>
	<string name="comment_reply_to_user">Replica a %s</string>
	<string name="pages_empty_list">Ancora nessuna pagina. Perché non crearne una?</string>
	<string name="media_empty_list_custom_date">Nessun elemento media in questo intervallo di tempo</string>
	<string name="posting_post">Pubblicazione di "%s"</string>
	<string name="signing_out">Scollegamento...</string>
	<string name="reader_empty_followed_blogs_title">Non stai ancora seguendo alcun sito</string>
	<string name="reader_toast_err_generic">Impossibile eseguire questa azione</string>
	<string name="reader_toast_err_block_blog">Impossibile bloccare questo blog</string>
	<string name="reader_toast_blog_blocked">Gli articoli di questo blog non appariranno più</string>
	<string name="reader_menu_block_blog">Blocca questo blog</string>
	<string name="contact_us">Contattaci</string>
	<string name="hs__conversation_detail_error">Descrivi il problema che si è presentato</string>
	<string name="hs__new_conversation_header">Chat di supporto</string>
	<string name="hs__conversation_header">Chat di supporto</string>
	<string name="hs__username_blank_error">Inserisce un nome valido</string>
	<string name="hs__invalid_email_error">Inserisci un email valida</string>
	<string name="add_location">Aggiungi una località</string>
	<string name="current_location">Località corrente</string>
	<string name="search_location">Cerca</string>
	<string name="edit_location">Modifica</string>
	<string name="search_current_location">Rintraccia</string>
	<string name="preference_send_usage_stats">Invia le statistiche</string>
	<string name="preference_send_usage_stats_summary">Invia automaticamente le statistiche di utilizzo per aiutarci a migliorare WordPress per Android</string>
	<string name="update_verb">Aggiorna</string>
	<string name="schedule_verb">Pianifica</string>
	<string name="reader_title_subs">Tag e blog</string>
	<string name="reader_page_followed_tags">Tag seguiti</string>
	<string name="reader_label_followed_blog">Blog seguito</string>
	<string name="reader_toast_err_get_blog_info">Impossibile mostrare questo blog</string>
	<string name="reader_toast_err_already_follow_blog">Segui già questo blog</string>
	<string name="reader_toast_err_follow_blog">Impossibile seguire questo blog</string>
	<string name="reader_toast_err_unfollow_blog">Impossibile smettere di seguire questo blog</string>
	<string name="reader_empty_recommended_blogs">Nessun blog consigliato</string>
	<string name="reader_label_tag_preview">Articolo con tag %s</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">Siti che segui</string>
	<string name="reader_hint_add_tag_or_url">Inserisci una URL o untag da seguire</string>
	<string name="saving">Salvataggio in corso...</string>
	<string name="media_empty_list">Nessun media</string>
	<string name="ptr_tip_message">Suggerimento: scorri il dito verso il basso per aggiornare</string>
	<string name="help">Aiuto</string>
	<string name="forgot_password">Password dimenticata?</string>
	<string name="forums">Forum</string>
	<string name="help_center">Centro assistenza</string>
	<string name="ssl_certificate_error">Certificato SSL non valido</string>
	<string name="ssl_certificate_ask_trust">Se in genere ti connetti al sito senza problemi, questo errore potrebbe significare che qualcuno sta tentando di impersonare il sito, pertanto non dovresti continuare. Desideri comunque confermare l\'affidabilità del certificato?</string>
	<string name="could_not_remove_account">Impossibile rimuovere il sito</string>
	<string name="out_of_memory">Memoria del dispositivo esaurita</string>
	<string name="no_network_message">Nessuna rete disponibile</string>
	<string name="gallery_error">Impossibile recuperare il file</string>
	<string name="blog_not_found">Si è verificato un errore durante l\'accesso a questo blog</string>
	<string name="wait_until_upload_completes">Attendi la fine del caricamento</string>
	<string name="theme_fetch_failed">Impossibile recuperare i temi</string>
	<string name="theme_set_failed">Impossibile impostare il tema</string>
	<string name="theme_auth_error_message">Assicurati di disporre dei privilegi per impostare i temi</string>
	<string name="comments_empty_list">Nessun commento</string>
	<string name="mnu_comment_unspam">Non spam</string>
	<string name="no_site_error">Impossibile connettersi al sito WordPress</string>
	<string name="adding_cat_failed">Impossibile aggiungere la categoria</string>
	<string name="adding_cat_success">Categoria aggiunta correttamente</string>
	<string name="cat_name_required">Il campo Nome categoria è obbligatorio</string>
	<string name="category_automatically_renamed">Il valore del campo Nome categoria %1$s non è valido. È stato rinominato in %2$s.</string>
	<string name="no_account">Impossibile trovare un account WordPress. Aggiungi un account e riprova</string>
	<string name="sdcard_message">Occorre una scheda SD per caricare i file</string>
	<string name="stats_empty_comments">Ancora nessun commento</string>
	<string name="stats_bar_graph_empty">Nessuna statistica disponibile</string>
	<string name="reply_failed">Impossibile rispondere</string>
	<string name="notifications_empty_list">Nessuna notifica</string>
	<string name="error_delete_post">Si è verificato un errore durante l\'eliminazione di %s</string>
	<string name="error_refresh_posts">Impossibile aggiornare gli articoli al momento</string>
	<string name="error_refresh_pages">Impossibile aggiornare le pagine al momento</string>
	<string name="error_refresh_notifications">Impossibile aggiornare le notifiche al momento</string>
	<string name="error_refresh_comments">Impossibile aggiornare i commenti al momento</string>
	<string name="error_refresh_stats">Impossibile aggiornare le statistiche al momento</string>
	<string name="error_generic">Si è verificato un errore</string>
	<string name="error_moderate_comment">Si è verificato un errore durante la moderazione</string>
	<string name="error_edit_comment">Si è verificato un errore durante la modifica del commento</string>
	<string name="error_upload">Si è verificato un errore durante il caricamento di %s</string>
	<string name="error_load_comment">Impossibile caricare il commento</string>
	<string name="error_downloading_image">Errore durante il download dell\'immagine</string>
	<string name="passcode_wrong_passcode">PIN errato</string>
	<string name="invalid_email_message">Il tuo indirizzo e-mail non è valido</string>
	<string name="invalid_password_message">La password deve contenere almeno 4 caratteri</string>
	<string name="invalid_username_too_short">Il nome utente deve contenere più di 4 caratteri</string>
	<string name="invalid_username_too_long">Il nome utente può contenere fino a 61 caratteri</string>
	<string name="username_only_lowercase_letters_and_numbers">Il nome utente può contenere solo lettere minuscole (a-z) e numeri</string>
	<string name="username_required">Inserisci un nome utente</string>
	<string name="username_not_allowed">Nome utente non consentito</string>
	<string name="username_must_be_at_least_four_characters">Il nome utente deve contenere almeno 4 caratteri</string>
	<string name="username_contains_invalid_characters">Il nome utente non può includere il carattere "_"</string>
	<string name="username_must_include_letters">Il nome utente deve includere almeno 1 lettera (a-z)</string>
	<string name="email_invalid">Inserisci un indirizzo e-mail valido</string>
	<string name="email_not_allowed">Indirizzo e-mail non consentito</string>
	<string name="username_exists">Il nome utente esiste già</string>
	<string name="email_exists">L\'indirizzo e-mail è già in uso</string>
	<string name="username_reserved_but_may_be_available">Il nome utente è attualmente riservato, ma potrebbe essere disponibile tra un paio di giorni</string>
	<string name="blog_name_required">Inserisci un indirizzo del sito</string>
	<string name="blog_name_not_allowed">Indirizzo del sito non consentito</string>
	<string name="blog_name_must_be_at_least_four_characters">Il sito deve contenere almeno 4 caratteri</string>
	<string name="blog_name_must_be_less_than_sixty_four_characters">Il sito deve contenere non più di 64 caratteri</string>
	<string name="blog_name_contains_invalid_characters">L\'indirizzo del sito non può includere il carattere "_"</string>
	<string name="blog_name_cant_be_used">Non puoi utilizzare questo indirizzo del sito</string>
	<string name="blog_name_only_lowercase_letters_and_numbers">L\'indirizzo del sito può contenere solo lettere minuscole (a-z) e numeri</string>
	<string name="blog_name_exists">Il sito esiste già</string>
	<string name="blog_name_reserved">Il sito è riservato</string>
	<string name="blog_name_reserved_but_may_be_available">Il sito è attualmente riservato, ma potrebbe essere disponibile tra un paio di giorni</string>
	<string name="username_or_password_incorrect">Il nome utente o la password immessi non sono corretti</string>
	<string name="nux_cannot_log_in">Impossibile effettuare l\'accesso</string>
	<string name="invalid_url_message">Verifica la validità dell\'URL inserita</string>
	<string name="blog_removed_successfully">Sito rimosso correttamente</string>
	<string name="remove_account">Rimuovi sito</string>
	<string name="xmlrpc_error">Impossibile connettersi. Inserisci il percorso completo a xmlrpc.php del tuo sito e riprova.</string>
	<string name="select_categories">Seleziona le categorie</string>
	<string name="account_details">Dati dell\'account</string>
	<string name="edit_post">Modifica articolo</string>
	<string name="add_comment">Aggiungi commento</string>
	<string name="connection_error">Errore di connessione</string>
	<string name="cancel_edit">Annulla la modifica</string>
	<string name="scaled_image_error">Inserisci un valore della larghezza in scala valido</string>
	<string name="post_not_found">Si è verificato un errore durante il caricamento dell\'articolo. Aggiorna gli articoli e riprova.</string>
	<string name="learn_more">Ulteriori informazioni</string>
	<string name="media_gallery_settings_title">Impostazioni della galleria</string>
	<string name="media_gallery_image_order">Ordine immagini</string>
	<string name="media_gallery_num_columns">Numero di colonne</string>
	<string name="media_gallery_type_thumbnail_grid">Griglia miniatura</string>
	<string name="media_gallery_edit">Modifica galleria</string>
	<string name="media_error_no_permission">Non disponi dell\'autorizzazione a visualizzare la libreria multimediale</string>
	<string name="cannot_delete_multi_media_items">Impossibile eliminare il file al momento. Riprova in seguito.</string>
	<string name="themes_live_preview">Anteprima live</string>
	<string name="theme_current_theme">Tema corrente</string>
	<string name="theme_premium_theme">Tema Premium</string>
	<string name="link_enter_url_text">Testo link (opzionale)</string>
	<string name="create_a_link">Crea un link</string>
	<string name="page_settings">Impostazioni pagina</string>
	<string name="local_draft">Bozza locale</string>
	<string name="upload_failed">Caricamento non riuscito</string>
	<string name="horizontal_alignment">Allineamento orizzontale</string>
	<string name="file_not_found">Impossibile trovare il file da caricare. È stato eliminato o spostato?</string>
	<string name="post_settings">Impostazioni articolo</string>
	<string name="delete_post">Elimina articolo</string>
	<string name="delete_page">Elimina pagina</string>
	<string name="comment_status_approved">Approvato</string>
	<string name="comment_status_unapproved">In attesa</string>
	<string name="comment_status_spam">Spam</string>
	<string name="comment_status_trash">Eliminato nel cestino</string>
	<string name="edit_comment">Modifica commento</string>
	<string name="mnu_comment_approve">Approva</string>
	<string name="mnu_comment_unapprove">Rimuovi approvazione</string>
	<string name="mnu_comment_spam">Spam</string>
	<string name="mnu_comment_trash">Cestina</string>
	<string name="dlg_approving_comments">Approvazione in corso</string>
	<string name="dlg_unapproving_comments">Rimozione dell\'approvazione in corso</string>
	<string name="dlg_spamming_comments">Contrassegno come spam in corso</string>
	<string name="dlg_trashing_comments">Invio al cestino in corso</string>
	<string name="dlg_confirm_trash_comments">Inviare al cestino?</string>
	<string name="trash_yes">Cestina</string>
	<string name="trash_no">Non cestinare</string>
	<string name="trash">Cestina</string>
	<string name="author_name">Nome autore</string>
	<string name="author_email">E-mail autore</string>
	<string name="author_url">URL autore</string>
	<string name="hint_comment_content">Commento</string>
	<string name="saving_changes">Salvataggio delle modifiche in corso</string>
	<string name="sure_to_cancel_edit_comment">Annullare la modifica a questo commento?</string>
	<string name="content_required">Il commento è richiesto</string>
	<string name="toast_comment_unedited">Il commento non è stato modificato</string>
	<string name="delete_draft">Elimina bozza</string>
	<string name="preview_page">Anteprima pagina</string>
	<string name="preview_post">Anteprima articolo</string>
	<string name="comment_added">Commento aggiunto correttamente</string>
	<string name="post_not_published">Articolo non pubblicato</string>
	<string name="page_not_published">Pagina non pubblicata</string>
	<string name="view_in_browser">Visualizza nel browser</string>
	<string name="add_new_category">Aggiungi nuova categoria</string>
	<string name="category_name">Nome categoria</string>
	<string name="category_slug">Abbreviazione categoria (opzionale)</string>
	<string name="category_desc">Descrizione categoria (opzionale)</string>
	<string name="category_parent">Categoria padre (opzionale)</string>
	<string name="share_action_post">Nuovo articolo</string>
	<string name="share_action_media">Libreria multimediale</string>
	<string name="file_error_create">Impossibile creare un file temporaneo per il caricamento. Assicurati che vi sia spazio libero sufficiente sul dispositivo.</string>
	<string name="location_not_found">Posizione non nota</string>
	<string name="open_source_licenses">Licenze Open Source</string>
	<string name="pending_review">In attesa di revisione</string>
	<string name="http_credentials">Credenziali HTTP (opzionale)</string>
	<string name="http_authorization_required">Autorizzazione richiesta</string>
	<string name="post_format">Formato articolo</string>
	<string name="new_post">Nuovo articolo</string>
	<string name="new_media">Nuovo supporto</string>
	<string name="view_site">Visualizza sito</string>
	<string name="privacy_policy">Informativa sulla privacy</string>
	<string name="local_changes">Modifiche locali</string>
	<string name="image_settings">Impostazioni immagini</string>
	<string name="add_account_blog_url">Indirizzo blog</string>
	<string name="wordpress_blog">Blog di WordPress</string>
	<string name="error_blog_hidden">Questo blog è nascosto e non può essere caricato. Abilitalo nuovamente nelle impostazioni e riprova.</string>
	<string name="fatal_db_error">Si è verificato un errore durante la creazione del database delle app. Prova a reinstallare l\'app.</string>
	<string name="jetpack_message_not_admin">Il plugin Jetpack è richiesto per le statistiche. Contatta l\'amministratore del sito.</string>
	<string name="reader_title_applog">Registro applicazione</string>
	<string name="reader_share_link">Condividi il link</string>
	<string name="reader_toast_err_add_tag">Impossibile aggiungere questo tag</string>
	<string name="reader_toast_err_remove_tag">Impossibile rimuovere questo tag</string>
	<string name="required_field">Campo obbligatorio</string>
	<string name="email_hint">Indirizzo e-mail</string>
	<string name="site_address">Indirizzo del tuo sito (URL)</string>
	<string name="email_cant_be_used_to_signup">Non puoi utilizzare questo indirizzo e-mail per effettuare l\'accesso. Si sono verificati dei problemi con questi indirizzi, poiché bloccano i nostri messaggi. Usa un altro provider del servizio di posta elettronica.</string>
	<string name="email_reserved">Questo indirizzo e-mail è già stato utilizzato. Controlla l\'e-mail di attivazione che ti abbiamo inviato. Se non esegui l\'attivazione, puoi riprovare tra alcuni giorni.</string>
	<string name="blog_name_must_include_letters">L\'indirizzo del sito deve includere almeno 1 lettera (a-z)</string>
	<string name="blog_name_invalid">Indirizzo del sito non valido</string>
	<string name="blog_title_invalid">Titolo del sito non valido</string>
	<string name="notifications_empty_all">Nessuna notifica... per ora.</string>
	<string name="invalid_site_url_message">Controlla che l\'URL del sito sia valido</string>
	<string name="deleting_page">Eliminando la pagina</string>
	<string name="deleting_post">Eliminando l\'articolo</string>
	<string name="share_url_post">Condividi l\'articolo</string>
	<string name="share_url_page">Condividi la pagina</string>
	<string name="share_link">Condividi il link</string>
	<string name="creating_your_account">Creazione dell\'account in corso</string>
	<string name="creating_your_site">Creazione del sito in corso</string>
	<string name="reader_empty_posts_in_tag_updating">Recupero post in corso...</string>
	<string name="error_refresh_media">Si è verificato un errore durante l\'aggiornamento della libreria multimediale. Ritenta in un secondo momento.</string>
	<string name="reader_likes_you_and_multi">Piace a te e ad altri %,d</string>
	<string name="reader_likes_multi">Piace a %,d persone</string>
	<string name="reader_toast_err_get_comment">Impossibile recuperare questo commento</string>
	<string name="reader_label_reply">Rispondi</string>
	<string name="video">Video</string>
	<string name="download">Download file multimediale in corso</string>
	<string name="comment_spammed">Commento contrassegnato come spam</string>
	<string name="cant_share_no_visible_blog">Non è possibile condividere su WordPress senza un blog visibile</string>
	<string name="select_time">Seleziona orario</string>
	<string name="reader_likes_you_and_one">Piace a te e a un\'altra persona</string>
	<string name="select_date">Seleziona data</string>
	<string name="pick_photo">Seleziona foto</string>
	<string name="account_two_step_auth_enabled">Per questo account è attiva l\'autenticazione in due fasi. Visita le tue impostazioni di sicurezza in WordPress.com e genera una password specifica per l\'applicazione.</string>
	<string name="pick_video">Seleziona video</string>
	<string name="reader_toast_err_get_post">Impossibile recuperare questo post</string>
	<string name="validating_user_data">Convalida dati utente in corso</string>
	<string name="validating_site_data">Convalida dati sito in corso</string>
	<string name="reader_empty_followed_blogs_description">Ma non preoccuparti, fai un tap sull\'icona in alto a destra per iniziare ad esplorare!</string>
	<string name="password_invalid">Devi impostare una password più sicura. Usa 7 o più caratteri sia minuscoli che maiuscoli, numeri o caratteri speciali.</string>
	<string name="nux_tap_continue">Continua</string>
	<string name="nux_welcome_create_account">Crea account</string>
	<string name="nux_add_selfhosted_blog">Aggiungi sito self-hosted</string>
	<string name="nux_oops_not_selfhosted_blog">Accedi a WordPress.com</string>
	<string name="signing_in">Collegamento...</string>
	<string name="media_add_popup_title">Aggiungi alla libreria multimediale</string>
	<string name="media_add_new_media_gallery">Crea una galleria</string>
	<string name="empty_list_default">Questo elenco è vuoto</string>
	<string name="select_from_media_library">Seleziona dalla libreria multimediale</string>
	<string name="jetpack_message">Il plugin Jetpack è necessario per accedere alle statistiche. Vuoi installare Jetpack?</string>
	<string name="jetpack_not_found">Il plugin Jetpack non è stato trovato</string>
	<string name="reader_label_added_tag">Aggiunto %s</string>
	<string name="reader_label_removed_tag">Rimosso %s</string>
	<string name="reader_likes_one">Ad una persona piace questo</string>
	<string name="reader_likes_only_you">Ti piace questo</string>
	<string name="reader_untitled_post">(Senza titolo)</string>
	<string name="reader_share_subject">Condividi da %s</string>
	<string name="reader_btn_share">Condividi</string>
	<string name="reader_btn_follow">Segui</string>
	<string name="reader_btn_unfollow">Seguendo</string>
	<string name="reader_toast_err_comment_failed">Non riesco ad inviare il tuo commento</string>
	<string name="reader_toast_err_tag_exists">Stai già seguendo questo tag</string>
	<string name="reader_toast_err_tag_invalid">Questo non è un tag valido</string>
	<string name="reader_toast_err_share_intent">Impossibile condividere</string>
	<string name="reader_toast_err_view_image">Impossibile visualizzare l\'immagine</string>
	<string name="reader_toast_err_url_intent">Impossibile aprire %s</string>
	<string name="reader_empty_followed_tags">Non stai seguendo alcun tag</string>
	<string name="create_account_wpcom">Apri un account su WordPress.com</string>
	<string name="connecting_wpcom">Collegamento con WordPress.com in corso</string>
	<string name="limit_reached">Limite raggiunto. Si consiglia di attendere almeno un minuto prima di riprovare. Se l\'errore persiste, o se pensi che sia un errore del sistema, si prega di contattare il supporto.</string>
	<string name="username_invalid">Nome utente non valido</string>
	<string name="nux_tutorial_get_started_title">Inizia!</string>
	<string name="reader_hint_comment_on_comment">Rispondi al commento…</string>
	<string name="button_next">Successivo</string>
	<string name="themes">Temi</string>
	<string name="all">Tutto</string>
	<string name="images">Immagini</string>
	<string name="custom_date">Data personalizzata</string>
	<string name="media_add_popup_capture_photo">Scatta una foto</string>
	<string name="media_add_popup_capture_video">Registra un video</string>
	<string name="media_edit_title_text">Titolo</string>
	<string name="media_edit_description_text">Descrizione</string>
	<string name="media_edit_title_hint">Inserisci un titolo qui</string>
	<string name="media_edit_description_hint">Inserisci una descrizione qui</string>
	<string name="theme_set_success">Tema impostato con successo!</string>
	<string name="share_action_title">Aggiungi a...</string>
	<string name="stats_view_tags_and_categories">Tag &amp; Categorie</string>
	<string name="stats_timeframe_today">Oggi</string>
	<string name="stats_timeframe_yesterday">Ieri</string>
	<string name="stats_timeframe_days">Giorni</string>
	<string name="stats_timeframe_weeks">Settimane</string>
	<string name="stats_totals_views">Visualizzazioni</string>
	<string name="stats_totals_clicks">Click</string>
	<string name="media_gallery_image_order_random">Casuale</string>
	<string name="media_gallery_image_order_reverse">Invertito</string>
	<string name="media_gallery_type">Tipo</string>
	<string name="stats_entry_country">Paese</string>
	<string name="stats_entry_posts_and_pages">Titolo</string>
	<string name="media_edit_failure">Aggiornamento fallito</string>
	<string name="passcode_preference_title">PIN bloccato</string>
	<string name="passcode_turn_off">Disattiva il blocco PIN</string>
	<string name="passcode_turn_on">Attiva il blocco PIN</string>
	<string name="passcode_change_passcode">Cambia PIN</string>
	<string name="passcode_enter_passcode">Inserisci il tuo PIN</string>
	<string name="passcode_enter_old_passcode">Inserisci il vecchio PIN</string>
	<string name="passcode_re_enter_passcode">Reimmetti il tuo PIN</string>
	<string name="media_gallery_type_tiled">A riquadri.</string>
	<string name="passcode_set">Imposta PIN</string>
	<string name="themes_details_label">Dettagli</string>
	<string name="themes_features_label">Funzionalità</string>
	<string name="theme_activate_button">Attiva</string>
	<string name="media_edit_caption_text">Didascalia</string>
	<string name="media_edit_caption_hint">Inserire qui la didascalia</string>
	<string name="stats">Statistiche</string>
	<string name="stats_timeframe_months">Mesi</string>
	<string name="stats_view_referrers">Referrer</string>
	<string name="post_excerpt">Riassunto</string>
	<string name="stats_entry_referrers">Referrer</string>
	<string name="stats_view_clicks">Clic</string>
	<string name="media_gallery_type_circles">Cerchi</string>
	<string name="stats_entry_authors">Autore</string>
	<string name="media_gallery_type_squares">Riquadri</string>
	<string name="stats_entry_tags_and_categories">Argomenti</string>
	<string name="theme_activating_button">Attivazione</string>
	<string name="passcode_manage">Gestione blocco PIN</string>
	<string name="media_gallery_type_slideshow">Visualizza come slideshow</string>
	<string name="share_action">Condividi</string>
	<string name="stats_totals_plays">Numero di riproduzioni</string>
	<string name="theme_auth_error_title">Impossibile recuperare i temi</string>
	<string name="media_edit_success">Aggiornato</string>
	<string name="unattached">Non allegato</string>
	<string name="stats_view_visitors_and_views">Visitatori e visite</string>
	<string name="upload">Caricamento</string>
	<string name="discard">Rimuovi</string>
	<string name="sign_in">Accedi</string>
	<string name="notifications">Notifiche</string>
	<string name="note_reply_successful">Risposta pubblicata</string>
	<string name="follows">Segui</string>
	<string name="new_notifications">%d nuove notifiche</string>
	<string name="more_notifications">e altre %d.</string>
	<string name="loading">Caricamento in corso…</string>
	<string name="httpuser">HTTP nome utente</string>
	<string name="httppassword">Password HTTP</string>
	<string name="error_media_upload">Si è verificato un errore durante il caricamento</string>
	<string name="post_content">Contenuto (tocca per aggiungere testo e file multimediali)</string>
	<string name="publish_date">Pubblica</string>
	<string name="content_description_add_media">Aggiungi file multimediale</string>
	<string name="incorrect_credentials">Nome utente o password errati</string>
	<string name="password">Password</string>
	<string name="username">Nome utente</string>
	<string name="reader">Lettore</string>
	<string name="width">Larghezza</string>
	<string name="featured">Usa come immagine in evidenza</string>
	<string name="featured_in_post">Includi immagine nel contenuto dell\'articolo</string>
	<string name="no_network_title">Nessuna rete disponibile</string>
	<string name="pages">Pagine</string>
	<string name="caption">Didascalia (facoltativa)</string>
	<string name="posts">Articoli</string>
	<string name="anonymous">Anonimo</string>
	<string name="page">Pagina</string>
	<string name="post">Articolo</string>
	<string name="ok">OK</string>
	<string name="blogusername">nomeutenteblog</string>
	<string name="upload_scaled_image">Carica e inserisci link all\'immagine ridimensionata</string>
	<string name="scaled_image">Larghezza immagine ridimensionata</string>
	<string name="scheduled">Programmato</string>
	<string name="link_enter_url">URL</string>
	<string name="uploading">Caricamento...</string>
	<string name="version">Versione</string>
	<string name="tos">Condizioni del servizio</string>
	<string name="app_title">WordPress per Android</string>
	<string name="max_thumbnail_px_width">Larghezza predefinita immagine</string>
	<string name="image_alignment">Allineamento</string>
	<string name="refresh">Aggiorna</string>
	<string name="untitled">Senza titolo</string>
	<string name="edit">Modifica</string>
	<string name="post_id">Articolo</string>
	<string name="page_id">Pagina</string>
	<string name="immediately">Subito</string>
	<string name="post_password">Password (facoltativa)</string>
	<string name="quickpress_add_alert_title">Imposta nome breve</string>
	<string name="today">Oggi</string>
	<string name="settings">Impostazioni</string>
	<string name="share_url">Condividi URL</string>
	<string name="quickpress_window_title">Selezionare il blog per la scelta rapida QuickPress</string>
	<string name="quickpress_add_error">Il nome breve non può essere vuoto</string>
	<string name="post_private">Privato</string>
	<string name="publish_post">Pubblica</string>
	<string name="draft">Bozza</string>
	<string name="upload_full_size_image">Carica e collega all\'immagine a pieno formato</string>
	<string name="title">Titolo</string>
	<string name="categories">Categorie</string>
	<string name="tags_separate_with_commas">Etichette (separate da una virgola)</string>
	<string name="dlg_deleting_comments">Eliminazione commenti</string>
	<string name="notification_vibrate">Vibrazione</string>
	<string name="notification_blink">Esegui notifica visiva</string>
	<string name="notification_sound">Suono di notifica</string>
	<string name="status">Stato</string>
	<string name="location">Posizione</string>
	<string name="sdcard_title">Scheda SD necessaria</string>
	<string name="select_video">Seleziona un video dalla Galleria</string>
	<string name="media">Media</string>
	<string name="delete">Elimina</string>
	<string name="none">Nessuna</string>
	<string name="blogs">Blog</string>
	<string name="select_photo">Seleziona una foto dalla galleria</string>
	<string name="cancel">Annulla</string>
	<string name="save">Salva</string>
	<string name="add">Aggiungi</string>
	<string name="no">No</string>
	<string name="error">Errore</string>
	<string name="category_refresh_error">Errore durante l\'aggiornamento delle categorie</string>
	<string name="preview">Anteprima</string>
	<string name="on">on</string>
	<string name="yes">Sì</string>
	<string name="reply">Rispondi</string>
	<string name="notification_settings">Impostazioni notifiche</string>
</resources>
