<!DOCTYPE html>
<!-- Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership. The
ASF licenses this file to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at .
http://www.apache.org/licenses/LICENSE-2.0 . Unless required by
applicable law or agreed to in writing, software distributed under the
License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES
OR CONDITIONS OF ANY KIND, either express or implied. See the License
for the specific language governing permissions and limitations under
the License. -->
<html lang="en">
  <head>
    <meta charset="utf-8">
    <base href="../">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=420, initial-scale=1">
    <!-- The above 3 meta tags *must* come first in the head; any other head content must come *after* these tags -->

    <!-- Left empty on purpose!-->
    <title></title>

    <!-- Bootstrap -->

    <link href="css/bootstrap.min.css" rel="stylesheet" media="all">
    <link href="css/scaffolding.css?revision=f3a4716" rel="stylesheet" media="all">
    <link href="css/modal.css" rel="stylesheet" media="all">
    <link href="css/spinner.css" rel="stylesheet" media="all">
    <link rel="alternate" href="/api/static.lua"/>
    <link rel="stylesheet" href="css/hack.css">

    <!-- HTML5 shim and Respond.js for IE8 support of HTML5 elements and media queries -->
    <!-- WARNING: Respond.js doesn't work if you view the page via file:// -->
    <!--[if lt IE 9]>
      <script src="https://oss.maxcdn.com/html5shiv/3.7.2/html5shiv.min.js"></script>
      <script src="https://oss.maxcdn.com/respond/1.4.2/respond.min.js"></script>
    <![endif]-->
  </head>

  <body onload="admin_init();">
    <header class="navbar navbar-default" style="margin-bottom: 0px; background: linear-gradient(to bottom, rgba(229,229,229,1) 0%,rgba(191,191,191,1) 100%);">
    <div class="container-fluid">
      <!-- Brand and toggle get grouped for better mobile display -->
      <div class="navbar-header collapse navbar-collapse">
      <a class="navbar-brand" href="./"><span><img src="images/foal.png" alt="Foal logo" style="margin-top: -10px !important;" height="30"/>&nbsp;<span class='hidden-xs title'>Pony Mail!</span></a>
      </div>

      <!-- User preferences and display options -->
      <div id="preferences">
        <ul class="nav" id="preferences_ul">
          <li class="dropdown navbar-right" id="login">
            <a href="#" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false"><img id="uimg" src="images/user_loggedout.png" alt="Logged out" style="width: 32px;"  title="Not logged in"/>
              <span class="caret"></span></a>
            <ul class="dropdown-menu" id="login_dropdown">
            </ul>
          </li>
        </ul>
      </div>

    </div>

    </header>

    <div class="container-fluid">
       <noscript>
          <div class="bs-callout bs-callout-alert">
            This site requires JavaScript enabled. Please enable it.
          </div>
      </noscript>
      <div class="row">

        <div id="panel">

        </div>
      </div>
    </div>
    <script src="js/jquery-1.12.4.min.js" integrity="sha256-ZosEbRLbNQzLpnKIkEdrPv7lOy9C27hHQ+Xp8a4MxAQ="></script>
    <!-- Include all compiled plugins (below), or include individual files as needed -->
    <script src="js/bootstrap.min.js"></script>
    <script src="js/config.js?revision=f3a4716"></script>
    <script src="js/wordcloud.js?revision=f3a4716"></script>
    <script src="js/ponymail.js?revision=f3a4716"></script>
    <div id="splash" class="splash fade-in"> &nbsp; </div>
    <div style="clear: both;"></div>
  </body>
</html>
