text: 'use strict';
  const MANIFEST = 'flutter-app-manifest';
  const TEMP = 'flutter-temp-cache';
  const CACHE_NAME = 'flutter-app-cache';
  const RESOURCES = {
    "assets/AssetManifest.json": "6be0f524d5903708d0fb80f8a7820134",
  "assets/assets/01.jpg": "70c1b02d105879dadf0f6a850a8bc2c6",
  "assets/assets/02.jpg": "714158bf91901ea598be04f6f7aae8bc",
  "assets/assets/03.jpg": "ca41d7ce2b42871dbd6782ea97655eef",
  "assets/assets/04.jpg": "c7f22a3c68b9fd844b57eccdb03eb419",
  "assets/assets/05.jpg": "29250bb0047aee580064080bd599e3d0",
  "assets/assets/06.jpg": "33b39b9f6974956eb02d9c7977b9dfe0",
  "assets/assets/07.jpg": "0863df335f920295059f4a8a118f62d0",
  "assets/assets/08.jpg": "0397d3a4c81d82894e2794e47e87bfcb",
  "assets/assets/09.jpg": "c4b917ae5452af6ce8221a316f93431c",
  "assets/assets/10.jpg": "5489ed284f49954521622c8c4374da07",
  "assets/assets/banner.jpg": "2030084328b776aa3be9fee2032a5920",
  "assets/assets/fonts/Lato-Bold.ttf": "2d15decc87393ec398f00dc3d7a2163d",
  "assets/assets/fonts/Lato-Regular.ttf": "c5eb54404c9dbda925f7142d6343c913",
  "assets/FontManifest.json": "ff6ea587a8d0d2b1bb92dcbc4395c088",
  "assets/fonts/MaterialIcons-Regular.otf": "1288c9e28052e028aba623321f7826ac",
  "assets/NOTICES": "f45de6e7e1dd6d217545dd13a0782df1",
  "assets/packages/cupertino_icons/assets/CupertinoIcons.ttf": "6d342eb68f170c97609e9da345464e5e",
  "favicon.png": "2086ecea0403b23c5ecaff3497da0440",
  "icons/Icon-192.png": "9fee251e1b831cbcedb13de3f8e1a1f2",
  "icons/Icon-512.png": "877bd4c66c7dae7ef462e6e86f294081",
  "index.html": "317173a5b825d015bb16a12d3be94da7",
  "/": "317173a5b825d015bb16a12d3be94da7",
  "main.dart.js": "72067f73d6f9adb23ec27a3f5fc0edaf",
  "manifest.json": "d3f5ff5c40024a005ed5e211dba95433",
  "version.json": "e10a5253d760dbcccf76c072e4d2a892"
  };
  
  // The application shell files that are downloaded before a service worker can
  // start.
  const CORE = [
    "/",
  "main.dart.js",
  "index.html",
  "assets/NOTICES",
  "assets/AssetManifest.json",
  "assets/FontManifest.json"];
  // During install, the TEMP cache is populated with the application shell files.
  self.addEventListener("install", (event) => {
    self.skipWaiting();
    return event.waitUntil(
      caches.open(TEMP).then((cache) => {
        return cache.addAll(
          CORE.map((value) => new Request(value + '?revision=' + RESOURCES[value], {'cache': 'reload'})));
      })
    );
  });
  
  // During activate, the cache is populated with the temp files downloaded in
  // install. If this service worker is upgrading from one with a saved
  // MANIFEST, then use this to retain unchanged resource files.
  self.addEventListener("activate", function(event) {
    return event.waitUntil(async function() {
      try {
        var contentCache = await caches.open(CACHE_NAME);
        var tempCache = await caches.open(TEMP);
        var manifestCache = await caches.open(MANIFEST);
        var manifest = await manifestCache.match('manifest');
        // When there is no prior manifest, clear the entire cache.
        if (!manifest) {
          await caches.delete(CACHE_NAME);
          contentCache = await caches.open(CACHE_NAME);
          for (var request of await tempCache.keys()) {
            var response = await tempCache.match(request);
            await contentCache.put(request, response);
          }
          await caches.delete(TEMP);
          // Save the manifest to make future upgrades efficient.
          await manifestCache.put('manifest', new Response(JSON.stringify(RESOURCES)));
          return;
        }
        var oldManifest = await manifest.json();
        var origin = self.location.origin;
        for (var request of await contentCache.keys()) {
          var key = request.url.substring(origin.length + 1);
          if (key == "") {
            key = "/";
          }
          // If a resource from the old manifest is not in the new cache, or if
          // the MD5 sum has changed, delete it. Otherwise the resource is left
          // in the cache and can be reused by the new service worker.
          if (!RESOURCES[key] || RESOURCES[key] != oldManifest[key]) {
            await contentCache.delete(request);
          }
        }
        // Populate the cache with the app shell TEMP files, potentially overwriting
        // cache files preserved above.
        for (var request of await tempCache.keys()) {
          var response = await tempCache.match(request);
          await contentCache.put(request, response);
        }
        await caches.delete(TEMP);
        // Save the manifest to make future upgrades efficient.
        await manifestCache.put('manifest', new Response(JSON.stringify(RESOURCES)));
        return;
      } catch (err) {
        // On an unhandled exception the state of the cache cannot be guaranteed.
        console.error('Failed to upgrade service worker: ' + err);
        await caches.delete(CACHE_NAME);
        await caches.delete(TEMP);
        await caches.delete(MANIFEST);
      }
    }());
  });
  
  // The fetch handler redirects requests for RESOURCE files to the service
  // worker cache.
  self.addEventListener("fetch", (event) => {
    if (event.request.method !== 'GET') {
      return;
    }
    var origin = self.location.origin;
    var key = event.request.url.substring(origin.length + 1);
    // Redirect URLs to the index.html
    if (key.indexOf('?v=') != -1) {
      key = key.split('?v=')[0];
    }
    if (event.request.url == origin || event.request.url.startsWith(origin + '/#') || key == '') {
      key = '/';
    }
    // If the URL is not the RESOURCE list then return to signal that the
    // browser should take over.
    if (!RESOURCES[key]) {
      return;
    }
    // If the URL is the index.html, perform an online-first request.
    if (key == '/') {
      return onlineFirst(event);
    }
    event.respondWith(caches.open(CACHE_NAME)
      .then((cache) =>  {
        return cache.match(event.request).then((response) => {
          // Either respond with the cached resource, or perform a fetch and
          // lazily populate the cache.
          return response || fetch(event.request).then((response) => {
            cache.put(event.request, response.clone());
            return response;
          });
        })
      })
    );
  });
  
  self.addEventListener('message', (event) => {
    // SkipWaiting can be used to immediately activate a waiting service worker.
    // This will also require a page refresh triggered by the main worker.
    if (event.data === 'skipWaiting') {
      self.skipWaiting();
      return;
    }
    if (event.data === 'downloadOffline') {
      downloadOffline();
      return;
    }
  });
  
  // Download offline will check the RESOURCES for all files not in the cache
  // and populate them.
  async function downloadOffline() {
    var resources = [];
    var contentCache = await caches.open(CACHE_NAME);
    var currentContent = {};
    for (var request of await contentCache.keys()) {
      var key = request.url.substring(origin.length + 1);
      if (key == "") {
        key = "/";
      }
      currentContent[key] = true;
    }
    for (var resourceKey of Object.keys(RESOURCES)) {
      if (!currentContent[resourceKey]) {
        resources.push(resourceKey);
      }
    }
    return contentCache.addAll(resources);
  }
  
  // Attempt to download the resource online before falling back to
  // the offline cache.
  function onlineFirst(event) {
    return event.respondWith(
      fetch(event.request).then((response) => {
        return caches.open(CACHE_NAME).then((cache) => {
          cache.put(event.request, response.clone());
          return response;
        });
      }).catch((error) => {
        return caches.open(CACHE_NAME).then((cache) => {
          return cache.match(event.request).then((response) => {
            if (response != null) {
              return response;
            }
            throw error;
          });
        });
      })
    );
  }
  