diff --git a/README.md b/README.md
index c7d2e15..68ee67d 100644
--- a/README.md
+++ b/README.md
@@ -1,27 +1,24 @@
 # python-mbtiles2compactcache
 (credits: https://github.com/Esri/raster-tiles-compactcache)
 
-## Compact Cache V2 sample code
+## Compact Cache V2
 
 ### mbtiles2compactcache.py
 
-Convert individual .mbtile files to the [Esri Compact Cache V2](./CompactCacheV2.md) format bundles.  It only builds individual bundles, not a completely functional cache.
+Convert a single raster/vector tiles .mbtile file to the [Esri Compact Cache V2](./CompactCacheV2.md) format bundles. It only builds a completely functional cache. This script is designed to export large to huge raster dataset mbtiles. the export occurs using multiple threads reading all records sequentially.
 
-While operational, this code is only provided as an example of how a bundle file is created and updated.
-This Python script takes two arguments, the input mbtile folder and the output folder. It assumes that the input folder contains mbtile files of the form: ```\<level#>.mbtile```.
+Requirement:
+- data must be in Web Mercator (EPSG:3857) 
+- the tiles table must be a rowid table. (if the tiles table is a view, please add the rowid field to the view.)
 
 The script does not check the input tile format, and assumes that all the files under the source contain valid SQLLite databases with tiles in MBTiles format. 
-The algorithm loops over files, inserting each tile in the appropriate bundle. It keeps one bundle open in case the next tile fits in the same bundle.  In most cases this combination results in good performance.
+The algorithm loops over the records, inserting each tile in the appropriate bundle. Each thread writes its records in a bundle and then close it.
 
-The [sample_mbtiles](./sample_mbtiles) folder contains example [MBTiles](./sample_mbtiles/README.md) the form of SQLite databases for the single zoom levels for the first three level of the Federal Agency for Cartography and Geodesy - TopPlusOpen cache in Web Mercator projection.  The [sample_cache] (../sample_cache) folder contains a Compact Cache V2 cache produced from these individual mbtiles using the mbtiles2compactcache.py script. The commands used to generate the bundles for each level are:
+The [file](./file) folder contains example [MBTiles]
+The [cache] (./cache) folder contains a Compact Cache V2 cache produced as result of the mbtiles2compactcache.py script. The commands used to generate the cache is:
 
-RGB processing:
 ```console
-python sample_code\mbtiles2compactcache.py -i sample_mbtiles -o sample_cache\_alllayers
-```
-Grayscale processing:
-```console
-python sample_code\mbtiles2compactcache.py -i sample_mbtiles -o sample_cache\_alllayers -g
+python .\code\mbtiles2compactcache.py -ml 15 -s .\file\countries-raster.mbtiles -d .\cache\A3_MyCachedService\Layers\_alllayers
 ```
 
 ## Documentation and sample code for Esri Compact Cache V2 format
@@ -34,7 +31,7 @@ The Compact Cache V2 is the current file format used by ArcGIS to store raster t
 | Row 1 | Row 1 Col 0 | Row 1 Col 1 |
 
 ## Content
-This repository contains [documentation](CompactCacheV2.md), a [sample cache](sample_cache) and a Python 2.x [code example](sample_code) of how to build Compact Cache V2 bundles from MBTiles.
+This repository contains [documentation](CompactCacheV2.md), a [cache](cache) and a Python 3.x [code example](code) of how to build Compact Cache V2 bundles from MBTiles.
 
 ## Licensing
 
diff --git a/code/check_contiguous_tiles.py b/code/check_contiguous_tiles.py
new file mode 100644
index 0000000..1ad29a0
--- /dev/null
+++ b/code/check_contiguous_tiles.py
@@ -0,0 +1,101 @@
+# -------------------------------------------------------------------------------
+# Name:        check_contiguous_tiles
+# Purpose:     Check if there is no hole (missing tiles) in a bundle.
+#
+# Author:      ltbam
+#
+# Created:     18/07/2022
+# Modified:    -
+#
+#  Copyright 2023 swisstopo.
+#
+#  Licensed 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.?
+#
+# -------------------------------------------------------------------------------
+# Changeset
+# Version 1.0.0 ltbam
+from mbtilesRaster2compactcache import Bundle
+import os
+import math
+
+
+cache_output_folder = r"C:\Temp\osm\A3_MyCachedService\Layers"
+
+def main():
+    print("Checking contiguous tiles in Bundle")
+    for path, subdirs, files in os.walk(cache_output_folder):
+        for name in files:
+            if name.endswith(".bundle"):
+                bdl = Bundle(os.path.join(path, name))
+                bdl.open()
+                results = listMissingTiles(bdl)
+                if len(results) == 0:
+                    print("bundle {} is ok".format(name))
+                else:
+                    for res in results:
+                        print("Missing contiguous tile: level {}, row {}, col {}".format(res["lvl"], res["row"],
+                                                                                         res["col"]))
+                # close bundle without writing anything
+                bdl.fd.close()
+                bdl.fd = None
+
+def listMissingTiles(bundle):
+    files = []
+    # Loop each Tile index and resolve if it has data
+    # range(0, 128) means 0-127
+    for row in range(0, 128):
+        startTile = 0
+        numTiles = 0
+        # count tiles with data, determine drawing center
+        for col in range(0, 128):
+            t_idx = bundle.curr_index[128 * row + col]
+            t_size = int(math.floor(t_idx / Bundle.M))
+            if t_size > 0:
+                numTiles += 1
+                if startTile == 0:
+                    startTile = col
+
+        if numTiles > 3:
+            data_started = False
+            mid_range = startTile + numTiles // 2
+            # print("lvl {} row {} mid_range: {}".format(bundle.level, row, mid_range))
+            # inspect from left
+            # range(0, 128) means 0-127
+            for col in range(0, mid_range):
+                t_idx = bundle.curr_index[128 * row + col]
+                t_size = int(math.floor(t_idx / Bundle.M))
+                if data_started:
+                    if t_size == 0:
+                        absrow = bundle.row_offset + row
+                        abscol = bundle.col_offset + col
+                        files.append(dict(col=abscol, row=absrow, lvl=int(bundle.level)))
+                else:
+                    if t_size != 0:
+                        data_started = True
+            data_started = False
+            # inspect from right
+            for col in range(127, mid_range - 1, -1):
+                t_idx = bundle.curr_index[128 * row + col]
+                t_size = int(math.floor(t_idx / Bundle.M))
+                if data_started:
+                    if t_size == 0:
+                        absrow = bundle.row_offset + row
+                        abscol = bundle.col_offset + col
+                        files.append(dict(col=abscol, row=absrow, lvl=int(bundle.level)))
+                else:
+                    if t_size != 0:
+                        data_started = True
+
+    return files
+
+if __name__ == '__main__':
+    main()
diff --git a/code/mbtiles2compactcache.py b/code/mbtiles2compactcache.py
new file mode 100644
index 0000000..d6f1bb8
--- /dev/null
+++ b/code/mbtiles2compactcache.py
@@ -0,0 +1,434 @@
+# -------------------------------------------------------------------------------
+# Name:        mbtilesRaster2compactcache
+# Purpose:     Build compact cache V2 bundles from single MBTiles Raster dataset file.
+#
+# Author:      ltbam, luci6974
+#
+# Created:     18/07/2022
+# Modified:    -
+#
+#  Copyright 2022 swisstopo. 2016 ESRI
+#
+#  Licensed 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.?
+#
+# -------------------------------------------------------------------------------
+#
+# Converts .mbtile file to the esri Compact Cache V2 format
+#
+# Takes two arguments, the first one is the input .mbfile folder
+# the second one being the output cache folder (_alllayers)
+#
+#
+# This script is intended to transform big Files, so it will loop each record
+# and resolve is it has to be exported based on the maxlvl parameter.
+#
+# It does not check the input tile format, and assumes that the file
+# is a valid sqlite tile databases.
+#
+# -------------------------------------------------------------------------------
+#
+# Changeset
+# Version 1.0.0 ltbam
+
+import argparse
+import sqlite3
+import os
+import struct
+import shutil
+import datetime
+import re
+import io
+import time
+import math
+
+from queue import Queue
+from threading import Lock, get_ident, Thread
+import multiprocessing
+
+
+class Bundle:
+    # Bundle linear size in tiles
+    BSZ = 128
+    # Tiles per bundle
+    BSZ2 = BSZ ** 2
+    # Index size in bytes
+    IDXSZ = BSZ2 * 8
+    # Max size
+    M = 2 ** 40
+
+    def __init__(self, file_name):
+        self.file_name = file_name
+        self.curr_max = 0
+        self.curr_offset = 0
+        self.curr_index = []
+        self.lock = Lock()
+        self.fd = None
+        regex = r"L(..)"
+        self.level = re.findall(regex, self.file_name)[0]
+        fname = self.file_name.split('.bundle')[0].split('\\')[-1]
+        s_val = fname[1:].split('C')
+        self.row_offset = int(s_val[0], 16)
+        self.col_offset = int(s_val[1], 16)
+        if not os.path.exists(self.file_name):
+            self.init_content()
+
+    def init_content(self):
+        # print("t {0}: initializing: {1}".format(get_ident(), self.file_name))
+        self.fd = open(self.file_name, "wb")
+        # Empty bundle file header, lots of magic numbers
+        header = struct.pack("<4I3Q6I",
+                             3,  # Version
+                             Bundle.BSZ2,  # numRecords
+                             0,  # maxRecord Size
+                             5,  # Offset Size
+                             0,  # Slack Space
+                             64 + Bundle.IDXSZ,  # File Size
+                             40,  # User Header Offset.
+                             20 + Bundle.IDXSZ,  # User Header Size
+                             3,  # Legacy 1
+                             16,  # Legacy 2
+                             Bundle.BSZ2,  # Legacy 3
+                             5,  # Legacy 4
+                             Bundle.IDXSZ  # Index Size
+                             )
+        self.fd.write(header)
+        # Write empty index.
+        self.fd.write(struct.pack("<{}Q".format(Bundle.BSZ2), *((0,) * Bundle.BSZ2)))
+        self.fd.close()
+        self.fd = None
+
+    def open(self):
+        # Open the bundle
+        # wait a bit if a thread closed a File before opening it again
+        self.fd = open(self.file_name, "r+b")
+        # Read the current max record size
+        self.fd.seek(8)
+        self.curr_max = int(struct.unpack("<I", self.fd.read(4))[0])
+        # Read the index as longs in a list
+        self.fd.seek(64)
+        self.curr_index = list(struct.unpack("<{}Q".format(Bundle.BSZ2),
+                                             self.fd.read(Bundle.IDXSZ)))
+        # Go to end
+        self.fd.seek(0, os.SEEK_END)
+        self.curr_offset = self.fd.tell()
+
+    def write_tile(self, tile, tile_size, row, col):
+        self.fd.write(struct.pack("<I", tile_size))
+        self.fd.write(tile)
+        self.curr_offset += 4
+        # Update the index, row major
+        self.curr_index[(row % Bundle.BSZ) * Bundle.BSZ + col % Bundle.BSZ] = self.curr_offset + (tile_size << 40)
+        self.curr_offset += tile_size
+        # Update the current bundle max tile size
+        self.curr_max = max(self.curr_max, tile_size)
+
+    def cleanup(self):
+        """
+        Updates header and closes the current bundle
+        """
+        # Update the max rec size and file size, then close the file
+        self.fd.seek(8)
+        self.fd.write(struct.pack("<I", self.curr_max))
+        self.fd.seek(24)
+        self.fd.write(struct.pack("<Q", self.curr_offset))
+        self.fd.seek(64)
+        self.fd.write(struct.pack("<{}Q".format(Bundle.BSZ2), *self.curr_index))
+        self.fd.close()
+        self.fd = None
+        # print("t {0}: cleaned up: {1}".format(get_ident(), self.file_name))
+        # time.sleep(0.2)
+
+
+class BundleManager:
+    b_list = {}
+
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def fetch_worker(mb_tile_file, max_level, queue, num_workers):
+        """
+        Single thread that owns the DB cursor and feeds batches into the queue.
+        Uses fetchmany() for efficient streaming without OFFSET scanning.
+        """
+        database = sqlite3.connect(mb_tile_file)
+        row_cursor = database.cursor()
+
+        if max_level != -1:
+            row_cursor.execute(
+                'SELECT zoom_level, tile_column, tile_row, tile_data '
+                'FROM tiles WHERE zoom_level <= ?', (max_level,)
+            )
+        else:
+            row_cursor.execute(
+                'SELECT zoom_level, tile_column, tile_row, tile_data FROM tiles'
+            )
+
+        while True:
+            rows = row_cursor.fetchmany(Application.rec_per_request)
+            if not rows:
+                break
+            queue.put(rows)  # blocks naturally if workers are slow (backpressure)
+
+        # Poison pill: one per worker so each exits cleanly
+        for _ in range(num_workers):
+            queue.put(None)
+
+        row_cursor.close()
+        database.close()
+
+    @staticmethod
+    def process(queue, arguments):
+        """
+        Worker thread: pulls batches from the queue and writes bundle files.
+        Exits when it receives the None poison pill.
+        """
+
+        while True:
+            batch = queue.get()
+            if batch is None:  # poison pill — this worker is done
+                break
+
+            data = {}
+            for rec in batch:
+                level = 'L' + '{:02d}'.format(rec[0])
+                output_path = os.path.join(arguments.destination, level)
+                max_rows = 2 ** int(rec[0]) - 1
+                tile = io.BytesIO(rec[3]).getvalue()
+                row = max_rows - int(rec[2])
+                col = int(rec[1])
+
+                # Resolve the bundle
+                start_row = (row // Bundle.BSZ) * Bundle.BSZ
+                start_col = (col // Bundle.BSZ) * Bundle.BSZ
+                bname = "R{:04x}C{:04x}".format(start_row, start_col)
+                fname = os.path.join(output_path, bname + ".bundle")
+
+                if fname not in data:
+                    data[fname] = []
+                data[fname].append([fname, tile, row, col])
+
+            if data:
+                BundleManager.add_tiles(data, arguments.lock)
+
+    @staticmethod
+    def add_tiles(data, lock):
+        for bundle in data.keys():
+
+            # init list one bundle/object at a time
+            with lock:
+                if bundle not in BundleManager.b_list:
+                    BundleManager.b_list[bundle] = Bundle(bundle)
+
+            # lock write operation on the bundle per thread
+            # print("t {0}: enter lock: {1}".format(get_ident(), bundle))
+            with BundleManager.b_list[bundle].lock:
+                if not BundleManager.b_list[bundle].fd:
+                    BundleManager.b_list[bundle].open()
+                for t in data[bundle]:
+                    tile = t[1]
+                    tile_size = len(t[1])
+                    row = t[2]
+                    col = t[3]
+                    # print("add tile row:{0} col:{1} buff:{2} path:{3}".format(row, col, tile_size, bundle))
+                    # Open or create it, seek to end of bundle file
+                    BundleManager.b_list[bundle].write_tile(tile, tile_size, row, col)
+
+                BundleManager.b_list[bundle].cleanup()
+                # free written bundle from mem.
+                del BundleManager.b_list[bundle]
+
+            # print("t {0}: left lock: {1}".format(get_ident(), bundle))
+
+    @staticmethod
+    def add_tile(output_path, byte_buffer, row, col=None):
+        """
+        Add this tile to the output cache
+
+        :param output_path: path where the bundle is.
+        :param byte_buffer: input tile as byte buffer
+        :param row: row number
+        :param col: column number
+        """
+
+        # Read the tile data
+        tile = io.BytesIO(byte_buffer).getvalue()
+        tile_size = len(tile)
+
+        # resolve the bundle
+        start_row = int((row / Bundle.BSZ)) * Bundle.BSZ
+        start_col = int((col / Bundle.BSZ)) * Bundle.BSZ
+        bname = "R{:04x}C{:04x}".format(start_row, start_col)
+        fname = os.path.join(output_path, bname + ".bundle")
+
+        print("add tile row:{0} col:{1} buff:{2} path:{3}".format(row, col, len(byte_buffer), output_path))
+
+        # should be thread safe
+        if not fname in BundleManager.b_list:
+            BundleManager.b_list[fname] = Bundle(fname)
+
+        # lock write operation on the bundle per thread
+        with BundleManager.b_list[fname].lock:
+            print("t {0}: enter lock: {1}".format(get_ident(), fname))
+            # Open or create it, seek to end of bundle file
+            if not BundleManager.b_list[fname].fd:
+                BundleManager.b_list[fname].open()
+
+            BundleManager.b_list[fname].write_tile(tile, tile_size, row, col)
+            BundleManager.b_list[fname].cleanup()
+            print("t {0}: left lock: {1}".format(get_ident(), fname))
+
+        return fname
+
+
+class Application:
+    # Number of concurrent jobs for the export
+    p_jobs = multiprocessing.cpu_count()
+    # Records per fetchmany() call — used as the streaming chunk size
+    rec_per_request = 500000
+    # Queue depth: don't let the fetcher run too far ahead of workers
+    queue_maxsize = p_jobs * 2
+
+    def __init__(self):
+        self.bm = BundleManager()
+
+    @staticmethod
+    def get_arguments():
+        """
+        Parses commandline arguments.
+
+        :return: commandline arguments
+        """
+        parser = argparse.ArgumentParser()
+
+        parser.add_argument('-s', '--source',
+                            help='Input folder containing the mbtile files.', required=True)
+        parser.add_argument('-d', '--destination',
+                            help='Output for level folders.', required=True)
+        parser.add_argument('-ml', '--max_level',
+                            help='Do until this Level. If omitted, the maximum zoom level '
+                                 'present in the MBTiles file is used automatically.',
+                            default=-1, type=int, required=False)
+
+        # Return the command line arguments.
+        arguments = parser.parse_args()
+
+        # validate folder parameters
+        if not os.path.exists(arguments.source):
+            parser.error("Input folder does not exist or is inaccessible.")
+
+        return arguments
+
+
+def get_max_level(mb_tile_file):
+    """
+    Resolve the maximum zoom level present in the MBTiles file.
+
+    Strategy (fastest-first, safe for very large files):
+      1. Check the 'metadata' table for the 'maxzoom' key — O(1) lookup,
+         no tile rows touched at all.
+      2. Fall back to SELECT MAX(zoom_level) FROM tiles — SQLite resolves
+         this via the index on (zoom_level, tile_column, tile_row) without
+         a full table scan.
+
+    :param mb_tile_file: path to the .mbtiles SQLite file
+    :return: integer max zoom level
+    :raises RuntimeError: if the level cannot be determined
+    """
+    db = sqlite3.connect(mb_tile_file)
+    try:
+        # 1. Fast path: metadata table
+        try:
+            cur = db.execute(
+                "SELECT value FROM metadata WHERE name = 'maxzoom' LIMIT 1"
+            )
+            row = cur.fetchone()
+            if row is not None:
+                return int(row[0])
+        except sqlite3.DatabaseError:
+            pass  # metadata table absent — fall through
+
+        # 2. Index-assisted MAX() scan on the tiles table
+        cur = db.execute("SELECT MAX(zoom_level) FROM tiles")
+        row = cur.fetchone()
+        if row is not None and row[0] is not None:
+            return int(row[0])
+
+        raise RuntimeError(
+            "Cannot determine max zoom level: 'tiles' table appears to be empty."
+        )
+    finally:
+        db.close()
+
+
+#
+# Entry point, start the Application
+#
+def main():
+    app = Application()
+    arguments = app.get_arguments()
+    arguments.lock = Lock()
+
+    # parse parameters
+    mb_tile_file = arguments.source
+    cache_output_folder = arguments.destination
+    max_level_param = arguments.max_level
+    print('Input file: {0}'.format(os.path.basename(mb_tile_file)))
+
+    # Resolve max zoom level when not provided by the user
+    if max_level_param == -1:
+        print('--max_level not specified, querying MBTiles file…')
+        max_level_param = get_max_level(mb_tile_file)
+        print('Max zoom level detected: {0}'.format(max_level_param))
+
+    # prepare output template
+    if os.path.exists(cache_output_folder):
+        shutil.rmtree(cache_output_folder)
+
+    # creating lvl directories
+    for lvl in range(max_level_param + 1):
+        level = 'L' + '{:02d}'.format(lvl)
+        dir = os.path.join(cache_output_folder, level)
+        if not os.path.exists(dir):
+            os.makedirs(dir)
+
+    start_time = datetime.datetime.now()
+
+    # One fetcher feeds all workers via a bounded queue (backpressure built-in)
+    queue = Queue(maxsize=Application.queue_maxsize)
+
+    fetcher = Thread(
+        target=BundleManager.fetch_worker,
+        args=(mb_tile_file, max_level_param, queue, app.p_jobs)
+    )
+    workers = [
+        Thread(target=BundleManager.process, args=(queue, arguments))
+        for _ in range(app.p_jobs)
+    ]
+
+    print('Exporting {0} rows at a time within {1} threads.'.format(
+        app.rec_per_request, app.p_jobs))
+
+    fetcher.start()
+    for w in workers:
+        w.start()
+
+    fetcher.join()
+    for w in workers:
+        w.join()
+
+    elapsed = (datetime.datetime.now() - start_time).total_seconds()
+    print('Done in {:.2f}s'.format(elapsed))
+
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/file/countries-raster-1.mbtiles b/file/countries-raster-1.mbtiles
new file mode 100644
index 0000000..78692ed
Binary files /dev/null and b/file/countries-raster-1.mbtiles differ
diff --git a/file/countries-raster-5.mbtiles b/file/countries-raster-5.mbtiles
new file mode 100644
index 0000000..e942a28
Binary files /dev/null and b/file/countries-raster-5.mbtiles differ
diff --git a/file/countries-raster.mbtiles b/file/countries-raster.mbtiles
new file mode 100644
index 0000000..cf2c684
Binary files /dev/null and b/file/countries-raster.mbtiles differ
diff --git a/sample_cache/_alllayers/L00/R0000C0000.bundle b/sample_cache/_alllayers/L00/R0000C0000.bundle
deleted file mode 100644
index 8020f2a..0000000
Binary files a/sample_cache/_alllayers/L00/R0000C0000.bundle and /dev/null differ
diff --git a/sample_cache/_alllayers/L01/R0000C0000.bundle b/sample_cache/_alllayers/L01/R0000C0000.bundle
deleted file mode 100644
index c250d85..0000000
Binary files a/sample_cache/_alllayers/L01/R0000C0000.bundle and /dev/null differ
diff --git a/sample_cache/_alllayers/L02/R0000C0000.bundle b/sample_cache/_alllayers/L02/R0000C0000.bundle
deleted file mode 100644
index 6ad0663..0000000
Binary files a/sample_cache/_alllayers/L02/R0000C0000.bundle and /dev/null differ
diff --git a/sample_cache/conf.xml b/sample_cache/conf.xml
deleted file mode 100644
index b28569a..0000000
--- a/sample_cache/conf.xml
+++ /dev/null
@@ -1,142 +0,0 @@
-<?xml version="1.0" encoding="utf-8" ?>
-<CacheInfo xsi:type='typens:CacheInfo' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:typens='http://www.esri.com/schemas/ArcGIS/10.5'>
-	<TileCacheInfo xsi:type='typens:TileCacheInfo'>
-		<SpatialReference xsi:type='typens:ProjectedCoordinateSystem'>
-			<WKT>PROJCS[&quot;WGS_1984_Web_Mercator_Auxiliary_Sphere&quot;,GEOGCS[&quot;GCS_WGS_1984&quot;,DATUM[&quot;D_WGS_1984&quot;,SPHEROID[&quot;WGS_1984&quot;,6378137.0,298.257223563]],PRIMEM[&quot;Greenwich&quot;,0.0],UNIT[&quot;Degree&quot;,0.0174532925199433]],PROJECTION[&quot;Mercator_Auxiliary_Sphere&quot;],PARAMETER[&quot;False_Easting&quot;,0.0],PARAMETER[&quot;False_Northing&quot;,0.0],PARAMETER[&quot;Central_Meridian&quot;,0.0],PARAMETER[&quot;Standard_Parallel_1&quot;,0.0],PARAMETER[&quot;Auxiliary_Sphere_Type&quot;,0.0],UNIT[&quot;Meter&quot;,1.0],AUTHORITY[&quot;EPSG&quot;,3857]]</WKT>
-			<XOrigin>-20037700</XOrigin>
-			<YOrigin>-30241100</YOrigin>
-			<XYScale>148923141.92838538</XYScale>
-			<ZOrigin>-100000</ZOrigin>
-			<ZScale>10000</ZScale>
-			<MOrigin>-100000</MOrigin>
-			<MScale>10000</MScale>
-			<XYTolerance>0.001</XYTolerance>
-			<ZTolerance>0.001</ZTolerance>
-			<MTolerance>0.001</MTolerance>
-			<HighPrecision>true</HighPrecision>
-			<WKID>102100</WKID>
-			<LatestWKID>3857</LatestWKID>
-		</SpatialReference>
-		<TileOrigin xsi:type='typens:PointN'>
-			<X>-20037508.342787001</X>
-			<Y>20037508.342787001</Y>
-		</TileOrigin>
-		<TileCols>256</TileCols>
-		<TileRows>256</TileRows>
-		<DPI>96</DPI>
-		<LODInfos xsi:type='typens:ArrayOfLODInfo'>
-			<LODInfo xsi:type='typens:LODInfo'>
-				<LevelID>0</LevelID>
-				<Scale>591657527.591555</Scale>
-				<Resolution>156543.03392799999</Resolution>
-			</LODInfo>
-			<LODInfo xsi:type='typens:LODInfo'>
-				<LevelID>1</LevelID>
-				<Scale>295828763.79577702</Scale>
-				<Resolution>78271.516963999893</Resolution>
-			</LODInfo>
-			<LODInfo xsi:type='typens:LODInfo'>
-				<LevelID>2</LevelID>
-				<Scale>147914381.89788899</Scale>
-				<Resolution>39135.758482000099</Resolution>
-			</LODInfo>
-			<LODInfo xsi:type='typens:LODInfo'>
-				<LevelID>3</LevelID>
-				<Scale>73957190.948944002</Scale>
-				<Resolution>19567.879240999901</Resolution>
-			</LODInfo>
-			<LODInfo xsi:type='typens:LODInfo'>
-				<LevelID>4</LevelID>
-				<Scale>36978595.474472001</Scale>
-				<Resolution>9783.9396204999593</Resolution>
-			</LODInfo>
-			<LODInfo xsi:type='typens:LODInfo'>
-				<LevelID>5</LevelID>
-				<Scale>18489297.737236001</Scale>
-				<Resolution>4891.9698102499797</Resolution>
-			</LODInfo>
-			<LODInfo xsi:type='typens:LODInfo'>
-				<LevelID>6</LevelID>
-				<Scale>9244648.8686180003</Scale>
-				<Resolution>2445.9849051249898</Resolution>
-			</LODInfo>
-			<LODInfo xsi:type='typens:LODInfo'>
-				<LevelID>7</LevelID>
-				<Scale>4622324.4343090001</Scale>
-				<Resolution>1222.9924525624899</Resolution>
-			</LODInfo>
-			<LODInfo xsi:type='typens:LODInfo'>
-				<LevelID>8</LevelID>
-				<Scale>2311162.2171550002</Scale>
-				<Resolution>611.49622628138002</Resolution>
-			</LODInfo>
-			<LODInfo xsi:type='typens:LODInfo'>
-				<LevelID>9</LevelID>
-				<Scale>1155581.108577</Scale>
-				<Resolution>305.74811314055802</Resolution>
-			</LODInfo>
-			<LODInfo xsi:type='typens:LODInfo'>
-				<LevelID>10</LevelID>
-				<Scale>577790.55428899999</Scale>
-				<Resolution>152.874056570411</Resolution>
-			</LODInfo>
-			<LODInfo xsi:type='typens:LODInfo'>
-				<LevelID>11</LevelID>
-				<Scale>288895.27714399999</Scale>
-				<Resolution>76.437028285073197</Resolution>
-			</LODInfo>
-			<LODInfo xsi:type='typens:LODInfo'>
-				<LevelID>12</LevelID>
-				<Scale>144447.638572</Scale>
-				<Resolution>38.218514142536598</Resolution>
-			</LODInfo>
-			<LODInfo xsi:type='typens:LODInfo'>
-				<LevelID>13</LevelID>
-				<Scale>72223.819285999998</Scale>
-				<Resolution>19.109257071268299</Resolution>
-			</LODInfo>
-			<LODInfo xsi:type='typens:LODInfo'>
-				<LevelID>14</LevelID>
-				<Scale>36111.909642999999</Scale>
-				<Resolution>9.5546285356341496</Resolution>
-			</LODInfo>
-			<LODInfo xsi:type='typens:LODInfo'>
-				<LevelID>15</LevelID>
-				<Scale>18055.954822</Scale>
-				<Resolution>4.7773142679493699</Resolution>
-			</LODInfo>
-			<LODInfo xsi:type='typens:LODInfo'>
-				<LevelID>16</LevelID>
-				<Scale>9027.9774109999998</Scale>
-				<Resolution>2.38865713397468</Resolution>
-			</LODInfo>
-			<LODInfo xsi:type='typens:LODInfo'>
-				<LevelID>17</LevelID>
-				<Scale>4513.9887049999998</Scale>
-				<Resolution>1.1943285668550501</Resolution>
-			</LODInfo>
-			<LODInfo xsi:type='typens:LODInfo'>
-				<LevelID>18</LevelID>
-				<Scale>2256.994353</Scale>
-				<Resolution>0.59716428355981699</Resolution>
-			</LODInfo>
-			<LODInfo xsi:type='typens:LODInfo'>
-				<LevelID>19</LevelID>
-				<Scale>1128.4971760000001</Scale>
-				<Resolution>0.29858214164761698</Resolution>
-			</LODInfo>
-		</LODInfos>
-		<PreciseDPI>96</PreciseDPI>
-	</TileCacheInfo>
-	<TileImageInfo xsi:type='typens:TileImageInfo'>
-		<CacheTileFormat>PNG32</CacheTileFormat>
-		<CompressionQuality>0</CompressionQuality>
-		<Antialiasing>false</Antialiasing>
-		<BandCount>1</BandCount>
-		<LERCError>0</LERCError>
-	</TileImageInfo>
-	<CacheStorageInfo xsi:type='typens:CacheStorageInfo'>
-		<StorageFormat>esriMapCacheStorageModeCompactV2</StorageFormat>
-		<PacketSize>128</PacketSize>
-	</CacheStorageInfo>
-</CacheInfo>
\ No newline at end of file
diff --git a/sample_code/README.md b/sample_code/README.md
deleted file mode 100644
index 9789163..0000000
--- a/sample_code/README.md
+++ /dev/null
@@ -1,35 +0,0 @@
-# Compact Cache V2 sample code
-
-## mbtiles2compactcache.py
-
-Convert individual .mbtile files to the [Esri Compact Cache V2](../CompactCacheV2.md) format bundles.  It only builds individual bundles, not a completely functional cache.
-
-While operational, this code is only provided as an example of how a bundle file is created and updated.
-This Python script takes two arguments, the input mbtile folder and the output folder. It assumes that the input folder contains mbtile files of the form: ```\<level#>.mbtile```.
-
-The script does not check the input tile format, and assumes that all the files under the source contain valid SQLLite databases with tiles in MBTiles format. 
-The algorithm loops over files, inserting each tile in the appropriate bundle. It keeps one bundle open in case the next tile fits in the same bundle.  In most cases this combination results in good performance.
-
-The [sample_mbtiles](../sample_mbtiles) folder contains example [MBTiles](../sample_mbtiles/README.md) the form of SQLite databases for the single zoom levels for the first three level of the Federal Agency for Cartography and Geodesy - TopPlusOpen cache in Web Mercator projection.  The [sample_cache] (../sample_cache) folder contains a Compact Cache V2 cache produced from these individual mbtiles using the mbtiles2compactcache.py script. The commands used to generate the bundles for each level are:
-
-RGB processing:
-``` console
-python sample_code\mbtiles2compactcache.py -i sample_mbtiles -o sample_cache\_alllayers
-```
-Grayscale processing:
-``` console
-python sample_code\mbtiles2compactcache.py -i sample_mbtiles -o sample_cache\_alllayers -g
-```
-
-## Licensing
-
-Copyright 2018 Esri Deutschland GmbH
-
-Licensed 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.
-
-A copy of the license is available in the repository's license.txt file.
-
diff --git a/sample_code/mbtiles2compactcache.py b/sample_code/mbtiles2compactcache.py
deleted file mode 100644
index 1ea27b7..0000000
--- a/sample_code/mbtiles2compactcache.py
+++ /dev/null
@@ -1,404 +0,0 @@
-# -------------------------------------------------------------------------------
-# Name:        mbtiles2compactcache
-# Purpose:     Build compact cache V2 bundles from MBTiles in SQLLite databases
-#
-# Author:      luci6974
-#
-# Created:     20/09/2016
-# Modified:    04/05/2018,esristeinicke
-#              23/10/2019,mimo
-#
-#  Copyright 2016 Esri
-#
-#  Licensed 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.?
-#
-# -------------------------------------------------------------------------------
-#
-# Converts .mbtile files to the esri Compact Cache V2 format
-#
-# Takes two arguments, the first one is the input .mbfile folder
-# the second one being the output cache folder (_alllayers)
-#
-#
-# Assumes that the input .mbtile files are named after the level.. (17.mbtile)
-#
-# Loops over columns and then row, in the order given by os.walk
-# Keeps one bundle open in case the next tile fits in the same bundle
-# In most cases this combination results in good performance
-#
-# It does not check the input tile format, and assumes that all
-# the files are valid sqlite tile databases.  In other
-# words, make sure there are no spurious files and folders under the input
-# path, otherwise the output bundles might have strange content.
-#
-# -------------------------------------------------------------------------------
-#
-# v1.2 added grayscale Option (requires pillow)
-#    * to install pillow:
-#       * make sure python & scripts/pip is in path
-#       * in cmd type pip install pillow
-#
-# v1.3 fixed grayscale (Grayscale + Alpha = fixed grayscale Image) & (96 DPI)
-#
-# v1.4 better logging / fixing for python 3 / fixed ETA
-#
-# v1.5 better parameter support & parameter help
-import argparse
-import sqlite3
-import os
-import struct
-import shutil
-import datetime
-import re
-import io
-
-try:
-    from PIL import Image
-    is_pillow = True
-except ImportError as import_error:
-    is_pillow = False
-
-
-
-# Bundle linear size in tiles
-BSZ = 128
-# Tiles per bundle
-BSZ2 = BSZ ** 2
-# Index size in bytes
-IDXSZ = BSZ2 * 8
-
-# Output path
-output_path = None
-
-# The curr_* variable are used for caching of open output bundles
-# current bundle is kept open to reduce overhead
-# TODO: Eliminate global variables
-curr_bundle = None
-# A bundle index list
-# Array would be better, but it lacks 8 byte int support
-curr_index = None
-# Bundle file name without path or extension
-curr_bname = None
-# Current size of bundle file
-# curr_offset = long(0)
-curr_offset = int(0)
-# max size of a tile in the current bundle
-curr_max = 0
-
-
-def get_arguments():
-    """
-    Parses commandline arguments.
-
-    :return: commandline arguments
-    """
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument('-s', '--source',
-                        help='Input folder containing the mbtile files.', required=True)
-    parser.add_argument('-d', '--destination',
-                        help='Output for level folders.', required=True)
-    parser.add_argument('-l', '--level',
-                        help='Do only this Level (useful for parallel starts with Grayscale).', default=-1, type=int,
-                        required=False)
-    parser.add_argument('-g', '--grayscale',
-                        help='Convert tiles to grayscale while processing.', default=False, action="store_true",
-                        required=False)
-
-    # Return the command line arguments.
-    arguments = parser.parse_args()
-
-    # validate folder parameters
-    if not is_pillow and arguments.grayscale:
-        parser.error("Grayscale option requires Pillow (PIL) module to be installed.")
-    if not os.path.exists(arguments.source):
-        parser.error("Input folder does not exist or is inaccessible.")
-    if not os.path.exists(arguments.destination):
-        parser.error("Output folder does not exist or is inaccessible.")
-
-    return arguments
-
-
-def init_bundle(file_name):
-    """Create an empty V2 bundle file
-    :param file_name: bundle file name
-    """
-    fd = open(file_name, "wb")
-    # Empty bundle file header, lots of magic numbers
-    header = struct.pack("<4I3Q6I",
-                         3,  # Version
-                         BSZ2,  # numRecords
-                         0,  # maxRecord Size
-                         5,  # Offset Size
-                         0,  # Slack Space
-                         64 + IDXSZ,  # File Size
-                         40,  # User Header Offset
-                         20 + IDXSZ,  # User Header Size
-                         3,  # Legacy 1
-                         16,  # Legacy 2
-                         BSZ2,  # Legacy 3
-                         5,  # Legacy 4
-                         IDXSZ  # Index Size
-                         )
-    fd.write(header)
-    # Write empty index.
-    fd.write(struct.pack("<{}Q".format(BSZ2), *((0,) * BSZ2)))
-    fd.close()
-
-
-def cleanup():
-    """
-    Updates header and closes the current bundle
-    """
-    global curr_bundle, curr_bname, curr_index, curr_max, curr_offset
-    curr_bname = None
-
-    # Update the max rec size and file size, then close the file
-    if curr_bundle is not None:
-        curr_bundle.seek(8)
-        curr_bundle.write(struct.pack("<I", curr_max))
-        curr_bundle.seek(24)
-        curr_bundle.write(struct.pack("<Q", curr_offset))
-        curr_bundle.seek(64)
-        curr_bundle.write(struct.pack("<{}Q".format(BSZ2), *curr_index))
-        curr_bundle.close()
-
-        curr_bundle = None
-
-
-def open_bundle(row, col):
-    """
-    Make the bundle corresponding to the row and col current
-    """
-    global curr_bname, curr_bundle, curr_index, curr_offset, output_path, curr_max
-    # row and column of top-left tile in the output bundle
-    # start_row = (row / BSZ) * BSZ
-    start_row = int((row / BSZ)) * BSZ
-    # start_col = (col / BSZ) * BSZ
-    start_col = int((col / BSZ)) * BSZ
-    bname = "R{:04x}C{:04x}".format(start_row, start_col)
-    # bname = "R%(r)04xC%(c)04x" % {"r": start_row, "c": start_col}
-
-    # If the name matches the current bundle, nothing to do
-    if bname == curr_bname:
-        return
-
-    # Close the current bundle, if it exists
-    cleanup()
-
-    # Make the new bundle current
-    curr_bname = bname
-    # Open or create it, seek to end of bundle file
-    fname = os.path.join(output_path, bname + ".bundle")
-
-    # Create the bundle file if it didn't exist already
-    if not os.path.exists(fname):
-        init_bundle(fname)
-
-    # Open the bundle
-    curr_bundle = open(fname, "r+b")
-    # Read the current max record size
-    curr_bundle.seek(8)
-    curr_max = int(struct.unpack("<I", curr_bundle.read(4))[0])
-    # Read the index as longs in a list
-    curr_bundle.seek(64)
-    curr_index = list(struct.unpack("<{}Q".format(BSZ2),
-                                    curr_bundle.read(IDXSZ)))
-    # Go to end
-    curr_bundle.seek(0, os.SEEK_END)
-    curr_offset = curr_bundle.tell()
-
-
-def add_tile(byte_buffer, row, col=None):
-    """
-    Add this tile to the output cache
-
-    :param byte_buffer: input tile as byte buffer
-    :param row: row number
-    :param col: column number
-    """
-    global BSZ, curr_bundle, curr_max, curr_offset
-
-    # Read the tile data
-    tile = io.BytesIO(byte_buffer).getvalue()
-    tile_size = len(tile)
-
-    # Write the tile at the end of the bundle, prefixed by size
-    open_bundle(row, col)
-    curr_bundle.write(struct.pack("<I", tile_size))
-    curr_bundle.write(tile)
-    # Skip the size
-    curr_offset += 4
-
-    # Update the index, row major
-    curr_index[(row % BSZ) * BSZ + col % BSZ] = curr_offset + (tile_size << 40)
-    curr_offset += tile_size
-
-    # Update the current bundle max tile size
-    curr_max = max(curr_max, tile_size)
-
-
-def add_tile_gray(byte_buffer, row, col=None):
-    """
-    Convert tile to grayscale before adding it to toe bundle.
-
-    :param byte_buffer: input tile as byte buffer
-    :param row: row number
-    :param col: column number
-    """
-    global BSZ, curr_bundle, curr_max, curr_offset
-
-    # read & convert to grayscale
-    image = Image.open(io.BytesIO(byte_buffer))
-    image_gray = image.convert('LA')
-    byte_buffer_gray = io.BytesIO()
-    # image_gray.save(byte_buffer_gray, format="PNG", dpi=(96, 96))
-    image_gray.save(byte_buffer_gray, 'PNG', dpi=(96, 96))
-
-    # Read the tile data
-    tile = byte_buffer_gray.getvalue()
-    tile_size = len(tile)
-
-    # Write the tile at the end of the bundle, prefixed by size
-    open_bundle(row, col)
-    curr_bundle.write(struct.pack("<I", tile_size))
-    curr_bundle.write(tile)
-    # Skip the size
-    curr_offset += 4
-
-    # Update the index, row major
-    curr_index[(row % BSZ) * BSZ + col % BSZ] = curr_offset + (tile_size << 40)
-    curr_offset += tile_size
-
-    # Update the current bundle max tile size
-    curr_max = max(curr_max, tile_size)
-
-
-def main(arguments):
-    global output_path
-
-    # parse parameter
-    mb_tile_folder = arguments.source
-    cache_output_folder = arguments.destination
-    level_param = arguments.level
-    do_grayscale = arguments.grayscale
-
-    # loop through all .mbtile files
-    for root, dirs, files in os.walk(mb_tile_folder):
-        # convert each .mbtile file to bundle cache
-        # sore the list of files numerical
-        for mbtile in sorted([x for x in files if x.endswith('.mbtile')],
-                             key=lambda s: [int(c) if c.isdigit() else c for c in re.split('([0-9]+)', s)]):
-            print('Working on file: {0}'.format(os.path.basename(mbtile)))
-            # construct level folder name from .mbtile file name
-            level = 'L' + '{:02d}'.format(int(os.path.splitext(os.path.basename(mbtile))[0]))
-            level_folder = os.path.join(cache_output_folder, level)
-            # get the level as int for later calculations
-            level_int = int(os.path.splitext(os.path.basename(mbtile))[0])
-            # Test if level-parameter is set
-            if level_param != -1 and level_param != level_int:
-                print('Level Parameter Set to {0} skipping\n'.format(level_param))
-                continue
-
-            print('Bundles are written to folder: {0}'.format(level_folder))
-            output_path = level_folder
-
-            # create level folder if not exists
-            if not os.path.exists(level_folder):
-                os.makedirs(level_folder)
-            else:
-                # if exists, clean it up
-                for sub_root, sub_dirs, sub_files in os.walk(level_folder):
-                    for sub_dir in sub_dirs:
-                        shutil.rmtree(sub_dir)
-                    for sub_file in sub_files:
-                        os.remove(os.path.join(sub_root, sub_file))
-
-            # open the .mbtile as sqlite database
-            database_file = os.path.join(mb_tile_folder, mbtile)
-            database = sqlite3.connect(database_file)
-
-            # create som indexes to speed up the process
-            column_cursor = database.cursor()
-            print('Creating column index...')
-            column_cursor.execute('CREATE INDEX IF NOT EXISTS column_idx ON tiles(tile_column)')
-
-            # get the total number of columns to work on
-            # this in not necessary, used for timing info only
-            print('Getting total number of Tiles to process...\t')
-            number_of_columns = column_cursor.execute('SELECT count(distinct tile_column) FROM tiles').fetchone()[0]
-            number_of_tiles = column_cursor.execute('SELECT count(*) FROM tiles').fetchone()[0]
-            # print('Total number of Columns: {0}'.format(number_of_columns))
-
-            # skipp level if there are not tiles to process in case of empty level, e.g. level 19
-            if not (number_of_columns and number_of_tiles):
-                print('Found no tiles to process, skipping level.')
-                continue
-            else:
-                print('Total number of Tiles: {0}'.format(number_of_tiles))
-
-            # loop over each column
-            column_cursor.execute('SELECT DISTINCT tile_column FROM tiles')
-            # start_time = time.time()
-            start_time = datetime.datetime.now()
-            current_column = 0
-            current_tile = 0
-            current_percent = float(current_column) / float(number_of_columns) * 100
-            print('  {0} % done - Time {1}'.format('{:3.2f}'.format(0),
-                                                   format(str(datetime.datetime.now().strftime("%m-%d-%Y %H:%M:%S")))))
-            for column in column_cursor:
-                current_column += 1
-
-                # Process each row in sqlite database
-                row_cursor = database.cursor()
-                # calculate the maximum row number (there are 2^n rows and column at level n)
-                # row numbering in .mbtile is reversed, row n must be converted to (max_rows -1 ) - n
-                max_rows = 2 ** level_int - 1
-                row_cursor.execute('SELECT * FROM tiles WHERE tile_column=?', (column[0],))
-                for row in row_cursor:
-                    current_tile += 1
-                    if do_grayscale:
-                        add_tile_gray(row[3], max_rows - int(row[2]), int(column[0]))
-                    else:
-                        add_tile(row[3], max_rows - int(row[2]), int(column[0]))
-
-                # calculate ETA
-                if current_column % 100 == 0:
-                    current_tile_time = (datetime.datetime.now() - start_time).total_seconds() / current_tile * (
-                                number_of_tiles - current_tile)  # seconds to reach 100% Tiles
-                    current_percent = current_tile / number_of_tiles * 100
-                    tiles_per_second = round((current_tile / (datetime.datetime.now() - start_time).total_seconds()), 2)
-                    print(' {0} % done - Time {1} | ETA {2} | Tiles per Second {3}'.format(
-                        '{:3.2f}'.format(current_percent),
-                        format(str(datetime.datetime.now().strftime("%m-%d-%Y %H:%M:%S"))), str(
-                            (datetime.datetime.now() + datetime.timedelta(0, current_tile_time)).strftime(
-                                "%m-%d-%Y %H:%M:%S")), format(tiles_per_second)))
-
-            # close the database when finished
-            database.close()
-            # final output
-            current_tile_time = (datetime.datetime.now() - start_time).total_seconds() / current_tile * (
-                        number_of_tiles - current_tile)  # seconds to reach 100% Tiles
-            current_percent = current_tile / number_of_tiles * 100
-            tiles_per_second = round((current_tile / (datetime.datetime.now() - start_time).total_seconds()), 2)
-            print('{0} % done - Time {1} | ETA {2} | Tiles per Second {3}\n'.format('{:3.2f}'.format(current_percent),
-                                                                                    format(str(
-                                                                                        datetime.datetime.now().strftime(
-                                                                                            "%m-%d-%Y %H:%M:%S"))), str(
-                    (datetime.datetime.now() + datetime.timedelta(0, current_tile_time)).strftime("%m-%d-%Y %H:%M:%S")),
-                                                                                    format(tiles_per_second)))
-            # cleanup open bundles
-            cleanup()
-
-
-if __name__ == '__main__':
-    main(get_arguments())
diff --git a/sample_mbtiles/00.mbtile b/sample_mbtiles/00.mbtile
deleted file mode 100644
index 454f4fe..0000000
Binary files a/sample_mbtiles/00.mbtile and /dev/null differ
diff --git a/sample_mbtiles/01.mbtile b/sample_mbtiles/01.mbtile
deleted file mode 100644
index fa26083..0000000
Binary files a/sample_mbtiles/01.mbtile and /dev/null differ
diff --git a/sample_mbtiles/02.mbtile b/sample_mbtiles/02.mbtile
deleted file mode 100644
index a21be17..0000000
Binary files a/sample_mbtiles/02.mbtile and /dev/null differ
diff --git a/sample_mbtiles/README.md b/sample_mbtiles/README.md
deleted file mode 100644
index 62d4d0a..0000000
--- a/sample_mbtiles/README.md
+++ /dev/null
@@ -1,18 +0,0 @@
-# Summary
-With the product TopPlus-Web-Open, the Federal Agency for Cartography and Geodesy breaks new grounds and creates for the first time a consistent web map, completely based on free or open data sources.
-
-# Description
-With the product [TopPlusOpen](http://www.geodatenzentrum.de/geodaten/gdz_rahmen.gdz_div?gdz_spr=eng&gdz_akt_zeile=5&gdz_anz_zeile=1&gdz_unt_zeile=41&gdz_user_id=0) (TPO), the BKG breaks new grounds and creates for the first time a consistent web map, completely based on free and official data sources. For this purpose, the BKG merged, processed and combined many different data sources in order to achieve the best possible map presentation. Among others, free official spatial data of the Federal Government and the Open Data states Berlin, Hamburg, North Rhine-Westphalia and Thuringia are presented in the product. Furthermore, Brandenburg, Mecklenburg-Western Pomerania and Rhineland-Palatinate provide their official spatial data for the TPO based on a cooperation agreement so that also these states are presented exclusively by official data. 
-
-The web map TopPlusOpen has 18 levels of detail – from the worldwide overview map to the detailed city map in Germany. As standard, the product is available in the widespread Web Mercator Projection (EPSG:3857). The web map is divided into three different display areas:
-* World (small scale)
-* Europe (medium scale)
-* Germany and neighboring countries (large scale)
-
-The tile archive of the TopPlusOpen you may download [here](https://daten.gdz.bkg.bund.de/produkte/topplus_open/TopPlusOpen/aktuell/) in the form of SQLite databases in the mbtile format for the single zoom levels (data volume 940 GB). 
-
-# Terms of use
-The geodata offered here are available via geodata services for download and for online use free of charge according to the [Open Data Datenlizenz Deutschland – Namensnennung – Version 2.0](https://www.govdata.de/dl-de/by-2-0).
-
-© [Federal Agency for Cartography and Geodesy](http://www.bkg.bund.de/) 2017, [data sources](http://sg.geodatenzentrum.de/web_public/Datenquellen_TopPlus_Open.pdf)
-
diff --git a/sample_cache/conf.cdi b/template/A3_MyCachedService/Layers/conf.cdi
similarity index 100%
rename from sample_cache/conf.cdi
rename to template/A3_MyCachedService/Layers/conf.cdi
diff --git a/template/A3_MyCachedService/Layers/conf.xml b/template/A3_MyCachedService/Layers/conf.xml
new file mode 100644
index 0000000..06bcf89
--- /dev/null
+++ b/template/A3_MyCachedService/Layers/conf.xml
@@ -0,0 +1 @@
+<?xml version="1.0" encoding="utf-8" ?><CacheInfo xsi:type='typens:CacheInfo' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:typens='http://www.esri.com/schemas/ArcGIS/10.5'><TileCacheInfo xsi:type='typens:TileCacheInfo'><SpatialReference xsi:type='typens:ProjectedCoordinateSystem'><WKT>PROJCS[&quot;WGS_1984_Web_Mercator_Auxiliary_Sphere&quot;,GEOGCS[&quot;GCS_WGS_1984&quot;,DATUM[&quot;D_WGS_1984&quot;,SPHEROID[&quot;WGS_1984&quot;,6378137.0,298.257223563]],PRIMEM[&quot;Greenwich&quot;,0.0],UNIT[&quot;Degree&quot;,0.0174532925199433]],PROJECTION[&quot;Mercator_Auxiliary_Sphere&quot;],PARAMETER[&quot;False_Easting&quot;,0.0],PARAMETER[&quot;False_Northing&quot;,0.0],PARAMETER[&quot;Central_Meridian&quot;,0.0],PARAMETER[&quot;Standard_Parallel_1&quot;,0.0],PARAMETER[&quot;Auxiliary_Sphere_Type&quot;,0.0],UNIT[&quot;Meter&quot;,1.0],AUTHORITY[&quot;EPSG&quot;,3857]]</WKT><XOrigin>-20037700</XOrigin><YOrigin>-30241100</YOrigin><XYScale>148923141.92838538</XYScale><ZOrigin>-100000</ZOrigin><ZScale>10000</ZScale><MOrigin>-100000</MOrigin><MScale>10000</MScale><XYTolerance>0.001</XYTolerance><ZTolerance>0.001</ZTolerance><MTolerance>0.001</MTolerance><HighPrecision>true</HighPrecision><WKID>102100</WKID><LatestWKID>3857</LatestWKID></SpatialReference><TileOrigin xsi:type='typens:PointN'><X>-20037508.342787001</X><Y>20037508.342787001</Y></TileOrigin><TileCols>256</TileCols><TileRows>256</TileRows><DPI>96</DPI><LODInfos xsi:type='typens:ArrayOfLODInfo'><LODInfo xsi:type='typens:LODInfo'><LevelID>0</LevelID><Scale>591657527.591555</Scale><Resolution>156543.03392799999</Resolution></LODInfo><LODInfo xsi:type='typens:LODInfo'><LevelID>1</LevelID><Scale>295828763.79577702</Scale><Resolution>78271.516963999893</Resolution></LODInfo><LODInfo xsi:type='typens:LODInfo'><LevelID>2</LevelID><Scale>147914381.89788899</Scale><Resolution>39135.758482000099</Resolution></LODInfo><LODInfo xsi:type='typens:LODInfo'><LevelID>3</LevelID><Scale>73957190.948944002</Scale><Resolution>19567.879240999901</Resolution></LODInfo><LODInfo xsi:type='typens:LODInfo'><LevelID>4</LevelID><Scale>36978595.474472001</Scale><Resolution>9783.9396204999593</Resolution></LODInfo><LODInfo xsi:type='typens:LODInfo'><LevelID>5</LevelID><Scale>18489297.737236001</Scale><Resolution>4891.9698102499797</Resolution></LODInfo><LODInfo xsi:type='typens:LODInfo'><LevelID>6</LevelID><Scale>9244648.8686180003</Scale><Resolution>2445.9849051249898</Resolution></LODInfo><LODInfo xsi:type='typens:LODInfo'><LevelID>7</LevelID><Scale>4622324.4343090001</Scale><Resolution>1222.9924525624899</Resolution></LODInfo><LODInfo xsi:type='typens:LODInfo'><LevelID>8</LevelID><Scale>2311162.2171550002</Scale><Resolution>611.49622628138002</Resolution></LODInfo><LODInfo xsi:type='typens:LODInfo'><LevelID>9</LevelID><Scale>1155581.108577</Scale><Resolution>305.74811314055802</Resolution></LODInfo><LODInfo xsi:type='typens:LODInfo'><LevelID>10</LevelID><Scale>577790.55428899999</Scale><Resolution>152.874056570411</Resolution></LODInfo><LODInfo xsi:type='typens:LODInfo'><LevelID>11</LevelID><Scale>288895.27714399999</Scale><Resolution>76.437028285073197</Resolution></LODInfo><LODInfo xsi:type='typens:LODInfo'><LevelID>12</LevelID><Scale>144447.638572</Scale><Resolution>38.218514142536598</Resolution></LODInfo><LODInfo xsi:type='typens:LODInfo'><LevelID>13</LevelID><Scale>72223.819285999998</Scale><Resolution>19.109257071268299</Resolution></LODInfo><LODInfo xsi:type='typens:LODInfo'><LevelID>14</LevelID><Scale>36111.909642999999</Scale><Resolution>9.5546285356341496</Resolution></LODInfo><LODInfo xsi:type='typens:LODInfo'><LevelID>15</LevelID><Scale>18055.954822</Scale><Resolution>4.7773142679493699</Resolution></LODInfo></LODInfos><PreciseDPI>96</PreciseDPI></TileCacheInfo><TileImageInfo xsi:type='typens:TileImageInfo'><CacheTileFormat>PNG32</CacheTileFormat><CompressionQuality>0</CompressionQuality><Antialiasing>false</Antialiasing><BandCount>1</BandCount><LERCError>0</LERCError></TileImageInfo><CacheStorageInfo xsi:type='typens:CacheStorageInfo'><StorageFormat>esriMapCacheStorageModeCompactV2</StorageFormat><PacketSize>128</PacketSize></CacheStorageInfo></CacheInfo>
\ No newline at end of file