<!--
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.
-->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta name="description" content="">
    <meta name="author" content="">

    <title>404 Page Not Found / {{ site.Title }}</title>

    {{ $favicon := "assets/img/favicon.ico" }}
    <link rel="icon" href="{{ $favicon | relURL }}">

    <!-- Bootstrap core CSS -->
    <link href="/assets/css/bootstrap.min.css" rel="stylesheet">

    <!-- Custom style -->
    <link href="/assets/css/style.css" rel="stylesheet">
</head>
<body class="light-grey">

{{ partial "header.html" . }}
{{ $configURL := printf "%s/blob/%s/config.toml" .Site.Params.siteRepositoryUrl .Site.Params.siteRepositorySourceBranch | safeURL }}

<div class="section">
    <div class="container">
        <div class="row py-4">
            <div class="col-sm-12 card">
                <div class="card-body pt-5">
                    <a class="edit-on-gh" href="{{ .Site.Params.siteRepositoryUrl }}/edit/{{ .Site.Params.siteRepositorySourceBranch }}/layouts/404.html" title="Edit this page on GitHub">Edit on GitHub</a>

                    <h1>404 Page Not Found</h1>

                    <p>
                        The page was moved or never existed. Use the menu above to navigate or go to <a href="{{ .Site.Home.RelPermalink }}">home page</a>.
                        If you noticed any site problem, typos, etc on any page, please correct
                        using the "Edit on GitHub" button or check on <a href="{{ .Site.Params.siteRepositoryUrl }}">{{ .Site.Params.siteRepositoryUrl }}</a>.
                        For example, the general site config is stored in the <a href="{{ $configURL }}"><code class="highlighter-rouge">config.toml</code></a>.
                    </p>
                </div>
            </div>
        </div>
    </div>
</div>

{{ partial "footer.html" . }}

</body>
</html>
