<!DOCTYPE html>
<html lang="en-US" class="no-js">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width">
    <link rel="profile" href="http://gmpg.org/xfn/11">
    <link rel="pingback" href="http://mockserver/xmlrpc.php">
    <!--[if lt IE 9]>
    <script src="http://mockserver/wp-content/themes/twentyfifteen/js/html5.js"></script>
    <![endif]-->
    <script>(function(html){html.className = html.className.replace(/\bno-js\b/,'js')})(document.documentElement);</script>
    <title>wplogin &#8211; Just another WordPress site</title>
    <meta name='robots' content='noindex,follow' />
    <link rel="alternate" type="application/rss+xml" title="wplogin &raquo; Feed" href="http://mockserver/feed/" />
    <link rel="alternate" type="application/rss+xml" title="wplogin &raquo; Comments Feed" href="http://mockserver/comments/feed/" />
    <script type="text/javascript">
			window._wpemojiSettings = {"baseUrl":"https:\/\/s.w.org\/images\/core\/emoji\/72x72\/","ext":".png","source":{"concatemoji":"https:\/\/mockserver\/wp-includes\/js\/wp-emoji-release.min.js?ver=4.4.2"}};
			!function(a,b,c){function d(a){var c,d=b.createElement("canvas"),e=d.getContext&&d.getContext("2d"),f=String.fromCharCode;return e&&e.fillText?(e.textBaseline="top",e.font="600 32px Arial","flag"===a?(e.fillText(f(55356,56806,55356,56826),0,0),d.toDataURL().length>3e3):"diversity"===a?(e.fillText(f(55356,57221),0,0),c=e.getImageData(16,16,1,1).data.toString(),e.fillText(f(55356,57221,55356,57343),0,0),c!==e.getImageData(16,16,1,1).data.toString()):("simple"===a?e.fillText(f(55357,56835),0,0):e.fillText(f(55356,57135),0,0),0!==e.getImageData(16,16,1,1).data[0])):!1}function e(a){var c=b.createElement("script");c.src=a,c.type="text/javascript",b.getElementsByTagName("head")[0].appendChild(c)}var f,g;c.supports={simple:d("simple"),flag:d("flag"),unicode8:d("unicode8"),diversity:d("diversity")},c.DOMReady=!1,c.readyCallback=function(){c.DOMReady=!0},c.supports.simple&&c.supports.flag&&c.supports.unicode8&&c.supports.diversity||(g=function(){c.readyCallback()},b.addEventListener?(b.addEventListener("DOMContentLoaded",g,!1),a.addEventListener("load",g,!1)):(a.attachEvent("onload",g),b.attachEvent("onreadystatechange",function(){"complete"===b.readyState&&c.readyCallback()})),f=c.source||{},f.concatemoji?e(f.concatemoji):f.wpemoji&&f.twemoji&&(e(f.twemoji),e(f.wpemoji)))}(window,document,window._wpemojiSettings);
		</script>
    <style type="text/css">
        img.wp-smiley,
        img.emoji {
        display: inline !important;
        border: none !important;
        box-shadow: none !important;
        height: 1em !important;
        width: 1em !important;
        margin: 0 .07em !important;
        vertical-align: -0.1em !important;
        background: none !important;
        padding: 0 !important;
        }
    </style>
    <link rel='stylesheet' id='twentyfifteen-fonts-css'  href='https://fonts.googleapis.com/css?family=Noto+Sans%3A400italic%2C700italic%2C400%2C700%7CNoto+Serif%3A400italic%2C700italic%2C400%2C700%7CInconsolata%3A400%2C700&#038;subset=latin%2Clatin-ext' type='text/css' media='all' />
    <link rel='stylesheet' id='genericons-css'  href='http://mockserver/wp-content/themes/twentyfifteen/genericons/genericons.css?ver=3.2' type='text/css' media='all' />
    <link rel='stylesheet' id='twentyfifteen-style-css'  href='http://mockserver/wp-content/themes/twentyfifteen/style.css?ver=4.4.2' type='text/css' media='all' />
    <!--[if lt IE 9]>
    <link rel='stylesheet' id='twentyfifteen-ie-css'  href='http://mockserver/wp-content/themes/twentyfifteen/css/ie.css?ver=20141010' type='text/css' media='all' />
    <![endif]-->
    <!--[if lt IE 8]>
    <link rel='stylesheet' id='twentyfifteen-ie7-css'  href='http://mockserver/wp-content/themes/twentyfifteen/css/ie7.css?ver=20141010' type='text/css' media='all' />
    <![endif]-->
    <script type='text/javascript' src='http://mockserver/wp-includes/js/jquery/jquery.js?ver=1.11.3'></script>
    <script type='text/javascript' src='http://mockserver/wp-includes/js/jquery/jquery-migrate.min.js?ver=1.2.1'></script>
    <link rel='https://api.w.org/' href='http://mockserver/wp-json/' />
    <link rel="EditURI" type="application/rsd+xml" title="RSD" href="http://mockserver/xmlrpc.php?rsd" />
    <link rel="wlwmanifest" type="application/wlwmanifest+xml" href="http://mockserver/wp-includes/wlwmanifest.xml" />
    <meta name="generator" content="WordPress 4.4.2" />
    <style type="text/css">.recentcomments a{display:inline !important;padding:0 !important;margin:0 !important;}</style>
    <script type='text/javascript' src='http://mockserver/wp-includes/js/tw-sack.min.js?ver=1.6.1'></script>
