<?xml version="1.0" encoding="utf-8"?>
<resources>
	<string name="export_your_content">Exportujem Váš obsah...</string>
	<string name="exporting_content_progress">Exportujem obsah...</string>
	<string name="are_you_sure">Ste si istý?</string>
	<string name="export_site_hint">Exportovať Vašu stránku ako XML súbor</string>
	<string name="keep_your_content">Ponechať Váš obsah</string>
	<string name="me_btn_app_settings">Nastavenia aplikácie</string>
	<string name="comments_empty_list_filtered_trashed">Žiadne komentáre zahodené</string>
	<string name="comments_empty_list_filtered_approved">Žiadne komentáre schválené</string>
	<string name="button_skip">Preskočiť</string>
	<string name="post_format_video">Video</string>
	<string name="post_format_gallery">Galéria</string>
	<string name="post_format_image">Obrázok</string>
	<string name="post_format_link">Odkaz</string>
	<string name="post_format_audio">Audio</string>
	<string name="notif_community">Komunita</string>
	<string name="notif_research">Výskum</string>
	<string name="site_settings_list_editor_summary_one">1 položka</string>
	<string name="days_quantity_one">1 deň</string>
	<string name="filter_trashed_posts">Zahodené</string>
	<string name="filter_scheduled_posts">Naplánované</string>
	<string name="filter_draft_posts">Koncepty</string>
	<string name="web_address">Webová adresa</string>
	<string name="editor_post_settings_set_featured_image">Nastaviť ilustračný obrázok</string>
	<string name="editor_post_settings_featured_image">Ilustračný obrázok</string>
	<string name="error_post_account_settings">Nepodarilo sa uložiť nastavenia vášho účtu</string>
	<string name="error_post_my_profile">Nepodarilo sa uložiť váš profil</string>
	<string name="error_fetch_account_settings">Nepodarilo sa načítať nastavenia vášho účtu</string>
	<string name="error_fetch_my_profile">Nepodarilo sa načítať váš profil</string>
	<string name="site_settings_unknown_language_code_error">Kód jazyka nebol rozpoznaný</string>
	<string name="site_settings_threading_dialog_description">Povoliť vnorenie komentárov do vlákien.</string>
	<string name="site_settings_threading_dialog_header">Vlákna do úrovne</string>
	<string name="remove">Odstrániť</string>
	<string name="search">Hľadať</string>
	<string name="add_category">Pridať kategóriu</string>
	<string name="site_settings_image_original_size">Pôvodná veľkosť</string>
	<string name="about_me_hint">Pár slov o vás...</string>
	<string name="first_name">Meno</string>
	<string name="last_name">Priezvisko</string>
	<string name="site_privacy_public_desc">Povoliť indexovanie vašej stránky vyhľadávačmi</string>
	<string name="site_privacy_hidden_desc">Vypnúť indexovanie vašej stránky vyhľadávačmi</string>
	<string name="blog_name_no_spaced_allowed">Adresa webovej stránky nemôže obsahovať medzery</string>
	<string name="invalid_username_no_spaces">Používateľské meno nemôže obsahovať medzery</string>
	<string name="reader_empty_followed_blogs_no_recent_posts_description">Webové stránky, ktoré sledujete v poslednej dobe nezverejnili nič.</string>
	<string name="reader_empty_followed_blogs_no_recent_posts_title">Žiadne nové články</string>
	<string name="media_details_copy_url_toast">URL adresa skopírovaná do schránky</string>
	<string name="edit_media">Upraviť súbory</string>
	<string name="media_details_copy_url">Kopírovať URL adresu</string>
	<string name="media_details_label_date_uploaded">Nahraté</string>
	<string name="media_details_label_date_added">Pridané</string>
	<string name="selected_theme">Zvolená téma</string>
	<string name="could_not_load_theme">Nie je možné načítať tému</string>
	<string name="theme_activation_error">Niečo nezafungovalo. Nie je možné aktivovať tému.</string>
	<string name="theme_by_author_prompt_append"> od %1$s</string>
	<string name="theme_prompt">Ďakujeme, že ste si vybrali %1$s</string>
	<string name="theme_try_and_customize">Vyskúšajte a prispôsobte si</string>
	<string name="theme_view">Zobraziť</string>
	<string name="theme_details">Detaily</string>
	<string name="theme_support">Podpora</string>
	<string name="theme_done">HOTOVO</string>
	<string name="theme_manage_site">SPRAVOVAŤ STRÁNKU</string>
	<string name="title_activity_theme_support">Témy</string>
	<string name="theme_activate">Aktivovať</string>
	<string name="date_range_start_date">Začiatok</string>
	<string name="date_range_end_date">Koniec</string>
	<string name="current_theme">Aktuálna téma</string>
	<string name="customize">Prispôsobiť</string>
	<string name="details">Detaily</string>
	<string name="support">Podpora</string>
	<string name="active">Aktívna</string>
	<string name="stats_referrers_spam_generic_error">Niečo sa nepodarilo. Označenie za spam nebolo zmenené.</string>
	<string name="stats_referrers_marking_not_spam">Odznačuje sa ako spam</string>
	<string name="stats_referrers_unspam">Nie je spam</string>
	<string name="stats_referrers_marking_spam">Označuje sa ako spam</string>
	<string name="theme_auth_error_authenticate">Nepodarilo sa načítať témy: nepodarilo sa autentifikovať používateľa</string>
	<string name="post_published">Článok bol publikovaný</string>
	<string name="page_published">Stránka bola publikovaná</string>
	<string name="post_updated">Článok bol aktualizovaný</string>
	<string name="page_updated">Stránka bola aktualizovaná</string>
	<string name="stats_referrers_spam">Spam</string>
	<string name="theme_no_search_result_found">Neboli nájdené žiadne témy.</string>
	<string name="media_file_name">Názov súboru: %s</string>
	<string name="media_uploaded_on">Nahrané: %s</string>
	<string name="media_dimensions">Rozmery: %s</string>
	<string name="upload_queued">Zaradené do fronty</string>
	<string name="media_file_type">Typ súboru: %s</string>
	<string name="reader_label_gap_marker">Načítať ďalšie články</string>
	<string name="notifications_no_search_results">Žiadne stránky sa nezhodujú s \'%s\'</string>
	<string name="search_sites">Nájsť webové stránky</string>
	<string name="unread">Neprečítané</string>
	<string name="notifications_empty_view_reader">Zobraziť čítačku</string>
	<string name="notifications_empty_action_followers_likes">Všimnite si: komentujte príspevky, ktoré ste prečítali.</string>
	<string name="notifications_empty_action_comments">Pridajte sa ku konverzácii: komentujte príspevky z blogov, ktoré sledujete.</string>
	<string name="notifications_empty_action_unread">Začnite konverzáciu: napíšte nový príspevok.</string>
	<string name="notifications_empty_action_all">Tvorte! Komentujte príspevky z blogov, ktoré sledujete.</string>
	<string name="notifications_empty_likes">Nemáte žiadne nové lajky... zatiaľ.</string>
	<string name="notifications_empty_followers">Žiadny nový sledujúci... zatiaľ.</string>
	<string name="notifications_empty_comments">Žiadne nové komentáre... zatiaľ.</string>
	<string name="notifications_empty_unread">Všetky sú prečítané!</string>
	<string name="stats_widget_error_jetpack_no_blogid">Prosím získajte štatistiku v aplikácii a pokúste sa pridať widgety neskôr</string>
	<string name="stats_widget_error_readd_widget">Prosím odstráňte widget a neskôr ho znovu pridajte</string>
	<string name="stats_widget_error_no_visible_blog">Žiaden prístup k štatistike bez viditeľného blogu</string>
	<string name="stats_widget_error_no_permissions">Váš účet na WordPress.com nemá prístup k štatistikám na tomto blogu</string>
	<string name="stats_widget_error_no_account">Prosím prihláste sa do WordPress</string>
	<string name="stats_widget_error_generic">Nemožno načítať štatistku</string>
	<string name="stats_widget_loading_data">Načítavanie údajov...</string>
	<string name="stats_widget_name_for_blog">Dnešná štatistika pre %1$s</string>
	<string name="stats_widget_name">Dnešná štatistika WordPress</string>
	<string name="add_location_permission_required">Vyžaduje sa súhlas k pridaniu polohy</string>
	<string name="add_media_permission_required">Vyžadujú sa súhlasy k pridaniu súborov</string>
	<string name="access_media_permission_required">Vyžadujú sa súhlasy na prístup k súborom</string>
	<string name="stats_enable_rest_api_in_jetpack">Povoľte modul JSON API v Jetpack k náhľadu vašej štatistiky.</string>
	<string name="error_open_list_from_notification">Tento článok alebo stránka boli zverejnené na inej webovej stránke</string>
	<string name="reader_short_comment_count_multi">%s komentárov</string>
	<string name="reader_short_comment_count_one">1 komentár</string>
	<string name="reader_label_submit_comment">ODOSLAŤ</string>
	<string name="reader_hint_comment_on_post">Pridať komentár k článku...</string>
	<string name="reader_discover_visit_blog">Návštevnosť %s</string>
	<string name="reader_discover_attribution_blog">Pôvodne publikované v %s</string>
	<string name="reader_discover_attribution_author">Pôvodne publikované autorom %s</string>
	<string name="reader_discover_attribution_author_and_blog">Pôvodne publikované autorom %1$s v %2$s</string>
	<string name="reader_short_like_count_multi">počet lajkov: %s</string>
	<string name="reader_label_follow_count">počet sledujúcich: %,d</string>
	<string name="reader_short_like_count_one">1 lajk</string>
	<string name="reader_short_like_count_none">lajk</string>
	<string name="reader_menu_tags">Upraviť značky a blogy</string>
	<string name="reader_title_post_detail">Článok čítačky</string>
	<string name="local_draft_explainer">Tento článok je koncept, ktorý nebol zverejnený</string>
	<string name="local_changes_explainer">Tento má úpravy, ktoré neboli zverejnené</string>
	<string name="notifications_push_summary">Nastavenia upozornení zobrazujúcich sa na vašom zariadení.</string>
	<string name="notifications_email_summary">Nastavenia upozornení odosielaných na e-mail, ktorý je spojený s vašim účtom.</string>
	<string name="notifications_tab_summary">Nastavenia upozornení zobrazujúcich sa v záložke Upozornenia.</string>
	<string name="notifications_disabled">Upozornenia aplikácie nie sú dostupné. Poklepte prstami na tomto mieste, aby sa zobrazili v Nastaveniach.</string>
	<string name="notification_types">Typy upozornení</string>
	<string name="error_loading_notifications">Nenačítali sa nastavenia upozornení</string>
	<string name="replies_to_your_comments">Odpovede na vaše komentáre</string>
	<string name="comment_likes">Lajky komentárov</string>
	<string name="email">E-mail</string>
	<string name="app_notifications">Upozornenia aplikácie</string>
	<string name="notifications_tab">Záložka Upozornenia</string>
	<string name="notifications_comments_other_blogs">Komentáre na ďalších webových stránkach</string>
	<string name="notifications_wpcom_updates">Aktualizácie WordPress.com</string>
	<string name="notifications_other">Iné</string>
	<string name="notifications_account_emails">E-mail od WordPress.com</string>
	<string name="notifications_account_emails_summary">Budeme vám posielať dôležité e-maily o vašom účte, ale rovnako môžete dostať aj iné, užitočné správy.</string>
	<string name="your_sites">Vaše webové stránky</string>
	<string name="notifications_sights_and_sounds">Sights and Sounds</string>
	<string name="stats_insights_latest_post_trend">Prešlo %1$s od zverejnenia %2$s. Môžete vidieť ako doteraz príspevok obstál...</string>
	<string name="stats_insights_latest_post_summary">Súhrn najnovších príspevkov</string>
	<string name="button_revert">Vrátiť</string>
	<string name="yesterday">Včera</string>
	<string name="days_ago">pred %d dňami</string>
	<string name="connectionbar_no_connection">Žiadne pripojenie</string>
	<string name="button_trash">Kôš</string>
	<string name="button_edit">Upraviť</string>
	<string name="button_stats">Štatistiky</string>
	<string name="button_preview">Náhľad</string>
	<string name="button_view">Zobraziť</string>
	<string name="page_deleted">Stránka vymazaná</string>
	<string name="button_back">Späť</string>
	<string name="trashed">Odstránené</string>
	<string name="page_trashed">Stránka presunutá do koša</string>
	<string name="stats_no_activity_this_period">Žiadna činnosť v toto obdobie</string>
	<string name="button_publish">Zverejniť</string>
	<string name="post_deleted">Článok vymazaný</string>
	<string name="post_trashed">Článok presunutý do koša</string>
	<string name="my_site_no_sites_view_subtitle">Prajete si pridať ďalšie?</string>
	<string name="my_site_no_sites_view_title">Nemáte žiadne webové stránky WordPress.</string>
	<string name="my_site_no_sites_view_drake">Ilustrácie</string>
	<string name="reader_toast_err_follow_blog_not_authorized">Nemáte prístup do tohto blogu</string>
	<string name="reader_toast_err_follow_blog_not_found">Blog sa nenašiel</string>
	<string name="undo">Zrušiť zmenu</string>
	<string name="tabbar_accessibility_label_my_site">Moja webová stránka</string>
	<string name="tabbar_accessibility_label_me">Ja</string>
	<string name="passcodelock_prompt_message">Zadajte svoj PIN</string>
	<string name="editor_toast_changes_saved">Zmeny uložené</string>
	<string name="push_auth_expired">Žiadosť vypršala. Prihláste sa do WordPress.com a skúste znovu.</string>
	<string name="stats_insights_best_ever">Najlepšie zobrazenia</string>
	<string name="ignore">Ignorovať</string>
	<string name="stats_insights_most_popular_percent_views">%1$d%% zobrazení</string>
	<string name="stats_insights_most_popular_hour">Najpopulárnejšia hodina</string>
	<string name="stats_insights_most_popular_day">Najobľúbenejší deň</string>
	<string name="stats_insights_popular">Najobľúbenejší deň a hodina</string>
	<string name="stats_insights_today">Dnešné štatistiky</string>
	<string name="stats_insights_all_time">Články, zobrazenia a návštevníci počas celej doby</string>
	<string name="stats_insights">Prehľady</string>
	<string name="stats_sign_in_jetpack_different_com_account">K zobrazeniu vašej štatistiky sa prihláste s WordPress.com účtom, s ktorým ste sa pripojili k Jetpack.</string>
	<string name="stats_other_recent_stats_moved_label">Hľadáte ďalšie nedávne štatistiky? Presunuli sme ich na stránku Prehľady.</string>
	<string name="me_disconnect_from_wordpress_com">Odpojiť z WordPress.com</string>
	<string name="me_connect_to_wordpress_com">Pripojiť sa k WordPress.com</string>
	<string name="me_btn_login_logout">Prihlásiť/Odhlásiť</string>
	<string name="me_btn_support">Pomoc a podpora</string>
	<string name="site_picker_cant_hide_current_site">"%s" nebola skrytá, pretože to je aktuálna webová stránka</string>
	<string name="site_picker_create_dotcom">Vytvoriť webovú stránku WordPress.com</string>
	<string name="site_picker_add_site">Pridať webovú stránku</string>
	<string name="site_picker_edit_visibility">Zobraziť/skryť webové stránky</string>
	<string name="site_picker_add_self_hosted">Pridať webovú stránku s vlastným hostingom</string>
	<string name="my_site_btn_view_site">Zobraziť webovú stránku</string>
	<string name="site_picker_title">Vybrať webovú stránku</string>
	<string name="my_site_btn_switch_site">Prepnúť webovú stránku</string>
	<string name="my_site_btn_view_admin">Zobraziť administráciu</string>
	<string name="my_site_btn_site_settings">Nastavenia</string>
	<string name="my_site_header_publish">Zverejniť</string>
	<string name="my_site_btn_blog_posts">Články blogu</string>
	<string name="my_site_header_look_and_feel">Vzhľad</string>
	<string name="my_site_header_configuration">Kanfigurácia</string>
	<string name="reader_label_new_posts_subtitle">Ťuknite k ich zobrazeniu</string>
	<string name="notifications_account_required">Prihláste sa do WordPress.com pre upozornenia</string>
	<string name="stats_unknown_author">Neznámy autor</string>
	<string name="image_added">Obrázok pridaný</string>
	<string name="signout">Odpojiť sa</string>
	<string name="show">Zobraziť</string>
	<string name="hide">Skryť</string>
	<string name="deselect_all">Odznačiť všetky</string>
	<string name="select_all">Vybrať všetky</string>
	<string name="sign_out_wpcom_confirm">Po odpojení sa vám z účtu vymažú všetky @%s’s WordPress.com údaje z tohto zariadenia, vrátane lokálnych konceptov a zmien.</string>
	<string name="select_from_new_picker">Viacnásobný výber v novej možnosti výberu</string>
	<string name="stats_generic_error">Požadované štatistiky nemohli byť načítané</string>
	<string name="loading_blog_images">Načítavajú sa obrázky</string>
	<string name="no_media_sources">Nie je možné načítať súbory</string>
	<string name="loading_blog_videos">Načítavajú sa videá</string>
	<string name="error_loading_blog_videos">Nie je možné načítať videá</string>
	<string name="error_loading_videos">Nie je možné načítať videá</string>
	<string name="error_loading_blog_images">Nie je možné načítať obrázky</string>
	<string name="error_loading_images">Pri načítavaní videa sa vyskytla chyba</string>
	<string name="no_device_videos">Žiadne videá</string>
	<string name="no_blog_videos">Žiadne videá</string>
	<string name="no_blog_images">Žiadne obrázky</string>
	<string name="no_device_images">Žiadne obrázky</string>
	<string name="no_media">Žiadne súbory</string>
	<string name="loading_images">Nahrávajú sa obrázky</string>
	<string name="loading_videos">Nahrávajú sa videá</string>
	<string name="media_picker_title">Vybrať súbory</string>
	<string name="sign_in_jetpack">Prihláste sa do účtu WordPress.com a pripojte sa na Jetpack.</string>
	<string name="two_step_sms_sent">Vložte overovací kód z SMS správy.</string>
	<string name="take_photo">Spraviť fotku</string>
	<string name="error_publish_no_network">Nedá sa publikovať, nefunguje pripojenie. Uložené ako koncept.</string>
	<string name="two_step_footer_label">Vložte kód z aplikácie Authenticator.</string>
	<string name="tab_title_site_images">Obrázky na stránke</string>
	<string name="take_video">Nahrať video</string>
	<string name="verify">Overiť</string>
	<string name="media_details_label_file_type">Typ súboru</string>
	<string name="auth_required">Pre pokračovanie sa opäť prihlláste.</string>
	<string name="two_step_footer_button">Odoslanie kódu textovou správou.</string>
	<string name="verification_code">Overovací kód</string>
	<string name="invalid_verification_code">Nesprávny overovací kód</string>
	<string name="editor_toast_invalid_path">Nesprávna cesta súboru</string>
	<string name="tab_title_site_videos">Videá na stánke</string>
	<string name="add_to_post">Pridať k príspevku</string>
	<string name="tab_title_device_images">Obrázky v zariadení</string>
	<string name="tab_title_device_videos">Videá v zariadení</string>
	<string name="language">Jazyk</string>
	<string name="device">Zariadenie</string>
	<string name="media_details_label_file_name">Názov súboru</string>
	<string name="stats_followers_total_wpcom_paged">WordPress.com odberatelia %1$d - %2$d z %3$s</string>
	<string name="stats_followers_total_email_paged">Zobrazuje sa %1$d - %2$d z %3$s odberateľov</string>
	<string name="media_fetching">Načítavajú sa súbory...</string>
	<string name="comments_fetching">Načítavajú sa komentáre...</string>
	<string name="posts_fetching">Načítavajú sa príspevky...</string>
	<string name="pages_fetching">Načítavajú sa stránky...</string>
	<string name="publisher">Vydavateľ:</string>
	<string name="stats_empty_search_terms_desc">Zistite, aké kľúčové slová zvyšujú návštevnosť stránky.</string>
	<string name="stats_empty_search_terms">Slovo nenájdené</string>
	<string name="reader_empty_posts_request_failed">Nie je možné obnoviť príspevky</string>
	<string name="toast_err_post_uploading">Nie je možné otvoriť príspevky počas odovzdávania</string>
	<string name="stats_search_terms_unknown_search_terms">Neznáme hľadané výrazy</string>
	<string name="stats_view_search_terms">Hľadané výrazy</string>
	<string name="stats_view_authors">Autori</string>
	<string name="stats_entry_search_terms">Hľadaný výraz</string>
	<string name="error_notification_open">Nie je možné otvoríť oznámenie</string>
	<string name="logs_copied_to_clipboard">Záznamy aplikácie boli skopírované do schránky</string>
	<string name="error_copy_to_clipboard">Pri kopírovaní textu do schránky nastala chyba </string>
	<string name="post_uploading">Nahráva sa</string>
	<string name="stats_recent_weeks">Posledné týždne</string>
	<string name="stats_months_and_years">Mesiace a roky</string>
	<string name="reader_empty_posts_in_blog">Tento blog je prázdny</string>
	<string name="stats_average_per_day">Priemer za deň</string>
	<string name="stats_overall">Celkom</string>
	<string name="reader_label_new_posts">Nové príspevky</string>
	<string name="stats_period">Obdobie</string>
	<string name="stats_total">Spolu</string>
	<string name="reader_page_recommended_blogs">Webové stránky, ktoré sa vám možno páčia</string>
	<string name="stats_empty_top_authors_desc">Sledujte zobrazenia jednotlivých príspevkov autorov a zistite, ktorý obsah je od jednotlivých autorov populárny.</string>
	<string name="stats_empty_comments_desc">Ak povolíte komentáre na stránke, môžete sledovať najaktívnejších komentátorov a na základe posledných 1000 komentárov zistiť, aký obsah podnecuje živú diskusiu.</string>
	<string name="stats_empty_referrers_desc">Zistite viac o viditeľnosti stránky prostredníctvom webových stránok a vyhľadávačov, ktoré zvyšujú jej návštevnosť</string>
	<string name="stats_followers_minutes">minút: %1$d</string>
	<string name="stats_empty_video">Žiadne prehraté videá</string>
	<string name="stats_pagination_label">Strana %1$s z %2$s</string>
	<string name="stats_empty_publicize_desc">Sledujte celkový počet odberateľov prichádzajúcich zo sociálych sietí prostredníctvom propagácie.</string>
	<string name="stats_empty_followers_desc">Sledujte celkový počet odberateľov a dobu odberu vašej stránky.</string>
	<string name="stats_comments_by_posts_and_pages">Podľa príspevkov a stránok </string>
	<string name="stats_empty_publicize">Žiadni známi odberatelia</string>
	<string name="stats_empty_video_desc">Ak ste nahrali videá pomocou VideoPress, zistite, koľkokrát boli videá zobrazené.</string>
	<string name="stats_empty_clicks_desc">Ak váš obsah obsahuje odkazy na iné stránky, pozrite sa, na ktoré návštevníci najviac klikajú.</string>
	<string name="stats_view_publicize">Propagovať</string>
	<string name="stats_likes">Počet lajkov</string>
	<string name="stats_empty_geoviews_desc">Pozrite si zoznam krajín, ktoré produkujú najvyššiu návštevnosť vašej stránky.</string>
	<string name="stats_empty_top_posts_desc">Zistite, čo je váš najúspešnejší obsah a skontrolujte, ako sa darí jednotlivým príspevkom a stránkam v priebehu času.</string>
	<string name="stats_empty_referrers_title">Žiadne odkazy</string>
	<string name="stats_empty_followers">Žiadny odberatelia</string>
	<string name="stats_empty_tags_and_categories">Žiadne označené príspevky alebo zobrazené stránky</string>
	<string name="stats_empty_tags_and_categories_desc">Získajte prehľad najpopulárnejších tém na stránke podľa príspevkov z uplynulého týždňa.</string>
	<string name="stats_followers_total_wpcom">Počet odberateľov WordPress.com: %1$s</string>
	<string name="stats_followers_total_email">Počet odberateľov emailov: %1$s</string>
	<string name="stats_totals_publicize">Odberatelia</string>
	<string name="stats_entry_followers">Odberateľ</string>
	<string name="stats_view_followers">Odberatelia</string>
	<string name="stats_other_recent_stats_label">Ostatné štatistiky</string>
	<string name="stats_followers_years">počet rokov: %1$d</string>
	<string name="stats_followers_months">počet mesiacov: %1$d</string>
	<string name="stats_followers_hours">hodín: %1$d</string>
	<string name="stats_view">Zobraziť</string>
	<string name="stats_followers_a_year">Rok</string>
	<string name="stats_visitors">Návštevníci</string>
	<string name="stats_views">Zobrazenia</string>
	<string name="stats_timeframe_years">Roky</string>
	<string name="stats_view_top_posts_and_pages">Príspevky a stránky</string>
	<string name="stats_view_countries">Krajiny</string>
	<string name="stats_view_videos">Videá</string>
	<string name="stats_entry_clicks_link">Odkaz</string>
	<string name="stats_comments_by_authors">Od autorov</string>
	<string name="stats_followers_email_selector">Email</string>
	<string name="stats_followers_wpcom_selector">WordPress.com</string>
	<string name="stats_followers_seconds_ago">Pred niekoľkými sekundami</string>
	<string name="stats_followers_a_day">Deň</string>
	<string name="stats_followers_days">%1$d dní</string>
	<string name="stats_followers_a_minute_ago">Pred minútou</string>
	<string name="stats_entry_publicize">Služba</string>
	<string name="stats_followers_a_month">Mesiac</string>
	<string name="stats_followers_an_hour_ago">Pred hodinou</string>
	<string name="stats_entry_video_plays">Video</string>
	<string name="stats_entry_top_commenter">Autor</string>
	<string name="stats_empty_geoviews">Nie sú zaznamenané žiadne krajiny</string>
	<string name="themes_fetching">Načítavajú sa témy</string>
	<string name="stats_empty_top_posts_title">Neboli žiadne návštevy príspevkov alebo stránok</string>
	<string name="stats_view_all">Zobraziť všetko</string>
	<string name="stats_for">Štatistiky pre %s</string>
	<string name="stats_totals_followers">Od</string>
	<string name="stats_empty_clicks_title">Nie sú zaznamenané žiadne kliknutia</string>
	<string name="stats_comments_total_comments_followers">Celkový počet článkov s odberateľmi: %1$s</string>
	<string name="ssl_certificate_details">Detaily</string>
	<string name="media_gallery_date_range">Zobrazuje médiá od %1$s do %2$s</string>
	<string name="delete_sure_page">Zmazať túto podstránku</string>
	<string name="delete_sure">Vymazať tento koncept</string>
	<string name="delete_sure_post">Vymazať tento príspevok</string>
	<string name="cab_selected">%d vybraných</string>
	<string name="confirm_delete_media">Zmazať vybranú položku?</string>
	<string name="confirm_delete_multi_media">Zmazať vybrané položky?</string>
	<string name="sure_to_remove_account">Odstrániť webovú stránku?</string>
	<string name="posts_empty_list">Žiadne príspevky. Želáte si nejaký vytvoriť?</string>
	<string name="reader_label_comment_count_multi">odpovedí: %,d</string>
	<string name="pages_empty_list">Zatiaľ nemáte žiadnu stránku. Želáte si nejakú vytvoriť?</string>
	<string name="nux_help_description">Pre odpovede na časté otázky navštívte naše centrum pomoci alebo fórum</string>
	<string name="error_refresh_unauthorized_pages">Nemáte oprávnenie prezerať alebo upravovať stránky</string>
	<string name="error_refresh_unauthorized_comments">Nemáte oprávnenie prezerať alebo upravovať komentáre</string>
	<string name="reader_label_comments_on">Komentáre k</string>
	<string name="comment">Komentár</string>
	<string name="sending_content">Nahrávanie obsahu %s</string>
	<string name="media_empty_list_custom_date">Žiadne súbory v tomto časovom intervale</string>
	<string name="posting_post">Publikuje sa "%s"</string>
	<string name="agree_terms_of_service">Založením účtu súhlasíte s našimi okúzľujúcimi %1$sPodmienkami používania%2$s</string>
	<string name="comment_reply_to_user">Odpovedať užívateľovi %s</string>
	<string name="reader_empty_posts_in_tag">Neexistuje žiadny príspevok s touto značkou</string>
	<string name="error_publish_empty_post">Nie je možné zverejniť prázdny príspevok</string>
	<string name="uploading_total">Nahrávanie %1$d z %2$d</string>
	<string name="stats_no_blog">Nebolo možné načítať štatistiky pre vybraný blog</string>
	<string name="signing_out">Odhlasuje sa...</string>
	<string name="comment_trashed">Komentár bol odstránený</string>
	<string name="reader_label_view_original">Pozrieť originál článku</string>
	<string name="error_refresh_unauthorized_posts">Nemáte oprávnenie prezerať alebo upravovať príspevky</string>
	<string name="reader_title_photo_viewer">%1$d z %2$d</string>
	<string name="reader_label_comments_closed">Už nie je možné pridávať komentáre</string>
	<string name="reader_label_comment_count_single">jeden komentár</string>
	<string name="reader_empty_comments">Zatiaľ nie sú žiadne komentáre</string>
	<string name="select_a_blog">Vybrať WordPress stránku</string>
	<string name="browse_our_faq_button">Prehľadávať časté otázky</string>
	<string name="create_new_blog_wpcom">Vytvoriť WordPress blog</string>
	<string name="faq_button">Časté otázky</string>
	<string name="older_month">Staršie ako mesiac</string>
	<string name="older_last_week">Staršie ako týždeň</string>
	<string name="older_two_days">Staršie ako 2 dni</string>
	<string name="more">Viac</string>
	<string name="new_blog_wpcom_created">WordPress.com blog bol vytvorený!</string>
	<string name="reader_empty_followed_blogs_title">Nesledujete zatiaľ žiadne webové stránky</string>
	<string name="reader_label_like">Lajk</string>
	<string name="mnu_comment_liked">Lajknuté</string>
	<string name="reader_empty_posts_liked">Zatiaľ ste nelajkli žiaden príspevok</string>
	<string name="reader_toast_blog_blocked">Príspevky z tomhto blogu sa už nebudú zobrazovať</string>
	<string name="reader_toast_err_generic">Nie je možné vykonať túto akciu</string>
	<string name="reader_toast_err_block_blog">Tento blog nie je možné zablokovať</string>
	<string name="reader_menu_block_blog">Zablokovať tento blog</string>
	<string name="hs__conversation_header">Chat technickej podpory</string>
	<string name="hs__new_conversation_header">Chat technickej podpory</string>
	<string name="hs__username_blank_error">Vložte platné meno</string>
	<string name="hs__conversation_detail_error">Popíšte váš problém</string>
	<string name="hs__invalid_email_error">Vložte platnú emailovú adresu</string>
	<string name="contact_us">Kontaktujte nás</string>
	<string name="add_location">Pridať lokalitu</string>
	<string name="current_location">Aktuálna pozícia</string>
	<string name="search_current_location">Vyhľadať aktuálnu lokalitu</string>
	<string name="search_location">Hľadať</string>
	<string name="edit_location">Upraviť</string>
	<string name="preference_send_usage_stats_summary">Automaticky odosielať štatistiky užívania pre zlepšenie WordPress pre Android</string>
	<string name="preference_send_usage_stats">Poslať štatistiky</string>
	<string name="schedule_verb">Rozvrh</string>
	<string name="update_verb">Aktualizovať</string>
	<string name="reader_toast_err_unfollow_blog">Nie je možné sledovať tento blog</string>
	<string name="reader_label_tag_preview">Príspevok označený: %s</string>
	<string name="reader_label_followed_blog">Sledovaný blog</string>
	<string name="reader_page_followed_tags">Sledované značky</string>
	<string name="reader_toast_err_already_follow_blog">Tento blog už sledujete</string>
	<string name="reader_toast_err_get_blog_info">Tento blog nie je možné zobraziť</string>
	<string name="reader_toast_err_follow_blog">Tento blog nie je možné sledovať</string>
	<string name="reader_title_subs">Značky a blogy</string>
	<string name="reader_empty_recommended_blogs">Žiadne odporúčané blogy</string>
	<string name="reader_page_followed_blogs">Sledované webové stránky</string>
	<string name="reader_title_tag_preview">Značka čítačky</string>
	<string name="reader_title_blog_preview">Blog čítačky</string>
	<string name="reader_hint_add_tag_or_url">Zadajte adresu URL alebo značku, ktorú chcete sledovať</string>
	<string name="media_empty_list">Žiadne súbory</string>
	<string name="ptr_tip_message">Potiahnite smerom nadol pre obnovu</string>
	<string name="saving">Ukladá sa ...</string>
	<string name="ssl_certificate_ask_trust">Ak sa bežne pripájate bez problémov, táto chyba môže znamenať, že sa niekto pokúša prevziať vašu identitu. Neodporúčame vám pokračovať. Chcete aj napriek tomu dôverovať tomuto certifikátu?</string>
	<string name="ssl_certificate_error">Neplatný SSL certifikát</string>
	<string name="forgot_password">Stratili ste heslo?</string>
	<string name="help_center">Centrum Pomocníka</string>
	<string name="forums">Fóra</string>
	<string name="help">Pomocník</string>
	<string name="theme_auth_error_message">Uistite sa, či máte prava nastaviť tému</string>
	<string name="blog_name_reserved_but_may_be_available">Stránka je momentálne rezervovaná, no možno sa o pár dní uvoľní</string>
	<string name="gallery_error">Súbor nebolo možné načítať</string>
	<string name="blog_name_cant_be_used">Nemôžete použiť túto adresu stránky</string>
	<string name="username_reserved_but_may_be_available">Toto používateľské meno je momentálne rezervované, no o niekoľko dní môže byť voľné</string>
	<string name="username_or_password_incorrect">Používateľské meno alebo heslo nie je správne</string>
	<string name="blog_name_contains_invalid_characters">Adresa stránky nemôže obsahovať znak “_”</string>
	<string name="username_not_allowed">Používateľské meno nie je povolené</string>
	<string name="blog_name_exists">Stránka už existuje</string>
	<string name="nux_cannot_log_in">Prihlásenie nie je možné</string>
	<string name="error_delete_post">Počas mazania %s nastala chyba</string>
	<string name="blog_name_reserved">Táto adresa je obsadená</string>
	<string name="out_of_memory">Nedostatok voľného miesta v pamäti</string>
	<string name="blog_not_found">Počas prístupu k blogu sa vyskytla chyba</string>
	<string name="error_refresh_notifications">Notifikácie nebolo možné znova načítať</string>
	<string name="blog_name_not_allowed">Táto adresa stránky nie je povolená</string>
	<string name="error_upload">Počas nahrávania %s nastala chyba</string>
	<string name="error_moderate_comment">Počas moderovania nastala chyba</string>
	<string name="error_refresh_stats">Štatistiky nebolo možné znova načítať</string>
	<string name="error_refresh_comments">Komentáre nebolo možné znova načítať</string>
	<string name="error_refresh_pages">Stránky nebolo možné znova načítať</string>
	<string name="error_refresh_posts">Príspevky nebolo možné znova načítať</string>
	<string name="notifications_empty_list">Žiadne notifikácie</string>
	<string name="reply_failed">Odpveď nebola úspešná</string>
	<string name="blog_name_must_be_less_than_sixty_four_characters">Adresa stránky musí mať menej ako 64 znakov</string>
	<string name="blog_name_must_be_at_least_four_characters">Adresa stránky musí mať aspoň 4 znaky</string>
	<string name="email_exists">Táto emailová adresa sa už používa</string>
	<string name="username_exists">Toto používateľské meno už existuje</string>
	<string name="email_not_allowed">Táto emailová adresa nie je povolená</string>
	<string name="username_contains_invalid_characters">Používateľské meno nesmie obsahovať znak "_"</string>
	<string name="username_only_lowercase_letters_and_numbers">Používateľské meno môže obsahovať iba malé písmená (a-z) a číslice</string>
	<string name="username_required">Zadajte používateľské meno</string>
	<string name="invalid_username_too_short">Používateľské meno musí byť dlhšie ako 4 znaky</string>
	<string name="invalid_username_too_long">Používateľské meno musí byť kratšie ako 61 znakov</string>
	<string name="invalid_password_message">Heslo musí obsahovať minimálne 4 znaky</string>
	<string name="passcode_wrong_passcode">Nesprávny PIN</string>
	<string name="invalid_email_message">Zadaná emailová adresa nie je platná</string>
	<string name="error_edit_comment">Počas úpravy komentára sa vyskytla chyba</string>
	<string name="error_load_comment">Nepodarilo sa načítať komentár</string>
	<string name="error_generic">Vyskytla sa chyba</string>
	<string name="category_automatically_renamed">Názov kategórie %1$s je neplatný. Bola premenovaná na %2$s.</string>
	<string name="cat_name_required">Vložte názov kategórie</string>
	<string name="adding_cat_success">Kategória bola úspešne pridaná</string>
	<string name="adding_cat_failed">Chyba pri pridávaní kategórie</string>
	<string name="no_site_error">Nie je možné pripojiť sa na WordPress stránku</string>
	<string name="username_must_be_at_least_four_characters">Používateľské meno musí mať aspoň 4 znaky</string>
	<string name="comments_empty_list">Žiadne komentáre</string>
	<string name="mnu_comment_unspam">Žiadny spam</string>
	<string name="theme_set_failed">Nepodarilo sa nastaviť tému</string>
	<string name="wait_until_upload_completes">Čakajte, kým bude nahrávanie dokončené</string>
	<string name="no_network_message">Nie sú k dispozícii žiadne siete</string>
	<string name="blog_name_required">Vložte adresu stránky</string>
	<string name="username_must_include_letters">Používatelské meno musí obsahovať min. 1 písmeno (a-z)</string>
	<string name="email_invalid">Vložte platnú emailovú adresu</string>
	<string name="stats_empty_comments">Bez komentárov</string>
	<string name="stats_bar_graph_empty">Štatistiky nie sú dostupné</string>
	<string name="sdcard_message">Pre nahratie súboru je potrebné vložiť SD kartu</string>
	<string name="no_account">Účet WordPress nenájdený, vytvorte nový účet</string>
	<string name="error_downloading_image">Chyba pri sťahovaní obrázka</string>
	<string name="theme_fetch_failed">Chyba pri načítavaní témy</string>
	<string name="blog_name_only_lowercase_letters_and_numbers">Adresa stránky môže obsahovať iba malé písmená (a-z) alebo čísla</string>
	<string name="could_not_remove_account">Webová stránka sa nedá odstrániť</string>
	<string name="cannot_delete_multi_media_items">Niektoré súbory nie je možné teraz zmazať. skúste neskôr.</string>
	<string name="xmlrpc_error">Nie je možné pripojiť sa. Zadajte adresu xmlrpc.php na vašej stránke a skúste znova.</string>
	<string name="scaled_image_error">Zadajte správnu hodnotu šírky</string>
	<string name="email_reserved">Emailová adresa už bola použitá. Skontrolujte si, či ste dostali email s aktivačným odkazom. Ak sa vám to nepodarí teraz, môžete skúsiť o pár dní.</string>
	<string name="file_not_found">Nie je možné nájsť súbor pre nahratie. Nebol zmazaný alebo presunutý?</string>
	<string name="email_cant_be_used_to_signup">Nemôžete použiť túto emailovú adresu na prihlásenie. Vyskytol sa problém s blokovanám niektorých našich emailov. Použite iného poskytovateľa emailu.</string>
	<string name="http_credentials">HTTP poverenia (voliteľné)</string>
	<string name="file_error_create">Nie je možné vytvoriť dočasný súbor. Uistite sa, či máte dostatok miesta vo vašom zariadení.</string>
	<string name="dlg_unapproving_comments">Ruší sa schválenie</string>
	<string name="error_blog_hidden">Blog je skrytý a nemôže byť načítaný. Povoľte ho v nastaveniach a skúste znova.</string>
	<string name="site_address">URL adresa vašej stránky</string>
	<string name="reader_title_applog">Záznamy aplikácie</string>
	<string name="media_gallery_type_thumbnail_grid">Mriežka s náhľadmi</string>
	<string name="local_draft">Lokálny koncept </string>
	<string name="account_details">Detaily účtu</string>
	<string name="blog_name_must_include_letters">Adresa stránky musí mať aspoň 1 písmeno</string>
	<string name="blog_title_invalid">Neplatný nadpis stránky</string>
	<string name="dlg_approving_comments">Schvaľovanie</string>
	<string name="new_media">Nový súbor</string>
	<string name="media_error_no_permission">Nemáte práva na zobrazenie knižnice súborov</string>
	<string name="share_action_media">Knižnica súborov</string>
	<string name="jetpack_message_not_admin">Pre zobrazenie štatistík sa vyžaduje plugin Jetpack. Kontaktujte administrátora stránky.</string>
	<string name="pending_review">Čaká na vybavenie</string>
	<string name="fatal_db_error">Počas vytvárania databázy sa vyskytla chyba. Preinštalujte aplikáciu.</string>
	<string name="privacy_policy">Ochrana osobných údajov</string>
	<string name="local_changes">Miestne zmeny</string>
	<string name="link_enter_url_text">Text odkazu (voliteľný)</string>
	<string name="post_not_found">Počas načítania príspevku sa vyskytla chyba. Obnovte príspevky a skúste znova.</string>
	<string name="open_source_licenses">Open source licencie</string>
	<string name="trash_no">Nevymazávať</string>
	<string name="trash">Kôš</string>
	<string name="dlg_trashing_comments">Vymazáva sa</string>
	<string name="themes_live_preview">Živý náhľad</string>
	<string name="page_not_published">Stránka nie je zverejnená</string>
	<string name="post_not_published">Príspevok nie je zverejnený</string>
	<string name="blog_name_invalid">Neplatná adresa</string>
	<string name="email_hint">Emailová adresa</string>
	<string name="reader_toast_err_remove_tag">Túto značku nie je možné odstrániť</string>
	<string name="reader_toast_err_add_tag">Túto značku nie je možné pridať</string>
	<string name="reader_share_link">Zdieľať odkaz</string>
	<string name="add_account_blog_url">Adresa blogu</string>
	<string name="image_settings">Nastavenie obrázka</string>
	<string name="http_authorization_required">Požaduje sa autorizácia</string>
	<string name="view_site">Pozrieť stránku</string>
	<string name="new_post">Nový príspevok</string>
	<string name="post_format">Formát príspevku</string>
	<string name="location_not_found">Neznáma lokalita</string>
	<string name="share_action_post">Nový príspevok</string>
	<string name="category_desc">Popis kategórie (voliteľné)</string>
	<string name="category_slug">Slug kategórie (voliteľné)</string>
	<string name="view_in_browser">Pozrieť v prehliadači</string>
	<string name="add_new_category">Pridať novú kategóriu</string>
	<string name="category_name">Názov kategórie</string>
	<string name="comment_added">Komentár bol úspešne pridaný</string>
	<string name="category_parent">Nadradená kategória (voliteľné):</string>
	<string name="preview_post">Pozrieť náhľad príspevku</string>
	<string name="delete_draft">Vymazať koncept</string>
	<string name="preview_page">Náhľad stránky</string>
	<string name="dlg_confirm_trash_comments">Odstrániť?</string>
	<string name="trash_yes">Kôš</string>
	<string name="toast_comment_unedited">Komentáre neboli zmenené</string>
	<string name="content_required">Vyžaduje sa komentár</string>
	<string name="sure_to_cancel_edit_comment">Zrušiť úpravu tohto komentáru?</string>
	<string name="saving_changes">Ukladajú sa zmeny</string>
	<string name="author_url">URL adresa autora</string>
	<string name="hint_comment_content">Komentár</string>
	<string name="author_email">Email autora</string>
	<string name="author_name">Meno autora</string>
	<string name="dlg_spamming_comments">Označené ako spam</string>
	<string name="mnu_comment_unapprove">Neschváliť</string>
	<string name="mnu_comment_spam">Spam</string>
	<string name="mnu_comment_trash">Kôš</string>
	<string name="comment_status_unapproved">Čakajúci na schválenie</string>
	<string name="edit_comment">Upraviť komentár</string>
	<string name="mnu_comment_approve">Schváliť</string>
	<string name="comment_status_trash">Vymazané</string>
	<string name="comment_status_spam">Spam</string>
	<string name="comment_status_approved">Schválené</string>
	<string name="delete_page">Vymazať stránku</string>
	<string name="delete_post">Vymazať príspevok</string>
	<string name="post_settings">Nastavenia príspevku</string>
	<string name="horizontal_alignment">Horizontálne zarovnanie</string>
	<string name="page_settings">Nastavenia stránky</string>
	<string name="theme_premium_theme">Prémiová téma</string>
	<string name="upload_failed">Nahratie sa nepodarilo</string>
	<string name="create_a_link">Vytvoriť odkaz</string>
	<string name="media_gallery_num_columns">Počet stĺpcov</string>
	<string name="theme_current_theme">Súčasná téma</string>
	<string name="select_categories">Vyberte si kategórie</string>
	<string name="media_gallery_edit">Upraviť galériu</string>
	<string name="media_gallery_image_order">Poradie obrázkov</string>
	<string name="learn_more">Zistiť viac</string>
	<string name="media_gallery_settings_title">Nastavenia galérie</string>
	<string name="cancel_edit">Zrušiť úpravu</string>
	<string name="connection_error">Chyba pripojenia</string>
	<string name="add_comment">Pridať komentár</string>
	<string name="edit_post">Upraviť príspevok</string>
	<string name="wordpress_blog">WordPress blog</string>
	<string name="required_field">Povinné pole</string>
	<string name="remove_account">Odstrániť webovú stránku</string>
	<string name="blog_removed_successfully">Webová stránka bola úspešne odstránená</string>
	<string name="notifications_empty_all">Žiadne upozornenia. Zatiaľ.</string>
	<string name="deleting_page">Odstraňuje sa stránka</string>
	<string name="deleting_post">Odstraňuje sa príspevok</string>
	<string name="share_url_page">Zdieľať stránku</string>
	<string name="share_link">Zdieľať odkaz</string>
	<string name="share_url_post">Zdieľať príspevok</string>
	<string name="creating_your_site">Stránka sa vytvára</string>
	<string name="creating_your_account">Váš účet sa vytvára</string>
	<string name="error_refresh_media">Počas načítania knižnice súborov sa vyskytla chyba, zopakujte to neskôr.</string>
	<string name="reader_empty_posts_in_tag_updating">Načítavajú sa príspevky</string>
	<string name="reader_likes_you_and_multi">Vy a niekoľkí ďalší (%,d) ste to lajkli</string>
	<string name="reader_likes_multi">počet ľudí, ktorým sa to páči: %,d</string>
	<string name="download">Sťahujú sa súbory</string>
	<string name="comment_spammed">Komentáre označené ako spam</string>
	<string name="reader_toast_err_get_comment">Nedá sa nahrať tento komentár</string>
	<string name="reader_label_reply">Odpovedať</string>
	<string name="video">Video</string>
	<string name="cant_share_no_visible_blog">Nemôžete zdieľať na WordPress bez viditeľného blogu</string>
	<string name="account_two_step_auth_enabled">Tento účet má povolenú dvojkrokové overovanie. Pre vytvorenie hesla pre aplikácie si otvorte bezpečnostné nastavenia na WordPress.com.</string>
	<string name="reader_likes_you_and_one">Lajkli ste to vy a niekto ďalší</string>
	<string name="reader_toast_err_get_post">Nie je možné načítať príspevok</string>
	<string name="validating_site_data">Validujú sa údaje na stránke</string>
	<string name="validating_user_data">Validujú sa používateľské dáta</string>
	<string name="pick_video">Vyberte video</string>
	<string name="select_time">Vyberte čas</string>
	<string name="pick_photo">Vyberte forografiu</string>
	<string name="select_date">Vyberte dátum</string>
	<string name="reader_empty_followed_blogs_description">Neznepokojujte sa a ťuknite na ikonu vpravo hore a poznávajte!</string>
	<string name="password_invalid">Zadajte bezpečnejšie heslo. Uistite sa, že má viac ako 7 znakov a obsahuje veľké písmená, malé písmená a čísla alebo špeciálne znaky.</string>
	<string name="nux_add_selfhosted_blog">Pridajte vlastnú webovú stránku</string>
	<string name="signing_in">Prihlasovanie...</string>
	<string name="nux_welcome_create_account">Vytvoriť účet</string>
	<string name="nux_tap_continue">Pokračovať</string>
	<string name="nux_oops_not_selfhosted_blog">Prihlásiť sa do WordPress.com</string>
	<string name="reader_label_added_tag">pridané: %s</string>
	<string name="reader_likes_one">Jeden lajk</string>
	<string name="limit_reached">Dosiahli ste limit. Môžete skúsiť o 1 minútu. Pokus o opakovanie skôr ako o minútu len predĺži čas čakania. Ak si myslíte, že nastala chyba, kontaktujte technickú podporu.</string>
	<string name="reader_share_subject">Zdieľané z %s</string>
	<string name="reader_empty_followed_tags">Nesledujete žiadne značky</string>
	<string name="reader_likes_only_you">Páči sa vám to</string>
	<string name="nux_tutorial_get_started_title">Začíname!</string>
	<string name="reader_untitled_post">(bez názvu)</string>
	<string name="select_from_media_library">Vybrať z knižnice súborov</string>
	<string name="reader_btn_unfollow">Sledujem</string>
	<string name="reader_btn_follow">Sledovať</string>
	<string name="reader_toast_err_view_image">Nie je možné zobraziť obrázok</string>
	<string name="reader_toast_err_share_intent">Nie je možné zdieľať</string>
	<string name="reader_toast_err_tag_invalid">Toto nie je platná značka</string>
	<string name="reader_toast_err_tag_exists">Túto značku už sledujete</string>
	<string name="reader_toast_err_comment_failed">Váš komentár nemohol byť odoslaný</string>
	<string name="jetpack_not_found">Modul Jetpack nebol nájdený</string>
	<string name="reader_label_removed_tag">Odstránené %s</string>
	<string name="jetpack_message">Pre štatistiky je potrebný modul Jetpack. Chcete nainštalovať Jetpack?</string>
	<string name="username_invalid">Nesprávne použivateľské meno</string>
	<string name="reader_toast_err_url_intent">Nie je možné otvoriť %s</string>
	<string name="reader_btn_share">Zdielať</string>
	<string name="empty_list_default">Tento zoznam je prázdny</string>
	<string name="media_add_new_media_gallery">Vytvoriť galériu</string>
	<string name="media_add_popup_title">Pridať do knižnice súborov</string>
	<string name="create_account_wpcom">Vytvoriť účet na WordPress.com</string>
	<string name="connecting_wpcom">Pripája sa na WordPress.com</string>
	<string name="reader_hint_comment_on_comment">Odpovedajte na komentár...</string>
	<string name="stats_view_referrers">Odkazujúci</string>
	<string name="stats_entry_referrers">Odkazujúci</string>
	<string name="media_gallery_type_squares">Štvorce</string>
	<string name="media_gallery_type_tiled">Dlaždice</string>
	<string name="media_gallery_type_slideshow">Prezent8cia</string>
	<string name="media_gallery_image_order_reverse">Opačné poradie</string>
	<string name="stats_view_visitors_and_views">Návštevníci a zobrazenia</string>
	<string name="stats_view_clicks">Kliknutia</string>
	<string name="media_gallery_type_circles">Kruhy</string>
	<string name="post_excerpt">Zhrnutie</string>
	<string name="media_add_popup_capture_video">Natočiť video</string>
	<string name="media_gallery_type">Typ</string>
	<string name="custom_date">Rozsah dátumov</string>
	<string name="media_add_popup_capture_photo">Spraviť fotku</string>
	<string name="unattached">Nepriložené</string>
	<string name="stats">Štatistiky</string>
	<string name="media_gallery_image_order_random">Náhodné</string>
	<string name="all">Všetko</string>
	<string name="stats_timeframe_yesterday">Včera</string>
	<string name="stats_timeframe_today">Dnes</string>
	<string name="share_action">Zdielať</string>
	<string name="share_action_title">Pridať  ...</string>
	<string name="theme_auth_error_title">Preberanie témy sa nepodarilo</string>
	<string name="theme_set_success">Téma úspešne nastavená!</string>
	<string name="theme_activating_button">Aktivuje sa</string>
	<string name="theme_activate_button">Aktivovať</string>
	<string name="themes_features_label">Funkcie</string>
	<string name="themes_details_label">Detaily</string>
	<string name="media_edit_failure">Aktualizácia sa nepodarila</string>
	<string name="media_edit_success">Aktualizované</string>
	<string name="media_edit_description_hint">Zadajte popis</string>
	<string name="media_edit_caption_hint">Zadajte titulok</string>
	<string name="media_edit_title_hint">Zadajte nadpis</string>
	<string name="media_edit_description_text">Popis</string>
	<string name="media_edit_caption_text">Titulok</string>
	<string name="media_edit_title_text">Nadpis</string>
	<string name="stats_totals_clicks">Kliknutí</string>
	<string name="stats_totals_plays">Prehratí</string>
	<string name="stats_totals_views">Zobrazení</string>
	<string name="stats_entry_authors">Autor</string>
	<string name="stats_entry_tags_and_categories">Téma</string>
	<string name="stats_entry_posts_and_pages">Nadpis</string>
	<string name="stats_entry_country">Krajina</string>
	<string name="stats_timeframe_months">Mesiacov</string>
	<string name="stats_timeframe_weeks">Týždňov</string>
	<string name="stats_timeframe_days">Dní</string>
	<string name="passcode_preference_title">Uzamknutie PIN kódom</string>
	<string name="passcode_change_passcode">Zmeniť PIN</string>
	<string name="passcode_set">Nastaviť PIN</string>
	<string name="passcode_re_enter_passcode">Znova zadajte PIN kód</string>
	<string name="images">Obrázky</string>
	<string name="themes">Témy</string>
	<string name="passcode_enter_old_passcode">Zadajte starý PIN kód</string>
	<string name="passcode_enter_passcode">Zadajte PIN kód</string>
	<string name="passcode_manage">Spravovať funkciu overovanie PIN kódom</string>
	<string name="passcode_turn_on">Zapnúť funkciu overovanie PIN kódom</string>
	<string name="passcode_turn_off">Vypnúť funkciu overovanie PIN kódom</string>
	<string name="stats_view_tags_and_categories">Značky a kategórie</string>
	<string name="upload">Nahrať</string>
	<string name="notifications">Upozornenia</string>
	<string name="sign_in">Prihlásiť sa</string>
	<string name="more_notifications">a %d ďalším.</string>
	<string name="new_notifications">Počet nových upozornení: %d</string>
	<string name="note_reply_successful">Odpoveď zverejnená</string>
	<string name="follows">Sledovania</string>
	<string name="loading">Načítava sa...</string>
	<string name="httpuser">HTTP používateľské meno</string>
	<string name="httppassword">HTTP heslo</string>
	<string name="error_media_upload">Pri nahrávaní multimédií sa vyskytla chyba</string>
	<string name="content_description_add_media">Pridať súbor</string>
	<string name="post_content">Obsah (kliknutím pridajte text a súbor)</string>
	<string name="publish_date">Zverejniť</string>
	<string name="incorrect_credentials">Nesprávne používatelské meno alebo heslo.</string>
	<string name="username">Používatelské meno</string>
	<string name="password">Heslo</string>
	<string name="reader">Čitateľ</string>
	<string name="pages">Podstránky</string>
	<string name="featured_in_post">Vložiť obrázok do príspevku</string>
	<string name="caption">Titulok (voliteľný)</string>
	<string name="no_network_title">Sieť nedostupná</string>
	<string name="anonymous">Anonymný</string>
	<string name="posts">Príspevky</string>
	<string name="width">Šírka</string>
	<string name="post">Príspevok</string>
	<string name="page">Stránka</string>
	<string name="featured">Použiť ilustračný obrázok</string>
	<string name="blogusername">Používateľské meno</string>
	<string name="ok">OK</string>
	<string name="upload_scaled_image">Nahrať a zobraziť odkaz na zmenšený obrázok</string>
	<string name="scaled_image">Šírka zmenšeného obrázku</string>
	<string name="scheduled">Načasované</string>
	<string name="link_enter_url">URL adresa</string>
	<string name="version">Verzia</string>
	<string name="app_title">WordPress pre Android</string>
	<string name="tos">Zmluvné podmienky</string>
	<string name="image_alignment">Zarovnanie</string>
	<string name="refresh">Obnoviť</string>
	<string name="untitled">Bez názvu</string>
	<string name="edit">Upraviť</string>
	<string name="page_id">Strana</string>
	<string name="post_id">Príspevok</string>
	<string name="immediately">Okamžite</string>
	<string name="post_password">Heslo (voliteľné)</string>
	<string name="quickpress_add_alert_title">Nastaviť skrátené meno</string>
	<string name="today">Dnes</string>
	<string name="settings">Nastavenia</string>
	<string name="share_url">Zdielať URL adresu</string>
	<string name="quickpress_window_title">Vyberte blog pre QuickPress skratku</string>
	<string name="quickpress_add_error">Názov skratky nemôže byť prázdny</string>
	<string name="draft">Koncept</string>
	<string name="post_private">Súkromné</string>
	<string name="publish_post">Zverejniť</string>
	<string name="upload_full_size_image">Nahrať a odkázať na obrázok v plnom rozlíšení</string>
	<string name="categories">Kategórie</string>
	<string name="tags_separate_with_commas">Značky (oddeľte značky čiarkami)</string>
	<string name="title">Názov</string>
	<string name="notification_vibrate">Vibrovať</string>
	<string name="notification_blink">Blikať oznamovacie svetlo</string>
	<string name="status">Stav</string>
	<string name="location">Umiestnenie</string>
	<string name="sdcard_title">Vyžadovaná SD karta</string>
	<string name="select_video">Vyberte video z galérie</string>
	<string name="media">Súbory</string>
	<string name="delete">Zmazať</string>
	<string name="none">Žiadny</string>
	<string name="blogs">Blogy</string>
	<string name="select_photo">Vybrať foografiu z galérie</string>
	<string name="reply">Odpovedať</string>
	<string name="preview">Preview</string>
	<string name="on">na</string>
	<string name="cancel">Zrušiť</string>
	<string name="save">Uložiť</string>
	<string name="add">Pridať</string>
	<string name="notification_settings">Nastavenie upozornení</string>
	<string name="yes">Áno</string>
	<string name="no">Nie</string>
	<string name="error">Chyba</string>
	<string name="category_refresh_error">Chyba aktualizací kategorií</string>
</resources>
