<!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
&quot;License&quot;); 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 &quot;AS IS&quot; 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">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <!-- The above 3 meta tags *must* come first in the head; any other head content must come *after* these tags -->
    <title>Pony Mail!</title>

    <!-- Bootstrap -->
    <!-- N.B. this page is invoked as part of a URL, e.g. permalink.html/mid, 
    so the relative links are different from the ones in most of the other html files -->
    <link href="../css/bootstrap.min.css" rel="stylesheet">
    <link href="../css/popup.css" rel="stylesheet">
    <link href="../css/solar.css" rel="alternate stylesheet" type="text/css" title="Solar theme" media="all">
    <link href="../css/metro.css" rel="alternate stylesheet" type="text/css" title="Metropolis" media="all">
    <link rel="stylesheet" href="//cdn.jsdelivr.net/font-hack/2.013/css/hack.min.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="getSingleEmail(unshortenID(window.location.pathname.substring(window.location.pathname.lastIndexOf('/')+1)));" style="margin: 20px;">
    
    <div class="row">
       <!-- Popup box for various notices -->
      <div style="display: none;" class="bs-callout bs-callout-success fade-in" id="popupper" style="margin: 2px !important; padding: 5px;">
      </div>
      <div id="email" class="col-md-8">
        
        
      </div>
      </div>
    </div>
  <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.3/jquery.min.js"></script>
    <!-- Include all compiled plugins (below), or include individual files as needed -->
    <!-- N.B. this page is invoked as part of a URL, e.g. permalink.html/mid, 
    so the relative links are different from the ones in most of the other html files -->
    <script src="../js/bootstrap.min.js"></script>
    <script src="../js/config.js"></script>
    <script src="../js/ponymail.js"></script>
    <script src="../js/weburl.js"></script>
    <div id="splash" class="splash fade-in"> &nbsp; </div>
     <noscript>
          <div class="bs-callout bs-callout-alert">
            This site requires JavaScript enabled. Please enable it.<br/>
            Or alternately, visit the <a href="?noscript">this page</a>
            to fetch the email as text.
          </div>
      </noscript>
  </body>
</html>