</head>

<body class="home blog">
<div id="page" class="hfeed site">
    <a class="skip-link screen-reader-text" href="#content">Skip to content</a>

    <div id="sidebar" class="sidebar">
        <header id="masthead" class="site-header" role="banner">
            <div class="site-branding">
                <h1 class="site-title"><a href="http://mockserver/" rel="home">wplogin</a></h1>
                <p class="site-description">Just another WordPress site</p>
                <button class="secondary-toggle">Menu and widgets</button>
            </div><!-- .site-branding -->
        </header><!-- .site-header -->

        <div id="secondary" class="secondary">



            <div id="widget-area" class="widget-area" role="complementary">
                <aside id="search-2" class="widget widget_search"><form role="search" method="get" class="search-form" action="http://mockserver/">
                    <label>
                        <span class="screen-reader-text">Search for:</span>
                        <input type="search" class="search-field" placeholder="Search &hellip;" value="" name="s" title="Search for:" />
                    </label>
                    <input type="submit" class="search-submit screen-reader-text" value="Search" />
                </form></aside>		<aside id="recent-posts-2" class="widget widget_recent_entries">		<h2 class="widget-title">Recent Posts</h2>		<ul>
                <li>
                    <a href="http://mockserver/2016/03/03/hello-world/">Hello world!</a>
                </li>
            </ul>
            </aside>		<aside id="recent-comments-2" class="widget widget_recent_comments"><h2 class="widget-title">Recent Comments</h2><ul id="recentcomments"><li class="recentcomments"><span class="comment-author-link"><a href='https://wordpress.org/' rel='external nofollow' class='url'>Mr WordPress</a></span> on <a href="http://mockserver/2016/03/03/hello-world/#comment-1">Hello world!</a></li></ul></aside><aside id="archives-2" class="widget widget_archive"><h2 class="widget-title">Archives</h2>		<ul>
                <li><a href='http://mockserver/2016/03/'>March 2016</a></li>
            </ul>
            </aside><aside id="categories-2" class="widget widget_categories"><h2 class="widget-title">Categories</h2>		<ul>
                <li class="cat-item cat-item-1"><a href="http://mockserver/category/uncategorized/" >Uncategorized</a>
                </li>
            </ul>
            </aside><aside id="meta-2" class="widget widget_meta"><h2 class="widget-title">Meta</h2>			<ul>
                <li><a href="http://mockserver/wp-login.php">Log in</a></li>
                <li><a href="http://mockserver/feed/">Entries <abbr title="Really Simple Syndication">RSS</abbr></a></li>
                <li><a href="http://mockserver/comments/feed/">Comments <abbr title="Really Simple Syndication">RSS</abbr></a></li>
                <li><a href="https://wordpress.org/" title="Powered by WordPress, state-of-the-art semantic personal publishing platform.">WordPress.org</a></li>			</ul>
            </aside>			</div><!-- .widget-area -->

        </div><!-- .secondary -->

    </div><!-- .sidebar -->

    <div id="content" class="site-content">

        <div id="primary" class="content-area">
            <main id="main" class="site-main" role="main">




                <article id="post-1" class="post-1 post type-post status-publish format-standard hentry category-uncategorized">

                    <header class="entry-header">
                        <h2 class="entry-title"><a href="http://mockserver/2016/03/03/hello-world/" rel="bookmark">Hello world!</a></h2>	</header><!-- .entry-header -->

                    <div class="entry-content">
                        <p>Welcome to WordPress. This is your first post. Edit or delete it, then start writing!</p>
                    </div><!-- .entry-content -->


                    <footer class="entry-footer">
                        <span class="posted-on"><span class="screen-reader-text">Posted on </span><a href="http://mockserver/2016/03/03/hello-world/" rel="bookmark"><time class="entry-date published updated" datetime="2016-03-03T10:07:52+00:00">March 3, 2016</time></a></span><span class="comments-link"><a href="http://mockserver/2016/03/03/hello-world/#comments">1 Comment<span class="screen-reader-text"> on Hello world!</span></a></span>			</footer><!-- .entry-footer -->

                </article><!-- #post-## -->

            </main><!-- .site-main -->
        </div><!-- .content-area -->


    </div><!-- .site-content -->

    <footer id="colophon" class="site-footer" role="contentinfo">
        <div class="site-info">
            <a href="https://wordpress.org/">Proudly powered by WordPress</a>
        </div><!-- .site-info -->
    </footer><!-- .site-footer -->

</div><!-- .site -->

<script type='text/javascript' src='http://mockserver/wp-content/themes/twentyfifteen/js/skip-link-focus-fix.js?ver=20141010'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var screenReaderText = {"expand":"<span class=\"screen-reader-text\">expand child menu<\/span>","collapse":"<span class=\"screen-reader-text\">collapse child menu<\/span>"};
/* ]]> */
</script>
<script type='text/javascript' src='http://mockserver/wp-content/themes/twentyfifteen/js/functions.js?ver=20150330'></script>
<script type='text/javascript' src='http://mockserver/wp-includes/js/wp-embed.min.js?ver=4.4.2'></script>
<script type="text/javascript">
/* <![CDATA[ */
jQuery(document).ready( function($) {
	$("ul.menu").not(":has(li)").closest('div').prev('h3.widget-title').hide();
});
/* ]]> */
</script>
</body>
</html>
