diff --git a/CMakeLists.txt b/CMakeLists.txt
index ba512d133..35047d154 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -39,6 +39,7 @@ set(SOURCES
     src/partition.cpp
     src/quantization.cpp
     src/rasterizer.cpp
+    src/remesher.cpp
     src/simplifier.cpp
     src/spatialorder.cpp
     src/stripifier.cpp
diff --git a/Makefile b/Makefile
index 8b1662d68..dd2b22a8a 100644
--- a/Makefile
+++ b/Makefile
@@ -51,8 +51,8 @@ WASM_DECODER_EXPORTS=meshopt_decodeVertexBuffer meshopt_decodeIndexBuffer meshop
 WASM_ENCODER_SOURCES=src/vertexcodec.cpp src/indexcodec.cpp src/vertexfilter.cpp src/vcacheoptimizer.cpp src/vfetchoptimizer.cpp src/spatialorder.cpp tools/wasmstubs.cpp
 WASM_ENCODER_EXPORTS=meshopt_encodeVertexBuffer meshopt_encodeVertexBufferBound meshopt_encodeVertexBufferLevel meshopt_encodeIndexBuffer meshopt_encodeIndexBufferBound meshopt_encodeIndexSequence meshopt_encodeIndexSequenceBound meshopt_encodeVertexVersion meshopt_encodeIndexVersion meshopt_encodeFilterOct meshopt_encodeFilterQuat meshopt_encodeFilterExp meshopt_encodeFilterColor meshopt_optimizeVertexCache meshopt_optimizeVertexCacheStrip meshopt_optimizeVertexFetchRemap meshopt_spatialSortRemap sbrk __wasm_call_ctors
 
-WASM_SIMPLIFIER_SOURCES=src/simplifier.cpp src/vfetchoptimizer.cpp src/indexgenerator.cpp tools/wasmstubs.cpp
-WASM_SIMPLIFIER_EXPORTS=meshopt_simplify meshopt_simplifyWithAttributes meshopt_simplifyWithUpdate meshopt_simplifyScale meshopt_simplifyPoints meshopt_simplifySloppy meshopt_simplifyPrune meshopt_optimizeVertexFetchRemap meshopt_generatePositionRemap sbrk __wasm_call_ctors
+WASM_SIMPLIFIER_SOURCES=src/simplifier.cpp src/remesher.cpp src/vfetchoptimizer.cpp src/indexgenerator.cpp tools/wasmstubs.cpp
+WASM_SIMPLIFIER_EXPORTS=meshopt_simplify meshopt_simplifyWithAttributes meshopt_simplifyWithUpdate meshopt_simplifyScale meshopt_simplifyPoints meshopt_simplifySloppy meshopt_simplifyPrune meshopt_remesh meshopt_optimizeVertexFetchRemap meshopt_generatePositionRemap sbrk __wasm_call_ctors
 
 WASM_CLUSTERIZER_SOURCES=src/clusterizer.cpp src/meshletutils.cpp tools/wasmstubs.cpp
 WASM_CLUSTERIZER_EXPORTS=meshopt_buildMeshletsBound meshopt_buildMeshletsFlex meshopt_buildMeshletsSpatial meshopt_computeClusterBounds meshopt_computeMeshletBounds meshopt_computeSphereBounds meshopt_optimizeMeshlet sbrk __wasm_call_ctors
diff --git a/demo/main.cpp b/demo/main.cpp
index d4b6c916c..63c3eaa37 100644
--- a/demo/main.cpp
+++ b/demo/main.cpp
@@ -1677,6 +1677,21 @@ void tangents(const Mesh& mesh)
 	printf("Tangents : %d corners, %d splits in %.2f msec\n", int(mesh.indices.size()), int(newvertices.size() - mesh.vertices.size()), (end - start) * 1000);
 }
 
+void remesh(const Mesh& mesh, char name, int resolution, unsigned int options = 0)
+{
+	double start = timestamp();
+	size_t capacity = meshopt_remesh(NULL, 0, &mesh.indices[0], mesh.indices.size(), &mesh.vertices[0].px, mesh.vertices.size(), sizeof(Vertex), resolution, options);
+	double middle = timestamp();
+	std::vector<float> triangles(capacity * 3 * 3);
+	size_t count = meshopt_remesh(&triangles[0], capacity, &mesh.indices[0], mesh.indices.size(), &mesh.vertices[0].px, mesh.vertices.size(), sizeof(Vertex), resolution, options);
+	double end = timestamp();
+
+	assert(count <= capacity);
+
+	printf("Remesh%c  : %d triangles => %d triangles in %.2f msec (count %.2f msec, compute %.2f msec)\n", name,
+	    int(mesh.indices.size() / 3), int(count), (end - start) * 1000, (middle - start) * 1000, (end - middle) * 1000);
+}
+
 void nanite(const std::vector<Vertex>& vertices, const std::vector<unsigned int>& indices); // nanite.cpp
 
 bool loadMesh(Mesh& mesh, const char* path)
@@ -1868,6 +1883,9 @@ void process(const char* path)
 
 	tangents(mesh);
 
+	remesh(mesh, ' ', 128);
+	remesh(mesh, 'T', 128, meshopt_RemeshThicken);
+
 	if (path)
 		processDeinterleaved(path);
 }
@@ -1878,7 +1896,8 @@ void processDev(const char* path)
 	if (!loadMesh(mesh, path))
 		return;
 
-	encodeMeshletsDXR(mesh, 128, /* min_exp= */ -14);
+	remesh(mesh, ' ', 128);
+	remesh(mesh, 'T', 128, meshopt_RemeshThicken);
 }
 
 void processNanite(const char* path)
diff --git a/demo/remesh.html b/demo/remesh.html
new file mode 100644
index 000000000..4a104ea8d
--- /dev/null
+++ b/demo/remesh.html
@@ -0,0 +1,828 @@
+<!doctype html>
+<html lang="en">
+	<head>
+		<title>meshoptimizer - demo</title>
+		<meta charset="utf-8" />
+		<meta name="viewport" content="width=device-width, user-scalable=no, minimum-scale=1.0, maximum-scale=1.0" />
+		<style>
+			body {
+				font-family: Monospace;
+				background-color: #300a24;
+				color: #fff;
+				margin: 0px;
+				overflow: hidden;
+				display: flex;
+				flex-direction: column;
+				height: 100vh;
+			}
+			#container {
+				width: 100%;
+				flex: 1;
+				position: relative;
+			}
+			.renderer-container {
+				position: relative;
+				width: 100%;
+				height: 100%;
+			}
+			.renderer-container canvas {
+				width: 100% !important;
+				height: 100% !important;
+				display: block;
+				user-select: none;
+			}
+			.renderer-label {
+				position: absolute;
+				top: 10px;
+				left: 10px;
+				background-color: rgba(0, 0, 0, 0.5);
+				padding: 5px 10px;
+				border-radius: 5px;
+				pointer-events: none;
+				font-size: 14px;
+			}
+			.stats-label {
+				position: absolute;
+				top: 45px;
+				left: 10px;
+				background-color: rgba(0, 0, 0, 0.5);
+				padding: 5px 10px;
+				border-radius: 5px;
+				pointer-events: none;
+				font-size: 12px;
+				line-height: 1.4;
+			}
+			#texture-view {
+				position: fixed;
+				left: 10px;
+				bottom: 10px;
+				width: 256px;
+				height: 256px;
+				display: none;
+			}
+		</style>
+
+		<script type="importmap">
+			{
+				"imports": {
+					"three": "https://cdn.jsdelivr.net/npm/three@0.183.0/build/three.module.js",
+					"three-examples/": "https://cdn.jsdelivr.net/npm/three@0.183.0/examples/jsm/",
+					"three-mesh-bvh": "https://cdn.jsdelivr.net/npm/three-mesh-bvh@0.9.10/build/index.module.js",
+					"watlas": "https://cdn.jsdelivr.net/npm/watlas@1.0.1/dist/watlas.js",
+					"lil-gui": "https://cdn.jsdelivr.net/npm/lil-gui@0.20.0/dist/lil-gui.esm.js"
+				}
+			}
+		</script>
+	</head>
+
+	<body>
+		<div id="container"></div>
+		<canvas id="texture-view"></canvas>
+		<input type="file" id="fileInput" style="display: none" accept=".obj,.glb" />
+
+		<script type="module">
+			import * as THREE from 'three';
+			import { GLTFLoader } from 'three-examples/loaders/GLTFLoader.js';
+			import { OBJLoader } from 'three-examples/loaders/OBJLoader.js';
+			import { OrbitControls } from 'three-examples/controls/OrbitControls.js';
+			import { mergeGeometries, mergeVertices, toCreasedNormals } from 'three-examples/utils/BufferGeometryUtils.js';
+			import { MeshBVH } from 'three-mesh-bvh';
+			import { MeshoptDecoder } from '../js/meshopt_decoder.mjs';
+			import { MeshoptSimplifier } from '../js/meshopt_simplifier.js';
+			import { Initialize as initializeWatlas, Atlas } from 'watlas';
+			import { GUI } from 'lil-gui';
+
+			var container;
+			var camera, renderer, scene, controls, model, merged, remeshed, remeshMaterial, wireframeMaterial, stats;
+			var textureImages = new WeakMap();
+
+			var settings = {
+				wireframe: false,
+				wireframeOverlay: false,
+				resolution: 64,
+				sloppy: false,
+				thicken: false,
+				shell: false,
+				solve: true,
+				debug: false,
+				normalCrease: 120,
+				simplify: {
+					enabled: false,
+					regularize: true,
+					solve: true,
+					errorThresholdLog10: 2.5,
+				},
+				paint: {
+					mode: 'vertex',
+					resolution: 512,
+					gutter: 1,
+				},
+
+				loadFile: function () {
+					var input = document.getElementById('fileInput');
+					input.onchange = function () {
+						var file = input.files[0];
+						var uri = URL.createObjectURL(file);
+						var ext = file.name.split('.').pop().toLowerCase();
+
+						container.querySelector('.renderer-label').textContent = file.name;
+						load(uri, ext);
+					};
+					input.click();
+				},
+
+				remesh: function () {
+					remesh();
+				},
+
+				revert: function () {
+					revert();
+				},
+
+				updateModule: function () {
+					reload();
+					remesh();
+				},
+				autoUpdate: false,
+				autoUpdateStatus: '',
+			};
+
+			var gui = new GUI({ width: 300 });
+			var guiDisplay = gui.addFolder('Display');
+			guiDisplay.add(settings, 'wireframe').onChange(update);
+			guiDisplay.add(settings, 'wireframeOverlay').onChange(update);
+
+			var guiRemesh = gui.addFolder('Remesh');
+			guiRemesh.add(settings, 'resolution', 4, 256, 1);
+			guiRemesh.add(settings, 'sloppy');
+			guiRemesh.add(settings, 'thicken');
+			guiRemesh.add(settings, 'shell');
+			guiRemesh.add(settings, 'solve');
+			guiRemesh.add(settings, 'debug');
+			guiRemesh.add(settings, 'normalCrease', 0, 180, 1).name('normal crease');
+			guiRemesh.add(settings, 'remesh');
+			guiRemesh.add(settings, 'revert');
+
+			var guiSimplify = gui.addFolder('Simplify');
+			guiSimplify.add(settings.simplify, 'enabled');
+			guiSimplify.add(settings.simplify, 'regularize');
+			guiSimplify.add(settings.simplify, 'solve');
+			guiSimplify.add(settings.simplify, 'errorThresholdLog10', 0, 3, 0.1);
+
+			var guiPaint = gui.addFolder('Paint');
+			guiPaint.add(settings.paint, 'mode', ['none', 'vertex', 'texture']);
+			guiPaint.add(settings.paint, 'resolution', [256, 512, 1024, 2048]);
+			guiPaint.add(settings.paint, 'gutter', 0, 8, 1);
+
+			var guiLoad = gui.addFolder('Load');
+			guiLoad.add(settings, 'loadFile');
+			guiLoad.add(settings, 'updateModule');
+			guiLoad.add(settings, 'autoUpdate').onChange(autoReload);
+			guiLoad.add(settings, 'autoUpdateStatus').listen();
+
+			init();
+			loadDefault();
+			render();
+
+			function createView(name) {
+				// Create renderer container
+				var rendererContainer = document.createElement('div');
+				rendererContainer.className = 'renderer-container';
+				container.appendChild(rendererContainer);
+
+				// Add label with file name
+				var label = document.createElement('div');
+				label.className = 'renderer-label';
+				label.textContent = name;
+				rendererContainer.appendChild(label);
+
+				// Add stats label
+				var statsLabel = document.createElement('div');
+				statsLabel.className = 'stats-label';
+				rendererContainer.appendChild(statsLabel);
+
+				// Initialize stats
+				stats = {
+					triangles: 0,
+					vertices: 0,
+					ratio: 0,
+					label: statsLabel,
+				};
+
+				// Create renderer
+				renderer = new THREE.WebGLRenderer();
+				renderer.setPixelRatio(window.devicePixelRatio);
+				rendererContainer.appendChild(renderer.domElement);
+
+				// Create scene
+				scene = new THREE.Scene();
+				scene.background = new THREE.Color(0x300a24);
+
+				// Add lighting
+				var ambientLight = new THREE.AmbientLight(0xcccccc, 1);
+				scene.add(ambientLight);
+
+				var pointLightR = new THREE.PointLight(0xffffff, 4);
+				pointLightR.position.set(3, 3, 0);
+				pointLightR.decay = 0.5;
+				scene.add(pointLightR);
+
+				var pointLightL = new THREE.PointLight(0xffffff, 1);
+				pointLightL.position.set(-3, 5, 0);
+				pointLightL.decay = 0.5;
+				scene.add(pointLightL);
+
+				remeshMaterial = new THREE.MeshStandardMaterial({ color: 0xdddddd, polygonOffsetFactor: 0.5, polygonOffsetUnits: 16 });
+				wireframeMaterial = new THREE.MeshBasicMaterial({ color: 0xffffff, wireframe: true, visible: false });
+
+				// Create controls
+				controls = new OrbitControls(camera, renderer.domElement);
+
+				// Adjust renderer size
+				updateRendererSizes();
+			}
+
+			function mergeMesh(model) {
+				var geometries = [];
+				var vertex = new THREE.Vector3();
+				var sourceTriangle = [];
+				var sourceMesh = [];
+
+				model.updateMatrixWorld(true);
+				model.traverse(function (object) {
+					if (object.isMesh && object.geometry.attributes.position) {
+						var source = object.geometry.attributes.position;
+						var positions = new Float32Array(source.count * 3);
+
+						// getVertexPosition applies the skinning transform, if present
+						for (var i = 0; i < source.count; ++i) {
+							object.getVertexPosition(i, vertex);
+							vertex.toArray(positions, i * 3);
+						}
+
+						var geometry = new THREE.BufferGeometry();
+						geometry.setAttribute('position', new THREE.BufferAttribute(positions, 3));
+						if (object.geometry.index) {
+							geometry.setIndex(object.geometry.index);
+						} else {
+							var indices = new Uint32Array(source.count);
+							for (var i = 0; i < source.count; ++i) indices[i] = i;
+							geometry.setIndex(new THREE.BufferAttribute(indices, 1));
+						}
+						geometry.applyMatrix4(object.matrixWorld);
+						geometries.push(geometry);
+
+						for (var i = 0; i < geometry.index.count / 3; ++i) {
+							sourceTriangle.push(i);
+							sourceMesh.push(object);
+						}
+					}
+				});
+
+				var result = mergeGeometries(geometries);
+				result.computeBoundingBox();
+				result.sourceTriangle = sourceTriangle;
+				result.sourceMesh = sourceMesh;
+				result.bvh = new MeshBVH(result, { indirect: true });
+				result.thickness = result.boundingBox.getSize(new THREE.Vector3()).length() * 0.01;
+				return result;
+			}
+
+			function getTextureImage(texture) {
+				if (!textureImages.has(texture.source)) {
+					var canvas = document.createElement('canvas');
+					canvas.width = texture.image.width;
+					canvas.height = texture.image.height;
+					var context = canvas.getContext('2d');
+					context.drawImage(texture.image, 0, 0);
+					textureImages.set(texture.source, context.getImageData(0, 0, texture.image.width, texture.image.height));
+				}
+				return textureImages.get(texture.source);
+			}
+
+			function sampleTexture(texture, uv) {
+				var image = getTextureImage(texture);
+				var point = texture.transformUv(uv.clone());
+				var x = Math.min(Math.floor(point.x * image.width), image.width - 1);
+				var y = Math.min(Math.floor(point.y * image.height), image.height - 1);
+
+				var offset = (y * image.width + x) * 4;
+				return new THREE.Color(image.data[offset] / 255, image.data[offset + 1] / 255, image.data[offset + 2] / 255);
+			}
+
+			function interpolate(attr, a, b, c, bary, comp) {
+				return attr.getComponent(a, comp) * bary.x + attr.getComponent(b, comp) * bary.y + attr.getComponent(c, comp) * bary.z;
+			}
+
+			function sampleColorBary(mesh, triangle, bary) {
+				var geometry = mesh.geometry;
+				var offset = triangle * 3,
+					indices = geometry.index;
+				var a = indices ? indices.array[offset] : offset,
+					b = indices ? indices.array[offset + 1] : offset + 1,
+					c = indices ? indices.array[offset + 2] : offset + 2;
+
+				var material = mesh.material;
+				if (Array.isArray(material)) {
+					var group = geometry.groups.find(function (group) {
+						return offset >= group.start && offset < group.start + group.count;
+					});
+					material = material[group ? group.materialIndex : 0];
+				}
+
+				var result = material.color.clone();
+
+				var uv = new THREE.Vector2();
+				if (geometry.attributes.uv) {
+					uv.x = interpolate(geometry.attributes.uv, a, b, c, bary, 0);
+					uv.y = interpolate(geometry.attributes.uv, a, b, c, bary, 1);
+				}
+
+				if (material.map) {
+					result.multiply(sampleTexture(material.map, uv).convertSRGBToLinear());
+				}
+
+				if (material.vertexColors) {
+					result.r *= interpolate(geometry.attributes.color, a, b, c, bary, 0);
+					result.g *= interpolate(geometry.attributes.color, a, b, c, bary, 1);
+					result.b *= interpolate(geometry.attributes.color, a, b, c, bary, 2);
+				}
+
+				if (material.aoMap) {
+					var ao = sampleTexture(material.aoMap, uv).r;
+					result.multiplyScalar(1 + material.aoMapIntensity * (ao - 1));
+				}
+
+				if (material.metalness) {
+					var metalness = material.metalness;
+					if (material.metalnessMap) metalness *= sampleTexture(material.metalnessMap, uv).b;
+					var roughness = material.roughness;
+					if (material.roughnessMap) roughness *= sampleTexture(material.roughnessMap, uv).g;
+					result.multiplyScalar(1 - metalness * (1 - roughness * roughness * roughness));
+				}
+
+				if (material.emissive) {
+					var emissive = material.emissive.clone().multiplyScalar(material.emissiveIntensity);
+					if (material.emissiveMap) emissive.multiply(sampleTexture(material.emissiveMap, uv).convertSRGBToLinear());
+					result.add(emissive);
+				}
+
+				return result;
+			}
+
+			function sampleColor(model, point, normal) {
+				var hit = undefined;
+				if (normal) {
+					var ray = new THREE.Ray();
+					ray.origin.copy(point).addScaledVector(normal, model.thickness);
+					ray.direction.copy(normal).negate();
+					hit = model.bvh.raycastFirst(ray, THREE.DoubleSide, 1e-12, model.thickness * 2);
+				}
+				if (!hit) hit = model.bvh.closestPointToPoint(point);
+
+				var a = new THREE.Vector3(),
+					b = new THREE.Vector3(),
+					c = new THREE.Vector3(),
+					bary = new THREE.Vector3();
+				a.fromBufferAttribute(model.attributes.position, model.index.array[hit.faceIndex * 3 + 0]);
+				b.fromBufferAttribute(model.attributes.position, model.index.array[hit.faceIndex * 3 + 1]);
+				c.fromBufferAttribute(model.attributes.position, model.index.array[hit.faceIndex * 3 + 2]);
+				THREE.Triangle.getBarycoord(hit.point, a, b, c, bary);
+
+				return sampleColorBary(model.sourceMesh[hit.faceIndex], model.sourceTriangle[hit.faceIndex], bary);
+			}
+
+			function transferColors(model, geometry) {
+				var colors = new Float32Array(geometry.attributes.position.count * 4);
+				var position = geometry.attributes.position,
+					normal = geometry.attributes.normal,
+					indices = geometry.index.array;
+				var query = new THREE.Vector3(),
+					direction = new THREE.Vector3(),
+					temp = new THREE.Vector3();
+
+				for (var i = 0; i < position.count; ++i) {
+					query.fromBufferAttribute(position, i);
+					direction.fromBufferAttribute(normal, i);
+
+					sampleColor(model, query, direction).toArray(colors, i * 4);
+					colors[i * 4 + 3] = 1;
+				}
+
+				for (var i = 0; i < indices.length; i += 3) {
+					query.fromBufferAttribute(position, indices[i]);
+					query.add(temp.fromBufferAttribute(position, indices[i + 1]));
+					query.add(temp.fromBufferAttribute(position, indices[i + 2]));
+					query.multiplyScalar(1 / 3);
+
+					direction.fromBufferAttribute(normal, indices[i]);
+					direction.add(temp.fromBufferAttribute(normal, indices[i + 1]));
+					direction.add(temp.fromBufferAttribute(normal, indices[i + 2]));
+					direction.normalize();
+
+					var color = sampleColor(model, query, direction);
+
+					for (var j = 0; j < 3; ++j) {
+						var v = indices[i + j];
+						colors[v * 4] += color.r;
+						colors[v * 4 + 1] += color.g;
+						colors[v * 4 + 2] += color.b;
+						colors[v * 4 + 3]++;
+					}
+				}
+
+				for (var i = 0; i < colors.length; i += 4) {
+					colors[i] /= colors[i + 3];
+					colors[i + 1] /= colors[i + 3];
+					colors[i + 2] /= colors[i + 3];
+					colors[i + 3] = 1;
+				}
+
+				geometry.setAttribute('color', new THREE.BufferAttribute(colors, 4));
+			}
+
+			function unwrapMesh(geometry, resolution, gutter) {
+				var positions = geometry.attributes.position.array;
+				var indices = new Uint32Array(geometry.index.array);
+
+				var atlas = new Atlas();
+				atlas.addMesh({
+					vertexPositionData: positions,
+					vertexCount: positions.length / 3,
+					vertexPositionStride: 12,
+					indexData: indices,
+					indexCount: indices.length,
+				});
+				atlas.generate({}, { resolution: resolution, padding: gutter });
+
+				var mesh = atlas.getMesh(0);
+				var atlasIndices = new Uint32Array(mesh.indexCount);
+				var uv = new Float32Array(mesh.indexCount * 2);
+				mesh.getIndexArray(atlasIndices);
+				for (var i = 0; i < mesh.indexCount; ++i) {
+					var v = mesh.getVertex(atlasIndices[i]);
+					uv[i * 2 + 0] = v.uv[0] / atlas.width;
+					uv[i * 2 + 1] = v.uv[1] / atlas.height;
+				}
+				atlas.delete();
+
+				geometry = geometry.toNonIndexed();
+				geometry.setAttribute('uv', new THREE.BufferAttribute(uv, 2));
+				geometry = mergeVertices(geometry);
+				return geometry;
+			}
+
+			function transferTexture(model, geometry, size, gutter) {
+				var data = new Float32Array(size * size * 4);
+				var position = geometry.attributes.position,
+					normal = geometry.attributes.normal,
+					uv = geometry.attributes.uv,
+					indices = geometry.index.array;
+				var bary = new THREE.Vector3(),
+					point = new THREE.Vector3(),
+					direction = new THREE.Vector3();
+
+				for (var i = 0; i < indices.length; i += 3) {
+					var a = indices[i],
+						b = indices[i + 1],
+						c = indices[i + 2];
+					var x0 = uv.getX(a) * size,
+						y0 = uv.getY(a) * size;
+					var x1 = uv.getX(b) * size,
+						y1 = uv.getY(b) * size;
+					var x2 = uv.getX(c) * size,
+						y2 = uv.getY(c) * size;
+					var minX = Math.max(0, Math.floor(Math.min(x0, x1, x2) - gutter)),
+						maxX = Math.min(size - 1, Math.ceil(Math.max(x0, x1, x2) + gutter));
+					var minY = Math.max(0, Math.floor(Math.min(y0, y1, y2) - gutter)),
+						maxY = Math.min(size - 1, Math.ceil(Math.max(y0, y1, y2) + gutter));
+					var denominator = (y1 - y2) * (x0 - x2) + (x2 - x1) * (y0 - y2);
+					if (Math.abs(denominator) < 1e-7) continue;
+
+					var scale = gutter / Math.abs(denominator);
+					var epsilonX = 1e-4 + Math.hypot(x1 - x2, y1 - y2) * scale;
+					var epsilonY = 1e-4 + Math.hypot(x2 - x0, y2 - y0) * scale;
+					var epsilonZ = 1e-4 + Math.hypot(x0 - x1, y0 - y1) * scale;
+
+					for (var y = minY; y <= maxY; ++y) {
+						for (var x = minX; x <= maxX; ++x) {
+							bary.x = ((y1 - y2) * (x + 0.5 - x2) + (x2 - x1) * (y + 0.5 - y2)) / denominator;
+							bary.y = ((y2 - y0) * (x + 0.5 - x2) + (x0 - x2) * (y + 0.5 - y2)) / denominator;
+							bary.z = 1 - bary.x - bary.y;
+							if (bary.x < -epsilonX || bary.y < -epsilonY || bary.z < -epsilonZ) continue;
+
+							point.set(
+								interpolate(position, a, b, c, bary, 0),
+								interpolate(position, a, b, c, bary, 1),
+								interpolate(position, a, b, c, bary, 2)
+							);
+							direction.set(
+								interpolate(normal, a, b, c, bary, 0),
+								interpolate(normal, a, b, c, bary, 1),
+								interpolate(normal, a, b, c, bary, 2)
+							);
+							direction.normalize();
+
+							var color = sampleColor(model, point, direction).convertLinearToSRGB();
+
+							var offset = (y * size + x) * 4;
+							data[offset] += color.r * 255;
+							data[offset + 1] += color.g * 255;
+							data[offset + 2] += color.b * 255;
+							data[offset + 3]++;
+						}
+					}
+				}
+
+				for (var i = 0; i < data.length; i += 4) {
+					var count = data[i + 3];
+					if (count) {
+						data[i] = Math.min(data[i] / count, 255);
+						data[i + 1] = Math.min(data[i + 1] / count, 255);
+						data[i + 2] = Math.min(data[i + 2] / count, 255);
+						data[i + 3] = 255;
+					}
+				}
+
+				var texture = new THREE.DataTexture(new Uint8Array(data), size, size, THREE.RGBAFormat);
+				texture.colorSpace = THREE.SRGBColorSpace;
+				texture.magFilter = THREE.LinearFilter;
+				texture.minFilter = THREE.LinearFilter;
+				texture.needsUpdate = true;
+				return texture;
+			}
+
+			function showTexture(texture) {
+				var canvas = document.getElementById('texture-view');
+				canvas.style.display = texture ? 'block' : 'none';
+				if (!texture) return;
+
+				canvas.width = texture.image.width;
+				canvas.height = texture.image.height;
+				canvas.getContext('2d').putImageData(new ImageData(new Uint8ClampedArray(texture.image.data), canvas.width, canvas.height), 0, 0);
+			}
+
+			function clearRemeshed() {
+				if (remeshed) {
+					scene.remove(remeshed);
+					remeshed.geometry.dispose();
+				}
+				remeshed = undefined;
+
+				if (remeshMaterial.map) remeshMaterial.map.dispose();
+				remeshMaterial.map = null;
+
+				showTexture(null);
+			}
+
+			function simplifyMesh(geo, threshold, flags, solve, sloppy) {
+				var positions = solve ? new Float32Array(geo.attributes.position.array) : geo.attributes.position.array;
+				var indices = solve ? new Uint32Array(geo.index.array) : geo.index.array;
+
+				var res;
+				if (sloppy) {
+					res = MeshoptSimplifier.simplifySloppy(indices, positions, 3, null, 0, threshold);
+				} else if (solve) {
+					res = MeshoptSimplifier.simplifyWithUpdate(indices, positions, 3, new Float32Array(), 0, [], null, 0, threshold, flags);
+					res[0] = indices.slice(0, res[0]);
+				} else {
+					res = MeshoptSimplifier.simplify(indices, positions, 3, 0, threshold, flags);
+				}
+
+				var [remap, unique] = MeshoptSimplifier.compactMesh(res[0]);
+				var compact = new Float32Array(unique * 3);
+				for (var i = 0; i < remap.length; ++i) {
+					if (remap[i] < unique) compact.set(positions.subarray(i * 3, i * 3 + 3), remap[i] * 3);
+				}
+
+				var rgeo = geo.clone();
+				rgeo.setAttribute('position', new THREE.BufferAttribute(compact, 3));
+				rgeo.setIndex(new THREE.BufferAttribute(res[0], 1));
+
+				return rgeo;
+			}
+
+			function remesh() {
+				MeshoptSimplifier.ready.then(initializeWatlas).then(function () {
+					if (!merged) return;
+
+					clearRemeshed();
+
+					var geometry;
+					if (settings.sloppy) {
+						geometry = simplifyMesh(merged, 1 / settings.resolution, [], false, true);
+					} else {
+						var flags = [];
+						if (settings.thicken) flags.push('Thicken');
+						if (settings.shell) flags.push('Shell');
+						if (settings.solve) flags.push('Solve');
+						if (settings.debug) flags.push('_InternalDebug');
+
+						var result = MeshoptSimplifier.remesh(merged.index.array, merged.attributes.position.array, 3, settings.resolution, flags);
+						geometry = new THREE.BufferGeometry();
+						geometry.setAttribute('position', new THREE.BufferAttribute(result, 3));
+						geometry = mergeVertices(geometry);
+					}
+
+					if (settings.simplify.enabled) {
+						var flags = settings.simplify.regularize ? ['RegularizeLight'] : [];
+						geometry = simplifyMesh(geometry, Math.pow(10, -settings.simplify.errorThresholdLog10), flags, settings.simplify.solve);
+					}
+
+					geometry = mergeVertices(toCreasedNormals(geometry, THREE.MathUtils.degToRad(settings.debug ? 30 : settings.normalCrease)));
+
+					remeshMaterial.vertexColors = false;
+
+					if (settings.paint.mode == 'vertex') {
+						transferColors(merged, geometry);
+						remeshMaterial.vertexColors = true;
+						remeshMaterial.color.set(0xffffff);
+					} else if (settings.paint.mode == 'texture') {
+						geometry = unwrapMesh(geometry, settings.paint.resolution, settings.paint.gutter);
+						remeshMaterial.color.set(0xffffff);
+						remeshMaterial.map = transferTexture(merged, geometry, settings.paint.resolution, settings.paint.gutter);
+					} else {
+						remeshMaterial.color.set(0xdddddd);
+					}
+					remeshMaterial.needsUpdate = true;
+
+					// remesh material + wireframe overlay material
+					geometry.addGroup(0, geometry.index.count, 0);
+					geometry.addGroup(0, geometry.index.count, 1);
+
+					remeshed = new THREE.Mesh(geometry, [remeshMaterial, wireframeMaterial]);
+					model.visible = false;
+					scene.add(remeshed);
+					showTexture(remeshMaterial.map);
+					update();
+
+					var triangles = geometry.index.count / 3;
+					stats.triangles = triangles;
+					stats.vertices = geometry.attributes.position.count;
+					stats.ratio = (triangles / (merged.index.count / 3)) * 100;
+					updateStatsDisplay();
+				});
+			}
+
+			function revert() {
+				if (!model) return;
+
+				model.visible = true;
+				clearRemeshed();
+
+				stats.triangles = 0;
+				stats.vertices = 0;
+				stats.ratio = 100;
+
+				model.traverse(function (object) {
+					if (object.isMesh) {
+						stats.triangles += (object.geometry.index ? object.geometry.index.count : object.geometry.attributes.position.count) / 3;
+						stats.vertices += object.geometry.attributes.position.count;
+					}
+				});
+
+				updateStatsDisplay();
+			}
+
+			function updateStatsDisplay() {
+				stats.label.innerHTML =
+					'Triangles: ' + stats.triangles + '<br>' + 'Vertices: ' + stats.vertices + '<br>' + 'Ratio: ' + stats.ratio.toFixed(1) + '%';
+			}
+
+			function reload() {
+				var simp = import('/js/meshopt_simplifier.js?x=' + Date.now());
+				MeshoptSimplifier.ready = simp.then(function (s) {
+					return s.MeshoptSimplifier.ready.then(function () {
+						for (var prop in s.MeshoptSimplifier) {
+							MeshoptSimplifier[prop] = s.MeshoptSimplifier[prop];
+						}
+					});
+				});
+			}
+
+			var moduleLastModified = 0;
+
+			function autoReload() {
+				if (!settings.autoUpdate) return;
+
+				fetch('/js/meshopt_simplifier.js?x=' + Date.now(), { method: 'HEAD' })
+					.then(function (r) {
+						var last = r.headers.get('Last-Modified');
+						if (last != moduleLastModified) {
+							moduleLastModified = last;
+							reload();
+							remesh();
+						}
+
+						settings.autoUpdateStatus = new Date(last).toLocaleTimeString();
+						setTimeout(autoReload, 1000);
+					})
+					.catch(function (e) {
+						settings.autoUpdateStatus = 'error';
+						setTimeout(autoReload, 5000);
+					});
+			}
+
+			function update() {
+				remeshMaterial.polygonOffset = settings.wireframeOverlay;
+				wireframeMaterial.visible = settings.wireframeOverlay;
+
+				scene.traverse(function (child) {
+					if (child.isMesh) {
+						if (Array.isArray(child.material)) {
+							child.material[0].wireframe = settings.wireframe;
+						} else {
+							child.material.wireframe = settings.wireframe;
+						}
+					}
+				});
+			}
+
+			function load(path, ext) {
+				if (model) scene.remove(model);
+				clearRemeshed();
+
+				model = undefined;
+				merged = undefined;
+
+				var onProgress = function (xhr) {};
+				var onError = function (e) {
+					console.log(e);
+				};
+
+				function center(model) {
+					var bbox = new THREE.Box3().setFromObject(model);
+					var scale = 2 / Math.max(bbox.max.x - bbox.min.x, bbox.max.y - bbox.min.y, bbox.max.z - bbox.min.z);
+					var offset = new THREE.Vector3().addVectors(bbox.max, bbox.min).multiplyScalar(scale / 2);
+
+					model.scale.set(scale, scale, scale);
+					model.position.set(-offset.x, -offset.y, -offset.z);
+				}
+
+				function finish(object) {
+					model = object;
+					center(model);
+					scene.add(model);
+					merged = mergeMesh(model);
+					revert();
+				}
+
+				if (ext == 'gltf' || ext == 'glb') {
+					var loader = new GLTFLoader();
+					loader.setMeshoptDecoder(MeshoptDecoder);
+					loader.load(
+						path,
+						function (gltf) {
+							finish(gltf.scene);
+						},
+						onProgress,
+						onError
+					);
+				} else if (ext == 'obj') {
+					var loader = new OBJLoader();
+					loader.load(
+						path,
+						function (obj) {
+							finish(obj);
+						},
+						onProgress,
+						onError
+					);
+				} else {
+					console.error('Unsupported file format');
+				}
+			}
+
+			function loadDefault() {
+				createView('pirate.glb');
+				load('pirate.glb', 'glb');
+			}
+
+			function init() {
+				container = document.getElementById('container');
+
+				camera = new THREE.PerspectiveCamera(45, window.innerWidth / window.innerHeight, 0.1, 1000);
+				camera.position.y = 1.0;
+				camera.position.z = 3.0;
+
+				window.addEventListener('resize', updateRendererSizes, false);
+			}
+
+			function updateRendererSizes() {
+				var rendererContainer = renderer.domElement.parentElement;
+				var aspectRatio = rendererContainer.clientWidth / rendererContainer.clientHeight;
+
+				camera.aspect = aspectRatio;
+				camera.updateProjectionMatrix();
+
+				renderer.setSize(rendererContainer.clientWidth, rendererContainer.clientHeight);
+			}
+
+			function render() {
+				requestAnimationFrame(render);
+				controls.update();
+				renderer.render(scene, camera);
+			}
+		</script>
+	</body>
+</html>
diff --git a/js/meshopt_simplifier.d.ts b/js/meshopt_simplifier.d.ts
index 0722274bf..b74ce5118 100644
--- a/js/meshopt_simplifier.d.ts
+++ b/js/meshopt_simplifier.d.ts
@@ -1,6 +1,7 @@
 // This file is part of meshoptimizer library and is distributed under the terms of MIT License.
 // Copyright (C) 2016-2026, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
 export type SimplifierFlags = 'LockBorder' | 'Sparse' | 'ErrorAbsolute' | 'Prune' | 'Regularize' | 'Permissive' | 'RegularizeLight';
+export type RemesherFlags = 'Thicken' | 'Shell' | 'Solve';
 
 /** @deprecated Use SimplifierFlags instead. */
 export type Flags = SimplifierFlags;
@@ -68,4 +69,12 @@ export const MeshoptSimplifier: {
 	) => Uint32Array;
 
 	simplifyPrune: (indices: Uint32Array, vertex_positions: Float32Array, vertex_positions_stride: number, target_error: number) => Uint32Array;
+
+	remesh: (
+		indices: Uint32Array,
+		vertex_positions: Float32Array,
+		vertex_positions_stride: number,
+		resolution: number,
+		flags?: RemesherFlags[]
+	) => Float32Array;
 };
diff --git a/js/meshopt_simplifier.js b/js/meshopt_simplifier.js
index d48b8316a..7af660f6f 100644
--- a/js/meshopt_simplifier.js
+++ b/js/meshopt_simplifier.js
@@ -4,7 +4,7 @@ var MeshoptSimplifier = (function () {
 	// Built with clang version 22.1.0-wasi-sdk
 	// Built from meshoptimizer 1.2
 	var wasm =
-		'b9H79Tebbbe:6eO9Geueu9Geub9Gbb9Gsuuuuuuuuuuuu99uueu9Gvuuuuub9Gruuuuuuub9Gouuuuuue999Gvuuuuueu9Gzuuuuuuuuuuu99uuuub9Gquuuuuuu99uueu9GPuuuuuuuuuuu99uueu9Gquuuuuuuu99ueu9Gruuuuuu99eu9Gwuuuuuu99ueu9Giuuue999Gluuuueu9Gluuuub9GiuuueuiLQdilvorlwDiqkxmPszbHHbelve9Weiiviebeoweuecj:Gdkr:Bdxo9TW9T9VV95dbH9F9F939H79T9F9J9H229F9Jt9VV7bbz9TW79O9V9Wt9F79P9T9W29P9M95bw8E9TW79O9V9Wt9F79P9T9W29P9M959x9Pt9OcttV9P9I91tW7bD8A9TW79O9V9Wt9F79P9T9W29P9M959x9Pt9O9v9W9K9HtWbqQ9TW79O9V9Wt9F79P9T9W29P9M959t29V9W9W95bkX9TW79O9V9Wt9F79P9T9W29P9M959qV919UWbxQ9TW79O9V9Wt9F79P9T9W29P9M959q9V9P9Ut7bmX9TW79O9V9Wt9F79P9T9W29P9M959t9J9H2WbPa9TW79O9V9Wt9F9V9Wt9P9T9P96W9wWVtW94SWt9J9O9sW9T9H9Wbs59TW79O9V9Wt9F9NW9UWV9HtW9q9V79Pt9P9V9U9sW9T9H9Wbzl79IV9RbHDwebcekdCXq;y;WeQdbk;r:herYue99iuY99Xue9:D998Jjjjjbcj;sb9Rgs8Kjjjjbcbhzasc:Cefcbc;Kbz:tjjjb8AdnabaeSmbabaeadcdtzMjjjb8AkdnamcdGTmbalcrfci4cbyd1:H:cjbHjjjjbbhHasc:Cefasyd;8egecdtfaHBdbasaecefBd;8ecbhlcbhednadTmbabheadhOinaHaeydbci4fcb86bbaeclfheaOcufgOmbkcbhlabheadhOinaHaeydbgAci4fgCaCRbbgCceaAcrGgAtV86bbaCcu7aA4ceGalfhlaeclfheaOcufgOmbkcualcdtalcFFFFi0Ehekaecbyd1:H:cjbHjjjjbbhzasc:Cefasyd;8egecdtfazBdbasaecefBd;8ealcd4alfhOcehHinaHgecethHaeaO6mbkcbhXcuaecdtgOaecFFFFi0Ecbyd1:H:cjbHjjjjbbhHasc:Cefasyd;8egAcdtfaHBdbasaAcefBd;8eaHcFeaOz:tjjjbhQdnadTmbaecufhLcbhKindndnaQabaKcdtfgYydbgAc:v;t;h;Ev2aLGgOcdtfgCydbgHcuSmbceheinazaHcdtfydbaASmdaOaefhHaecefheaQaHaLGgOcdtfgCydbgHcu9hmbkkazaXcdtfaABdbaCaXBdbaXhHaXcefhXkaYaHBdbaKcefgKad9hmbkkaQcbyd:m:H:cjbH:bjjjbbasasyd;8ecufBd;8ekcbh8AcualcefgecdtaecFFFFi0Ecbyd1:H:cjbHjjjjbbhLasc:Cefasyd;8egecdtfaLBdbasaLBdNeasaecefBd;8ecuadcitadcFFFFe0Ecbyd1:H:cjbHjjjjbbhEasc:Cefasyd;8egecdtfaEBdbasaEBd:yeasaecefBd;8eascNefabadalcbz:cjjjbcualcdtgealcFFFFi0Eg3cbyd1:H:cjbHjjjjbbhOasc:Cefasyd;8egHcdtfaOBdbasaHcefBd;8ea3cbyd1:H:cjbHjjjjbbhQasc:Cefasyd;8egHcdtfaQBdbasaHcefBd;8eaOaQaialavazasc:Cefz:djjjbalcbyd1:H:cjbHjjjjbbhYasc:Cefasyd;8egHcdtfaYBdbasaHcefBd;8ea3cbyd1:H:cjbHjjjjbbhHasc:Cefasyd;8egAcdtfaHBdbasaAcefBd;8ea3cbyd1:H:cjbHjjjjbbhAasc:Cefasyd;8egCcdtfaABdbasaCcefBd;8eaHcFeaez:tjjjbh5aAcFeaez:tjjjbh8EdnalTmbindnaLa8AgAcefg8AcdtfydbgCaLaAcdtgefydbgHSmbaCaH9Rh8FaEaHcitfhaa8Eaefhha5aefhKcbhCindndnaaaCcitfydbgXaA9hmbaKaABdbahaABdbxekdnaLaXcdtggfgeclfydbgHaeydbgeSmbaHae9RhHaEaecitfheinaeydbaASmdaecwfheaHcufgHmbkka8EagfgeaAaXaeydbcuSEBdbaKaXaAaKydbcuSEBdbkaCcefgCa8F9hmbkka8Aal9hmbkaOhHaQhAa5hXa8EhCcbheindndnaeaHydbgK9hmbdnaeaAydbgK9hmbaXydbhKdnaCydbg8Fcu9hmbaKcu9hmbaYaefcb86bbxikdna8FcuSmbaKcuSmbaea8FSmbaOa8FcdtfydbaOaKcdtfydb9hmbaYaefcd86bbxikaYaefhadnaea8FSmbaeaKSmbaace86bbxikaacl86bbxdkdnaeaQaKcdtg8Ffydb9hmbdnaCydbgacuSmbaeaaSmbaXydbggcuSmbaeagSmba8Ea8FfydbghcuSmbahaKSmba5a8Ffydbg8FcuSmba8FaKSmbdnaOaacdtfydbgKaOa8Fcdtfydb9hmbaKaOagcdtfydbg8FSmba8FaOahcdtfydb9hmbaYaefcd86bbxlkaYaefcl86bbxikaYaefcl86bbxdkaYaefcl86bbxekaYaefaYaKfRbb86bbkaHclfhHaAclfhAaXclfhXaCclfhCalaecefge9hmbkdnamcaGTmbcbh8JindndnaYa8Jfg8KRbbg8Lc9:fPibebekdndndnaOa8Jcdtfydbgea8J9hmbdnaqmbcbh8FxdkdnazTmbcbh8Fa8JheinaqazaecdtgefydbfRbbce4a8FVceGh8FaQaefydbgea8J9hmbxikkcbh8Fa8JheinaqaefRbbce4a8FVceGh8FaQaecdtfydbgea8J9hmbxdkkaYaefRbbhexeka8JheindnaLaecdtg8AfgeclfydbgHaeydbgeSmbaHae9RhgaEaecitfhhaOa8AfhacbhKinahaKcitfydbgXhednindnaLaecdtgCfgeclfydbgHaeydbgeSmbaHae9RhHaEaecitfheaaydbhAdninaOaeydbcdtfydbaASmeaecwfheaHcufgHTmdxbkkcbhexdkaQaCfydbgeaX9hmbkceheka8FaeVh8FaKcefgKag9hmbkkaQa8Afydbgea8J9hmbka8Lcia8FceGEheka8Kae86bbka8Jcefg8Jal9hmbkkdnaqTmbdndnazTmbazheaOhHalhAindnaqaeydbfRbbceGTmbaYaHydbfcl86bbkaeclfheaHclfhHaAcufgAmbxdkkaqheaOhHalhAindnaeRbbceGTmbaYaHydbfcl86bbkaecefheaHclfhHaAcufgAmbkkaOhealhAaYhHindnaYaeydbfRbbcl9hmbaHcl86bbkaeclfheaHcefhHaAcufgAmbkkamceGTmbaYhealhHindnaeRbbce9hmbaecl86bbkaecefheaHcufgHmbkkcbh8Mcualcx2alc;v:Q;v:Qe0Ecbyd1:H:cjbHjjjjbbh8Nasc:Cefasyd;8egecdtfa8NBdbasaecefBd;8eascbBd:qeas9cb83i1ea8Naialavazasc1efz:ejjjbhydndnaDmbcbh8PcbhCxekcbhCawhecbhHindnaeIdbJbbbb9ETmbasaCcdtfaHBdbaCcefhCkaeclfheaDaHcefgH9hmbkcuaCal2gecdtaecFFFFi0Ecbyd1:H:cjbHjjjjbbh8Pasc:Cefasyd;8egecdtfa8PBdbasaecefBd;8ealTmbdnaCmbcbhCxekarcd4hgdnazTmbaCcdthhcbh8Fa8Phainaoaza8Fcdtfydbag2cdtfhKasheaahHaChAinaHaKaeydbcdtgXfIdbawaXfIdbNUdbaeclfheaHclfhHaAcufgAmbkaaahfhaa8Fcefg8Fal9hmbxdkkaCcdthhcbh8Fa8Phainaoa8Fag2cdtfhKasheaahHaChAinaHaKaeydbcdtgXfIdbawaXfIdbNUdbaeclfheaHclfhHaAcufgAmbkaaahfhaa8Fcefg8Fal9hmbkkcualc8S2gHalc;D;O;f8U0EgXcbyd1:H:cjbHjjjjbbheasc:Cefasyd;8egAcdtfaeBdbasaAcefBd;8eaecbaHz:tjjjbhIcbh8RcbhgdnaCTmbcbh8MaXcbyd1:H:cjbHjjjjbbhgasc:Cefasyd;8egecdtfagBdbasaecefBd;8eagcbaHz:tjjjb8AcuaCal2gecltgHaecFFFFb0Ecbyd1:H:cjbHjjjjbbh8Rasc:Cefasyd;8egecdtfa8RBdbasaecefBd;8ea8RcbaHz:tjjjb8AamcjjjjdGTmbcualcltgealcFFFFb0Ecbyd1:H:cjbHjjjjbbh8Masc:Cefasyd;8egHcdtfa8MBdbasaHcefBd;8ea8Mcbaez:tjjjb8AkdnadTmbcbhKabhHina8NaHclfydbg8Fcx2fgeIdba8NaHydbgacx2fgAIdbg8S:tgRa8NaHcwfydbghcx2fgXIdlaAIdlg8U:tg8VNaeIdla8U:tg8WaXIdba8S:tg8XN:tg8Ya8YNa8WaXIdwaAIdwg8Z:tg80NaeIdwa8Z:tg8Wa8VN:tg81a81Na8Wa8XNaRa80N:tg80a80NMMg8V:rhBa8Yh8Xa80h8Wa81hRdna8VJbbbb9EgATmba8YaB:vh8Xa80aB:vh8Wa81aB:vhRkaIaOaacdtfydbgXc8S2fgeaRaB:rg8VaRNNg83aeIdbMUdbaea8Wa8Va8WNgUNg85aeIdlMUdlaea8Xa8Va8XNg86Ng87aeIdwMUdwaeaRaUNgUaeIdxMUdxaea86aRNg88aeIdzMUdzaea8Wa86Ng89aeIdCMUdCaeaRa8Va8Xa8ZNaRa8SNa8Ua8WNMM:mg8:Ng86NgRaeIdKMUdKaea8Wa86Ng8WaeId3MUd3aea8Xa86Ng8XaeIdaMUdaaea86a8:Ng86aeId8KMUd8Kaea8VaeIdyMUdyaIaOa8Fcdtfydbg8Fc8S2fgea83aeIdbMUdbaea85aeIdlMUdlaea87aeIdwMUdwaeaUaeIdxMUdxaea88aeIdzMUdzaea89aeIdCMUdCaeaRaeIdKMUdKaea8WaeId3MUd3aea8XaeIdaMUdaaea86aeId8KMUd8Kaea8VaeIdyMUdyaIaOahcdtfydbgac8S2fgea83aeIdbMUdbaea85aeIdlMUdlaea87aeIdwMUdwaeaUaeIdxMUdxaea88aeIdzMUdzaea89aeIdCMUdCaeaRaeIdKMUdKaea8WaeId3MUd3aea8XaeIdaMUdaaea86aeId8KMUd8Kaea8VaeIdyMUdydna8MTmbdnaATmba8YaB:vh8Ya80aB:vh80a81aB:vh81ka8MaXcltfgeaBJbbbZNgRa80Ng8VaeIdlMUdlaeaRa8YNg8WaeIdwMUdwaeaRa81Ng8XaeIdbMUdbaeaRa8S:ma81Na8Ua80N:ta8Za8YN:tNgRaeIdxMUdxa8Ma8Fcltfgea8VaeIdlMUdlaea8WaeIdwMUdwaea8XaeIdbMUdbaeaRaeIdxMUdxa8Maacltfgea8VaeIdlMUdlaea8WaeIdwMUdwaea8XaeIdbMUdbaeaRaeIdxMUdxkaHcxfhHaKcifgKad6mbkkdnalTmbJq;x8J88J;n;m;m89J:v:;;w8ZamczGEamc;abGEh80cbhHaOhXazhKaIhea8NhAindnaHaXydb9hmbaHh8FdnazTmbaKydbh8Fka80hRdnaqTmbJbbjZa80aqa8FfRbbclGEhRkaecxfg8Fa8FIdbJbbbbMUdbaeczfg8Fa8FIdbJbbbbMUdbaecCfg8Fa8FIdbJbbbbMUdbaeaRaecyfg8FIdbg8YNgRaeIdbMUdbaeclfgaaRaaIdbMUdbaecwfgaaRaaIdbMUdbaecKfgaaaIdbaAIdbg8WaRN:tUdbaAcwfIdbh8Vaec3fgaaaIdbaRaAclfIdbg8XN:tUdbaecafgaaaIdbaRa8VN:tUdbaec8KfgaIdbh81a8Fa8YaRMUdbaaa81aRa8Va8VNa8Wa8WNa8Xa8XNMMNMUdbkaXclfhXaKclfhKaec8SfheaAcxfhAalaHcefgH9hmbkkdnadTmbcbh8Aabhainaba8Acdtfh8FcbhHinaYa8FaHc:G:G:cjbfydbcdtfydbgAfRbbhedndnaYaaaHfydbgXfRbbgKc99fcFeGcpe0mbaec99fcFeGc;:e6mekdnaKcufcFeGce0mba5aXcdtfydbaA9hmekdnaecufcFeGce0mba8EaAcdtfydbaX9hmekJbbacJbbacJbbbZaecFeGceSEaKcFeGceSEhUdna8Na8FaHc:K:G:cjbfydbcdtfydbcx2fgeIdwa8NaXcx2fgKIdwg86:tg8Sa8NaAcx2fghIdwa86:tg8Xa8XNahIdbaKIdbg8U:tg80a80NahIdlaKIdlg8Z:tg8Va8VNMMg81Na8Xa8Sa8XNaeIdba8U:tg83a80Na8VaeIdla8Z:tg85NMMg8WN:tg8Ya8YNa83a81Na80a8WN:tgRaRNa85a81Na8Va8WN:tg8Wa8WNMMgBJbbbb9ETmba8YaB:rgB:vh8Ya8WaB:vh8WaRaB:vhRkaUa81:rNgBa8Ya86NaRa8UNa8Za8WNMM:mg81Ng87a81Nh88a80a85Na8Va83N:tg81a81Na8Va8SNa8Xa85N:tg8Va8VNa8Xa83Na80a8SN:tg8Xa8XNMMg83:rh80a8Ya87Nh85a8Wa87Nh89aRa87Nh87a8WaBa8YNg8SNh8:a8SaRNhZaRaBa8WNgnNhca8Ya8SNh8Ya8WanNh8WaRaBaRNNh8Sdna83Jbbbb9ETmba81a80:vh81a8Xa80:vh8Xa8Va80:vh8VkaIaOaXcdtfydbc8S2fgeaeIdba8Sa8VaUa80:rNgRa8VNNMg80MUdbaea8Wa8XaRa8XNg8SNMg83aeIdlMUdlaea8Ya81aRa81Ng8WNMg8YaeIdwMUdwaeaca8Va8SNMg8SaeIdxMUdxaeaZa8Wa8VNMgUaeIdzMUdzaea8:a8Xa8WNMg8WaeIdCMUdCaea87a8VaRa81a86Na8Va8UNa8Za8XNMMg86:mNgRNMg8VaeIdKMUdKaea89a8XaRNMg8XaeId3MUd3aea85a81aRNMg81aeIdaMUdaaea88a86aRN:tgRaeId8KMUd8KaeaBaeIdyMUdyaIaOaAcdtfydbc8S2fgea80aeIdbMUdbaea83aeIdlMUdlaea8YaeIdwMUdwaea8SaeIdxMUdxaeaUaeIdzMUdzaea8WaeIdCMUdCaea8VaeIdKMUdKaea8XaeId3MUd3aea81aeIdaMUdaaeaRaeId8KMUd8KaeaBaeIdyMUdykaHclfgHcx9hmbkaacxfhaa8Acifg8Aad6mbkaCTmbcbhainJbbbbh80a8Nabaacdtfgeclfydbg8Fcx2fgHIdwa8Naeydbghcx2fgAIdwg8Z:tg8Va8VNaHIdbaAIdbg83:tg8Wa8WNaHIdlaAIdlg85:tg8Xa8XNMMg8Sa8Naecwfydbg8Acx2fgeIdwa8Z:tg8YNa8Va8YNa8WaeIdba83:tg81Na8XaeIdla85:tgBNMMgRa8VN:tJbbbbJbbjZa8Sa8Ya8YNa81a81NaBaBNMMg8UNaRaRN:tg86:va86Jbbbb9BEg86Nh88a8Ua8VNaRa8YN:ta86Nh89a8SaBNaRa8XN:ta86Nh8:a8Ua8XNaRaBN:ta86NhZa8Sa81NaRa8WN:ta86Nhna8Ua8WNaRa81N:ta86Nhca8WaBNa8Xa81N:tgRaRNa8Xa8YNa8VaBN:tgRaRNa8Va81Na8Wa8YN:tgRaRNMM:rJbbbZNhRa8PahaC2g8JcdtfhHa8Pa8AaC2gDcdtfhAa8Pa8FaC2g8KcdtfhXa8Z:mh9ca85:mhJa83:mh9eascjdfheaChKJbbbbhBJbbbbh86Jbbbbh8SJbbbbh8UJbbbbh8ZJbbbbh83Jbbbbh85Jbbbbh87JbbbbhUinaecwfaRa89aXIdbaHIdbg8Y:tg8XNa88aAIdba8Y:tg81NMg8VNUdbaeclfaRaZa8XNa8:a81NMg8WNUdbaeaRaca8XNana81NMg8XNUdbaecxfaRa9ca8VNaJa8WNa8Ya9ea8XNMMMg8YNUdbaRa8Va8WNNa8ZMh8ZaRa8Va8XNNa8UMh8UaRa8Wa8XNNa8SMh8SaRa8Ya8YNNaUMhUaRa8Va8YNNa87Mh87aRa8Wa8YNNa85Mh85aRa8Xa8YNNa83Mh83aRa8Va8VNNa86Mh86aRa8Wa8WNNaBMhBaRa8Xa8XNNa80Mh80aHclfhHaXclfhXaAclfhAaeczfheaKcufgKmbkagahc8S2fgea80aeIdbMUdbaeaBaeIdlMUdlaea86aeIdwMUdwaea8SaeIdxMUdxaea8UaeIdzMUdzaea8ZaeIdCMUdCaea83aeIdKMUdKaea85aeId3MUd3aea87aeIdaMUdaaeaUaeId8KMUd8KaeaRaeIdyMUdyaga8Fc8S2fgea80aeIdbMUdbaeaBaeIdlMUdlaea86aeIdwMUdwaea8SaeIdxMUdxaea8UaeIdzMUdzaea8ZaeIdCMUdCaea83aeIdKMUdKaea85aeId3MUd3aea87aeIdaMUdaaeaUaeId8KMUd8KaeaRaeIdyMUdyaga8Ac8S2fgea80aeIdbMUdbaeaBaeIdlMUdlaea86aeIdwMUdwaea8SaeIdxMUdxaea8UaeIdzMUdzaea8ZaeIdCMUdCaea83aeIdKMUdKaea85aeId3MUd3aea87aeIdaMUdaaeaUaeId8KMUd8KaeaRaeIdyMUdya8Ra8Jcltfh8FcbhHaChXina8FaHfgeascjdfaHfgAIdbaeIdbMUdbaeclfgKaAclfIdbaKIdbMUdbaecwfgKaAcwfIdbaKIdbMUdbaecxfgeaAcxfIdbaeIdbMUdbaHczfhHaXcufgXmbka8Ra8Kcltfh8FcbhHaChXina8FaHfgeascjdfaHfgAIdbaeIdbMUdbaeclfgKaAclfIdbaKIdbMUdbaecwfgKaAcwfIdbaKIdbMUdbaecxfgeaAcxfIdbaeIdbMUdbaHczfhHaXcufgXmbka8RaDcltfh8FcbhHaChXina8FaHfgeascjdfaHfgAIdbaeIdbMUdbaeclfgKaAclfIdbaKIdbMUdbaecwfgKaAcwfIdbaKIdbMUdbaecxfgeaAcxfIdbaeIdbMUdbaHczfhHaXcufgXmbkaacifgaad6mbkkcbhAdndnamcwGgTmbJbbbbh8ScbhScbh9hcbh9ixekcbhSa3cbyd1:H:cjbHjjjjbbh9iasc:Cefasyd;8egecdtfa9iBdbasaecefBd;8ecua9ialabadaOz:fjjjbgXcltaXcjjjjiGEcbyd1:H:cjbHjjjjbbh9hasc:Cefasyd;8egecdtfa9hBdbasaecefBd;8ea9haXa9ia8Nalz:gjjjbJFFuuh8SaXTmba9hheaXhHinaeIdbgRa8Sa8SaR9EEh8SaeclfheaHcufgHmbkaXhSkdnalTmbaLclfheaLydbhXaYhHalhKcbhAincbaeydbg8FaX9RaHRbbcpeGEaAfhAaHcefhHaeclfhea8FhXaKcufgKmbkaAce4hAkcuadaA9Rcifg6cx2a6c;v:Q;v:Qe0Ecbyd1:H:cjbHjjjjbbh9kasc:Cefasyd;8egecdtfa9kBdbasaecefBd;8ecua6cdta6cFFFFi0Ecbyd1:H:cjbHjjjjbbh0asc:Cefasyd;8egecdtfa0BdbasaecefBd;8ea3cbyd1:H:cjbHjjjjbbh9masc:Cefasyd;8egecdtfa9mBdbasaecefBd;8ealcbyd1:H:cjbHjjjjbbh9nasc:Cefasyd;8egecdtfa9nBdbasaecefBd;8eaxaxNayJbbjZamclGEgZaZN:vh87JbbbbhUdnadak9nmbdna6ci6mbaCclth9oa9kcwfh9pJbbbbh85JbbbbhUinascNefabadalaOz:cjjjbabh8Acbh9qcbh9rinaba9rcdtfhDcbheindnaOa8AaefydbgAcdtghfydbgXaOaDaec:W:G:cjbfydbcdtfydbgHcdtg8JfydbgKSmbaYaHfRbbgacv2aYaAfRbbg8FfRb;a:G:cjbg8La8Fcv2aafg8KRb;a:G:cjbg3VcFeGTmbdnaKaX9nmba8KRb;G:G:cjbcFeGmekdna8FcufcFeGce0mbaaTmba5ahfydbaH9hmekdna8FTmbaacufcFeGce0mba8Ea8JfydbaA9hmeka9ka9qcx2fgXaHaAa3cFeGgKEBdlaXaAaHaKEBdbaXaKa8LGcb9hBdwa9qcefh9qkaeclfgecx9hmbkdna9rcifg9rad9pmba8Acxfh8Aa9qcifa69nmekka9qTmdcbh8KinaIaOa9ka8Kcx2fghydbgKcdtgXfydbg8Ac8S2fgeIdwa8Nahydlg8Fcx2fgHIdwg8WNaeIdzaHIdbg8XNaeIdaMgRaRMMa8WNaeIdlaHIdlg8YNaeIdCa8WNaeId3MgRaRMMa8YNaeIdba8XNaeIdxa8YNaeIdKMgRaRMMa8XNaeId8KMMM:lhRJbbbbJbbjZaeIdyg8V:va8VJbbbb9BEh8VdndnahydwgDmbJFFuuh86xekJbbbbJbbjZaIaOa8Fcdtfydbc8S2fgeIdyg81:va81Jbbbb9BEaeIdwa8NaKcx2fgHIdwg81NaeIdzaHIdbg80NaeIdaMgBaBMMa81NaeIdlaHIdlgBNaeIdCa81NaeId3Mg81a81MMaBNaeIdba80NaeIdxaBNaeIdKMg81a81MMa80NaeId8KMMM:lNh86ka8VaRNhBdnaCTmbagaKc8S2fgAIdwa8WNaAIdza8XNaAIdaMgRaRMMa8WNaAIdla8YNaAIdCa8WNaAId3MgRaRMMa8YNaAIdba8XNaAIdxa8YNaAIdKMgRaRMMa8XNaAId8KMMMhRa8Pa8FaC2gacdtfhHa8RaKaC2g8JcltfheaAIdyh81aChAinaHIdbg8Va8Va81NaecxfIdba8WaecwfIdbNa8XaeIdbNa8YaeclfIdbNMMMg8Va8VM:tNaRMhRaHclfhHaeczfheaAcufgAmbkdndnaDmbJbbbbh8Vxekaga8Fc8S2fgAIdwa8NaKcx2fgeIdwg8XNaAIdzaeIdbg8YNaAIdaMg8Va8VMMa8XNaAIdlaeIdlg81NaAIdCa8XNaAId3Mg8Va8VMMa81NaAIdba8YNaAIdxa81NaAIdKMg8Va8VMMa8YNaAId8KMMMh8Va8Pa8JcdtfhHa8RaacltfheaAIdyh80aChAinaHIdbg8Wa8Wa80NaecxfIdba8XaecwfIdbNa8YaeIdbNa81aeclfIdbNMMMg8Wa8WM:tNa8VMh8VaHclfhHaeczfheaAcufgAmbka8V:lh8VkaBaR:lMhBa86a8VMh86dndndnaYaKfRbbc9:fPddbekaQaXfydbgXaKSmbaOa8Fcdtfydbh8Jindndna5aXcdtgafydbgecuSmbaOaecdtfydba8JSmekdna8EaafydbgecuSmbaOaecdtfydba8JSmeka8FhekagaXc8S2fgAIdwa8Naecx2fgHIdwg8WNaAIdzaHIdbg8XNaAIdaMgRaRMMa8WNaAIdlaHIdlg8YNaAIdCa8WNaAId3MgRaRMMa8YNaAIdba8XNaAIdxa8YNaAIdKMgRaRMMa8XNaAId8KMMMhRa8PaeaC2cdtfhHa8RaXaC2cltfheaAIdyh81aChAinaHIdbg8Va8Va81NaecxfIdba8WaecwfIdbNa8XaeIdbNa8YaeclfIdbNMMMg8Va8VM:tNaRMhRaHclfhHaeczfheaAcufgAmbkaBaR:lMhBaQaafydbgXaK9hmbkkaYa8FfRbbci9hmeaDTmeaQa8FcdtfydbgXa8FSmeindndna5aXcdtgafydbgecuSmbaOaecdtfydba8ASmekdna8EaafydbgecuSmbaOaecdtfydba8ASmekaKhekagaXc8S2fgAIdwa8Naecx2fgHIdwg8WNaAIdzaHIdbg8XNaAIdaMgRaRMMa8WNaAIdlaHIdlg8YNaAIdCa8WNaAId3MgRaRMMa8YNaAIdba8XNaAIdxa8YNaAIdKMgRaRMMa8XNaAId8KMMMhRa8PaeaC2cdtfhHa8RaXaC2cltfheaAIdyh81aChAinaHIdbg8Va8Va81NaecxfIdba8WaecwfIdbNa8XaeIdbNa8YaeclfIdbNMMMg8Va8VM:tNaRMhRaHclfhHaeczfheaAcufgAmbka86aR:lMh86aQaafydbgXa8F9hmbxdkkdna8Ea5a5aXfydba8FSEaQaXfydbgacdtfydbgXcu9hmbaQa8FcdtfydbhXkagaac8S2fgAIdwa8NaXcx2fgeIdwg8WNaAIdzaeIdbg8XNaAIdaMgRaRMMa8WNaAIdlaeIdlg8YNaAIdCa8WNaAId3MgRaRMMa8YNaAIdba8XNaAIdxa8YNaAIdKMgRaRMMa8XNaAId8KMMMhRa8PaXaC2g8AcdtfhHa8RaaaC2g8JcltfheaAIdyh81aChAinaHIdbg8Va8Va81NaecxfIdba8WaecwfIdbNa8XaeIdbNa8YaeclfIdbNMMMg8Va8VM:tNaRMhRaHclfhHaeczfheaAcufgAmbkdndnaDmbJbbbbh8VxekagaXc8S2fgAIdwa8Naacx2fgeIdwg8XNaAIdzaeIdbg8YNaAIdaMg8Va8VMMa8XNaAIdlaeIdlg81NaAIdCa8XNaAId3Mg8Va8VMMa81NaAIdba8YNaAIdxa81NaAIdKMg8Va8VMMa8YNaAId8KMMMh8Va8Pa8JcdtfhHa8Ra8AcltfheaAIdyh80aChAinaHIdbg8Wa8Wa80NaecxfIdba8XaecwfIdbNa8YaeIdbNa81aeclfIdbNMMMg8Wa8WM:tNa8VMh8VaHclfhHaeczfheaAcufgAmbka8V:lh8VkaBaR:lMhBa86a8VMh86kaha86aBa86aB9DgeEUdwahaKa8FaeaDcb9hGgeEBdlaha8FaKaeEBdba8Kcefg8Ka9q9hmbkascjdfcbcj;qbz:tjjjb8Aa9phea9qhHinascjdfaeydbcA4cF8FGgAcFAaAcFA6EcdtfgAaAydbcefBdbaecxfheaHcufgHmbkcbhecbhHinascjdfaefgAydbhXaAaHBdbaXaHfhHaeclfgecj;qb9hmbkcbhea9phHinascjdfaHydbcA4cF8FGgAcFAaAcFA6EcdtfgAaAydbgAcefBdba0aAcdtfaeBdbaHcxfhHa9qaecefge9hmbkadak9RgAci9Uh9sdnalTmbcbhea9mhHinaHaeBdbaHclfhHalaecefge9hmbkkcbh9ta9ncbalz:tjjjbh3aAcO9Uh9ua9sce4h9rcbh8Lcbh8Kdnina9ka0a8Kcdtfydbcx2fg8JIdwgRa879Emea8La9s9pmeJFFuuh8Vdna9ra9q9pmba9ka0a9rcdtfydbcx2fIdwJbb;aZNh8VkdnaRa8V9ETmbaRaU9ETmba8La9u0mdkdna3aOa8JydlgDcdtg9vfg8AydbgAfg9wRbba3aOa8Jydbghcdtg9xfydbgefg9yRbbVmbaYahfRbbh9zdndnaLaecdtfgHclfydbgXaHydbgHSmbaXaH9RhXa8NaAcx2fh8Fa8Naecx2fhaaEaHcitfheindna9maeydbcdtfydbgHaASmba9maeclfydbcdtfydbgKaASmbaHaKSmba8NaKcx2fgKIdba8NaHcx2fgHIdbg8W:tgRaaIdlaHIdlg8X:tg80NaKIdla8X:tg8VaaIdba8W:tgBN:tg8YaRa8FIdla8X:tg86Na8Va8FIdba8W:tg8UN:tg8XNa8VaaIdwaHIdwg81:tg8ZNaKIdwa81:tg8Wa80N:tg80a8Va8FIdwa81:tg83Na8Wa86N:tg8VNa8WaBNaRa8ZN:tg81a8Wa8UNaRa83N:tgRNMMa8Ya8YNa80a80Na81a81NMMa8Xa8XNa8Va8VNaRaRNMMN:rJbbj8:N9FmikaecwfheaXcufgXmbkkdndndndna9zc9:fPdebdkahheina8AydbhAdndna5aecdtgHfydbgecuSmbaOaecdtfydbaASmekdna8EaHfydbgecuSmbaOaecdtfydbaASmekaDheka9maHfaeBdbaQaHfydbgeah9hmbxikkdna8Ea5a5a9xfydbaDSEaQa9xfydbghcdtfydbgecu9hmbaQa9vfydbheka9ma9xfaDBdbaehDka9mahcdtfaDBdbka9yce86bba9wce86bba8JIdwgRaUaUaR9DEhUa9tcefh9tcecda9zceSEa8Lfh8Lxeka9rcefh9rka8Kcefg8Ka9q9hmbkka9tTmddnalTmbcbh8Fcbhhindna9mahcdtgefydbgAahSmbaOaAcdtfydbh8AdnahaOaefydb9hg8JmbaIa8Ac8S2fgeaIahc8S2fgHIdbaeIdbMUdbaeaHIdlaeIdlMUdlaeaHIdwaeIdwMUdwaeaHIdxaeIdxMUdxaeaHIdzaeIdzMUdzaeaHIdCaeIdCMUdCaeaHIdKaeIdKMUdKaeaHId3aeId3MUd3aeaHIdaaeIdaMUdaaeaHId8KaeId8KMUd8KaeaHIdyaeIdyMUdya8MTmba8Ma8Acltfgea8MahcltfgHIdbaeIdbMUdbaeaHIdlaeIdlMUdlaeaHIdwaeIdwMUdwaeaHIdxaeIdxMUdxkaCTmbagaAc8S2fgeagahc8S2gDfgHIdbaeIdbMUdbaeaHIdlaeIdlMUdlaeaHIdwaeIdwMUdwaeaHIdxaeIdxMUdxaeaHIdzaeIdzMUdzaeaHIdCaeIdCMUdCaeaHIdKaeIdKMUdKaeaHId3aeId3MUd3aeaHIdaaeIdaMUdaaeaHId8KaeId8KMUd8KaeaHIdyaeIdyMUdya9oaA2haa8RhHaChXinaHaafgeaHa8FfgAIdbaeIdbMUdbaeclfgKaAclfIdbaKIdbMUdbaecwfgKaAcwfIdbaKIdbMUdbaecxfgeaAcxfIdbaeIdbMUdbaHczfhHaXcufgXmbka8JmbJbbbbJbbjZaIaDfgeIdygR:vaRJbbbb9BEaeIdwa8Na8Acx2fgHIdwgRNaeIdzaHIdbg8VNaeIdaMg8Wa8WMMaRNaeIdlaHIdlg8WNaeIdCaRNaeId3MgRaRMMa8WNaeIdba8VNaeIdxa8WNaeIdKMgRaRMMa8VNaeId8KMMM:lNgRa85a85aR9DEh85ka8Fa9ofh8Fahcefghal9hmbkcbhHa5heindnaeydbgAcuSmbdnaHa9maAcdtgXfydbgA9hmbcuhAa5aXfydbgXcuSmba9maXcdtfydbhAkaeaABdbkaeclfhealaHcefgH9hmbkcbhHa8EheindnaeydbgAcuSmbdnaHa9maAcdtgXfydbgA9hmbcuhAa8EaXfydbgXcuSmba9maXcdtfydbhAkaeaABdbkaeclfhealaHcefgH9hmbkka85aUaCEh85cbhHabhecbhAindnaOa9maeydbcdtfydbg8FcdtfydbgXaOa9maeclfydbcdtfydbgacdtfydbgKSmbaXaOa9maecwfydbcdtfydbg8AcdtfydbghSmbaKahSmbabaHcdtfgXa8FBdbaXcwfa8ABdbaXclfaaBdbaHcifhHkaecxfheaAcifgAad6mbkdndnaTmbaHhdxekdnaHak0mbaHhdxekdna8Sa859FmbaHhdxekJFFuuh8ScbhdabhecbhAindna9ha9iaeydbgXcdtfydbcdtfIdbgRa859ETmbaeclf8Pdbh9AabadcdtfgKaXBdbaKclfa9A83dbaRa8Sa8SaR9EEh8SadcifhdkaecxfheaAcifgAaH6mbkkadak0mbxdkkascNefabadalaOz:cjjjbkdndnadak0mbadhaxekdnaTmbadhaxekdna8Sa879FmbadhaxekcehKina8SJbb;aZNgRa87aRa879DEh8WJbbbbhRdnaSTmba9hheaShHinaeIdbg8VaRa8Va8W9FEaRa8VaR9EEhRaeclfheaHcufgHmbkkJFFuuh8ScbhaabhecbhHindna9ha9iaeydbgAcdtfydbcdtfIdbg8Va8W9ETmbaeclf8Pdbh9AabaacdtfgXaABdbaXclfa9A83dba8Va8Sa8Sa8V9EEh8SaacifhakaecxfheaHcifgHad6mbkdnaKaaad9hVceGmbadhaxdkaRaUaUaR9DEhUaaak9nmecbhKaahda8Sa879FmbkkdnamcjjjjdGTmba9ncbalz:tjjjbh8AdnaaTmbabheaahHina8AaeydbgAfce86bba8AaOaAcdtfydbfce86bbaeclfheaHcufgHmbkkascNefabaaalaOz:cjjjbdndnalTmbcbhXindna8AaXfRbbTmbdnaYaXfRbbgecl0mbceaetcQGmekdnaOaXcdtg8FfydbgeaXSmba8NaXcx2fgHa8Naecx2fgeydwBdwaHae8Pdb83dbxekaIaXc8S2fgKIdygcacJL:3;rUNgRMh87aKIdwg9BaRMh8SaKIdlg9CaRMh8UaKIdbg9DaRMh81aKIdag9EaRa8NaXcx2fg8JIdwg88N:th8ZaKId3g9FaRa8JIdlg89N:th83aKIdKg9Ga8JIdbg8:aRN:th80JbbbbhnaKIdCg9HJbbbbMh85aKIdzg9IJbbbbMhBaKIdxg9JJbbbbMh86dndnaCTmbaXhAinJbbbba87agaAc8S2fgHIdygR:vaRJbbbb9BEhRa8RaAaC2cltfheaHIdaa87Na8ZMh8ZaHId3a87Na83Mh83aHIdKa87Na80Mh80aHIdCa87Na85Mh85aHIdza87NaBMhBaHIdxa87Na86Mh86aHIdwa87Na8SMh8SaHIdla87Na8UMh8UaHIdba87Na81Mh81aChHina8ZaecwfIdbg8VaecxfIdbg8YNaRN:th8Za83aeclfIdbg8Wa8YNaRN:th83a85a8Wa8VNaRN:th85a81aeIdbg8Xa8XNaRN:th81a80a8Xa8YNaRN:th80aBa8Xa8VNaRN:thBa86a8Xa8WNaRN:th86a8Sa8Va8VNaRN:th8Sa8Ua8Wa8WNaRN:th8UaeczfheaHcufgHmbkaQaAcdtfydbgAaX9hmbka8MTmba8MaXcltfgeIdxhxaeIdwh9caeIdlhJaeIdbhRxekJbbbbhxJbbbbh9cJbbbbhJJbbbbhRkaBa81:vg8Wa80Na8Z:ta85aBa86a81:vg8VN:tg8Za8Ua86a8VN:tg8Y:vg8Xa8Va80Na83:tg8UN:th83a9caRa8WN:taJaRa8VN:tg86a8XN:tg85a8SaBa8WN:ta8Za8XN:tgB:vg8S:mh8Za86a8Y:vg9c:mhJdnJbbbbaRaRa81:vg9eN:ta86a9cN:ta85a8SN:tg86:la87J:983:g81NgR9ETmba8Za83NaJa8UNa9ea80Nax:tMMa86:vhnka81:laR9ETmba8Y:laR9ETmbaB:laR9ETmba9e:manNa8W:ma8ZanNa83aB:vMgBNa8V:maJanNa8X:maBNa8Ua8Y:vMMg85Na80:ma81:vMMMh87aLa8FfgeclfydbgHaeydbge9RhhaEaecitfh8FJbbbbhRdnaHaeSgDmbJbbbbhRa8FheahhAina8Naeclfydbcx2fgHIdwa88:tg8Va8VNaHIdba8::tg8Va8VNaHIdla89:tg8Va8VNMMg8Va8Naeydbcx2fgHIdwa88:tg8Wa8WNaHIdba8::tg8Wa8WNaHIdla89:tg8Wa8WNMMg8WaRaRa8W9DEgRaRa8V9DEhRaecwfheaAcufgAmbkaR:rgRaRNhRkaBa88:tg8Va8VNa87a8::tg8Va8VNa85a89:tg8Va8VNMMaR9EmbaKId8KhndnaDmbina8Na8Fclfydbcx2fgeIdba8Na8Fydbcx2fgHIdbg8W:tgRa89aHIdlg8X:tg80NaeIdla8X:tg8Va8:a8W:tg86N:tg8YaRa85a8X:tg8SNa8Va87a8W:tg8UN:tg8XNa8Va88aHIdwg81:tg8ZNaeIdwa81:tg8Wa80N:tg80a8VaBa81:tg83Na8Wa8SN:tg8VNa8Wa86NaRa8ZN:tg81a8Wa8UNaRa83N:tgRNMMa8Ya8YNa80a80Na81a81NMMa8Xa8XNa8Va8VNaRaRNMMN:rJbbj8:N9Fmda8Fcwfh8FahcufghmbkkJbbbbJbbjZac:vacJbbbb9BEgRa9BaBNa9Ia87Na9EMg8Va8VMMaBNa9Ca85Na9HaBNa9FMg8Va8VMMa85Na9Da87Na9Ja85Na9GMg8Va8VMMa87NanMMM:lNaRa9Ba88Na9Ia8:Na9EMg8Va8VMMa88Na9Ca89Na9Ha88Na9FMg8Va8VMMa89Na9Da8:Na9Ja89Na9GMg8Va8VMMa8:NanMMM:lNJbb;aZNJ:983:g81M9Emba8JaBUdwa8Ja85Udla8Ja87UdbkaXcefgXal9hmbkdnaCmbcbhCxdkcbhXindna8AaXfRbbTmbaOaXcdtgefydbaX9hmbaYaXfhhaQaefh8Ja8NaXcx2fhAa8PaXaC2cdtfhDcbhEincuhLdnahRbbci9hmbaXhLa8JydbgeaXSmba8PaEcdtgHfhKaDaHfIdbhRaXhLinaLhHcuhLdnaKaeaC2cdtfIdbaR9CmbaHcuSmbaHhLagaec8S2fIdyagaHc8S2fIdy9ETmbaehLkaQaecdtfydbgeaX9hmbkka8PaEcdtfhKa8RaEcltfh8FaXheinaKaeaC2cdtfJbbbbJbbjZagaeaLaLcuSEgHc8S2fIdygR:vaRJbbbb9BEa8FaHaC2cltfgHIdwaAIdwNaHIdbaAIdbNaHIdlaAIdlNMMaHIdxMNUdbaQaecdtfydbgeaX9hmbkaEcefgEaC9hmbkkaXcefgXal9hmbxdkkaCmbcbhCkaiavaoarawaCala8Na8Pazasayasc1efaYa8Aaqz:hjjjbkdnamcjjjjlGTmbazmbaaTmbabhecbhLinaYaeydbgAfRbbc3thQaecwfgXydbhHcjjjj94hCdna5aAcdtgEfydbaeclfgKydbgOSmbcjjjj94cba8EaOcdtfydbaASEhCkaeaQaCVaAVBdbaYaOfRbbc3th8Fcjjjj94hCcjjjj94hQdna5aOcdtfydbaHSmbcjjjj94cba8EaHcdtfydbaOSEhQkaKa8FaQVaOVBdbaYaHfRbbc3thOdna5aHcdtfydbaASmbcjjjj94cba8EaEfydbaHSEhCkaXaOaCVaHVBdbaecxfheaLcifgLaa6mbkkdnazTmbaaTmbaaheinabazabydbcdtfydbBdbabclfhbaecufgembkkdnaPTmbaPaZaU:rNUdbkdnasyd;8egHTmbaHcdtasc:Ceffc98fheinaeydbcbyd:m:H:cjbH:bjjjbbaec98fheaHcufgHmbkkascj;sbf8Kjjjjbaak;Yieouabydlhvabydbclfcbaicdtz:tjjjbhoadci9UhrdnadTmbdnalTmbaehwadhDinaoalawydbcdtfydbcdtfgqaqydbcefBdbawclfhwaDcufgDmbxdkkaehwadhDinaoawydbcdtfgqaqydbcefBdbawclfhwaDcufgDmbkkdnaiTmbcbhDaohwinawydbhqawaDBdbawclfhwaqaDfhDaicufgimbkkdnadci6mbinaecwfydbhwaeclfydbhDaeydbhidnalTmbalawcdtfydbhwalaDcdtfydbhDalaicdtfydbhikavaoaicdtfgqydbcitfaDBdbavaqydbcitfawBdlaqaqydbcefBdbavaoaDcdtfgqydbcitfawBdbavaqydbcitfaiBdlaqaqydbcefBdbavaoawcdtfgwydbcitfaiBdbavawydbcitfaDBdlawawydbcefBdbaecxfhearcufgrmbkkabydbcbBdbk:todDue99aicd4aifhrcehwinawgDcethwaDar6mbkcuaDcdtgraDcFFFFi0Ecbyd1:H:cjbHjjjjbbhwaoaoyd9GgqcefBd9GaoaqcdtfawBdbawcFearz:tjjjbhkdnaiTmbalcd4hlaDcufhxcbhminamhDdnavTmbavamcdtfydbhDkcbadaDal2cdtfgDydlgwawcjjjj94SEgwcH4aw7c:F:b:DD2cbaDydbgwawcjjjj94SEgwcH4aw7c;D;O:B8J27cbaDydwgDaDcjjjj94SEgDcH4aD7c:3F;N8N27axGhwamcdthPdndndnavTmbakawcdtfgrydbgDcuSmeadavaPfydbal2cdtfgsIdbhzcehqinaqhrdnadavaDcdtfydbal2cdtfgqIdbaz9CmbaqIdlasIdl9CmbaqIdwasIdw9BmlkarcefhqakawarfaxGgwcdtfgrydbgDcu9hmbxdkkakawcdtfgrydbgDcuSmbadamal2cdtfgsIdbhzcehqinaqhrdnadaDal2cdtfgqIdbaz9CmbaqIdlasIdl9CmbaqIdwasIdw9BmikarcefhqakawarfaxGgwcdtfgrydbgDcu9hmbkkaramBdbamhDkabaPfaDBdbamcefgmai9hmbkkakcbyd:m:H:cjbH:bjjjbbaoaoyd9GcufBd9GdnaeTmbaiTmbcbhDaehwinawaDBdbawclfhwaiaDcefgD9hmbkcbhDaehwindnaDabydbgrSmbawaearcdtfgrydbBdbaraDBdbkabclfhbawclfhwaiaDcefgD9hmbkkk;:odvuv998Jjjjjbca9Rgocbyd1:G:cjbBdKaocb8Pdj:G:cjb83izaocbydN:G:cjbBdwaocb8Pd:m:G:cjb83ibdnadTmbaicd4hrdnabmbdnalTmbcbhwinaealawcdtfydbar2cdtfhDcbhiinaoczfaifgqaDaifIdbgkaqIdbgxaxak9EEUdbaoaifgqakaqIdbgxaxak9DEUdbaiclfgicx9hmbkawcefgwad9hmbxikkarcdthwcbhDincbhiinaoczfaifgqaeaifIdbgkaqIdbgxaxak9EEUdbaoaifgqakaqIdbgxaxak9DEUdbaiclfgicx9hmbkaeawfheaDcefgDad9hmbxdkkdnalTmbcbhwinabawcx2fgiaealawcdtfydbar2cdtfgDIdbUdbaiaDIdlUdlaiaDIdwUdwcbhiinaoczfaifgqaDaifIdbgkaqIdbgxaxak9EEUdbaoaifgqakaqIdbgxaxak9DEUdbaiclfgicx9hmbkawcefgwad9hmbxdkkarcdthlcbhwaehDinabawcx2fgiaeawar2cdtfgqIdbUdbaiaqIdlUdlaiaqIdwUdwcbhiinaoczfaifgqaDaifIdbgkaqIdbgxaxak9EEUdbaoaifgqakaqIdbgxaxak9DEUdbaiclfgicx9hmbkaDalfhDawcefgwad9hmbkkJbbbbaoIdbaoIdzgx:tgkakJbbbb9DEgkaoIdlaoIdCgm:tgPaPak9DEgkaoIdwaoIdKgP:tgsasak9DEhsdnabTmbadTmbJbbbbJbbjZas:vasJbbbb9BEhkinabakabIdbax:tNUdbabclfgoakaoIdbam:tNUdbabcwfgoakaoIdbaP:tNUdbabcxfhbadcufgdmbkkdnavTmbavaPUdwavamUdlavaxUdbkask:WlewudnaeTmbcbhvabhoinaoavBdbaoclfhoaeavcefgv9hmbkkdnaiTmbcbhrinadarcdtfhwcbhDinalawaDcdtgvyd:G:G:cjbcdtfydbcdtfydbhodnalawavfydbcdtfydbgqabaqcdtfgkydbgvSmbinakabavgqcdtfgxydbgvBdbaxhkaqav9hmbkkdnaoabaocdtfgkydbgvSmbinakabavgocdtfgxydbgvBdbaxhkaoav9hmbkkdnaqaoSmbabaqaoaqao0Ecdtfaqaoaqao6EBdbkaDcefgDci9hmbkarcifgrai6mbkkdnaembcbskcbhxindnalaxcdtgvfydbax9hmbaxhodnaxabavfgDydbgvSmbaDhqinaqabavgocdtfgkydbgvBdbakhqaoav9hmbkkaDaoBdbkaxcefgxae9hmbkcbhkabhvcbhoindndnaoalydbgq9hmbdnaoavydbgq9hmbavakBdbakcefhkxdkavabaqcdtfydbBdbxekavabaqcdtfydbBdbkalclfhlavclfhvaeaocefgo9hmbkakk;jiilud99euabcbaecltz:tjjjbhvdnalTmbadhoaihralhwinarcwfIdbhDarclfIdbhqavaoydbcltfgkarIdbakIdbMUdbakaqakIdlMUdlakaDakIdwMUdwakakIdxJbbjZMUdxaoclfhoarcxfhrawcufgwmbkkdnaeTmbavhkaehrinakcxfgoIdbhDaocbBdbakakIdbJbbbbJbbjZaD:vaDJbbbb9BEgDNUdbakclfgoaDaoIdbNUdbakcwfgoaDaoIdbNUdbakczfhkarcufgrmbkkdnalTmbinavadydbcltfgkaicwfIdbakIdw:tgDaDNaiIdbakIdb:tgDaDNaiclfIdbakIdl:tgDaDNMMgDakIdxgqaqaD9DEUdxadclfhdaicxfhialcufglmbkkdnaeTmbavcxfhkinabakIdbUdbakczfhkabclfhbaecufgembkkk:moerudnaoTmbaecd4hzdnavTmbaicd4hHavcdthOcbhAindnaPaAfRbbTmbaAhednaDTmbaDaAcdtfydbhekdnasTmbasaefRbbceGmekdnamaAfRbbclSmbabaeaz2cdtfgiaraAcx2fgCIdbakNaxIdbMUdbaiaCIdlakNaxIdlMUdlaiaCIdwakNaxIdwMUdwkadaeaH2cdtfhXaqheawhiavhCinaXaeydbcdtgQfaiIdbalaQfIdb:vUdbaeclfheaiclfhiaCcufgCmbkkawaOfhwaAcefgAao9hmbxdkkdnasmbcbheaDhiindnaPaefRbbTmbaehCdnaDTmbaiydbhCkamaefRbbclSmbabaCaz2cdtfgCarIdbakNaxIdbMUdbaCarclfIdbakNaxIdlMUdlaCarcwfIdbakNaxIdwMUdwkaiclfhiarcxfhraoaecefge9hmbxdkkdnaDTmbindnaPRbbTmbasaDydbgefRbbceGmbamRbbclSmbabaeaz2cdtfgearIdbakNaxIdbMUdbaearclfIdbakNaxIdlMUdlaearcwfIdbakNaxIdwMUdwkaPcefhPaDclfhDamcefhmarcxfhraocufgombxdkkazcdthicbheindnaPaefRbbTmbasaefRbbceGmbamaefRbbclSmbabarIdbakNaxIdbMUdbabclfarclfIdbakNaxIdlMUdbabcwfarcwfIdbakNaxIdwMUdbkarcxfhrabaifhbaoaecefge9hmbkkk8MbabaeadaialavcbcbcbcbcbaoarawaDz:bjjjbk8MbabaeadaialavaoarawaDaqakaxamaPz:bjjjbkRbababaeadaialavaoarawaDaqakaxcjjjjdVamz:bjjjbk:g8Koque99due99duq998Jjjjjbc;Wb9Rgq8Kjjjjbcbhkaqcxfcbc;Kbz:tjjjb8Aaqcualcx2alc;v:Q;v:Qe0Ecbyd1:H:cjbHjjjjbbgxBdxaqceBd2axaialavcbcbz:ejjjb8AaqcualcdtalcFFFFi0Egmcbyd1:H:cjbHjjjjbbgiBdzaqcdBd2dndnJFF959eJbbjZawJbbjZawJbbjZ9DE:vawJ9VO:d869DEgw:lJbbb9p9DTmbaw:OhPxekcjjjj94hPkadci9Uhsarco9UhzdndnaombaPcd9imekdnalTmbaPcuf:YhwdnaoTmbcbhvaihHaxhOindndnaoavfRbbceGTmbavcjjjjlVhAxekdndnaOclfIdbawNJbbbZMgC:lJbbb9p9DTmbaC:OhAxekcjjjj94hAkaAcqthAdndnaOcwfIdbawNJbbbZMgC:lJbbb9p9DTmbaC:OhXxekcjjjj94hXkaAaXVhAdndnaOIdbawNJbbbZMgC:lJbbb9p9DTmbaC:OhXxekcjjjj94hXkaAaXcCtVhAkaHaABdbaHclfhHaOcxfhOalavcefgv9hmbxdkkaxhvaihOalhHindndnavIdbawNJbbbZMgC:lJbbb9p9DTmbaC:OhAxekcjjjj94hAkaAcCthAdndnavclfIdbawNJbbbZMgC:lJbbb9p9DTmbaC:OhXxekcjjjj94hXkaXcqtaAVhAdndnavcwfIdbawNJbbbZMgC:lJbbb9p9DTmbaC:OhXxekcjjjj94hXkaOaAaXVBdbavcxfhvaOclfhOaHcufgHmbkkadTmbcbhkaehvcbhOinakaiavclfydbcdtfydbgHaiavcwfydbcdtfydbgA9haiavydbcdtfydbgXaH9haXaA9hGGfhkavcxfhvaOcifgOad6mbkkarci9UhQdndnaz:Z:rJbbbZMgw:lJbbb9p9DTmbaw:Ohvxekcjjjj94hvkaQ:ZhLcbhKc:bwhzdninakaQ9pmeazaP9Rcd9imeavazcufgOavaO9iEaPcefavaP9kEhYdnalTmbaYcuf:YhwdnaoTmbcbhOaihHaxhvindndnaoaOfRbbceGTmbaOcjjjjlVhAxekdndnavclfIdbawNJbbbZMgC:lJbbb9p9DTmbaC:OhAxekcjjjj94hAkaAcqthAdndnavcwfIdbawNJbbbZMgC:lJbbb9p9DTmbaC:OhXxekcjjjj94hXkaAaXVhAdndnavIdbawNJbbbZMgC:lJbbb9p9DTmbaC:OhXxekcjjjj94hXkaAaXcCtVhAkaHaABdbaHclfhHavcxfhvalaOcefgO9hmbxdkkaxhvaihOalhHindndnavIdbawNJbbbZMgC:lJbbb9p9DTmbaC:OhAxekcjjjj94hAkaAcCthAdndnavclfIdbawNJbbbZMgC:lJbbb9p9DTmbaC:OhXxekcjjjj94hXkaXcqtaAVhAdndnavcwfIdbawNJbbbZMgC:lJbbb9p9DTmbaC:OhXxekcjjjj94hXkaOaAaXVBdbavcxfhvaOclfhOaHcufgHmbkkcbhOdnadTmbaehvcbhHinaOaiavclfydbcdtfydbgAaiavcwfydbcdtfydbgX9haiavydbcdtfydbgraA9haraX9hGGfhOavcxfhvaHcifgHad6mbkkdnas:ZgCaL:taY:Ygwaz:Y:tg8ANak:ZgEaO:Zg3:tNaEaL:tawaP:Y:tg5Na3aC:tNMg8EJbbbb9BmbaCaE:ta5a8Aa3aL:tNNNa8E:vawMhwkdndnaOaQ0mbaOhkaYhPxekaOhsaYhzkdndnaKcl0mbdnawJbbbZMgw:lJbbb9p9DTmbaw:Ohvxdkcjjjj94hvxekaPazfcd9ThvkaKcefgKcs9hmbkkdndndnakmbJbbjZhwcbhOcdhvaDmexdkalcd4alfhHcehOinaOgvcethOavaH6mbkcbhOaqcuavcdtgYavcFFFFi0Ecbyd1:H:cjbHjjjjbbgKBdCaqciBd2aqamcbyd1:H:cjbHjjjjbbgzBdKaqclBd2dndndndnalTmbaPcuf:YhwaoTmecbhOaihAaxhHindndnaoaOfRbbceGTmbaOcjjjjlVhXxekdndnaHclfIdbawNJbbbZMgC:lJbbb9p9DTmbaC:OhXxekcjjjj94hXkaXcqthXdndnaHcwfIdbawNJbbbZMgC:lJbbb9p9DTmbaC:Ohrxekcjjjj94hrkaXarVhXdndnaHIdbawNJbbbZMgC:lJbbb9p9DTmbaC:Ohrxekcjjjj94hrkaXarcCtVhXkaAaXBdbaAclfhAaHcxfhHalaOcefgO9hmbxikkaKcFeaYz:tjjjb8AcbhPcbhvxdkaxhOaihHalhAindndnaOIdbawNJbbbZMgC:lJbbb9p9DTmbaC:OhXxekcjjjj94hXkaXcCthXdndnaOclfIdbawNJbbbZMgC:lJbbb9p9DTmbaC:Ohrxekcjjjj94hrkarcqtaXVhXdndnaOcwfIdbawNJbbbZMgC:lJbbb9p9DTmbaC:Ohrxekcjjjj94hrkaHaXarVBdbaOcxfhOaHclfhHaAcufgAmbkkaKcFeaYz:tjjjbhravcufhocbhPcbhYindndndnaraiaYcdtgKfydbgAcm4aA7c:v;t;h;Ev2gvcs4av7aoGgHcdtfgXydbgOcuSmbcehvinaiaOcdtgOfydbaASmdaHavfhOavcefhvaraOaoGgHcdtfgXydbgOcu9hmbkkaXaYBdbaPhvaPcefhPxekazaOfydbhvkazaKfavBdbaYcefgYal9hmbkcuaPc8S2gOaPc;D;O;f8U0EhvkcbhXaqavcbyd1:H:cjbHjjjjbbgvBd3aqcvBd2avcbaOz:tjjjbhOdnadTmbaehiinaxaiclfydbgrcx2fgvIdbaxaiydbgocx2fgHIdbg3:tgCaxaicwfydbgYcx2fgAIdlaHIdlg8A:tgwNavIdla8A:tgEaAIdba3:tg8EN:tgLaLNaEaAIdwaHIdwg5:tg8FNavIdwa5:tgEawN:tgwawNaEa8ENaCa8FN:tgCaCNMMg8E:rhEJbbnnJbbjZazaocdtfydbgvazarcdtfydbgASavazaYcdtfydbgrSGgHEh8Fdna8EJbbbb9ETmbaLaE:vhLaCaE:vhCawaE:vhwkaOavc8S2fgvavIdbawa8FaE:rNgEawNNg8FMUdbavaCaEaCNgaNghavIdlMUdlavaLaEaLNg8ENggavIdwMUdwavawaaNgaavIdxMUdxava8EawNg8JavIdzMUdzavaCa8ENg8EavIdCMUdCavawaEaLa5Nawa3Na8AaCNMM:mg8ANg3NgwavIdKMUdKavaCa3NgCavId3MUd3avaLa3NgLavIdaMUdaava3a8ANg3avId8KMUd8KavaEavIdyMUdydnaHmbaOaAc8S2fgva8FavIdbMUdbavahavIdlMUdlavagavIdwMUdwavaaavIdxMUdxava8JavIdzMUdzava8EavIdCMUdCavawavIdKMUdKavaCavId3MUd3avaLavIdaMUdaava3avId8KMUd8KavaEavIdyMUdyaOarc8S2fgva8FavIdbMUdbavahavIdlMUdlavagavIdwMUdwavaaavIdxMUdxava8JavIdzMUdzava8EavIdCMUdCavawavIdKMUdKavaCavId3MUd3avaLavIdaMUdaava3avId8KMUd8KavaEavIdyMUdykaicxfhiaXcifgXad6mbkkcbhAaqcuaPcdtgvaPcFFFFi0Egicbyd1:H:cjbHjjjjbbgHBdaaqcoBd2aqaicbyd1:H:cjbHjjjjbbgiBd8KaqcrBd2aHcFeavz:tjjjbhYdnalTmbazhHinJbbbbJbbjZaOaHydbgXc8S2fgvIdygw:vawJbbbb9BEavIdwaxcwfIdbgwNavIdzaxIdbgCNavIdaMgLaLMMawNavIdlaxclfIdbgLNavIdCawNavId3MgwawMMaLNavIdbaCNavIdxaLNavIdKMgwawMMaCNavId8KMMM:lNhwdndnaYaXcdtgvfgXydbcuSmbaiavfIdbaw9ETmekaXaABdbaiavfawUdbkaHclfhHaxcxfhxalaAcefgA9hmbkkdndnaPmbJbbbbhwxekJbbbbhwinaiIdbgCawawaC9DEhwaiclfhiaPcufgPmbkaw:rhwkakcd4akfhOcehiinaigvcethiavaO6mbkcbhOaqcuavcdtgiavcFFFFi0Ecbyd1:H:cjbHjjjjbbgHBdyaHcFeaiz:tjjjbhXdnadTmbavcufhrcbhPcbhxindnazaeaxcdtfgvydbcdtfydbgiazavclfydbcdtfydbgOSmbaiazavcwfydbcdtfydbgvSmbaOavSmbaYavcdtfydbhAdndnaYaOcdtfydbgvaYaicdtfydbgi9pmbavaA9pmbaAhlaihoavhAxekdnaAai9pmbaAav9pmbaihlavhoxekavhlaAhoaihAkabaPcx2fgvaABdbavcwfaoBdbavclfalBdbdnaXaoc:3F;N8N2alc:F:b:DD27aAc;D;O:B8J27arGgOcdtfgvydbgicuSmbcehHinaHhvdnabaicx2fgiydbaA9hmbaiydlal9hmbaiydwaoSmikavcefhHaXaOavfarGgOcdtfgvydbgicu9hmbkkavaPBdbaPcefhPkaxcifgxad6mbkaPci2hOkcwhvaDTmekaDawUdbkavcdthvaqcxfc98fhiinaiavfydbcbyd:m:H:cjbH:bjjjbbavc98fgvmbkaqc;Wbf8KjjjjbaOk:3ldrue9:8Jjjjjbc;Wb9Rgr8Kjjjjbcbhwarcxfcbc;Kbz:tjjjb8AdnabaeSmbabaeadcdtzMjjjb8AkarcualcdtalcFFFFi0EgDcbyd1:H:cjbHjjjjbbgqBdxarceBd2aqcbaialavcbarcxfz:djjjbcualcx2alc;v:Q;v:Qe0Ecbyd1:H:cjbHjjjjbbhkarcxfaryd2gxcdtfakBdbaraxcefgmBd2akaialavcbcbz:ejjjb8AarcxfamcdtfaDcbyd1:H:cjbHjjjjbbgiBdbaraxcdfgvBd2arcxfavcdtfcuaialaeadaqz:fjjjbgecltaecjjjjiGEcbyd1:H:cjbHjjjjbbgqBdbaqaeaiakalz:gjjjbaxcifhkdnadTmbaoaoNhocbhwabhlcbheindnaqaialydbgvcdtfydbcdtfIdbao9ETmbalclf8PdbhPabawcdtfgDavBdbaDclfaP83dbawcifhwkalcxfhlaecifgead6mbkkdnakTmbaxcdtarcxffcwfhlinalydbcbyd:m:H:cjbH:bjjjbbalc98fhlakcufgkmbkkarc;Wbf8Kjjjjbawk:WCoDud99vue99vuv998Jjjjjbc;Wb9Rgw8KjjjjbdndnarmbcbhDxekawcxfcbc;Kbz:tjjjb8Aawcuadcx2adc;v:Q;v:Qe0Ecbyd1:H:cjbHjjjjbbgqBdxawceBd2aqaeadaicbcbz:ejjjb8AawcuadcdtadcFFFFi0Egkcbyd1:H:cjbHjjjjbbgxBdzawcdBd2adcd4adfhmceheinaegicetheaiam6mbkcbhPawcuaicdtgsaicFFFFi0Ecbyd1:H:cjbHjjjjbbgzBdCawciBd2dndnar:ZgH:rJbbbZMgO:lJbbb9p9DTmbaO:Ohexekcjjjj94hekaicufhAc:bwhCcbhXadhQcbhLinaeaCcufgiaeai9iEaPcefaeaP9kEhDdndnadTmbaDcuf:YhOaqhiaxheadhmindndnaiIdbaONJbbbZMgK:lJbbb9p9DTmbaK:OhYxekcjjjj94hYkaYcCthYdndnaiclfIdbaONJbbbZMgK:lJbbb9p9DTmbaK:Oh8Axekcjjjj94h8Aka8AcqtaYVhYdndnaicwfIdbaONJbbbZMgK:lJbbb9p9DTmbaK:Oh8Axekcjjjj94h8AkaeaYa8AVBdbaicxfhiaeclfheamcufgmmbkazcFeasz:tjjjbhEcbh3cbh5indnaEaxa5cdtfydbgYcm4aY7c:v;t;h;Ev2gics4ai7aAGgmcdtfg8AydbgecuSmbaeaYSmbcehiinaEamaifaAGgmcdtfg8AydbgecuSmeaicefhiaeaY9hmbkka8AaYBdba3aecuSfh3a5cefg5ad9hmbxdkkazcFeasz:tjjjb8Acbh3kdnaQ:ZgKaH:taD:YgOaC:Y:tg8ENaX:Zg8Fa3:Zga:tNa8FaH:taOaP:Y:tghNaaaK:tNMggJbbbb9BmbaKa8F:taha8EaaaH:tNNNag:vaOMhOkaPaDa3ar0giEhPaXa3aiEhXdna3arSmbaDaCaiEgCaP9Rcd9imbdndnaLcl0mbdnaOJbbbZMgO:lJbbb9p9DTmbaO:Ohexdkcjjjj94hexekaPaCfcd9Theka3aQaiEhQaLcefgLcs9hmekkdndnaXmbcihicbhDxekcbhiawakcbyd1:H:cjbHjjjjbbg5BdKawclBd2aPcuf:YhKdndnadTmbaqhiaxheadhmindndnaiIdbaKNJbbbZMgO:lJbbb9p9DTmbaO:OhYxekcjjjj94hYkaYcCthYdndnaiclfIdbaKNJbbbZMgO:lJbbb9p9DTmbaO:Oh8Axekcjjjj94h8Aka8AcqtaYVhYdndnaicwfIdbaKNJbbbZMgO:lJbbb9p9DTmbaO:Oh8Axekcjjjj94h8AkaeaYa8AVBdbaicxfhiaeclfheamcufgmmbkazcFeasz:tjjjbhEcbhDcbh3indndndnaEaxa3cdtgCfydbgYcm4aY7c:v;t;h;Ev2gics4ai7aAGgmcdtfg8AydbgecuSmbcehiinaxaecdtgefydbaYSmdamaifheaicefhiaEaeaAGgmcdtfg8Aydbgecu9hmbkka8Aa3BdbaDhiaDcefhDxeka5aefydbhika5aCfaiBdba3cefg3ad9hmbkcuaDc32giaDc;j:KM;jb0EhexekazcFeasz:tjjjb8AcbhDcbhekawaecbyd1:H:cjbHjjjjbbgeBd3awcvBd2aecbaiz:tjjjbh8Aavcd4hxdnadTmbdnalTmbaxcdthEa5hYaqhealhmadhAina8AaYydbc32fgiaeIdbaiIdbMUdbaiaeclfIdbaiIdlMUdlaiaecwfIdbaiIdwMUdwaiamIdbaiIdxMUdxaiamclfIdbaiIdzMUdzaiamcwfIdbaiIdCMUdCaiaiIdKJbbjZMUdKaYclfhYaecxfheamaEfhmaAcufgAmbxdkka5hmaqheadhYina8Aamydbc32fgiaeIdbaiIdbMUdbaiaeclfIdbaiIdlMUdlaiaecwfIdbaiIdwMUdwaiaiIdxJbbbbMUdxaiaiIdzJbbbbMUdzaiaiIdCJbbbbMUdCaiaiIdKJbbjZMUdKamclfhmaecxfheaYcufgYmbkkdnaDTmba8AhiaDheinaiaiIdbJbbbbJbbjZaicKfIdbgO:vaOJbbbb9BEgONUdbaiclfgmaOamIdbNUdbaicwfgmaOamIdbNUdbaicxfgmaOamIdbNUdbaiczfgmaOamIdbNUdbaicCfgmaOamIdbNUdbaic3fhiaecufgembkkcbhYawcuaDcdtgCaDcFFFFi0Egicbyd1:H:cjbHjjjjbbgeBdaawcoBd2awaicbyd1:H:cjbHjjjjbbgEBd8KaecFeaCz:tjjjbh3dnadTmbaoJbbjZJbbjZaK:vaPceSENgOaONhKaxcdthxalheinaKaec;8:G:cjbalEgmIdwa8Aa5ydbgAc32fgiIdC:tgOaONamIdbaiIdx:tgOaONamIdlaiIdz:tgOaONMMNaqcwfIdbaiIdw:tgOaONaqIdbaiIdb:tgOaONaqclfIdbaiIdl:tgOaONMMMhOdndna3aAcdtgifgmydbcuSmbaEaifIdbaO9ETmekamaYBdbaEaifaOUdbka5clfh5aqcxfhqaeaxfheadaYcefgY9hmbkkaba3aCzMjjjb8Acrhikaicdthiawcxfc98fheinaeaifydbcbyd:m:H:cjbH:bjjjbbaic98fgimbkkawc;Wbf8KjjjjbaDk:Pdidui99ducbhi8Jjjjjbca9Rglcbyd1:G:cjbBdKalcb8Pdj:G:cjb83izalcbydN:G:cjbBdwalcb8Pd:m:G:cjb83ibdndnaembJbbjFhvJbbjFhoJbbjFhrxekadcd4cdthwincbhdinalczfadfgDabadfIdbgvaDIdbgoaoav9EEUdbaladfgDavaDIdbgoaoav9DEUdbadclfgdcx9hmbkabawfhbaicefgiae9hmbkalIdwalIdK:thralIdlalIdC:thoalIdbalIdz:thvkJbbbbavavJbbbb9DEgvaoaoav9DEgvararav9DEk9DeeuabcFeaicdtz:tjjjbhlcbhbdnadTmbindnalaeydbcdtfgiydbcu9hmbaiabBdbabcefhbkaeclfheadcufgdmbkkabk;Bidqui998Jjjjjbc;Wb9Rgl8Kjjjjbalcxfcbc;Kbz:tjjjb8Aadcd4adfhvcehoinaogrcethoarav6mbkalcuarcdtgoarcFFFFi0Ecbyd1:H:cjbHjjjjbbgvBdxavcFeaoz:tjjjbhwdnadTmbaicd4hDarcufhqcbhkindndnawcbaeakaD2cdtfgrydlgiaicjjjj94SEgocH4ao7c:F:b:DD2cbarydbgxaxcjjjj94SEgocH4ao7c;D;O:B8J27cbarydwgmamcjjjj94SEgrcH4ar7c:3F;N8N27aqGgvcdtfgrydbgocuSmbam::hPai::hsax::hzcehiinaihrdnaeaoaD2cdtfgiIdbaz9CmbaiIdlas9CmbaiIdwaP9BmikarcefhiawavarfaqGgvcdtfgrydbgocu9hmbkkarakBdbakhokabakcdtfaoBdbakcefgkad9hmbkkalydxcbyd:m:H:cjbH:bjjjbbalc;Wbf8Kjjjjbk9teiucbcbyd:q:H:cjbgeabcifc98GfgbBd:q:H:cjbdndnabZbcztgd9nmbcuhiabad9RcFFifcz4nbcuSmekaehikaik;LeeeudndnaeabVciGTmbabhixekdndnadcz9pmbabhixekabhiinaiaeydbBdbaiclfaeclfydbBdbaicwfaecwfydbBdbaicxfaecxfydbBdbaeczfheaiczfhiadc9Wfgdcs0mbkkadcl6mbinaiaeydbBdbaeclfheaiclfhiadc98fgdci0mbkkdnadTmbinaiaeRbb86bbaicefhiaecefheadcufgdmbkkabk;aeedudndnabciGTmbabhixekaecFeGc:b:c:ew2hldndnadcz9pmbabhixekabhiinaialBdbaicxfalBdbaicwfalBdbaiclfalBdbaiczfhiadc9Wfgdcs0mbkkadcl6mbinaialBdbaiclfhiadc98fgdci0mbkkdnadTmbinaiae86bbaicefhiadcufgdmbkkabk9teiucbcbyd:q:H:cjbgeabcrfc94GfgbBd:q:H:cjbdndnabZbcztgd9nmbcuhiabad9RcFFifcz4nbcuSmekaehikaikTeeucbabcbyd:q:H:cjbge9Rcifc98GaefgbBd:q:H:cjbdnabZbcztge9nmbabae9RcFFifcz4nb8Akkk:Kedbcj:Gdk1eFFuuFFuuFFuuFFuFFFuFFFuFbbbbbbbbebbbdbbbbbbbebbbebbbdbbbbbbbbbbbeeeeebebbebbebebbbeebbbbbbbbbbbbeeeeeebebbeeebeebbbbebebbbbbbbbbbbbbbbbbbc1:Hdkxebbbdbbb:G:qbb'; // embed! wasm
+		'b9H79Tebbbe;veC9Geueu9Geub9Gbb9Gsuuuuuuuuuuuu99uueu9Gvuuuuub9Gruuuuuuub9Gouuuuuue999Gvuuuuueu9Gzuuuuuuuuuuu99uuuub9Gquuuuuuu99uueu9GPuuuuuuuuuuu99uueu9Gquuuuuuuu99ueu9Gruuuuuu99eu9Gwuuuuuu99ueu9Giuuue999GDuuuuuuuuueu9Gkuuuuuuuu99uub9Gluuuueu9Gluuuub9GiuuueuiYKdilvorlwDiqkxmPszHObAAbelve9Weiiviebeoweuecj:Gdkr:Sdmo9TW9T9VV95dbH9F9F939H79T9F9J9H229F9Jt9VV7bbz9TW79O9V9Wt9F79P9T9W29P9M95bw8E9TW79O9V9Wt9F79P9T9W29P9M959x9Pt9OcttV9P9I91tW7bD8A9TW79O9V9Wt9F79P9T9W29P9M959x9Pt9O9v9W9K9HtWbqQ9TW79O9V9Wt9F79P9T9W29P9M959t29V9W9W95bkX9TW79O9V9Wt9F79P9T9W29P9M959qV919UWbxQ9TW79O9V9Wt9F79P9T9W29P9M959q9V9P9Ut7bmX9TW79O9V9Wt9F79P9T9W29P9M959t9J9H2WbPP9TW79O9V9Wt9FVW9TW79Obsa9TW79O9V9Wt9F9V9Wt9P9T9P96W9wWVtW94SWt9J9O9sW9T9H9WbH59TW79O9V9Wt9F9NW9UWV9HtW9q9V79Pt9P9V9U9sW9T9H9WbOl79IV9RbADwebcekdQLq:c:FdKdbk;r:herYue99iuY99Xue9:D998Jjjjjbcj;sb9Rgs8Kjjjjbcbhzasc:Cefcbc;Kbz:vjjjb8AdnabaeSmbabaeadcdtzNjjjb8AkdnamcdGTmbalcrfci4cbyd:G;d:cjbHjjjjbbhHasc:Cefasyd;8egecdtfaHBdbasaecefBd;8ecbhlcbhednadTmbabheadhOinaHaeydbci4fcb86bbaeclfheaOcufgOmbkcbhlabheadhOinaHaeydbgAci4fgCaCRbbgCceaAcrGgAtV86bbaCcu7aA4ceGalfhlaeclfheaOcufgOmbkcualcdtalcFFFFi0Ehekaecbyd:G;d:cjbHjjjjbbhzasc:Cefasyd;8egecdtfazBdbasaecefBd;8ealcd4alfhOcehHinaHgecethHaeaO6mbkcbhXcuaecdtgOaecFFFFi0Ecbyd:G;d:cjbHjjjjbbhHasc:Cefasyd;8egAcdtfaHBdbasaAcefBd;8eaHcFeaOz:vjjjbhQdnadTmbaecufhLcbhKindndnaQabaKcdtfgYydbgAc:v;t;h;Ev2aLGgOcdtfgCydbgHcuSmbceheinazaHcdtfydbaASmdaOaefhHaecefheaQaHaLGgOcdtfgCydbgHcu9hmbkkazaXcdtfaABdbaCaXBdbaXhHaXcefhXkaYaHBdbaKcefgKad9hmbkkaQcbyd:K;d:cjbH:bjjjbbasasyd;8ecufBd;8ekcbh8AcualcefgecdtaecFFFFi0Ecbyd:G;d:cjbHjjjjbbhLasc:Cefasyd;8egecdtfaLBdbasaLBdNeasaecefBd;8ecuadcitadcFFFFe0Ecbyd:G;d:cjbHjjjjbbhEasc:Cefasyd;8egecdtfaEBdbasaEBd:yeasaecefBd;8eascNefabadalcbz:cjjjbcualcdtgealcFFFFi0Eg3cbyd:G;d:cjbHjjjjbbhOasc:Cefasyd;8egHcdtfaOBdbasaHcefBd;8ea3cbyd:G;d:cjbHjjjjbbhQasc:Cefasyd;8egHcdtfaQBdbasaHcefBd;8eaOaQaialavazasc:Cefz:djjjbalcbyd:G;d:cjbHjjjjbbhYasc:Cefasyd;8egHcdtfaYBdbasaHcefBd;8ea3cbyd:G;d:cjbHjjjjbbhHasc:Cefasyd;8egAcdtfaHBdbasaAcefBd;8ea3cbyd:G;d:cjbHjjjjbbhAasc:Cefasyd;8egCcdtfaABdbasaCcefBd;8eaHcFeaez:vjjjbh5aAcFeaez:vjjjbh8EdnalTmbindnaLa8AgAcefg8AcdtfydbgCaLaAcdtgefydbgHSmbaCaH9Rh8FaEaHcitfhaa8Eaefhha5aefhKcbhCindndnaaaCcitfydbgXaA9hmbaKaABdbahaABdbxekdnaLaXcdtggfgeclfydbgHaeydbgeSmbaHae9RhHaEaecitfheinaeydbaASmdaecwfheaHcufgHmbkka8EagfgeaAaXaeydbcuSEBdbaKaXaAaKydbcuSEBdbkaCcefgCa8F9hmbkka8Aal9hmbkaOhHaQhAa5hXa8EhCcbheindndnaeaHydbgK9hmbdnaeaAydbgK9hmbaXydbhKdnaCydbg8Fcu9hmbaKcu9hmbaYaefcb86bbxikdna8FcuSmbaKcuSmbaea8FSmbaOa8FcdtfydbaOaKcdtfydb9hmbaYaefcd86bbxikaYaefhadnaea8FSmbaeaKSmbaace86bbxikaacl86bbxdkdnaeaQaKcdtg8Ffydb9hmbdnaCydbgacuSmbaeaaSmbaXydbggcuSmbaeagSmba8Ea8FfydbghcuSmbahaKSmba5a8Ffydbg8FcuSmba8FaKSmbdnaOaacdtfydbgKaOa8Fcdtfydb9hmbaKaOagcdtfydbg8FSmba8FaOahcdtfydb9hmbaYaefcd86bbxlkaYaefcl86bbxikaYaefcl86bbxdkaYaefcl86bbxekaYaefaYaKfRbb86bbkaHclfhHaAclfhAaXclfhXaCclfhCalaecefge9hmbkdnamcaGTmbcbh8JindndnaYa8Jfg8KRbbg8Lc9:fPibebekdndndnaOa8Jcdtfydbgea8J9hmbdnaqmbcbh8FxdkdnazTmbcbh8Fa8JheinaqazaecdtgefydbfRbbce4a8FVceGh8FaQaefydbgea8J9hmbxikkcbh8Fa8JheinaqaefRbbce4a8FVceGh8FaQaecdtfydbgea8J9hmbxdkkaYaefRbbhexeka8JheindnaLaecdtg8AfgeclfydbgHaeydbgeSmbaHae9RhgaEaecitfhhaOa8AfhacbhKinahaKcitfydbgXhednindnaLaecdtgCfgeclfydbgHaeydbgeSmbaHae9RhHaEaecitfheaaydbhAdninaOaeydbcdtfydbaASmeaecwfheaHcufgHTmdxbkkcbhexdkaQaCfydbgeaX9hmbkceheka8FaeVh8FaKcefgKag9hmbkkaQa8Afydbgea8J9hmbka8Lcia8FceGEheka8Kae86bbka8Jcefg8Jal9hmbkkdnaqTmbdndnazTmbazheaOhHalhAindnaqaeydbfRbbceGTmbaYaHydbfcl86bbkaeclfheaHclfhHaAcufgAmbxdkkaqheaOhHalhAindnaeRbbceGTmbaYaHydbfcl86bbkaecefheaHclfhHaAcufgAmbkkaOhealhAaYhHindnaYaeydbfRbbcl9hmbaHcl86bbkaeclfheaHcefhHaAcufgAmbkkamceGTmbaYhealhHindnaeRbbce9hmbaecl86bbkaecefheaHcufgHmbkkcbh8Mcualcx2alc;v:Q;v:Qe0Ecbyd:G;d:cjbHjjjjbbh8Nasc:Cefasyd;8egecdtfa8NBdbasaecefBd;8eascbBd:qeas9cb83i1ea8Naialavazasc1efz:ejjjbhydndnaDmbcbh8PcbhCxekcbhCawhecbhHindnaeIdbJbbbb9ETmbasaCcdtfaHBdbaCcefhCkaeclfheaDaHcefgH9hmbkcuaCal2gecdtaecFFFFi0Ecbyd:G;d:cjbHjjjjbbh8Pasc:Cefasyd;8egecdtfa8PBdbasaecefBd;8ealTmbdnaCmbcbhCxekarcd4hgdnazTmbaCcdthhcbh8Fa8Phainaoaza8Fcdtfydbag2cdtfhKasheaahHaChAinaHaKaeydbcdtgXfIdbawaXfIdbNUdbaeclfheaHclfhHaAcufgAmbkaaahfhaa8Fcefg8Fal9hmbxdkkaCcdthhcbh8Fa8Phainaoa8Fag2cdtfhKasheaahHaChAinaHaKaeydbcdtgXfIdbawaXfIdbNUdbaeclfheaHclfhHaAcufgAmbkaaahfhaa8Fcefg8Fal9hmbkkcualc8S2gHalc;D;O;f8U0EgXcbyd:G;d:cjbHjjjjbbheasc:Cefasyd;8egAcdtfaeBdbasaAcefBd;8eaecbaHz:vjjjbhIcbh8RcbhgdnaCTmbcbh8MaXcbyd:G;d:cjbHjjjjbbhgasc:Cefasyd;8egecdtfagBdbasaecefBd;8eagcbaHz:vjjjb8AcuaCal2gecltgHaecFFFFb0Ecbyd:G;d:cjbHjjjjbbh8Rasc:Cefasyd;8egecdtfa8RBdbasaecefBd;8ea8RcbaHz:vjjjb8AamcjjjjdGTmbcualcltgealcFFFFb0Ecbyd:G;d:cjbHjjjjbbh8Masc:Cefasyd;8egHcdtfa8MBdbasaHcefBd;8ea8Mcbaez:vjjjb8AkdnadTmbcbhKabhHina8NaHclfydbg8Fcx2fgeIdba8NaHydbgacx2fgAIdbg8S:tgRa8NaHcwfydbghcx2fgXIdlaAIdlg8U:tg8VNaeIdla8U:tg8WaXIdba8S:tg8XN:tg8Ya8YNa8WaXIdwaAIdwg8Z:tg80NaeIdwa8Z:tg8Wa8VN:tg81a81Na8Wa8XNaRa80N:tg80a80NMMg8V:rhBa8Yh8Xa80h8Wa81hRdna8VJbbbb9EgATmba8YaB:vh8Xa80aB:vh8Wa81aB:vhRkaIaOaacdtfydbgXc8S2fgeaRaB:rg8VaRNNg83aeIdbMUdbaea8Wa8Va8WNgUNg85aeIdlMUdlaea8Xa8Va8XNg86Ng87aeIdwMUdwaeaRaUNgUaeIdxMUdxaea86aRNg88aeIdzMUdzaea8Wa86Ng89aeIdCMUdCaeaRa8Va8Xa8ZNaRa8SNa8Ua8WNMM:mg8:Ng86NgRaeIdKMUdKaea8Wa86Ng8WaeId3MUd3aea8Xa86Ng8XaeIdaMUdaaea86a8:Ng86aeId8KMUd8Kaea8VaeIdyMUdyaIaOa8Fcdtfydbg8Fc8S2fgea83aeIdbMUdbaea85aeIdlMUdlaea87aeIdwMUdwaeaUaeIdxMUdxaea88aeIdzMUdzaea89aeIdCMUdCaeaRaeIdKMUdKaea8WaeId3MUd3aea8XaeIdaMUdaaea86aeId8KMUd8Kaea8VaeIdyMUdyaIaOahcdtfydbgac8S2fgea83aeIdbMUdbaea85aeIdlMUdlaea87aeIdwMUdwaeaUaeIdxMUdxaea88aeIdzMUdzaea89aeIdCMUdCaeaRaeIdKMUdKaea8WaeId3MUd3aea8XaeIdaMUdaaea86aeId8KMUd8Kaea8VaeIdyMUdydna8MTmbdnaATmba8YaB:vh8Ya80aB:vh80a81aB:vh81ka8MaXcltfgeaBJbbbZNgRa80Ng8VaeIdlMUdlaeaRa8YNg8WaeIdwMUdwaeaRa81Ng8XaeIdbMUdbaeaRa8S:ma81Na8Ua80N:ta8Za8YN:tNgRaeIdxMUdxa8Ma8Fcltfgea8VaeIdlMUdlaea8WaeIdwMUdwaea8XaeIdbMUdbaeaRaeIdxMUdxa8Maacltfgea8VaeIdlMUdlaea8WaeIdwMUdwaea8XaeIdbMUdbaeaRaeIdxMUdxkaHcxfhHaKcifgKad6mbkkdnalTmbJq;x8J88J;n;m;m89J:v:;;w8ZamczGEamc;abGEh80cbhHaOhXazhKaIhea8NhAindnaHaXydb9hmbaHh8FdnazTmbaKydbh8Fka80hRdnaqTmbJbbjZa80aqa8FfRbbclGEhRkaecxfg8Fa8FIdbJbbbbMUdbaeczfg8Fa8FIdbJbbbbMUdbaecCfg8Fa8FIdbJbbbbMUdbaeaRaecyfg8FIdbg8YNgRaeIdbMUdbaeclfgaaRaaIdbMUdbaecwfgaaRaaIdbMUdbaecKfgaaaIdbaAIdbg8WaRN:tUdbaAcwfIdbh8Vaec3fgaaaIdbaRaAclfIdbg8XN:tUdbaecafgaaaIdbaRa8VN:tUdbaec8KfgaIdbh81a8Fa8YaRMUdbaaa81aRa8Va8VNa8Wa8WNa8Xa8XNMMNMUdbkaXclfhXaKclfhKaec8SfheaAcxfhAalaHcefgH9hmbkkdnadTmbcbh8Aabhainaba8Acdtfh8FcbhHinaYa8FaHc:G:G:cjbfydbcdtfydbgAfRbbhedndnaYaaaHfydbgXfRbbgKc99fcFeGcpe0mbaec99fcFeGc;:e6mekdnaKcufcFeGce0mba5aXcdtfydbaA9hmekdnaecufcFeGce0mba8EaAcdtfydbaX9hmekJbbacJbbacJbbbZaecFeGceSEaKcFeGceSEhUdna8Na8FaHc:K:G:cjbfydbcdtfydbcx2fgeIdwa8NaXcx2fgKIdwg86:tg8Sa8NaAcx2fghIdwa86:tg8Xa8XNahIdbaKIdbg8U:tg80a80NahIdlaKIdlg8Z:tg8Va8VNMMg81Na8Xa8Sa8XNaeIdba8U:tg83a80Na8VaeIdla8Z:tg85NMMg8WN:tg8Ya8YNa83a81Na80a8WN:tgRaRNa85a81Na8Va8WN:tg8Wa8WNMMgBJbbbb9ETmba8YaB:rgB:vh8Ya8WaB:vh8WaRaB:vhRkaUa81:rNgBa8Ya86NaRa8UNa8Za8WNMM:mg81Ng87a81Nh88a80a85Na8Va83N:tg81a81Na8Va8SNa8Xa85N:tg8Va8VNa8Xa83Na80a8SN:tg8Xa8XNMMg83:rh80a8Ya87Nh85a8Wa87Nh89aRa87Nh87a8WaBa8YNg8SNh8:a8SaRNhZaRaBa8WNgnNhca8Ya8SNh8Ya8WanNh8WaRaBaRNNh8Sdna83Jbbbb9ETmba81a80:vh81a8Xa80:vh8Xa8Va80:vh8VkaIaOaXcdtfydbc8S2fgeaeIdba8Sa8VaUa80:rNgRa8VNNMg80MUdbaea8Wa8XaRa8XNg8SNMg83aeIdlMUdlaea8Ya81aRa81Ng8WNMg8YaeIdwMUdwaeaca8Va8SNMg8SaeIdxMUdxaeaZa8Wa8VNMgUaeIdzMUdzaea8:a8Xa8WNMg8WaeIdCMUdCaea87a8VaRa81a86Na8Va8UNa8Za8XNMMg86:mNgRNMg8VaeIdKMUdKaea89a8XaRNMg8XaeId3MUd3aea85a81aRNMg81aeIdaMUdaaea88a86aRN:tgRaeId8KMUd8KaeaBaeIdyMUdyaIaOaAcdtfydbc8S2fgea80aeIdbMUdbaea83aeIdlMUdlaea8YaeIdwMUdwaea8SaeIdxMUdxaeaUaeIdzMUdzaea8WaeIdCMUdCaea8VaeIdKMUdKaea8XaeId3MUd3aea81aeIdaMUdaaeaRaeId8KMUd8KaeaBaeIdyMUdykaHclfgHcx9hmbkaacxfhaa8Acifg8Aad6mbkaCTmbcbhainJbbbbh80a8Nabaacdtfgeclfydbg8Fcx2fgHIdwa8Naeydbghcx2fgAIdwg8Z:tg8Va8VNaHIdbaAIdbg83:tg8Wa8WNaHIdlaAIdlg85:tg8Xa8XNMMg8Sa8Naecwfydbg8Acx2fgeIdwa8Z:tg8YNa8Va8YNa8WaeIdba83:tg81Na8XaeIdla85:tgBNMMgRa8VN:tJbbbbJbbjZa8Sa8Ya8YNa81a81NaBaBNMMg8UNaRaRN:tg86:va86Jbbbb9BEg86Nh88a8Ua8VNaRa8YN:ta86Nh89a8SaBNaRa8XN:ta86Nh8:a8Ua8XNaRaBN:ta86NhZa8Sa81NaRa8WN:ta86Nhna8Ua8WNaRa81N:ta86Nhca8WaBNa8Xa81N:tgRaRNa8Xa8YNa8VaBN:tgRaRNa8Va81Na8Wa8YN:tgRaRNMM:rJbbbZNhRa8PahaC2g8JcdtfhHa8Pa8AaC2gDcdtfhAa8Pa8FaC2g8KcdtfhXa8Z:mh9ca85:mhJa83:mh9eascjdfheaChKJbbbbhBJbbbbh86Jbbbbh8SJbbbbh8UJbbbbh8ZJbbbbh83Jbbbbh85Jbbbbh87JbbbbhUinaecwfaRa89aXIdbaHIdbg8Y:tg8XNa88aAIdba8Y:tg81NMg8VNUdbaeclfaRaZa8XNa8:a81NMg8WNUdbaeaRaca8XNana81NMg8XNUdbaecxfaRa9ca8VNaJa8WNa8Ya9ea8XNMMMg8YNUdbaRa8Va8WNNa8ZMh8ZaRa8Va8XNNa8UMh8UaRa8Wa8XNNa8SMh8SaRa8Ya8YNNaUMhUaRa8Va8YNNa87Mh87aRa8Wa8YNNa85Mh85aRa8Xa8YNNa83Mh83aRa8Va8VNNa86Mh86aRa8Wa8WNNaBMhBaRa8Xa8XNNa80Mh80aHclfhHaXclfhXaAclfhAaeczfheaKcufgKmbkagahc8S2fgea80aeIdbMUdbaeaBaeIdlMUdlaea86aeIdwMUdwaea8SaeIdxMUdxaea8UaeIdzMUdzaea8ZaeIdCMUdCaea83aeIdKMUdKaea85aeId3MUd3aea87aeIdaMUdaaeaUaeId8KMUd8KaeaRaeIdyMUdyaga8Fc8S2fgea80aeIdbMUdbaeaBaeIdlMUdlaea86aeIdwMUdwaea8SaeIdxMUdxaea8UaeIdzMUdzaea8ZaeIdCMUdCaea83aeIdKMUdKaea85aeId3MUd3aea87aeIdaMUdaaeaUaeId8KMUd8KaeaRaeIdyMUdyaga8Ac8S2fgea80aeIdbMUdbaeaBaeIdlMUdlaea86aeIdwMUdwaea8SaeIdxMUdxaea8UaeIdzMUdzaea8ZaeIdCMUdCaea83aeIdKMUdKaea85aeId3MUd3aea87aeIdaMUdaaeaUaeId8KMUd8KaeaRaeIdyMUdya8Ra8Jcltfh8FcbhHaChXina8FaHfgeascjdfaHfgAIdbaeIdbMUdbaeclfgKaAclfIdbaKIdbMUdbaecwfgKaAcwfIdbaKIdbMUdbaecxfgeaAcxfIdbaeIdbMUdbaHczfhHaXcufgXmbka8Ra8Kcltfh8FcbhHaChXina8FaHfgeascjdfaHfgAIdbaeIdbMUdbaeclfgKaAclfIdbaKIdbMUdbaecwfgKaAcwfIdbaKIdbMUdbaecxfgeaAcxfIdbaeIdbMUdbaHczfhHaXcufgXmbka8RaDcltfh8FcbhHaChXina8FaHfgeascjdfaHfgAIdbaeIdbMUdbaeclfgKaAclfIdbaKIdbMUdbaecwfgKaAcwfIdbaKIdbMUdbaecxfgeaAcxfIdbaeIdbMUdbaHczfhHaXcufgXmbkaacifgaad6mbkkcbhAdndnamcwGgTmbJbbbbh8ScbhScbh9hcbh9ixekcbhSa3cbyd:G;d:cjbHjjjjbbh9iasc:Cefasyd;8egecdtfa9iBdbasaecefBd;8ecua9ialabadaOz:fjjjbgXcltaXcjjjjiGEcbyd:G;d:cjbHjjjjbbh9hasc:Cefasyd;8egecdtfa9hBdbasaecefBd;8ea9haXa9ia8Nalz:gjjjbJFFuuh8SaXTmba9hheaXhHinaeIdbgRa8Sa8SaR9EEh8SaeclfheaHcufgHmbkaXhSkdnalTmbaLclfheaLydbhXaYhHalhKcbhAincbaeydbg8FaX9RaHRbbcpeGEaAfhAaHcefhHaeclfhea8FhXaKcufgKmbkaAce4hAkcuadaA9Rcifg6cx2a6c;v:Q;v:Qe0Ecbyd:G;d:cjbHjjjjbbh9kasc:Cefasyd;8egecdtfa9kBdbasaecefBd;8ecua6cdta6cFFFFi0Ecbyd:G;d:cjbHjjjjbbh0asc:Cefasyd;8egecdtfa0BdbasaecefBd;8ea3cbyd:G;d:cjbHjjjjbbh9masc:Cefasyd;8egecdtfa9mBdbasaecefBd;8ealcbyd:G;d:cjbHjjjjbbh9nasc:Cefasyd;8egecdtfa9nBdbasaecefBd;8eaxaxNayJbbjZamclGEgZaZN:vh87JbbbbhUdnadak9nmbdna6ci6mbaCclth9oa9kcwfh9pJbbbbh85JbbbbhUinascNefabadalaOz:cjjjbabh8Acbh9qcbh9rinaba9rcdtfhDcbheindnaOa8AaefydbgAcdtghfydbgXaOaDaec:W:G:cjbfydbcdtfydbgHcdtg8JfydbgKSmbaYaHfRbbgacv2aYaAfRbbg8FfRb;a:G:cjbg8La8Fcv2aafg8KRb;a:G:cjbg3VcFeGTmbdnaKaX9nmba8KRb;G:G:cjbcFeGmekdna8FcufcFeGce0mbaaTmba5ahfydbaH9hmekdna8FTmbaacufcFeGce0mba8Ea8JfydbaA9hmeka9ka9qcx2fgXaHaAa3cFeGgKEBdlaXaAaHaKEBdbaXaKa8LGcb9hBdwa9qcefh9qkaeclfgecx9hmbkdna9rcifg9rad9pmba8Acxfh8Aa9qcifa69nmekka9qTmdcbh8KinaIaOa9ka8Kcx2fghydbgKcdtgXfydbg8Ac8S2fgeIdwa8Nahydlg8Fcx2fgHIdwg8WNaeIdzaHIdbg8XNaeIdaMgRaRMMa8WNaeIdlaHIdlg8YNaeIdCa8WNaeId3MgRaRMMa8YNaeIdba8XNaeIdxa8YNaeIdKMgRaRMMa8XNaeId8KMMM:lhRJbbbbJbbjZaeIdyg8V:va8VJbbbb9BEh8VdndnahydwgDmbJFFuuh86xekJbbbbJbbjZaIaOa8Fcdtfydbc8S2fgeIdyg81:va81Jbbbb9BEaeIdwa8NaKcx2fgHIdwg81NaeIdzaHIdbg80NaeIdaMgBaBMMa81NaeIdlaHIdlgBNaeIdCa81NaeId3Mg81a81MMaBNaeIdba80NaeIdxaBNaeIdKMg81a81MMa80NaeId8KMMM:lNh86ka8VaRNhBdnaCTmbagaKc8S2fgAIdwa8WNaAIdza8XNaAIdaMgRaRMMa8WNaAIdla8YNaAIdCa8WNaAId3MgRaRMMa8YNaAIdba8XNaAIdxa8YNaAIdKMgRaRMMa8XNaAId8KMMMhRa8Pa8FaC2gacdtfhHa8RaKaC2g8JcltfheaAIdyh81aChAinaHIdbg8Va8Va81NaecxfIdba8WaecwfIdbNa8XaeIdbNa8YaeclfIdbNMMMg8Va8VM:tNaRMhRaHclfhHaeczfheaAcufgAmbkdndnaDmbJbbbbh8Vxekaga8Fc8S2fgAIdwa8NaKcx2fgeIdwg8XNaAIdzaeIdbg8YNaAIdaMg8Va8VMMa8XNaAIdlaeIdlg81NaAIdCa8XNaAId3Mg8Va8VMMa81NaAIdba8YNaAIdxa81NaAIdKMg8Va8VMMa8YNaAId8KMMMh8Va8Pa8JcdtfhHa8RaacltfheaAIdyh80aChAinaHIdbg8Wa8Wa80NaecxfIdba8XaecwfIdbNa8YaeIdbNa81aeclfIdbNMMMg8Wa8WM:tNa8VMh8VaHclfhHaeczfheaAcufgAmbka8V:lh8VkaBaR:lMhBa86a8VMh86dndndnaYaKfRbbc9:fPddbekaQaXfydbgXaKSmbaOa8Fcdtfydbh8Jindndna5aXcdtgafydbgecuSmbaOaecdtfydba8JSmekdna8EaafydbgecuSmbaOaecdtfydba8JSmeka8FhekagaXc8S2fgAIdwa8Naecx2fgHIdwg8WNaAIdzaHIdbg8XNaAIdaMgRaRMMa8WNaAIdlaHIdlg8YNaAIdCa8WNaAId3MgRaRMMa8YNaAIdba8XNaAIdxa8YNaAIdKMgRaRMMa8XNaAId8KMMMhRa8PaeaC2cdtfhHa8RaXaC2cltfheaAIdyh81aChAinaHIdbg8Va8Va81NaecxfIdba8WaecwfIdbNa8XaeIdbNa8YaeclfIdbNMMMg8Va8VM:tNaRMhRaHclfhHaeczfheaAcufgAmbkaBaR:lMhBaQaafydbgXaK9hmbkkaYa8FfRbbci9hmeaDTmeaQa8FcdtfydbgXa8FSmeindndna5aXcdtgafydbgecuSmbaOaecdtfydba8ASmekdna8EaafydbgecuSmbaOaecdtfydba8ASmekaKhekagaXc8S2fgAIdwa8Naecx2fgHIdwg8WNaAIdzaHIdbg8XNaAIdaMgRaRMMa8WNaAIdlaHIdlg8YNaAIdCa8WNaAId3MgRaRMMa8YNaAIdba8XNaAIdxa8YNaAIdKMgRaRMMa8XNaAId8KMMMhRa8PaeaC2cdtfhHa8RaXaC2cltfheaAIdyh81aChAinaHIdbg8Va8Va81NaecxfIdba8WaecwfIdbNa8XaeIdbNa8YaeclfIdbNMMMg8Va8VM:tNaRMhRaHclfhHaeczfheaAcufgAmbka86aR:lMh86aQaafydbgXa8F9hmbxdkkdna8Ea5a5aXfydba8FSEaQaXfydbgacdtfydbgXcu9hmbaQa8FcdtfydbhXkagaac8S2fgAIdwa8NaXcx2fgeIdwg8WNaAIdzaeIdbg8XNaAIdaMgRaRMMa8WNaAIdlaeIdlg8YNaAIdCa8WNaAId3MgRaRMMa8YNaAIdba8XNaAIdxa8YNaAIdKMgRaRMMa8XNaAId8KMMMhRa8PaXaC2g8AcdtfhHa8RaaaC2g8JcltfheaAIdyh81aChAinaHIdbg8Va8Va81NaecxfIdba8WaecwfIdbNa8XaeIdbNa8YaeclfIdbNMMMg8Va8VM:tNaRMhRaHclfhHaeczfheaAcufgAmbkdndnaDmbJbbbbh8VxekagaXc8S2fgAIdwa8Naacx2fgeIdwg8XNaAIdzaeIdbg8YNaAIdaMg8Va8VMMa8XNaAIdlaeIdlg81NaAIdCa8XNaAId3Mg8Va8VMMa81NaAIdba8YNaAIdxa81NaAIdKMg8Va8VMMa8YNaAId8KMMMh8Va8Pa8JcdtfhHa8Ra8AcltfheaAIdyh80aChAinaHIdbg8Wa8Wa80NaecxfIdba8XaecwfIdbNa8YaeIdbNa81aeclfIdbNMMMg8Wa8WM:tNa8VMh8VaHclfhHaeczfheaAcufgAmbka8V:lh8VkaBaR:lMhBa86a8VMh86kaha86aBa86aB9DgeEUdwahaKa8FaeaDcb9hGgeEBdlaha8FaKaeEBdba8Kcefg8Ka9q9hmbkascjdfcbcj;qbz:vjjjb8Aa9phea9qhHinascjdfaeydbcA4cF8FGgAcFAaAcFA6EcdtfgAaAydbcefBdbaecxfheaHcufgHmbkcbhecbhHinascjdfaefgAydbhXaAaHBdbaXaHfhHaeclfgecj;qb9hmbkcbhea9phHinascjdfaHydbcA4cF8FGgAcFAaAcFA6EcdtfgAaAydbgAcefBdba0aAcdtfaeBdbaHcxfhHa9qaecefge9hmbkadak9RgAci9Uh9sdnalTmbcbhea9mhHinaHaeBdbaHclfhHalaecefge9hmbkkcbh9ta9ncbalz:vjjjbh3aAcO9Uh9ua9sce4h9rcbh8Lcbh8Kdnina9ka0a8Kcdtfydbcx2fg8JIdwgRa879Emea8La9s9pmeJFFuuh8Vdna9ra9q9pmba9ka0a9rcdtfydbcx2fIdwJbb;aZNh8VkdnaRa8V9ETmbaRaU9ETmba8La9u0mdkdna3aOa8JydlgDcdtg9vfg8AydbgAfg9wRbba3aOa8Jydbghcdtg9xfydbgefg9yRbbVmbaYahfRbbh9zdndnaLaecdtfgHclfydbgXaHydbgHSmbaXaH9RhXa8NaAcx2fh8Fa8Naecx2fhaaEaHcitfheindna9maeydbcdtfydbgHaASmba9maeclfydbcdtfydbgKaASmbaHaKSmba8NaKcx2fgKIdba8NaHcx2fgHIdbg8W:tgRaaIdlaHIdlg8X:tg80NaKIdla8X:tg8VaaIdba8W:tgBN:tg8YaRa8FIdla8X:tg86Na8Va8FIdba8W:tg8UN:tg8XNa8VaaIdwaHIdwg81:tg8ZNaKIdwa81:tg8Wa80N:tg80a8Va8FIdwa81:tg83Na8Wa86N:tg8VNa8WaBNaRa8ZN:tg81a8Wa8UNaRa83N:tgRNMMa8Ya8YNa80a80Na81a81NMMa8Xa8XNa8Va8VNaRaRNMMN:rJbbj8:N9FmikaecwfheaXcufgXmbkkdndndndna9zc9:fPdebdkahheina8AydbhAdndna5aecdtgHfydbgecuSmbaOaecdtfydbaASmekdna8EaHfydbgecuSmbaOaecdtfydbaASmekaDheka9maHfaeBdbaQaHfydbgeah9hmbxikkdna8Ea5a5a9xfydbaDSEaQa9xfydbghcdtfydbgecu9hmbaQa9vfydbheka9ma9xfaDBdbaehDka9mahcdtfaDBdbka9yce86bba9wce86bba8JIdwgRaUaUaR9DEhUa9tcefh9tcecda9zceSEa8Lfh8Lxeka9rcefh9rka8Kcefg8Ka9q9hmbkka9tTmddnalTmbcbh8Fcbhhindna9mahcdtgefydbgAahSmbaOaAcdtfydbh8AdnahaOaefydb9hg8JmbaIa8Ac8S2fgeaIahc8S2fgHIdbaeIdbMUdbaeaHIdlaeIdlMUdlaeaHIdwaeIdwMUdwaeaHIdxaeIdxMUdxaeaHIdzaeIdzMUdzaeaHIdCaeIdCMUdCaeaHIdKaeIdKMUdKaeaHId3aeId3MUd3aeaHIdaaeIdaMUdaaeaHId8KaeId8KMUd8KaeaHIdyaeIdyMUdya8MTmba8Ma8Acltfgea8MahcltfgHIdbaeIdbMUdbaeaHIdlaeIdlMUdlaeaHIdwaeIdwMUdwaeaHIdxaeIdxMUdxkaCTmbagaAc8S2fgeagahc8S2gDfgHIdbaeIdbMUdbaeaHIdlaeIdlMUdlaeaHIdwaeIdwMUdwaeaHIdxaeIdxMUdxaeaHIdzaeIdzMUdzaeaHIdCaeIdCMUdCaeaHIdKaeIdKMUdKaeaHId3aeId3MUd3aeaHIdaaeIdaMUdaaeaHId8KaeId8KMUd8KaeaHIdyaeIdyMUdya9oaA2haa8RhHaChXinaHaafgeaHa8FfgAIdbaeIdbMUdbaeclfgKaAclfIdbaKIdbMUdbaecwfgKaAcwfIdbaKIdbMUdbaecxfgeaAcxfIdbaeIdbMUdbaHczfhHaXcufgXmbka8JmbJbbbbJbbjZaIaDfgeIdygR:vaRJbbbb9BEaeIdwa8Na8Acx2fgHIdwgRNaeIdzaHIdbg8VNaeIdaMg8Wa8WMMaRNaeIdlaHIdlg8WNaeIdCaRNaeId3MgRaRMMa8WNaeIdba8VNaeIdxa8WNaeIdKMgRaRMMa8VNaeId8KMMM:lNgRa85a85aR9DEh85ka8Fa9ofh8Fahcefghal9hmbkcbhHa5heindnaeydbgAcuSmbdnaHa9maAcdtgXfydbgA9hmbcuhAa5aXfydbgXcuSmba9maXcdtfydbhAkaeaABdbkaeclfhealaHcefgH9hmbkcbhHa8EheindnaeydbgAcuSmbdnaHa9maAcdtgXfydbgA9hmbcuhAa8EaXfydbgXcuSmba9maXcdtfydbhAkaeaABdbkaeclfhealaHcefgH9hmbkka85aUaCEh85cbhHabhecbhAindnaOa9maeydbcdtfydbg8FcdtfydbgXaOa9maeclfydbcdtfydbgacdtfydbgKSmbaXaOa9maecwfydbcdtfydbg8AcdtfydbghSmbaKahSmbabaHcdtfgXa8FBdbaXcwfa8ABdbaXclfaaBdbaHcifhHkaecxfheaAcifgAad6mbkdndnaTmbaHhdxekdnaHak0mbaHhdxekdna8Sa859FmbaHhdxekJFFuuh8ScbhdabhecbhAindna9ha9iaeydbgXcdtfydbcdtfIdbgRa859ETmbaeclf8Pdbh9AabadcdtfgKaXBdbaKclfa9A83dbaRa8Sa8SaR9EEh8SadcifhdkaecxfheaAcifgAaH6mbkkadak0mbxdkkascNefabadalaOz:cjjjbkdndnadak0mbadhaxekdnaTmbadhaxekdna8Sa879FmbadhaxekcehKina8SJbb;aZNgRa87aRa879DEh8WJbbbbhRdnaSTmba9hheaShHinaeIdbg8VaRa8Va8W9FEaRa8VaR9EEhRaeclfheaHcufgHmbkkJFFuuh8ScbhaabhecbhHindna9ha9iaeydbgAcdtfydbcdtfIdbg8Va8W9ETmbaeclf8Pdbh9AabaacdtfgXaABdbaXclfa9A83dba8Va8Sa8Sa8V9EEh8SaacifhakaecxfheaHcifgHad6mbkdnaKaaad9hVceGmbadhaxdkaRaUaUaR9DEhUaaak9nmecbhKaahda8Sa879FmbkkdnamcjjjjdGTmba9ncbalz:vjjjbh8AdnaaTmbabheaahHina8AaeydbgAfce86bba8AaOaAcdtfydbfce86bbaeclfheaHcufgHmbkkascNefabaaalaOz:cjjjbdndnalTmbcbhXindna8AaXfRbbTmbdnaYaXfRbbgecl0mbceaetcQGmekdnaOaXcdtg8FfydbgeaXSmba8NaXcx2fgHa8Naecx2fgeydwBdwaHae8Pdb83dbxekaIaXc8S2fgKIdygcacJL:3;rUNgRMh87aKIdwg9BaRMh8SaKIdlg9CaRMh8UaKIdbg9DaRMh81aKIdag9EaRa8NaXcx2fg8JIdwg88N:th8ZaKId3g9FaRa8JIdlg89N:th83aKIdKg9Ga8JIdbg8:aRN:th80JbbbbhnaKIdCg9HJbbbbMh85aKIdzg9IJbbbbMhBaKIdxg9JJbbbbMh86dndnaCTmbaXhAinJbbbba87agaAc8S2fgHIdygR:vaRJbbbb9BEhRa8RaAaC2cltfheaHIdaa87Na8ZMh8ZaHId3a87Na83Mh83aHIdKa87Na80Mh80aHIdCa87Na85Mh85aHIdza87NaBMhBaHIdxa87Na86Mh86aHIdwa87Na8SMh8SaHIdla87Na8UMh8UaHIdba87Na81Mh81aChHina8ZaecwfIdbg8VaecxfIdbg8YNaRN:th8Za83aeclfIdbg8Wa8YNaRN:th83a85a8Wa8VNaRN:th85a81aeIdbg8Xa8XNaRN:th81a80a8Xa8YNaRN:th80aBa8Xa8VNaRN:thBa86a8Xa8WNaRN:th86a8Sa8Va8VNaRN:th8Sa8Ua8Wa8WNaRN:th8UaeczfheaHcufgHmbkaQaAcdtfydbgAaX9hmbka8MTmba8MaXcltfgeIdxhxaeIdwh9caeIdlhJaeIdbhRxekJbbbbhxJbbbbh9cJbbbbhJJbbbbhRkaBa81:vg8Wa80Na8Z:ta85aBa86a81:vg8VN:tg8Za8Ua86a8VN:tg8Y:vg8Xa8Va80Na83:tg8UN:th83a9caRa8WN:taJaRa8VN:tg86a8XN:tg85a8SaBa8WN:ta8Za8XN:tgB:vg8S:mh8Za86a8Y:vg9c:mhJdnJbbbbaRaRa81:vg9eN:ta86a9cN:ta85a8SN:tg86:la87J:983:g81NgR9ETmba8Za83NaJa8UNa9ea80Nax:tMMa86:vhnka81:laR9ETmba8Y:laR9ETmbaB:laR9ETmba9e:manNa8W:ma8ZanNa83aB:vMgBNa8V:maJanNa8X:maBNa8Ua8Y:vMMg85Na80:ma81:vMMMh87aLa8FfgeclfydbgHaeydbge9RhhaEaecitfh8FJbbbbhRdnaHaeSgDmbJbbbbhRa8FheahhAina8Naeclfydbcx2fgHIdwa88:tg8Va8VNaHIdba8::tg8Va8VNaHIdla89:tg8Va8VNMMg8Va8Naeydbcx2fgHIdwa88:tg8Wa8WNaHIdba8::tg8Wa8WNaHIdla89:tg8Wa8WNMMg8WaRaRa8W9DEgRaRa8V9DEhRaecwfheaAcufgAmbkaR:rgRaRNhRkaBa88:tg8Va8VNa87a8::tg8Va8VNa85a89:tg8Va8VNMMaR9EmbaKId8KhndnaDmbina8Na8Fclfydbcx2fgeIdba8Na8Fydbcx2fgHIdbg8W:tgRa89aHIdlg8X:tg80NaeIdla8X:tg8Va8:a8W:tg86N:tg8YaRa85a8X:tg8SNa8Va87a8W:tg8UN:tg8XNa8Va88aHIdwg81:tg8ZNaeIdwa81:tg8Wa80N:tg80a8VaBa81:tg83Na8Wa8SN:tg8VNa8Wa86NaRa8ZN:tg81a8Wa8UNaRa83N:tgRNMMa8Ya8YNa80a80Na81a81NMMa8Xa8XNa8Va8VNaRaRNMMN:rJbbj8:N9Fmda8Fcwfh8FahcufghmbkkJbbbbJbbjZac:vacJbbbb9BEgRa9BaBNa9Ia87Na9EMg8Va8VMMaBNa9Ca85Na9HaBNa9FMg8Va8VMMa85Na9Da87Na9Ja85Na9GMg8Va8VMMa87NanMMM:lNaRa9Ba88Na9Ia8:Na9EMg8Va8VMMa88Na9Ca89Na9Ha88Na9FMg8Va8VMMa89Na9Da8:Na9Ja89Na9GMg8Va8VMMa8:NanMMM:lNJbb;aZNJ:983:g81M9Emba8JaBUdwa8Ja85Udla8Ja87UdbkaXcefgXal9hmbkdnaCmbcbhCxdkcbhXindna8AaXfRbbTmbaOaXcdtgefydbaX9hmbaYaXfhhaQaefh8Ja8NaXcx2fhAa8PaXaC2cdtfhDcbhEincuhLdnahRbbci9hmbaXhLa8JydbgeaXSmba8PaEcdtgHfhKaDaHfIdbhRaXhLinaLhHcuhLdnaKaeaC2cdtfIdbaR9CmbaHcuSmbaHhLagaec8S2fIdyagaHc8S2fIdy9ETmbaehLkaQaecdtfydbgeaX9hmbkka8PaEcdtfhKa8RaEcltfh8FaXheinaKaeaC2cdtfJbbbbJbbjZagaeaLaLcuSEgHc8S2fIdygR:vaRJbbbb9BEa8FaHaC2cltfgHIdwaAIdwNaHIdbaAIdbNaHIdlaAIdlNMMaHIdxMNUdbaQaecdtfydbgeaX9hmbkaEcefgEaC9hmbkkaXcefgXal9hmbxdkkaCmbcbhCkaiavaoarawaCala8Na8Pazasayasc1efaYa8Aaqz:hjjjbkdnamcjjjjlGTmbazmbaaTmbabhecbhLinaYaeydbgAfRbbc3thQaecwfgXydbhHcjjjj94hCdna5aAcdtgEfydbaeclfgKydbgOSmbcjjjj94cba8EaOcdtfydbaASEhCkaeaQaCVaAVBdbaYaOfRbbc3th8Fcjjjj94hCcjjjj94hQdna5aOcdtfydbaHSmbcjjjj94cba8EaHcdtfydbaOSEhQkaKa8FaQVaOVBdbaYaHfRbbc3thOdna5aHcdtfydbaASmbcjjjj94cba8EaEfydbaHSEhCkaXaOaCVaHVBdbaecxfheaLcifgLaa6mbkkdnazTmbaaTmbaaheinabazabydbcdtfydbBdbabclfhbaecufgembkkdnaPTmbaPaZaU:rNUdbkdnasyd;8egHTmbaHcdtasc:Ceffc98fheinaeydbcbyd:K;d:cjbH:bjjjbbaec98fheaHcufgHmbkkascj;sbf8Kjjjjbaak;Yieouabydlhvabydbclfcbaicdtz:vjjjbhoadci9UhrdnadTmbdnalTmbaehwadhDinaoalawydbcdtfydbcdtfgqaqydbcefBdbawclfhwaDcufgDmbxdkkaehwadhDinaoawydbcdtfgqaqydbcefBdbawclfhwaDcufgDmbkkdnaiTmbcbhDaohwinawydbhqawaDBdbawclfhwaqaDfhDaicufgimbkkdnadci6mbinaecwfydbhwaeclfydbhDaeydbhidnalTmbalawcdtfydbhwalaDcdtfydbhDalaicdtfydbhikavaoaicdtfgqydbcitfaDBdbavaqydbcitfawBdlaqaqydbcefBdbavaoaDcdtfgqydbcitfawBdbavaqydbcitfaiBdlaqaqydbcefBdbavaoawcdtfgwydbcitfaiBdbavawydbcitfaDBdlawawydbcefBdbaecxfhearcufgrmbkkabydbcbBdbk:todDue99aicd4aifhrcehwinawgDcethwaDar6mbkcuaDcdtgraDcFFFFi0Ecbyd:G;d:cjbHjjjjbbhwaoaoyd9GgqcefBd9GaoaqcdtfawBdbawcFearz:vjjjbhkdnaiTmbalcd4hlaDcufhxcbhminamhDdnavTmbavamcdtfydbhDkcbadaDal2cdtfgDydlgwawcjjjj94SEgwcH4aw7c:F:b:DD2cbaDydbgwawcjjjj94SEgwcH4aw7c;D;O:B8J27cbaDydwgDaDcjjjj94SEgDcH4aD7c:3F;N8N27axGhwamcdthPdndndnavTmbakawcdtfgrydbgDcuSmeadavaPfydbal2cdtfgsIdbhzcehqinaqhrdnadavaDcdtfydbal2cdtfgqIdbaz9CmbaqIdlasIdl9CmbaqIdwasIdw9BmlkarcefhqakawarfaxGgwcdtfgrydbgDcu9hmbxdkkakawcdtfgrydbgDcuSmbadamal2cdtfgsIdbhzcehqinaqhrdnadaDal2cdtfgqIdbaz9CmbaqIdlasIdl9CmbaqIdwasIdw9BmikarcefhqakawarfaxGgwcdtfgrydbgDcu9hmbkkaramBdbamhDkabaPfaDBdbamcefgmai9hmbkkakcbyd:K;d:cjbH:bjjjbbaoaoyd9GcufBd9GdnaeTmbaiTmbcbhDaehwinawaDBdbawclfhwaiaDcefgD9hmbkcbhDaehwindnaDabydbgrSmbawaearcdtfgrydbBdbaraDBdbkabclfhbawclfhwaiaDcefgD9hmbkkk;:odvuv998Jjjjjbca9Rgocbyd1:G:cjbBdKaocb8Pdj:G:cjb83izaocbydN:G:cjbBdwaocb8Pd:m:G:cjb83ibdnadTmbaicd4hrdnabmbdnalTmbcbhwinaealawcdtfydbar2cdtfhDcbhiinaoczfaifgqaDaifIdbgkaqIdbgxaxak9EEUdbaoaifgqakaqIdbgxaxak9DEUdbaiclfgicx9hmbkawcefgwad9hmbxikkarcdthwcbhDincbhiinaoczfaifgqaeaifIdbgkaqIdbgxaxak9EEUdbaoaifgqakaqIdbgxaxak9DEUdbaiclfgicx9hmbkaeawfheaDcefgDad9hmbxdkkdnalTmbcbhwinabawcx2fgiaealawcdtfydbar2cdtfgDIdbUdbaiaDIdlUdlaiaDIdwUdwcbhiinaoczfaifgqaDaifIdbgkaqIdbgxaxak9EEUdbaoaifgqakaqIdbgxaxak9DEUdbaiclfgicx9hmbkawcefgwad9hmbxdkkarcdthlcbhwaehDinabawcx2fgiaeawar2cdtfgqIdbUdbaiaqIdlUdlaiaqIdwUdwcbhiinaoczfaifgqaDaifIdbgkaqIdbgxaxak9EEUdbaoaifgqakaqIdbgxaxak9DEUdbaiclfgicx9hmbkaDalfhDawcefgwad9hmbkkJbbbbaoIdbaoIdzgx:tgkakJbbbb9DEgkaoIdlaoIdCgm:tgPaPak9DEgkaoIdwaoIdKgP:tgsasak9DEhsdnabTmbadTmbJbbbbJbbjZas:vasJbbbb9BEhkinabakabIdbax:tNUdbabclfgoakaoIdbam:tNUdbabcwfgoakaoIdbaP:tNUdbabcxfhbadcufgdmbkkdnavTmbavaPUdwavamUdlavaxUdbkask:WlewudnaeTmbcbhvabhoinaoavBdbaoclfhoaeavcefgv9hmbkkdnaiTmbcbhrinadarcdtfhwcbhDinalawaDcdtgvyd:G:G:cjbcdtfydbcdtfydbhodnalawavfydbcdtfydbgqabaqcdtfgkydbgvSmbinakabavgqcdtfgxydbgvBdbaxhkaqav9hmbkkdnaoabaocdtfgkydbgvSmbinakabavgocdtfgxydbgvBdbaxhkaoav9hmbkkdnaqaoSmbabaqaoaqao0Ecdtfaqaoaqao6EBdbkaDcefgDci9hmbkarcifgrai6mbkkdnaembcbskcbhxindnalaxcdtgvfydbax9hmbaxhodnaxabavfgDydbgvSmbaDhqinaqabavgocdtfgkydbgvBdbakhqaoav9hmbkkaDaoBdbkaxcefgxae9hmbkcbhkabhvcbhoindndnaoalydbgq9hmbdnaoavydbgq9hmbavakBdbakcefhkxdkavabaqcdtfydbBdbxekavabaqcdtfydbBdbkalclfhlavclfhvaeaocefgo9hmbkakk;jiilud99euabcbaecltz:vjjjbhvdnalTmbadhoaihralhwinarcwfIdbhDarclfIdbhqavaoydbcltfgkarIdbakIdbMUdbakaqakIdlMUdlakaDakIdwMUdwakakIdxJbbjZMUdxaoclfhoarcxfhrawcufgwmbkkdnaeTmbavhkaehrinakcxfgoIdbhDaocbBdbakakIdbJbbbbJbbjZaD:vaDJbbbb9BEgDNUdbakclfgoaDaoIdbNUdbakcwfgoaDaoIdbNUdbakczfhkarcufgrmbkkdnalTmbinavadydbcltfgkaicwfIdbakIdw:tgDaDNaiIdbakIdb:tgDaDNaiclfIdbakIdl:tgDaDNMMgDakIdxgqaqaD9DEUdxadclfhdaicxfhialcufglmbkkdnaeTmbavcxfhkinabakIdbUdbakczfhkabclfhbaecufgembkkk:moerudnaoTmbaecd4hzdnavTmbaicd4hHavcdthOcbhAindnaPaAfRbbTmbaAhednaDTmbaDaAcdtfydbhekdnasTmbasaefRbbceGmekdnamaAfRbbclSmbabaeaz2cdtfgiaraAcx2fgCIdbakNaxIdbMUdbaiaCIdlakNaxIdlMUdlaiaCIdwakNaxIdwMUdwkadaeaH2cdtfhXaqheawhiavhCinaXaeydbcdtgQfaiIdbalaQfIdb:vUdbaeclfheaiclfhiaCcufgCmbkkawaOfhwaAcefgAao9hmbxdkkdnasmbcbheaDhiindnaPaefRbbTmbaehCdnaDTmbaiydbhCkamaefRbbclSmbabaCaz2cdtfgCarIdbakNaxIdbMUdbaCarclfIdbakNaxIdlMUdlaCarcwfIdbakNaxIdwMUdwkaiclfhiarcxfhraoaecefge9hmbxdkkdnaDTmbindnaPRbbTmbasaDydbgefRbbceGmbamRbbclSmbabaeaz2cdtfgearIdbakNaxIdbMUdbaearclfIdbakNaxIdlMUdlaearcwfIdbakNaxIdwMUdwkaPcefhPaDclfhDamcefhmarcxfhraocufgombxdkkazcdthicbheindnaPaefRbbTmbasaefRbbceGmbamaefRbbclSmbabarIdbakNaxIdbMUdbabclfarclfIdbakNaxIdlMUdbabcwfarcwfIdbakNaxIdwMUdbkarcxfhrabaifhbaoaecefge9hmbkkk8MbabaeadaialavcbcbcbcbcbaoarawaDz:bjjjbk8MbabaeadaialavaoarawaDaqakaxamaPz:bjjjbkRbababaeadaialavaoarawaDaqakaxcjjjjdVamz:bjjjbk:g8Koque99due99duq998Jjjjjbc;Wb9Rgq8Kjjjjbcbhkaqcxfcbc;Kbz:vjjjb8Aaqcualcx2alc;v:Q;v:Qe0Ecbyd:G;d:cjbHjjjjbbgxBdxaqceBd2axaialavcbcbz:ejjjb8AaqcualcdtalcFFFFi0Egmcbyd:G;d:cjbHjjjjbbgiBdzaqcdBd2dndnJFF959eJbbjZawJbbjZawJbbjZ9DE:vawJ9VO:d869DEgw:lJbbb9p9DTmbaw:OhPxekcjjjj94hPkadci9Uhsarco9UhzdndnaombaPcd9imekdnalTmbaPcuf:YhwdnaoTmbcbhvaihHaxhOindndnaoavfRbbceGTmbavcjjjjlVhAxekdndnaOclfIdbawNJbbbZMgC:lJbbb9p9DTmbaC:OhAxekcjjjj94hAkaAcqthAdndnaOcwfIdbawNJbbbZMgC:lJbbb9p9DTmbaC:OhXxekcjjjj94hXkaAaXVhAdndnaOIdbawNJbbbZMgC:lJbbb9p9DTmbaC:OhXxekcjjjj94hXkaAaXcCtVhAkaHaABdbaHclfhHaOcxfhOalavcefgv9hmbxdkkaxhvaihOalhHindndnavIdbawNJbbbZMgC:lJbbb9p9DTmbaC:OhAxekcjjjj94hAkaAcCthAdndnavclfIdbawNJbbbZMgC:lJbbb9p9DTmbaC:OhXxekcjjjj94hXkaXcqtaAVhAdndnavcwfIdbawNJbbbZMgC:lJbbb9p9DTmbaC:OhXxekcjjjj94hXkaOaAaXVBdbavcxfhvaOclfhOaHcufgHmbkkadTmbcbhkaehvcbhOinakaiavclfydbcdtfydbgHaiavcwfydbcdtfydbgA9haiavydbcdtfydbgXaH9haXaA9hGGfhkavcxfhvaOcifgOad6mbkkarci9UhQdndnaz:Z:rJbbbZMgw:lJbbb9p9DTmbaw:Ohvxekcjjjj94hvkaQ:ZhLcbhKc:bwhzdninakaQ9pmeazaP9Rcd9imeavazcufgOavaO9iEaPcefavaP9kEhYdnalTmbaYcuf:YhwdnaoTmbcbhOaihHaxhvindndnaoaOfRbbceGTmbaOcjjjjlVhAxekdndnavclfIdbawNJbbbZMgC:lJbbb9p9DTmbaC:OhAxekcjjjj94hAkaAcqthAdndnavcwfIdbawNJbbbZMgC:lJbbb9p9DTmbaC:OhXxekcjjjj94hXkaAaXVhAdndnavIdbawNJbbbZMgC:lJbbb9p9DTmbaC:OhXxekcjjjj94hXkaAaXcCtVhAkaHaABdbaHclfhHavcxfhvalaOcefgO9hmbxdkkaxhvaihOalhHindndnavIdbawNJbbbZMgC:lJbbb9p9DTmbaC:OhAxekcjjjj94hAkaAcCthAdndnavclfIdbawNJbbbZMgC:lJbbb9p9DTmbaC:OhXxekcjjjj94hXkaXcqtaAVhAdndnavcwfIdbawNJbbbZMgC:lJbbb9p9DTmbaC:OhXxekcjjjj94hXkaOaAaXVBdbavcxfhvaOclfhOaHcufgHmbkkcbhOdnadTmbaehvcbhHinaOaiavclfydbcdtfydbgAaiavcwfydbcdtfydbgX9haiavydbcdtfydbgraA9haraX9hGGfhOavcxfhvaHcifgHad6mbkkdnas:ZgCaL:taY:Ygwaz:Y:tg8ANak:ZgEaO:Zg3:tNaEaL:tawaP:Y:tg5Na3aC:tNMg8EJbbbb9BmbaCaE:ta5a8Aa3aL:tNNNa8E:vawMhwkdndnaOaQ0mbaOhkaYhPxekaOhsaYhzkdndnaKcl0mbdnawJbbbZMgw:lJbbb9p9DTmbaw:Ohvxdkcjjjj94hvxekaPazfcd9ThvkaKcefgKcs9hmbkkdndndnakmbJbbjZhwcbhOcdhvaDmexdkalcd4alfhHcehOinaOgvcethOavaH6mbkcbhOaqcuavcdtgYavcFFFFi0Ecbyd:G;d:cjbHjjjjbbgKBdCaqciBd2aqamcbyd:G;d:cjbHjjjjbbgzBdKaqclBd2dndndndnalTmbaPcuf:YhwaoTmecbhOaihAaxhHindndnaoaOfRbbceGTmbaOcjjjjlVhXxekdndnaHclfIdbawNJbbbZMgC:lJbbb9p9DTmbaC:OhXxekcjjjj94hXkaXcqthXdndnaHcwfIdbawNJbbbZMgC:lJbbb9p9DTmbaC:Ohrxekcjjjj94hrkaXarVhXdndnaHIdbawNJbbbZMgC:lJbbb9p9DTmbaC:Ohrxekcjjjj94hrkaXarcCtVhXkaAaXBdbaAclfhAaHcxfhHalaOcefgO9hmbxikkaKcFeaYz:vjjjb8AcbhPcbhvxdkaxhOaihHalhAindndnaOIdbawNJbbbZMgC:lJbbb9p9DTmbaC:OhXxekcjjjj94hXkaXcCthXdndnaOclfIdbawNJbbbZMgC:lJbbb9p9DTmbaC:Ohrxekcjjjj94hrkarcqtaXVhXdndnaOcwfIdbawNJbbbZMgC:lJbbb9p9DTmbaC:Ohrxekcjjjj94hrkaHaXarVBdbaOcxfhOaHclfhHaAcufgAmbkkaKcFeaYz:vjjjbhravcufhocbhPcbhYindndndnaraiaYcdtgKfydbgAcm4aA7c:v;t;h;Ev2gvcs4av7aoGgHcdtfgXydbgOcuSmbcehvinaiaOcdtgOfydbaASmdaHavfhOavcefhvaraOaoGgHcdtfgXydbgOcu9hmbkkaXaYBdbaPhvaPcefhPxekazaOfydbhvkazaKfavBdbaYcefgYal9hmbkcuaPc8S2gOaPc;D;O;f8U0EhvkcbhXaqavcbyd:G;d:cjbHjjjjbbgvBd3aqcvBd2avcbaOz:vjjjbhOdnadTmbaehiinaxaiclfydbgrcx2fgvIdbaxaiydbgocx2fgHIdbg3:tgCaxaicwfydbgYcx2fgAIdlaHIdlg8A:tgwNavIdla8A:tgEaAIdba3:tg8EN:tgLaLNaEaAIdwaHIdwg5:tg8FNavIdwa5:tgEawN:tgwawNaEa8ENaCa8FN:tgCaCNMMg8E:rhEJbbnnJbbjZazaocdtfydbgvazarcdtfydbgASavazaYcdtfydbgrSGgHEh8Fdna8EJbbbb9ETmbaLaE:vhLaCaE:vhCawaE:vhwkaOavc8S2fgvavIdbawa8FaE:rNgEawNNg8FMUdbavaCaEaCNgaNghavIdlMUdlavaLaEaLNg8ENggavIdwMUdwavawaaNgaavIdxMUdxava8EawNg8JavIdzMUdzavaCa8ENg8EavIdCMUdCavawaEaLa5Nawa3Na8AaCNMM:mg8ANg3NgwavIdKMUdKavaCa3NgCavId3MUd3avaLa3NgLavIdaMUdaava3a8ANg3avId8KMUd8KavaEavIdyMUdydnaHmbaOaAc8S2fgva8FavIdbMUdbavahavIdlMUdlavagavIdwMUdwavaaavIdxMUdxava8JavIdzMUdzava8EavIdCMUdCavawavIdKMUdKavaCavId3MUd3avaLavIdaMUdaava3avId8KMUd8KavaEavIdyMUdyaOarc8S2fgva8FavIdbMUdbavahavIdlMUdlavagavIdwMUdwavaaavIdxMUdxava8JavIdzMUdzava8EavIdCMUdCavawavIdKMUdKavaCavId3MUd3avaLavIdaMUdaava3avId8KMUd8KavaEavIdyMUdykaicxfhiaXcifgXad6mbkkcbhAaqcuaPcdtgvaPcFFFFi0Egicbyd:G;d:cjbHjjjjbbgHBdaaqcoBd2aqaicbyd:G;d:cjbHjjjjbbgiBd8KaqcrBd2aHcFeavz:vjjjbhYdnalTmbazhHinJbbbbJbbjZaOaHydbgXc8S2fgvIdygw:vawJbbbb9BEavIdwaxcwfIdbgwNavIdzaxIdbgCNavIdaMgLaLMMawNavIdlaxclfIdbgLNavIdCawNavId3MgwawMMaLNavIdbaCNavIdxaLNavIdKMgwawMMaCNavId8KMMM:lNhwdndnaYaXcdtgvfgXydbcuSmbaiavfIdbaw9ETmekaXaABdbaiavfawUdbkaHclfhHaxcxfhxalaAcefgA9hmbkkdndnaPmbJbbbbhwxekJbbbbhwinaiIdbgCawawaC9DEhwaiclfhiaPcufgPmbkaw:rhwkakcd4akfhOcehiinaigvcethiavaO6mbkcbhOaqcuavcdtgiavcFFFFi0Ecbyd:G;d:cjbHjjjjbbgHBdyaHcFeaiz:vjjjbhXdnadTmbavcufhrcbhPcbhxindnazaeaxcdtfgvydbcdtfydbgiazavclfydbcdtfydbgOSmbaiazavcwfydbcdtfydbgvSmbaOavSmbaYavcdtfydbhAdndnaYaOcdtfydbgvaYaicdtfydbgi9pmbavaA9pmbaAhlaihoavhAxekdnaAai9pmbaAav9pmbaihlavhoxekavhlaAhoaihAkabaPcx2fgvaABdbavcwfaoBdbavclfalBdbdnaXaoc:3F;N8N2alc:F:b:DD27aAc;D;O:B8J27arGgOcdtfgvydbgicuSmbcehHinaHhvdnabaicx2fgiydbaA9hmbaiydlal9hmbaiydwaoSmikavcefhHaXaOavfarGgOcdtfgvydbgicu9hmbkkavaPBdbaPcefhPkaxcifgxad6mbkaPci2hOkcwhvaDTmekaDawUdbkavcdthvaqcxfc98fhiinaiavfydbcbyd:K;d:cjbH:bjjjbbavc98fgvmbkaqc;Wbf8KjjjjbaOk:3ldrue9:8Jjjjjbc;Wb9Rgr8Kjjjjbcbhwarcxfcbc;Kbz:vjjjb8AdnabaeSmbabaeadcdtzNjjjb8AkarcualcdtalcFFFFi0EgDcbyd:G;d:cjbHjjjjbbgqBdxarceBd2aqcbaialavcbarcxfz:djjjbcualcx2alc;v:Q;v:Qe0Ecbyd:G;d:cjbHjjjjbbhkarcxfaryd2gxcdtfakBdbaraxcefgmBd2akaialavcbcbz:ejjjb8AarcxfamcdtfaDcbyd:G;d:cjbHjjjjbbgiBdbaraxcdfgvBd2arcxfavcdtfcuaialaeadaqz:fjjjbgecltaecjjjjiGEcbyd:G;d:cjbHjjjjbbgqBdbaqaeaiakalz:gjjjbaxcifhkdnadTmbaoaoNhocbhwabhlcbheindnaqaialydbgvcdtfydbcdtfIdbao9ETmbalclf8PdbhPabawcdtfgDavBdbaDclfaP83dbawcifhwkalcxfhlaecifgead6mbkkdnakTmbaxcdtarcxffcwfhlinalydbcbyd:K;d:cjbH:bjjjbbalc98fhlakcufgkmbkkarc;Wbf8Kjjjjbawk:WCoDud99vue99vuv998Jjjjjbc;Wb9Rgw8KjjjjbdndnarmbcbhDxekawcxfcbc;Kbz:vjjjb8Aawcuadcx2adc;v:Q;v:Qe0Ecbyd:G;d:cjbHjjjjbbgqBdxawceBd2aqaeadaicbcbz:ejjjb8AawcuadcdtadcFFFFi0Egkcbyd:G;d:cjbHjjjjbbgxBdzawcdBd2adcd4adfhmceheinaegicetheaiam6mbkcbhPawcuaicdtgsaicFFFFi0Ecbyd:G;d:cjbHjjjjbbgzBdCawciBd2dndnar:ZgH:rJbbbZMgO:lJbbb9p9DTmbaO:Ohexekcjjjj94hekaicufhAc:bwhCcbhXadhQcbhLinaeaCcufgiaeai9iEaPcefaeaP9kEhDdndnadTmbaDcuf:YhOaqhiaxheadhmindndnaiIdbaONJbbbZMgK:lJbbb9p9DTmbaK:OhYxekcjjjj94hYkaYcCthYdndnaiclfIdbaONJbbbZMgK:lJbbb9p9DTmbaK:Oh8Axekcjjjj94h8Aka8AcqtaYVhYdndnaicwfIdbaONJbbbZMgK:lJbbb9p9DTmbaK:Oh8Axekcjjjj94h8AkaeaYa8AVBdbaicxfhiaeclfheamcufgmmbkazcFeasz:vjjjbhEcbh3cbh5indnaEaxa5cdtfydbgYcm4aY7c:v;t;h;Ev2gics4ai7aAGgmcdtfg8AydbgecuSmbaeaYSmbcehiinaEamaifaAGgmcdtfg8AydbgecuSmeaicefhiaeaY9hmbkka8AaYBdba3aecuSfh3a5cefg5ad9hmbxdkkazcFeasz:vjjjb8Acbh3kdnaQ:ZgKaH:taD:YgOaC:Y:tg8ENaX:Zg8Fa3:Zga:tNa8FaH:taOaP:Y:tghNaaaK:tNMggJbbbb9BmbaKa8F:taha8EaaaH:tNNNag:vaOMhOkaPaDa3ar0giEhPaXa3aiEhXdna3arSmbaDaCaiEgCaP9Rcd9imbdndnaLcl0mbdnaOJbbbZMgO:lJbbb9p9DTmbaO:Ohexdkcjjjj94hexekaPaCfcd9Theka3aQaiEhQaLcefgLcs9hmekkdndnaXmbcihicbhDxekcbhiawakcbyd:G;d:cjbHjjjjbbg5BdKawclBd2aPcuf:YhKdndnadTmbaqhiaxheadhmindndnaiIdbaKNJbbbZMgO:lJbbb9p9DTmbaO:OhYxekcjjjj94hYkaYcCthYdndnaiclfIdbaKNJbbbZMgO:lJbbb9p9DTmbaO:Oh8Axekcjjjj94h8Aka8AcqtaYVhYdndnaicwfIdbaKNJbbbZMgO:lJbbb9p9DTmbaO:Oh8Axekcjjjj94h8AkaeaYa8AVBdbaicxfhiaeclfheamcufgmmbkazcFeasz:vjjjbhEcbhDcbh3indndndnaEaxa3cdtgCfydbgYcm4aY7c:v;t;h;Ev2gics4ai7aAGgmcdtfg8AydbgecuSmbcehiinaxaecdtgefydbaYSmdamaifheaicefhiaEaeaAGgmcdtfg8Aydbgecu9hmbkka8Aa3BdbaDhiaDcefhDxeka5aefydbhika5aCfaiBdba3cefg3ad9hmbkcuaDc32giaDc;j:KM;jb0EhexekazcFeasz:vjjjb8AcbhDcbhekawaecbyd:G;d:cjbHjjjjbbgeBd3awcvBd2aecbaiz:vjjjbh8Aavcd4hxdnadTmbdnalTmbaxcdthEa5hYaqhealhmadhAina8AaYydbc32fgiaeIdbaiIdbMUdbaiaeclfIdbaiIdlMUdlaiaecwfIdbaiIdwMUdwaiamIdbaiIdxMUdxaiamclfIdbaiIdzMUdzaiamcwfIdbaiIdCMUdCaiaiIdKJbbjZMUdKaYclfhYaecxfheamaEfhmaAcufgAmbxdkka5hmaqheadhYina8Aamydbc32fgiaeIdbaiIdbMUdbaiaeclfIdbaiIdlMUdlaiaecwfIdbaiIdwMUdwaiaiIdxJbbbbMUdxaiaiIdzJbbbbMUdzaiaiIdCJbbbbMUdCaiaiIdKJbbjZMUdKamclfhmaecxfheaYcufgYmbkkdnaDTmba8AhiaDheinaiaiIdbJbbbbJbbjZaicKfIdbgO:vaOJbbbb9BEgONUdbaiclfgmaOamIdbNUdbaicwfgmaOamIdbNUdbaicxfgmaOamIdbNUdbaiczfgmaOamIdbNUdbaicCfgmaOamIdbNUdbaic3fhiaecufgembkkcbhYawcuaDcdtgCaDcFFFFi0Egicbyd:G;d:cjbHjjjjbbgeBdaawcoBd2awaicbyd:G;d:cjbHjjjjbbgEBd8KaecFeaCz:vjjjbh3dnadTmbaoJbbjZJbbjZaK:vaPceSENgOaONhKaxcdthxalheinaKaec;8:G:cjbalEgmIdwa8Aa5ydbgAc32fgiIdC:tgOaONamIdbaiIdx:tgOaONamIdlaiIdz:tgOaONMMNaqcwfIdbaiIdw:tgOaONaqIdbaiIdb:tgOaONaqclfIdbaiIdl:tgOaONMMMhOdndna3aAcdtgifgmydbcuSmbaEaifIdbaO9ETmekamaYBdbaEaifaOUdbka5clfh5aqcxfhqaeaxfheadaYcefgY9hmbkkaba3aCzNjjjb8Acrhikaicdthiawcxfc98fheinaeaifydbcbyd:K;d:cjbH:bjjjbbaic98fgimbkkawc;Wbf8KjjjjbaDk:Pdidui99ducbhi8Jjjjjbca9Rglcbyd1:G:cjbBdKalcb8Pdj:G:cjb83izalcbydN:G:cjbBdwalcb8Pd:m:G:cjb83ibdndnaembJbbjFhvJbbjFhoJbbjFhrxekadcd4cdthwincbhdinalczfadfgDabadfIdbgvaDIdbgoaoav9EEUdbaladfgDavaDIdbgoaoav9DEUdbadclfgdcx9hmbkabawfhbaicefgiae9hmbkalIdwalIdK:thralIdlalIdC:thoalIdbalIdz:thvkJbbbbavavJbbbb9DEgvaoaoav9DEgvararav9DEk;hgrduo99lue99Huk99lu8Jjjjjbc:qe9RgD8KjjjjbcbhqaDcxfcbc;Kbz:vjjjb8AaDcbyd:q:H:cjbBd1eaDcb8Pd1:H:cjb83ijeaDcbyd:C:H:cjbBd94aDcb8PdN:H:cjb83i9WdndnavmbJFFuFhkJFFuuhxJFFuuhmJFFuFhPJFFuuhsJFFuFhzxekaocd4cdthHalhOincbhAinaDcjefaAfgCaOaAfIdbgXaCIdbgkakaX9EEUdbaDc;WbfaAfgCaXaCIdbgkakaX9DEUdbaAclfgAcx9hmbkaOaHfhOaqcefgqav9hmbkaDId1ehxaDId94hkaDId:eehmaDIdthPaDIdjehsaDId9WhzkJbbbbhXdnJbbbbazas:tgzazJbbbb9DEgzaPam:tgPaPaz9DEgPakax:tgkakaP9DEgkJbbbb9Bmbarc9:f:Yak:vhXkaDaxUdwaDamUdlaDasUdbcbhQaDarar2gLar2gAcbyd:G;d:cjbHjjjjbbgCBdxcehKaDceBd2aCcbaAz:vjjjbgYcbcbadaialaoaraXaDawz:qjjjbdndnabmbaDcxfclfhOcbh8AcbhExekaDcuaLcdtgOaLcFFFFi0Ecbyd:G;d:cjbHjjjjbbg8ABdzaDcdBd2cbhAcbhQcbhCdnaLTmbdnarce9imbaYhvcbhQcbhHinavhAarhOcbhCinaAaCaARbbcFeGgqfgCcbaqE86bbaAcefhAaOcufgOmbka8AaHcdtfaQBdbavarfhvaCaQfhQaHcefgHaL9hmbkcuaQc802gAaQc;e:D:X8N0EhCxekcbhAa8AcbaOz:vjjjb8AcbhQcbhCkaDcxfcxfhOaDaCcbyd:G;d:cjbHjjjjbbgEBdCcihKaDciBd2aEcbaAz:vjjjb8AkdnawcdGmbaOcuaLcdtaLcFFFFi0Ecbyd:G;d:cjbHjjjjbbg3BdbaDaKcefgABd2aDcxfaAcdtfaLcbyd:G;d:cjbHjjjjbbgABdbaAcbaLz:vjjjbh5arcufh8Ednarci9imbarc9:fhHararcef2aYfcefh8Fcehaincehva8FhqinaqhAaHhCinaAaARbbgOcuaOE86bbaAcefhAaCcufgCmbkaqarfhqavcefgva8E9hmbka8FaLfh8Faacefgaa8E9hmbkkaKcdfhKarce9imbcbh8Fcbhqcbhvina5aqfhOcbhAindnaOaAfgCRbbmbaCce86bba3a8FcdtfaqaAfBdba8Fcefh8FkaraAcefgA9hmbkaqarfhqavcefgvar9hmbka8FTmbcbar9RhOaYc9:fhharc9:fhgarci9ih8Jina5a3a8Fcufg8Fcdtfydbgafcb86bbaYaaar2fhCdna8JmbaChqaghHindnaqcefgARbbgvcFe9hmbaqRbbmbcbhvkaAav86bbaAhqaHcufgHmbkaharaacef2fhAa8EhvindnaARbbgqcFe9hmbaAcefRbbmbcbhqkaAaq86bbaAcufhAavcufgvce9kmbkkaaaaar9Ug8Kar29RhacbhqindnaqceScuaqEaafgAce9imbaAa8E9ombcuaqciSaqcdSEa8Kfgvce9imbava8E9omba8JmbaYavar2aAfg8Lar2fhvceh8McehAinaAcefhAdndnindnaCaAfcufRbbmbavaAfcufgHRbbcFeGcFeSmdkaOaAcefgAfmbka8MceGTmexikcbh8MaHcb86bbaOaAfcu9hmekka5a8LfgARbbmbaAce86bba3a8Fcdtfa8LBdba8Fcefh8Fkaqcefgqcl9hmbka8FmbkkdnaETmbaYaEa8AadaialaoaraXaDawz:qjjjbaQTmbdnawclGTmbJbbnnaXaXN:vh8NaEhAinaAcwfgCIdbgyaAcxfIdbgk:vhzaAclfgOIdbg8Pak:vhIaAIdbg8Rak:vh8SdnakJq;x:J88NgRaAczfIdbMgP:lakJ:983:g81Ngk9ETmbaRaAcCfIdbMaAc3fIdbg8Ua8UaP:vg8UN:tg8V:lak9ETmbaRaAcKfIdbMaAcafIdbgRaRaP:vg8WN:taAc8KfIdbaRa8UN:tgRaRa8V:vgRN:tg8X:lak9ETmbayJq;x:J88NaAc8WfIdb:ta8Wa8RJq;x:J88NaAcyfIdb:tgyN:taRa8PJq;x:J88NaAc8SfIdb:ta8UayN:tg8PN:ta8X:vgkaz:tg8Ra8RNayaP:va8Ua8Pa8V:vaRakN:tgPN:ta8WakN:tg8Ua8S:tgRaRNaPaI:tgRaRNMMa8N9DTmba8Uh8SaPhIakhzkaAa8SUdbaCazUdbaOaIUdbaAc80fhAaQcufgQmbxdkkaEhAinaAcwfgCaCIdbaAcxfIdbgk:vUdbaAclfgCaCIdbak:vUdbaAaAIdbak:vUdbaAc80fhAaQcufgQmbkkcbhvdnarcd9imbarcufh8YawceGh8Kdndnabmba8KTmekawcjjjjlGhlJ;n;m;m89aX:vhkcbhvcbh3ina3ar2h8ZcbhaincbhicbclaYaaa8Zfar2fg80arfRbbEa80RbbTVcbcza80aLfg81RbbEVcbc;aba81arfRbbEVhdindnadcbcla80aig8FcefgifgAarfRbbEaARbbTVcbcza81aifgARbbEVcbc;abaAarfRbbEVgdcetVgATmbaAcFeSmbaAcltgAc:J:J:cjbfhqaARb:G:J:cjbhCinabcbavae6EcbabEhAaCco4ceGhOaCcv4ceGh8LaCcl4ceGhQdndna8KTmba8Laafh8EaOa3fh8MaQa8Ffh8JcbhHaCcFeGgCceGaQ9RgQaCce4ceGa8L9Rg8LfaCcd4ceGaO9RgCfce9imeaYa8JaQ9Rfa8Ea8L9Ra8MaC9Rar2far2fRbbcFeGmea8LcetcdGaQceGVaCcdtclGVhHxekaQa8Ffh8JaOa3fh8Ma8Laafh8EcbhHkaqcufRbbhCaqc9:fRbbhOa8Mar2a8Efg8Lar2a8JfhhdnaATmbdndnalTmbaAavc8K2gQfg8Lclfama8E:YJbbb:;MaX:vMUdba8Lasa8J:YJbbb:;MaX:vMUdba8M:YJbbb:;MaX:vhPxekaAavc8K2gQfg8MasaHceG:ZakNaEa8Aa8Lcdtfydbc802faYahfRbbc802fg8Ec9mfIdbMMUdba8MclfamaHce4ceG:ZakNa8Ec9qfIdbMMUdbaHcd4:ZakNa8Ec9ufIdbMhPkabaQfcwfaxaPMUdbkaOco4ceGhQaOcv4ceGh5aOcl4ceGhwdndna8KTmba5aafh8MaQa3fh8Jawa8Ffh8Lcbh8EaOceGaw9RgwaOce4ceGa59Rg5faOcd4ceGaQ9RgOfce9imeaYa8Law9Rfa8Ma59Ra8JaO9Rar2far2fRbbcFeGmea5cetcdGawceGVaOcdtclGVh8Exekawa8Ffh8LaQa3fh8Ja5aafh8Mcbh8Ekavci2hga8Jar2a8MfgQar2a8LfhOdnaATmbagcefh5dndnalTmbaAa5cx2g5fgQclfama8M:YJbbb:;MaX:vMUdbaQasa8L:YJbbb:;MaX:vMUdba8J:YJbbb:;MaX:vhPxekaAa5cx2g5fg8Jasa8EceG:ZakNaEa8AaQcdtfydbc802faYaOfRbbc802fg8Mc9mfIdbMMUdba8Jclfama8Ece4ceG:ZakNa8Mc9qfIdbMMUdba8Ecd4:ZakNa8Mc9ufIdbMhPkaba5fcwfaxaPMUdbkahcithhaCco4ceGhQaCcv4ceGh5aCcl4ceGhwaOcithodndna8KTmba5aafh8MaQa3fh8Jawa8Ffh8LcbhOaCceGaw9RgwaCce4ceGa59Rg5faCcd4ceGaQ9RgCfce9imeaYa8Law9Rfa8Ma59Ra8JaC9Rar2far2fRbbcFeGmea5cetcdGawceGVaCcdtclGVhOxekawa8Ffh8LaQa3fh8Ja5aafh8McbhOkahaHVhCaoa8EVhHa8Jar2a8MfgQar2a8Lfh8EdnaATmbagcdfh5dndnalTmbaAa5cx2g5fgAclfama8M:YJbbb:;MaX:vMUdbaAasa8L:YJbbb:;MaX:vMUdba8J:YJbbb:;MaX:vhPxekaAa5cx2g5fg8MasaOceG:ZakNaEa8AaQcdtfydbc802faYa8EfRbbc802fgAc9mfIdbMMUdba8MclfamaOce4ceG:ZakNaAc9qfIdbMMUdbaOcd4:ZakNaAc9ufIdbMhPkaba5fcwfaxaPMUdbkavaCaH9haHa8EcitaOVgA9haAaC9hGGfhvaqRbbhCaqcifhqaCmbkkaia8Y9hmbkaacefgaa8Y9hmbka3cefg3a8Y9hmbxdkkaYcefg8LararcefgA2fhQaYaAfh5a8LaLfhwcbhvcbhhinahar2h8Ja8Lh8Fa5haawh3aQh8Kcbh8MincbclaYa8Ma8Jfar2fgAarfRbbEaARbbTVcbczaAaLfgARbbEVcbc;abaAarfRbbEVhba8FhAaahCa3hOa8Khqa8YhHindnabcbclaCRbbEaARbbTVcbczaORbbEVcbc;abaqRbbEVgbcetVg8ETmba8EcFeSmbava8ERb:G:H:cjbfhvkaAcefhAaCcefhCaOcefhOaqcefhqaHcufgHmbka8Farfh8Faaarfhaa3arfh3a8Karfh8Ka8Mcefg8Ma8Y9hmbka8LaLfh8La5aLfh5awaLfhwaQaLfhQahcefgha8Y9hmbkkaKcdthraDcxfc98fhAinaAarfydbcbyd:K;d:cjbH:bjjjbbarc98fgrmbkaDc:qef8Kjjjjbavk;Fkkvue99euz99eui99eud99dud99eudnalTmbaocd4hkaqclGhxarc99fhoarcethmcbhPindndnawavaiaPcdtfgqclfydbak2cdtfgsIdwgzavaqydbak2cdtfgHIdwgO:tgAaANasIdbgCaHIdbgX:tgQaQNasIdlgLaHIdlgK:tgYaYNMM:rg8Aavaqcwfydbak2cdtfgqIdwgEaO:tg3a3NaqIdbg5aX:tg8Ea8ENaqIdlg8FaK:tgaaaNMM:rgha8Aah9EEg8AaEaz:tgzazNa5aC:tgzazNa8FaL:tgzazNMM:rgza8Aaz9EENgzazMgz:lJbbb9p9DTmbaz:Ohqxekcjjjj94hqkdnaQaaNaYa8EN:tgCaCNaYa3NaAaaN:tg8Fa8FNaAa8ENaQa3N:tgLaLNMMgE:rg5aqceaqce9kEgqamaqam9iEggcefagcdf2:Y:vgzJbbbb9Bmbarcb9imbJbbjZag:Y:vh8AaOaDIdw:th8JaKaDIdl:th8KaXaDIdb:th8Lagcbagcb9kEh8MdnaeTmbaCJbbbbJbbjZa5:vaEJbbbb9BEgONgEazNh5aLaONgLazNh8Na8FaONgCaCazNNhycbh8Pinagcbagcb9kEcefhIa8Aa8P:ZNgOaANa8JMhhaOaYNa8KMh8RaOaQNa8LMh8Scbhsindndnawa8Aas:ZNgOaaNa8RMgXNgK:lJbbb9p9DTmbaK:Ohqxekcjjjj94hqkaoaqaoaq6EhHdndnawaOa3NahMgKNg8F:lJbbb9p9DTmba8F:Ohqxekcjjjj94hqkaHaoaqaoaq6Ecefar2fcefgHar2hRdndnawaOa8ENa8SMgONg8F:lJbbb9p9DTmba8F:Ohqxekcjjjj94hqkaeadaHcdtfydbc802fabaoaqaoaq6EfaRfcefRbbc802fgqc9mfgHaOazNaHIdbMUdbaqc9qfgHaXazNaHIdbMUdbaqc9ufgHaKazNaHIdbMUdbaqc9yfgHazaHIdbMUdbdnaxTmbaqc9CfgHayaHIdbMUdbaqc9GfgHaLa8NNaHIdbMUdbaqc9KfgHaEa5NaHIdbMUdbaqc9OfgHaCa8NNaHIdbMUdbaqc2fgHaCa5NaHIdbMUdbaqc9WfgHaLa5NaHIdbMUdbaqctfgHaCazaEaKNaCaONaLaXNMM:mNgONaHIdbMUdbaqc94fgHaLaONaHIdbMUdbaqc98fgqaEaONaqIdbMUdbkaIascefgs9hmbkagcufhga8Pa8MShqa8Pcefh8PaqTmbxdkkcbhIinagcbagcb9kEcefhRa8AaI:ZNgzaANa8JMhXazaYNa8KMhKazaQNa8LMhCcbhqindndnawa8Aaq:ZNgzaaNaKMNgO:lJbbb9p9DTmbaO:Ohsxekcjjjj94hskaoasaoas6EhHdndnawaza3NaXMNgO:lJbbb9p9DTmbaO:Ohsxekcjjjj94hskaHaoasaoas6Ecefar2fcefar2hHdndnawaza8ENaCMNgz:lJbbb9p9DTmbaz:Ohsxekcjjjj94hskabaoasaoas6EfaHfcefce86bbaRaqcefgq9hmbkagcufhgaIa8MShqaIcefhIaqTmbkkaPcifgPal6mbkkk9DeeuabcFeaicdtz:vjjjbhlcbhbdnadTmbindnalaeydbcdtfgiydbcu9hmbaiabBdbabcefhbkaeclfheadcufgdmbkkabk;Bidqui998Jjjjjbc;Wb9Rgl8Kjjjjbalcxfcbc;Kbz:vjjjb8Aadcd4adfhvcehoinaogrcethoarav6mbkalcuarcdtgoarcFFFFi0Ecbyd:G;d:cjbHjjjjbbgvBdxavcFeaoz:vjjjbhwdnadTmbaicd4hDarcufhqcbhkindndnawcbaeakaD2cdtfgrydlgiaicjjjj94SEgocH4ao7c:F:b:DD2cbarydbgxaxcjjjj94SEgocH4ao7c;D;O:B8J27cbarydwgmamcjjjj94SEgrcH4ar7c:3F;N8N27aqGgvcdtfgrydbgocuSmbam::hPai::hsax::hzcehiinaihrdnaeaoaD2cdtfgiIdbaz9CmbaiIdlas9CmbaiIdwaP9BmikarcefhiawavarfaqGgvcdtfgrydbgocu9hmbkkarakBdbakhokabakcdtfaoBdbakcefgkad9hmbkkalydxcbyd:K;d:cjbH:bjjjbbalc;Wbf8Kjjjjbk9teiucbcbyd:O;d:cjbgeabcifc98GfgbBd:O;d:cjbdndnabZbcztgd9nmbcuhiabad9RcFFifcz4nbcuSmekaehikaik;LeeeudndnaeabVciGTmbabhixekdndnadcz9pmbabhixekabhiinaiaeydbBdbaiclfaeclfydbBdbaicwfaecwfydbBdbaicxfaecxfydbBdbaeczfheaiczfhiadc9Wfgdcs0mbkkadcl6mbinaiaeydbBdbaeclfheaiclfhiadc98fgdci0mbkkdnadTmbinaiaeRbb86bbaicefhiaecefheadcufgdmbkkabk;aeedudndnabciGTmbabhixekaecFeGc:b:c:ew2hldndnadcz9pmbabhixekabhiinaialBdbaicxfalBdbaicwfalBdbaiclfalBdbaiczfhiadc9Wfgdcs0mbkkadcl6mbinaialBdbaiclfhiadc98fgdci0mbkkdnadTmbinaiae86bbaicefhiadcufgdmbkkabk9teiucbcbyd:O;d:cjbgeabcrfc94GfgbBd:O;d:cjbdndnabZbcztgd9nmbcuhiabad9RcFFifcz4nbcuSmekaehikaikTeeucbabcbyd:O;d:cjbge9Rcifc98GaefgbBd:O;d:cjbdnabZbcztge9nmbabae9RcFFifcz4nb8Akkk:88Jdbcj:Gdk:G8JFFuuFFuuFFuuFFuFFFuFFFuFbbbbbbbbebbbdbbbbbbbebbbebbbdbbbbbbbbbbbeeeeebebbebbebebbbeebbbbbbbbbbbbeeeeeebebbeeebeebbbbebebbbbbbbbbbbbbbbbbFFuuFFuuFFuuFFuFFFuFFFuFbeededddedddddddedddddiediididieeddddiiddideiideddddidieiidelddbeddiddiddiiidededdidddieiilddedbdiiiiildilididdbdedededbiddbdbbbeddidiiididdddeediiiiildilididdbdiddiliddideddebddeeiddbddebdbbbdiilddiddidddeebddideedbdddbebbbdidddddbedebebbbdeebebbbebbbbbbbbbbbbbbbbbbbbbbbznabbbbbbbbbbbbbe8X9rbbbbbbbbbbbbb8Xna9rn8Xbbbbbbbbbbd9I8Ybbbbbbbbbbbbbz9I8Yn9Izbbbbbbbbbb8X9re8Yd9Ibbbbbbbbbb8X9I8Y8X9r9I9rn9IbbbbbbbA8J7bbbbbbbbbbbbbznaA8J7bbbbbbbbbb9r8J7e8J9rbbbbbbbbbb8Jna8J7n79rnbbbbbbbd7A9I7dbbbbbbbbbbz7Azn7n9I7bbbbbbbd9red9I9r9I79rbbbbbbb9rn77n9Ibbbbbbbbbb9u9Klbbbbbbbbbbbbb9uaz9Ka9ubbbbbbbbbbe8X9rl9u9Kbbbbbbbbbb9u8X9r9u9K8X9Ka8Xbbbbbbbl9u9Kd9I8Ybbbbbbbbbb9I9u9K9I8Y9u8Yz9ubbbbbbb9re8Xl9u9K8Yd9Ibbbbbbb9u9K9I9r9u9I9r9I8Y9r8Y8XbbbbA8J7l9u9Kbbbbbbbbbba9u9Kaz9uA8J7bbbbbbb9r8J79re8Jl9u9Kbbbbbbb8J79r8J9r9K8J9Ka9K9r9ubbbbd7Ad9I79Kl9ubbbbbbbA9I7A9u9IAz9u9K9I9ubbbb9u9Kl9re9I9r9I79Iedbbbb9u9K9I9u9I9r9r9I7bbbbbbbX91TbbbbbbbbbbbbbX91Tznabbbbbbbbbbe91T8X91ebbbbbbbbbbn91Tna91a8X91bbbbbbbX91T8Yd9Ibbbbbbbbbbz9I8Yzn9ITX91bbbbbbbe91Te8X918Yd9Ibbbbbbb8Y8X918Y91n8Yn9ITn91bbbbA8J7X91TbbbbbbbbbbaznA8J7TX91bbbbbbb918J791T8JTe8Jbbbbbbb8J791a8J91a91TaTnbbbb7d9I7AdX91TbbbbbbbTX91znAn7An9I7bbbb91Te91e9I919I79Iedbbbb91Tn91n77n9IbbbbbbbX9Kl919KXbbbbbbbbbbXazX91a919Kabbbbbbbe9Kle8X9K8X919Kbbbbbbb8X91aa919Kbbbbbbbbbb9KX919KlXd9I8YbbbbbbbX919KX9K8YX8Yz8Y9K9Ibbbb8Yd9Ie8Xl8X9Kl8X919Kbbbb9I8Y8X9I8X9K9K8X91bbbbbbbX9KlX919K7A8Jbbbbbbb7A8JX91z91az919Kabbbble8Jl8J91l919K7918Jbbbb8J7918J91aa919KbbbbbbbX91ll919K7Ad7d9Ibbbb919Kz91zX9K9IzAz79I7zb9I7e9Ied791ele9K919Keb9I7919K9I91bbbbbbbbbbS48Mbbbbbbbbbbbbbazn8MS4bbbbbbbbbbe8X9r8MS4bbbbbbbbbbn8X9rna8X8MS4bbbbbbbS8Yd48YSbbbbbbbbbbSznS4z48Yzbbbbbbb8YS48YdSe8X9rbbbbbbb8X48Y8Xn48X9rnnS4bbbb7A8J48MSbbbbbbbbbbA8J7azn48MSbbbbbbb8J9re8J79r48MSbbbbbbb48MS8J7a7na79rnbbbb7S47ASAdSbbbbbbb7S4AS7AnSAznbbbbedSeS7e79r47SbbbbS47S7nn79rbbbbbbb4l9u8Ml4bbbbbbbbbba48Maz4z9u4bbbbbbbl48Ml9u49re8Xbbbbbbb9r9u49r4a9ra8X8Ma4bbbbl8Ydl9u8Y9u48Ybbbbbbbz9u8Y9u48Ybbbbbbbbbb8X9re8Yd9u8Y9u49udlbbbb8X9r9u8X9u8Y8Y9u4bbbbbbb4l9u48Ml8J7AbbbbbbbA8J7az8Mz48Mz9u4bbbb9u8Ml9u48Me8J9r8J79rbbbb79ra7a8J9r9ua8Ma49u4ablAdl4Al9u447Abbbb7Az7z44z9ubbbbbbb9u4d9udl47ded9r79rdb79r9u479ubbbbbbbbbbTX91S48MbbbbbbbbbbznaTX918MS4bbbbbbb91e8X91TeS48Mbbbbbbb8MS4naTa91Ta8X91bbbbS8YdS48Y91TXbbbbbbbX91Tzn4z48Y4nSbbbbd48YdS48X91e91Tebbbb48Yn4nS8Y8XnTn918X91nbX91T7A8JS48Mbbbbbbb48MSA8J7znaTX91bbbbS48M91T7T8J7Te8JbbbbaTna91Ta8J917918J8MS4bX91T7A4AS4AdSbbbbA47AS4AzSnSzX91TbTe7T791ed747SdS7bS47S7n91T7Tn7bbbb4X9148MX8MlXbbbbbbba48Mz4az914zX91bbbbe8Mle918Me8X919148Mbbbb48Ma4a9191a8Xbbbbbbb91lX918Yl9148Ydl8YbbbbX914X4zz48Ybbbbbbb8X91l8Xle914ldl8Y48Ylb8X9148Y8X4bbbbbbbbbbA8J7X918MX8Ml8M914bbbbz8Maz48MzX4914XA8J7b8Ml918M914le917918Je8J91b48Ma4a918J7a791abbbbAd4A47dl4914XlX4b7Az7z4X91z914zbbbbedl9147bbbbbbbbbb7914bbbbbbbbbbbbb839N9xbbbbbbbbbbbbbzna9x839Nbbbbbbbbbb9re8X9x839Nbbbbbbbbbb8Xna8X9rn9x839Nbbbbbbb8Yd9I839N9xbbbbbbbbbb9Izn9I8Yz839N9xbbbbbbbe8X9r8Yd9I9x839Nbbbbbbb9x839N8X9r8Y9r9I8Y9rn9IbbbbA9N9x8J9NAbbbbbbbbbbA9N9xA8J9Naznbbbbbbb9r9N9x9re9Ne8J9Nbbbbbbb9x9rn9xn8J9x8J9Na8Jnbbbb9Nd9I9N9xd9xAdbbbbbbbzn9Iz9I9xz9xA9x9I9Nbbbbd9I9Ned9Ne9N9xe9x9rbbbb9N9x9r9N9r9I9I9rnbbbbbbb9x839N9u9Klbbbbbbbbbb9uaz9u9Ka9N9x83bbbbbbb8X9re9x839Nl9u9Kbbbbbbb839N9x8X9r9K8X9Ka9K9r9ubbbbd9I8Y9Kl9u839N9xbbbbbbb9x839N9u9K8Y9u8Yz8Y9K9Ibbbbe8X9r9u9Kl8Yd9I9x839Nbbbb9r8Y8X9r9I8Y9r9u9I9K9I9u9x839Nb9NA8J9N9xA9u9KlbbbbbbbA8J9x9x8J9Naz9ua9u9Kbbbbl9u9K9re9xe9N9xe8J9Nbbbb9Ka9r9K9r9ua8J9r9x9r9N8J9N9rbl9u9Kd9I9xd9xA9x9I9Nbbbb9xA9I9x9I9NAz9I9K9I9uz9u9Ibe9x9re9N9xed9N9I9Ndl9u9Kb9N9x9r9N9r9I9u9K9r9K9I9rbbbb83TX9NT83bbbbbbbbbbT839NTX83znabbbbbbb83e8X839Ne9NTebbbbbbbna8Xn8X9Nn9NT9N8X83bbbb83TX839NT9I8Ydbbbbbbbzn8Y8Yn9ITX83T839Nbbbbd9I8Ye8X9Ne9NT9N8X83bbbb9NT8X9N8X83Tn8X8Y8X9In9I8XbATXA8JT8J9NTbbbbbbbaznA8JX8JTX8J9NTbbbbe8JTT8J9Nbbbbbbbbbbna8Jn8JTT8J9NbbbbbbbX9NTXd9NXAd9I9Ndbbbbn9IAnAz9I9NAXAT9NTAbd9I9Nd9Nee9NTbbbbbbb9NTn9I9Nnbbbbbbbbbb9K839N9Kl83lX83bbbbbbbz9Kaz839KzX839N9K83bbbb839N9K8X839K8X9Kl8Xlebbbb839N9K839K8X8X9Kabbbbbbb8Yd9I839Nl83lXl9N9Kbbbb8Yz9K8Y9K9IzX9K9N9K83X839Kb8Xle8X9Kl8X839K9N9K838Yd9Ib9I8Y8X9I8X9K839N8X9N9K8XbbbbA8J9NA9NlAlXl9N9Kbbbb8J9NX8JXA9N9KXzXa9KaXb9Kle9Ke9N9Ne8Jbbbbbbb9Ka8J9N9K8JbbbbbbbbbblX9Nl9N9KXA9N9I9NdAd9NbzXA9I9N9Kbbbbbbbbbb9Kle9Ke9Nd9Ie9I9Nebbbb9K9I9Nbbbbbbbbbbbbb8M9x83S9x8Mbbbbbbbbbb8M9x838MS9xnazbbbbbbb9x8MS9x838M8X9rebbbbbbb83S9x838MS9rn8Xna8Xbbbb8Y9x838Yd9xdS9xbbbbbbbn8Yzn9x8YnS9x838Y9xbbbb9re8X9x83d9xdSd838Ybbbb9rn8Y9r8Y8XnS8Y838Y9xS9x8Yb8MA8J8MSAS9xAbbbbbbbznaA8JSAS9xS8J8Mbbbb9rS9x9r8JS9re8J8J8MSbbbbS9x8JS8J8M9x9r8Ja8Jn9rn8JbAd9xdS9xbbbbbbbbbbznSzSAAS9xbbbbbbb9red9rd9x9xdSbbbbbbb9rnS9x9rSbbbbbbbbbb9xl9u9x83l838Mlbbbbbbb9xz9u9x8Mz9x838M8Mazbbbbe8X9rl9u83l838M839u9xbbbb838M9u839u9x8Ma9u9r9u8Xa8X9ub8Y9x83d9x8Yd9u9xdl9ubbbb9x838Y9x8Y9u9u8Yzbbbbbbbd838Yd9x83dl9x9u9xle8X9rb9x838Y9x8Y9u8X9r8Y9r9u8Ybbbb8J9xA8Jl9x8J8Ml9u9xlbbbbz9u8Mz8Ma9u9x8M8J8MA9xA8Mbe8J9xe9x9r8J8M9x9u9xl8Ml9xb9r9u9x8J8Mabbbbbbbbbbl9u9xl9xdd9xAbbbbbbbz9u9xAz9xbbbbbbbbbbl9u9xl9xd9re9xed9xbbbb9r9u9xbbbbbbbbbbbbbT8MSTX8MX838MbbbbbbbznaTXSX8MSX838Mbbbb8X838M8X8MT8XTeST8Mbbbba8XTaTn8X83TST8M838MTb8YX838YSX8YdSSTXbbbbX83SXST838YSnSz8YzSbdS83d838YST838X83eTe83b8X838YnSTbbbbbbbbbbT8MSX8MTX8J8MXA8JbbbbXSTX8MSXA8M8J8MAznab8MST8MT8J8JTebbbbbbb8MST8MT8JnaTa8JTbbbbTXATASSAdbbbbbbbTXATASznAnSAbbbbTedSTdbbbbbbbbbbTnSbbbbbbbbbbbbbX83l838MlbbbbbbbbbbazXaX8M8MX83bbbbbbbe8X83e83ll838Mbbbbbbba8X838Ma83bbbbbbbbbb8Ydl8Yl8383lXbbbbbbbX838YzX8Ybbbbbbbbbb8Ydl8Yl83e8Xl8X83lbbbb8X838YbbbbbbbbbbbbbA8J8MA8MXX8MlbbbbbbbazXaX8MA8JX8J8MXbbbbe8J8Mle8Mbbbbbbbbbba8J8MbbbbbbbbbbbbbAdlXAlbbbbbbbbbbzXAbbbbbbbbbbbbbedlbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc:G;ddkxebbbdbbb:W:Hbb'; // embed! wasm
 
 	var wasmpack = new Uint8Array([
 		32, 0, 65, 2, 1, 106, 34, 33, 3, 128, 11, 4, 13, 64, 6, 253, 10, 7, 15, 116, 127, 5, 8, 12, 40, 16, 19, 54, 20, 9, 27, 255, 113, 17, 42, 67,
@@ -314,6 +314,26 @@ var MeshoptSimplifier = (function () {
 		return target;
 	}
 
+	function remesh(fun, indices, vertex_positions, vertex_positions_stride, resolution, options) {
+		var sbrk = instance.exports.sbrk;
+		var sp = sbrk(vertex_positions.byteLength);
+		var si = sbrk(indices.byteLength);
+		var heap = new Uint8Array(instance.exports.memory.buffer);
+		heap.set(bytes(vertex_positions), sp);
+		heap.set(bytes(indices), si);
+		var vertex_count = vertex_positions.byteLength / vertex_positions_stride;
+		var capacity = fun(0, 0, si, indices.length, sp, vertex_count, vertex_positions_stride, resolution, options);
+		var tp = sbrk(capacity * 9 * 4);
+		var count = fun(tp, capacity, si, indices.length, sp, vertex_count, vertex_positions_stride, resolution, options);
+		assert(count <= capacity);
+		// heap may have grown
+		heap = new Uint8Array(instance.exports.memory.buffer);
+		var target = new Float32Array(count * 9);
+		bytes(target).set(heap.subarray(tp, tp + target.byteLength));
+		sbrk(sp - sbrk(0));
+		return target;
+	}
+
 	var simplifyOptions = {
 		LockBorder: 1,
 		Sparse: 2,
@@ -325,6 +345,13 @@ var MeshoptSimplifier = (function () {
 		_InternalDebug: 1 << 30, // internal, don't use!
 	};
 
+	var remeshOptions = {
+		Thicken: 1,
+		Shell: 2,
+		Solve: 4,
+		_InternalDebug: 1 << 30, // internal, don't use!
+	};
+
 	return {
 		ready: ready,
 		supported: true,
@@ -621,6 +648,26 @@ var MeshoptSimplifier = (function () {
 
 			return result;
 		},
+
+		remesh: function (indices, vertex_positions, vertex_positions_stride, resolution, flags) {
+			assert(
+				indices instanceof Uint32Array || indices instanceof Int32Array || indices instanceof Uint16Array || indices instanceof Int16Array
+			);
+			assert(indices.length % 3 == 0);
+			assert(vertex_positions instanceof Float32Array);
+			assert(vertex_positions.length % vertex_positions_stride == 0);
+			assert(vertex_positions_stride >= 3);
+			assert(resolution >= 4 && resolution <= 256);
+
+			var options = 0;
+			for (var i = 0; i < (flags ? flags.length : 0); ++i) {
+				assert(flags[i] in remeshOptions);
+				options |= remeshOptions[flags[i]];
+			}
+
+			var indices32 = indices.BYTES_PER_ELEMENT == 4 ? indices : new Uint32Array(indices);
+			return remesh(instance.exports.meshopt_remesh, indices32, vertex_positions, vertex_positions_stride * 4, resolution, options);
+		},
 	};
 })();
 
diff --git a/src/meshoptimizer.h b/src/meshoptimizer.h
index e6aa58eb4..b101810cb 100644
--- a/src/meshoptimizer.h
+++ b/src/meshoptimizer.h
@@ -950,6 +950,33 @@ enum
  */
 MESHOPTIMIZER_EXPERIMENTAL void meshopt_generateTangents(float* result, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, const float* vertex_normals, size_t vertex_normals_stride, const float* vertex_uvs, size_t vertex_uvs_stride, unsigned int options);
 
+/**
+ * Experimental: Remeshing flags
+ */
+enum
+{
+	/* Thicken thin geometry sheets, producing unique vertex positions for each side of thin geometry. */
+	meshopt_RemeshThicken = 1 << 0,
+	/* Produce a two-sided shell that wraps around surfaces of the original mesh, instead of a solid mesh. */
+	meshopt_RemeshShell = 1 << 1,
+	/* Compute optimal output positions that approximate the original surface as closely as possible. */
+	meshopt_RemeshSolve = 1 << 2,
+};
+
+/**
+ * Experimental: Voxel remesher
+ * Generates a new mesh that approximates or refines the original mesh, attempting to preserve mesh appearance at a given voxel resolution.
+ * The original topology is not preserved; features that are closer than the voxel size may be merged, and small gaps in the original mesh may be closed.
+ * Returns the number of triangles in the new mesh, with destination containing a vertex position for each triangle corner.
+ *
+ * destination can be NULL; when it's not NULL, it must contain enough space for the resulting triangle buffer (max_triangle_count * 3 vertices, 3 floats per vertex)
+ * max_triangle_count is the number of triangles that can be written; the returned value is always the number of triangles that would be generated given sufficient output space
+ * vertex_positions should have float3 position in the first 12 bytes of each vertex
+ * resolution is the dimension of the internal voxel grid and should be in the range [4, 256]
+ * options must be a bitmask composed of meshopt_RemeshX options; 0 is a safe default
+ */
+MESHOPTIMIZER_EXPERIMENTAL size_t meshopt_remesh(float* destination, size_t max_triangle_count, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, int resolution, unsigned int options);
+
 /**
  * Quantize a float into half-precision (as defined by IEEE-754 fp16) floating point value
  * Generates +-inf for overflow, preserves NaN, flushes denormals to zero, rounds to nearest
@@ -1116,6 +1143,8 @@ template <typename T>
 inline void meshopt_spatialSortTriangles(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
 template <typename T>
 inline void meshopt_generateTangents(float* result, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, const float* vertex_normals, size_t vertex_normals_stride, const float* vertex_uvs, size_t vertex_uvs_stride, unsigned int options = 0);
+template <typename T>
+inline size_t meshopt_remesh(float* destination, size_t max_triangle_count, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, int resolution, unsigned int options = 0);
 #endif
 
 /* Inline implementation */
@@ -1632,6 +1661,14 @@ inline void meshopt_generateTangents(float* result, const T* indices, size_t ind
 
 	meshopt_generateTangents(result, indices ? in.data : NULL, index_count, vertex_positions, vertex_count, vertex_positions_stride, vertex_normals, vertex_normals_stride, vertex_uvs, vertex_uvs_stride, options);
 }
+
+template <typename T>
+inline size_t meshopt_remesh(float* destination, size_t max_triangle_count, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, int resolution, unsigned int options)
+{
+	meshopt_IndexAdapter<T> in(NULL, indices, index_count);
+
+	return meshopt_remesh(destination, max_triangle_count, in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride, resolution, options);
+}
 #endif
 
 /**
diff --git a/src/remesher.cpp b/src/remesher.cpp
new file mode 100644
index 000000000..f568d1fb2
--- /dev/null
+++ b/src/remesher.cpp
@@ -0,0 +1,701 @@
+// This file is part of meshoptimizer library; see meshoptimizer.h for version/license details
+#include "meshoptimizer.h"
+
+#include <assert.h>
+#include <float.h>
+#include <math.h>
+#include <string.h>
+
+#ifndef TRACE
+#define TRACE 0
+#endif
+
+#if TRACE
+#include <stdio.h>
+#endif
+
+// Note: this is only exposed for development purposes; do *not* use
+enum
+{
+	meshopt_RemeshInternalDebug = 1 << 30
+};
+
+// This work is based on:
+// Paul Bourke. Polygonising a scalar field. 1994
+// Michael Garland and Paul S. Heckbert. Surface simplification using quadric error metrics. 1997
+namespace meshopt
+{
+
+// the tables are taken from Bourke's source data, but each triangle corner is encoded as an edge with two nibbles corresponding to vertex codes
+// additionally, vertex codes have been renumbered to match the bit order XYZ (e.g. 3 maps to X=1 Y=1 Z=0)
+static const unsigned char kTriangleTable[256][16] = {
+    {}, {0x10, 0x40, 0x20},
+    {0x01, 0x31, 0x51}, {0x31, 0x40, 0x20, 0x51, 0x40, 0x31},
+    {0x02, 0x62, 0x32}, {0x10, 0x62, 0x32, 0x40, 0x62, 0x10},
+    {0x31, 0x51, 0x01, 0x32, 0x02, 0x62}, {0x31, 0x62, 0x32, 0x31, 0x51, 0x62, 0x51, 0x40, 0x62},
+    {0x13, 0x23, 0x73}, {0x10, 0x40, 0x20, 0x13, 0x23, 0x73},
+    {0x51, 0x23, 0x73, 0x01, 0x23, 0x51}, {0x23, 0x40, 0x20, 0x23, 0x73, 0x40, 0x73, 0x51, 0x40},
+    {0x02, 0x73, 0x13, 0x62, 0x73, 0x02}, {0x10, 0x73, 0x13, 0x10, 0x40, 0x73, 0x40, 0x62, 0x73},
+    {0x02, 0x51, 0x01, 0x02, 0x62, 0x51, 0x62, 0x73, 0x51}, {0x51, 0x40, 0x73, 0x73, 0x40, 0x62},
+    {0x54, 0x64, 0x04}, {0x54, 0x20, 0x10, 0x64, 0x20, 0x54},
+    {0x01, 0x31, 0x51, 0x04, 0x54, 0x64}, {0x54, 0x31, 0x51, 0x54, 0x64, 0x31, 0x64, 0x20, 0x31},
+    {0x04, 0x54, 0x64, 0x02, 0x62, 0x32}, {0x62, 0x54, 0x64, 0x62, 0x32, 0x54, 0x32, 0x10, 0x54},
+    {0x51, 0x01, 0x31, 0x04, 0x54, 0x64, 0x32, 0x02, 0x62}, {0x54, 0x64, 0x62, 0x51, 0x54, 0x62, 0x51, 0x62, 0x32, 0x51, 0x32, 0x31},
+    {0x13, 0x23, 0x73, 0x04, 0x54, 0x64}, {0x20, 0x54, 0x64, 0x20, 0x10, 0x54, 0x13, 0x23, 0x73},
+    {0x51, 0x23, 0x73, 0x51, 0x01, 0x23, 0x04, 0x54, 0x64}, {0x23, 0x73, 0x51, 0x23, 0x51, 0x64, 0x23, 0x64, 0x20, 0x64, 0x51, 0x54},
+    {0x02, 0x73, 0x13, 0x02, 0x62, 0x73, 0x64, 0x04, 0x54}, {0x13, 0x62, 0x73, 0x13, 0x54, 0x62, 0x13, 0x10, 0x54, 0x64, 0x62, 0x54},
+    {0x54, 0x64, 0x04, 0x51, 0x01, 0x62, 0x51, 0x62, 0x73, 0x62, 0x01, 0x02}, {0x54, 0x64, 0x62, 0x54, 0x62, 0x51, 0x51, 0x62, 0x73},
+    {0x15, 0x75, 0x45}, {0x15, 0x75, 0x45, 0x10, 0x40, 0x20},
+    {0x01, 0x75, 0x45, 0x31, 0x75, 0x01}, {0x40, 0x75, 0x45, 0x40, 0x20, 0x75, 0x20, 0x31, 0x75},
+    {0x15, 0x75, 0x45, 0x32, 0x02, 0x62}, {0x10, 0x62, 0x32, 0x10, 0x40, 0x62, 0x45, 0x15, 0x75},
+    {0x01, 0x75, 0x45, 0x01, 0x31, 0x75, 0x32, 0x02, 0x62}, {0x32, 0x31, 0x75, 0x32, 0x75, 0x40, 0x32, 0x40, 0x62, 0x45, 0x40, 0x75},
+    {0x13, 0x23, 0x73, 0x15, 0x75, 0x45}, {0x20, 0x10, 0x40, 0x13, 0x23, 0x73, 0x45, 0x15, 0x75},
+    {0x75, 0x23, 0x73, 0x75, 0x45, 0x23, 0x45, 0x01, 0x23}, {0x23, 0x73, 0x75, 0x20, 0x23, 0x75, 0x20, 0x75, 0x45, 0x20, 0x45, 0x40},
+    {0x73, 0x02, 0x62, 0x73, 0x13, 0x02, 0x15, 0x75, 0x45}, {0x45, 0x15, 0x75, 0x10, 0x40, 0x13, 0x40, 0x73, 0x13, 0x40, 0x62, 0x73},
+    {0x75, 0x45, 0x01, 0x75, 0x01, 0x62, 0x75, 0x62, 0x73, 0x62, 0x01, 0x02}, {0x75, 0x45, 0x40, 0x75, 0x40, 0x73, 0x73, 0x40, 0x62},
+    {0x15, 0x64, 0x04, 0x75, 0x64, 0x15}, {0x15, 0x20, 0x10, 0x15, 0x75, 0x20, 0x75, 0x64, 0x20},
+    {0x01, 0x64, 0x04, 0x01, 0x31, 0x64, 0x31, 0x75, 0x64}, {0x31, 0x75, 0x20, 0x20, 0x75, 0x64},
+    {0x64, 0x15, 0x75, 0x64, 0x04, 0x15, 0x02, 0x62, 0x32}, {0x15, 0x75, 0x64, 0x15, 0x64, 0x32, 0x15, 0x32, 0x10, 0x32, 0x64, 0x62},
+    {0x32, 0x02, 0x62, 0x01, 0x31, 0x04, 0x31, 0x64, 0x04, 0x31, 0x75, 0x64}, {0x62, 0x32, 0x31, 0x62, 0x31, 0x64, 0x64, 0x31, 0x75},
+    {0x15, 0x64, 0x04, 0x15, 0x75, 0x64, 0x73, 0x13, 0x23}, {0x73, 0x13, 0x23, 0x15, 0x75, 0x10, 0x75, 0x20, 0x10, 0x75, 0x64, 0x20},
+    {0x04, 0x01, 0x23, 0x04, 0x23, 0x75, 0x04, 0x75, 0x64, 0x73, 0x75, 0x23}, {0x23, 0x73, 0x75, 0x23, 0x75, 0x20, 0x20, 0x75, 0x64},
+    {0x15, 0x75, 0x04, 0x04, 0x75, 0x64, 0x73, 0x13, 0x02, 0x73, 0x02, 0x62}, {0x75, 0x64, 0x10, 0x75, 0x10, 0x15, 0x64, 0x62, 0x10, 0x13, 0x10, 0x73, 0x62, 0x73, 0x10},
+    {0x62, 0x73, 0x01, 0x62, 0x01, 0x02, 0x73, 0x75, 0x01, 0x04, 0x01, 0x64, 0x75, 0x64, 0x01}, {0x62, 0x73, 0x75, 0x64, 0x62, 0x75},
+    {0x46, 0x76, 0x26}, {0x20, 0x10, 0x40, 0x26, 0x46, 0x76},
+    {0x01, 0x31, 0x51, 0x26, 0x46, 0x76}, {0x40, 0x31, 0x51, 0x40, 0x20, 0x31, 0x26, 0x46, 0x76},
+    {0x46, 0x32, 0x02, 0x76, 0x32, 0x46}, {0x46, 0x10, 0x40, 0x46, 0x76, 0x10, 0x76, 0x32, 0x10},
+    {0x32, 0x46, 0x76, 0x32, 0x02, 0x46, 0x01, 0x31, 0x51}, {0x31, 0x76, 0x32, 0x31, 0x40, 0x76, 0x31, 0x51, 0x40, 0x40, 0x46, 0x76},
+    {0x73, 0x13, 0x23, 0x76, 0x26, 0x46}, {0x13, 0x23, 0x73, 0x20, 0x10, 0x40, 0x76, 0x26, 0x46},
+    {0x23, 0x51, 0x01, 0x23, 0x73, 0x51, 0x76, 0x26, 0x46}, {0x76, 0x26, 0x46, 0x23, 0x73, 0x20, 0x73, 0x40, 0x20, 0x73, 0x51, 0x40},
+    {0x73, 0x46, 0x76, 0x73, 0x13, 0x46, 0x13, 0x02, 0x46}, {0x73, 0x46, 0x76, 0x13, 0x46, 0x73, 0x13, 0x40, 0x46, 0x13, 0x10, 0x40},
+    {0x01, 0x02, 0x46, 0x01, 0x46, 0x73, 0x01, 0x73, 0x51, 0x76, 0x73, 0x46}, {0x46, 0x76, 0x73, 0x46, 0x73, 0x40, 0x40, 0x73, 0x51},
+    {0x76, 0x04, 0x54, 0x26, 0x04, 0x76}, {0x20, 0x76, 0x26, 0x20, 0x10, 0x76, 0x10, 0x54, 0x76},
+    {0x04, 0x76, 0x26, 0x04, 0x54, 0x76, 0x51, 0x01, 0x31}, {0x51, 0x54, 0x76, 0x51, 0x76, 0x20, 0x51, 0x20, 0x31, 0x26, 0x20, 0x76},
+    {0x04, 0x32, 0x02, 0x04, 0x54, 0x32, 0x54, 0x76, 0x32}, {0x10, 0x54, 0x32, 0x54, 0x76, 0x32},
+    {0x31, 0x51, 0x01, 0x32, 0x02, 0x54, 0x32, 0x54, 0x76, 0x54, 0x02, 0x04}, {0x31, 0x51, 0x54, 0x31, 0x54, 0x32, 0x32, 0x54, 0x76},
+    {0x76, 0x04, 0x54, 0x76, 0x26, 0x04, 0x23, 0x73, 0x13}, {0x13, 0x23, 0x73, 0x20, 0x10, 0x26, 0x10, 0x76, 0x26, 0x10, 0x54, 0x76},
+    {0x54, 0x26, 0x04, 0x54, 0x76, 0x26, 0x01, 0x23, 0x51, 0x23, 0x73, 0x51}, {0x73, 0x51, 0x20, 0x73, 0x20, 0x23, 0x51, 0x54, 0x20, 0x26, 0x20, 0x76, 0x54, 0x76, 0x20},
+    {0x04, 0x13, 0x02, 0x04, 0x76, 0x13, 0x04, 0x54, 0x76, 0x76, 0x73, 0x13}, {0x73, 0x13, 0x10, 0x73, 0x10, 0x76, 0x76, 0x10, 0x54},
+    {0x54, 0x76, 0x02, 0x54, 0x02, 0x04, 0x76, 0x73, 0x02, 0x01, 0x02, 0x51, 0x73, 0x51, 0x02}, {0x73, 0x51, 0x54, 0x76, 0x73, 0x54},
+    {0x45, 0x15, 0x75, 0x46, 0x76, 0x26}, {0x10, 0x40, 0x20, 0x45, 0x15, 0x75, 0x26, 0x46, 0x76},
+    {0x75, 0x01, 0x31, 0x75, 0x45, 0x01, 0x46, 0x76, 0x26}, {0x26, 0x46, 0x76, 0x40, 0x20, 0x45, 0x20, 0x75, 0x45, 0x20, 0x31, 0x75},
+    {0x46, 0x32, 0x02, 0x46, 0x76, 0x32, 0x75, 0x45, 0x15}, {0x15, 0x75, 0x45, 0x10, 0x40, 0x76, 0x10, 0x76, 0x32, 0x76, 0x40, 0x46},
+    {0x02, 0x76, 0x32, 0x02, 0x46, 0x76, 0x31, 0x75, 0x01, 0x75, 0x45, 0x01}, {0x76, 0x32, 0x40, 0x76, 0x40, 0x46, 0x32, 0x31, 0x40, 0x45, 0x40, 0x75, 0x31, 0x75, 0x40},
+    {0x15, 0x75, 0x45, 0x73, 0x13, 0x23, 0x46, 0x76, 0x26}, {0x76, 0x26, 0x46, 0x13, 0x23, 0x73, 0x10, 0x40, 0x20, 0x45, 0x15, 0x75},
+    {0x46, 0x76, 0x26, 0x75, 0x45, 0x73, 0x45, 0x23, 0x73, 0x45, 0x01, 0x23}, {0x20, 0x45, 0x40, 0x20, 0x75, 0x45, 0x20, 0x23, 0x75, 0x73, 0x75, 0x23, 0x26, 0x46, 0x76},
+    {0x15, 0x75, 0x45, 0x73, 0x13, 0x76, 0x13, 0x46, 0x76, 0x13, 0x02, 0x46}, {0x13, 0x76, 0x73, 0x13, 0x46, 0x76, 0x13, 0x10, 0x46, 0x40, 0x46, 0x10, 0x15, 0x75, 0x45},
+    {0x45, 0x01, 0x73, 0x45, 0x73, 0x75, 0x01, 0x02, 0x73, 0x76, 0x73, 0x46, 0x02, 0x46, 0x73}, {0x46, 0x76, 0x73, 0x46, 0x73, 0x40, 0x75, 0x45, 0x73, 0x45, 0x40, 0x73},
+    {0x76, 0x15, 0x75, 0x76, 0x26, 0x15, 0x26, 0x04, 0x15}, {0x20, 0x76, 0x26, 0x10, 0x76, 0x20, 0x10, 0x75, 0x76, 0x10, 0x15, 0x75},
+    {0x01, 0x26, 0x04, 0x01, 0x75, 0x26, 0x01, 0x31, 0x75, 0x75, 0x76, 0x26}, {0x76, 0x26, 0x20, 0x76, 0x20, 0x75, 0x75, 0x20, 0x31},
+    {0x75, 0x04, 0x15, 0x75, 0x32, 0x04, 0x75, 0x76, 0x32, 0x02, 0x04, 0x32}, {0x15, 0x75, 0x76, 0x15, 0x76, 0x10, 0x10, 0x76, 0x32},
+    {0x31, 0x75, 0x04, 0x31, 0x04, 0x01, 0x75, 0x76, 0x04, 0x02, 0x04, 0x32, 0x76, 0x32, 0x04}, {0x31, 0x75, 0x76, 0x32, 0x31, 0x76},
+    {0x13, 0x23, 0x73, 0x15, 0x75, 0x26, 0x15, 0x26, 0x04, 0x26, 0x75, 0x76}, {0x10, 0x26, 0x20, 0x10, 0x76, 0x26, 0x10, 0x15, 0x76, 0x75, 0x76, 0x15, 0x13, 0x23, 0x73},
+    {0x26, 0x04, 0x75, 0x26, 0x75, 0x76, 0x04, 0x01, 0x75, 0x73, 0x75, 0x23, 0x01, 0x23, 0x75}, {0x76, 0x26, 0x20, 0x76, 0x20, 0x75, 0x23, 0x73, 0x20, 0x73, 0x75, 0x20},
+    {0x13, 0x02, 0x76, 0x13, 0x76, 0x73, 0x02, 0x04, 0x76, 0x75, 0x76, 0x15, 0x04, 0x15, 0x76}, {0x73, 0x13, 0x10, 0x73, 0x10, 0x76, 0x15, 0x75, 0x10, 0x75, 0x76, 0x10},
+    {0x01, 0x02, 0x04, 0x75, 0x76, 0x73}, {0x73, 0x75, 0x76},
+    {0x37, 0x67, 0x57}, {0x10, 0x40, 0x20, 0x57, 0x37, 0x67},
+    {0x51, 0x01, 0x31, 0x57, 0x37, 0x67}, {0x31, 0x40, 0x20, 0x31, 0x51, 0x40, 0x57, 0x37, 0x67},
+    {0x32, 0x02, 0x62, 0x37, 0x67, 0x57}, {0x62, 0x10, 0x40, 0x62, 0x32, 0x10, 0x37, 0x67, 0x57},
+    {0x01, 0x31, 0x51, 0x32, 0x02, 0x62, 0x57, 0x37, 0x67}, {0x57, 0x37, 0x67, 0x31, 0x51, 0x32, 0x51, 0x62, 0x32, 0x51, 0x40, 0x62},
+    {0x13, 0x67, 0x57, 0x23, 0x67, 0x13}, {0x13, 0x67, 0x57, 0x13, 0x23, 0x67, 0x20, 0x10, 0x40},
+    {0x51, 0x67, 0x57, 0x51, 0x01, 0x67, 0x01, 0x23, 0x67}, {0x57, 0x51, 0x40, 0x57, 0x40, 0x23, 0x57, 0x23, 0x67, 0x20, 0x23, 0x40},
+    {0x67, 0x02, 0x62, 0x67, 0x57, 0x02, 0x57, 0x13, 0x02}, {0x10, 0x40, 0x62, 0x10, 0x62, 0x57, 0x10, 0x57, 0x13, 0x57, 0x62, 0x67},
+    {0x02, 0x62, 0x67, 0x01, 0x02, 0x67, 0x01, 0x67, 0x57, 0x01, 0x57, 0x51}, {0x67, 0x57, 0x51, 0x67, 0x51, 0x62, 0x62, 0x51, 0x40},
+    {0x57, 0x37, 0x67, 0x54, 0x64, 0x04}, {0x54, 0x20, 0x10, 0x54, 0x64, 0x20, 0x67, 0x57, 0x37},
+    {0x31, 0x51, 0x01, 0x57, 0x37, 0x67, 0x04, 0x54, 0x64}, {0x37, 0x67, 0x57, 0x31, 0x51, 0x64, 0x31, 0x64, 0x20, 0x64, 0x51, 0x54},
+    {0x02, 0x62, 0x32, 0x64, 0x04, 0x54, 0x37, 0x67, 0x57}, {0x57, 0x37, 0x67, 0x54, 0x64, 0x32, 0x54, 0x32, 0x10, 0x32, 0x64, 0x62},
+    {0x01, 0x31, 0x51, 0x54, 0x64, 0x04, 0x32, 0x02, 0x62, 0x57, 0x37, 0x67}, {0x51, 0x32, 0x31, 0x51, 0x62, 0x32, 0x51, 0x54, 0x62, 0x64, 0x62, 0x54, 0x57, 0x37, 0x67},
+    {0x67, 0x13, 0x23, 0x67, 0x57, 0x13, 0x54, 0x64, 0x04}, {0x13, 0x23, 0x57, 0x57, 0x23, 0x67, 0x20, 0x10, 0x54, 0x20, 0x54, 0x64},
+    {0x04, 0x54, 0x64, 0x51, 0x01, 0x57, 0x01, 0x67, 0x57, 0x01, 0x23, 0x67}, {0x64, 0x20, 0x51, 0x64, 0x51, 0x54, 0x20, 0x23, 0x51, 0x57, 0x51, 0x67, 0x23, 0x67, 0x51},
+    {0x04, 0x54, 0x64, 0x02, 0x62, 0x57, 0x02, 0x57, 0x13, 0x57, 0x62, 0x67}, {0x57, 0x13, 0x62, 0x57, 0x62, 0x67, 0x13, 0x10, 0x62, 0x64, 0x62, 0x54, 0x10, 0x54, 0x62},
+    {0x01, 0x57, 0x51, 0x01, 0x67, 0x57, 0x01, 0x02, 0x67, 0x62, 0x67, 0x02, 0x04, 0x54, 0x64}, {0x67, 0x57, 0x51, 0x67, 0x51, 0x62, 0x54, 0x64, 0x51, 0x64, 0x62, 0x51},
+    {0x37, 0x45, 0x15, 0x67, 0x45, 0x37}, {0x45, 0x37, 0x67, 0x45, 0x15, 0x37, 0x10, 0x40, 0x20},
+    {0x37, 0x01, 0x31, 0x37, 0x67, 0x01, 0x67, 0x45, 0x01}, {0x40, 0x20, 0x31, 0x40, 0x31, 0x67, 0x40, 0x67, 0x45, 0x67, 0x31, 0x37},
+    {0x37, 0x45, 0x15, 0x37, 0x67, 0x45, 0x62, 0x32, 0x02}, {0x10, 0x40, 0x32, 0x32, 0x40, 0x62, 0x45, 0x15, 0x37, 0x45, 0x37, 0x67},
+    {0x02, 0x62, 0x32, 0x01, 0x31, 0x67, 0x01, 0x67, 0x45, 0x67, 0x31, 0x37}, {0x67, 0x45, 0x31, 0x67, 0x31, 0x37, 0x45, 0x40, 0x31, 0x32, 0x31, 0x62, 0x40, 0x62, 0x31},
+    {0x13, 0x45, 0x15, 0x13, 0x23, 0x45, 0x23, 0x67, 0x45}, {0x20, 0x10, 0x40, 0x13, 0x23, 0x15, 0x23, 0x45, 0x15, 0x23, 0x67, 0x45},
+    {0x01, 0x23, 0x45, 0x45, 0x23, 0x67}, {0x40, 0x20, 0x23, 0x40, 0x23, 0x45, 0x45, 0x23, 0x67},
+    {0x15, 0x67, 0x45, 0x15, 0x02, 0x67, 0x15, 0x13, 0x02, 0x62, 0x67, 0x02}, {0x40, 0x62, 0x13, 0x40, 0x13, 0x10, 0x62, 0x67, 0x13, 0x15, 0x13, 0x45, 0x67, 0x45, 0x13},
+    {0x02, 0x62, 0x67, 0x02, 0x67, 0x01, 0x01, 0x67, 0x45}, {0x67, 0x45, 0x40, 0x62, 0x67, 0x40},
+    {0x64, 0x37, 0x67, 0x64, 0x04, 0x37, 0x04, 0x15, 0x37}, {0x10, 0x64, 0x20, 0x10, 0x37, 0x64, 0x10, 0x15, 0x37, 0x67, 0x64, 0x37},
+    {0x37, 0x67, 0x64, 0x31, 0x37, 0x64, 0x31, 0x64, 0x04, 0x31, 0x04, 0x01}, {0x37, 0x67, 0x64, 0x37, 0x64, 0x31, 0x31, 0x64, 0x20},
+    {0x32, 0x02, 0x62, 0x37, 0x67, 0x04, 0x37, 0x04, 0x15, 0x04, 0x67, 0x64}, {0x32, 0x10, 0x64, 0x32, 0x64, 0x62, 0x10, 0x15, 0x64, 0x67, 0x64, 0x37, 0x15, 0x37, 0x64},
+    {0x31, 0x04, 0x01, 0x31, 0x64, 0x04, 0x31, 0x37, 0x64, 0x67, 0x64, 0x37, 0x32, 0x02, 0x62}, {0x62, 0x32, 0x31, 0x62, 0x31, 0x64, 0x37, 0x67, 0x31, 0x67, 0x64, 0x31},
+    {0x13, 0x23, 0x67, 0x13, 0x67, 0x04, 0x13, 0x04, 0x15, 0x04, 0x67, 0x64}, {0x23, 0x67, 0x15, 0x23, 0x15, 0x13, 0x67, 0x64, 0x15, 0x10, 0x15, 0x20, 0x64, 0x20, 0x15},
+    {0x64, 0x04, 0x01, 0x64, 0x01, 0x67, 0x67, 0x01, 0x23}, {0x64, 0x20, 0x23, 0x67, 0x64, 0x23},
+    {0x04, 0x15, 0x67, 0x04, 0x67, 0x64, 0x15, 0x13, 0x67, 0x62, 0x67, 0x02, 0x13, 0x02, 0x67}, {0x10, 0x15, 0x13, 0x62, 0x67, 0x64},
+    {0x64, 0x04, 0x01, 0x64, 0x01, 0x67, 0x02, 0x62, 0x01, 0x62, 0x67, 0x01}, {0x64, 0x62, 0x67},
+    {0x26, 0x57, 0x37, 0x46, 0x57, 0x26}, {0x26, 0x57, 0x37, 0x26, 0x46, 0x57, 0x40, 0x20, 0x10},
+    {0x57, 0x26, 0x46, 0x57, 0x37, 0x26, 0x31, 0x51, 0x01}, {0x37, 0x46, 0x57, 0x37, 0x26, 0x46, 0x51, 0x40, 0x31, 0x40, 0x20, 0x31},
+    {0x32, 0x57, 0x37, 0x32, 0x02, 0x57, 0x02, 0x46, 0x57}, {0x40, 0x32, 0x10, 0x40, 0x57, 0x32, 0x40, 0x46, 0x57, 0x37, 0x32, 0x57},
+    {0x51, 0x01, 0x31, 0x57, 0x37, 0x02, 0x57, 0x02, 0x46, 0x02, 0x37, 0x32}, {0x51, 0x40, 0x32, 0x51, 0x32, 0x31, 0x40, 0x46, 0x32, 0x37, 0x32, 0x57, 0x46, 0x57, 0x32},
+    {0x26, 0x13, 0x23, 0x26, 0x46, 0x13, 0x46, 0x57, 0x13}, {0x10, 0x40, 0x20, 0x13, 0x23, 0x46, 0x13, 0x46, 0x57, 0x46, 0x23, 0x26},
+    {0x51, 0x46, 0x57, 0x51, 0x23, 0x46, 0x51, 0x01, 0x23, 0x23, 0x26, 0x46}, {0x46, 0x57, 0x23, 0x46, 0x23, 0x26, 0x57, 0x51, 0x23, 0x20, 0x23, 0x40, 0x51, 0x40, 0x23},
+    {0x13, 0x02, 0x57, 0x02, 0x46, 0x57}, {0x10, 0x40, 0x46, 0x10, 0x46, 0x13, 0x13, 0x46, 0x57},
+    {0x51, 0x01, 0x02, 0x51, 0x02, 0x57, 0x57, 0x02, 0x46}, {0x51, 0x40, 0x46, 0x57, 0x51, 0x46},
+    {0x57, 0x04, 0x54, 0x57, 0x37, 0x04, 0x37, 0x26, 0x04}, {0x57, 0x10, 0x54, 0x57, 0x26, 0x10, 0x57, 0x37, 0x26, 0x26, 0x20, 0x10},
+    {0x01, 0x31, 0x51, 0x04, 0x54, 0x37, 0x04, 0x37, 0x26, 0x37, 0x54, 0x57}, {0x37, 0x26, 0x54, 0x37, 0x54, 0x57, 0x26, 0x20, 0x54, 0x51, 0x54, 0x31, 0x20, 0x31, 0x54},
+    {0x32, 0x57, 0x37, 0x02, 0x57, 0x32, 0x02, 0x54, 0x57, 0x02, 0x04, 0x54}, {0x57, 0x37, 0x32, 0x57, 0x32, 0x54, 0x54, 0x32, 0x10},
+    {0x02, 0x37, 0x32, 0x02, 0x57, 0x37, 0x02, 0x04, 0x57, 0x54, 0x57, 0x04, 0x01, 0x31, 0x51}, {0x57, 0x37, 0x32, 0x57, 0x32, 0x54, 0x31, 0x51, 0x32, 0x51, 0x54, 0x32},
+    {0x23, 0x57, 0x13, 0x23, 0x04, 0x57, 0x23, 0x26, 0x04, 0x54, 0x57, 0x04}, {0x10, 0x54, 0x26, 0x10, 0x26, 0x20, 0x54, 0x57, 0x26, 0x23, 0x26, 0x13, 0x57, 0x13, 0x26},
+    {0x01, 0x23, 0x57, 0x01, 0x57, 0x51, 0x23, 0x26, 0x57, 0x54, 0x57, 0x04, 0x26, 0x04, 0x57}, {0x51, 0x54, 0x57, 0x23, 0x26, 0x20},
+    {0x04, 0x54, 0x57, 0x04, 0x57, 0x02, 0x02, 0x57, 0x13}, {0x10, 0x54, 0x57, 0x13, 0x10, 0x57},
+    {0x04, 0x54, 0x57, 0x04, 0x57, 0x02, 0x51, 0x01, 0x57, 0x01, 0x02, 0x57}, {0x51, 0x54, 0x57},
+    {0x45, 0x26, 0x46, 0x45, 0x15, 0x26, 0x15, 0x37, 0x26}, {0x10, 0x40, 0x20, 0x45, 0x15, 0x46, 0x15, 0x26, 0x46, 0x15, 0x37, 0x26},
+    {0x31, 0x37, 0x26, 0x31, 0x26, 0x45, 0x31, 0x45, 0x01, 0x46, 0x45, 0x26}, {0x20, 0x31, 0x45, 0x20, 0x45, 0x40, 0x31, 0x37, 0x45, 0x46, 0x45, 0x26, 0x37, 0x26, 0x45},
+    {0x32, 0x15, 0x37, 0x32, 0x46, 0x15, 0x32, 0x02, 0x46, 0x46, 0x45, 0x15}, {0x15, 0x37, 0x46, 0x15, 0x46, 0x45, 0x37, 0x32, 0x46, 0x40, 0x46, 0x10, 0x32, 0x10, 0x46},
+    {0x02, 0x46, 0x37, 0x02, 0x37, 0x32, 0x46, 0x45, 0x37, 0x31, 0x37, 0x01, 0x45, 0x01, 0x37}, {0x31, 0x37, 0x32, 0x40, 0x46, 0x45},
+    {0x45, 0x26, 0x46, 0x15, 0x26, 0x45, 0x15, 0x23, 0x26, 0x15, 0x13, 0x23}, {0x15, 0x46, 0x45, 0x15, 0x26, 0x46, 0x15, 0x13, 0x26, 0x23, 0x26, 0x13, 0x10, 0x40, 0x20},
+    {0x26, 0x46, 0x45, 0x26, 0x45, 0x23, 0x23, 0x45, 0x01}, {0x26, 0x46, 0x45, 0x26, 0x45, 0x23, 0x40, 0x20, 0x45, 0x20, 0x23, 0x45},
+    {0x45, 0x15, 0x13, 0x45, 0x13, 0x46, 0x46, 0x13, 0x02}, {0x45, 0x15, 0x13, 0x45, 0x13, 0x46, 0x10, 0x40, 0x13, 0x40, 0x46, 0x13},
+    {0x45, 0x01, 0x02, 0x46, 0x45, 0x02}, {0x45, 0x40, 0x46},
+    {0x15, 0x37, 0x04, 0x37, 0x26, 0x04}, {0x20, 0x10, 0x15, 0x20, 0x15, 0x26, 0x26, 0x15, 0x37},
+    {0x01, 0x31, 0x37, 0x01, 0x37, 0x04, 0x04, 0x37, 0x26}, {0x20, 0x31, 0x37, 0x26, 0x20, 0x37},
+    {0x32, 0x02, 0x04, 0x32, 0x04, 0x37, 0x37, 0x04, 0x15}, {0x15, 0x37, 0x32, 0x10, 0x15, 0x32},
+    {0x32, 0x02, 0x04, 0x32, 0x04, 0x37, 0x01, 0x31, 0x04, 0x31, 0x37, 0x04}, {0x31, 0x37, 0x32},
+    {0x13, 0x23, 0x26, 0x13, 0x26, 0x15, 0x15, 0x26, 0x04}, {0x20, 0x10, 0x15, 0x20, 0x15, 0x26, 0x13, 0x23, 0x15, 0x23, 0x26, 0x15},
+    {0x01, 0x23, 0x26, 0x04, 0x01, 0x26}, {0x20, 0x23, 0x26},
+    {0x13, 0x02, 0x04, 0x15, 0x13, 0x04}, {0x10, 0x15, 0x13},
+    {0x01, 0x02, 0x04}, {}};
+
+// when we use pure dual mode, every voxel gets one position, and triangles in many cube configurations become degenerate (when two vertices use the same voxel)
+// this can be determined statically from the cube configuration; for now we only use this to accelerate counting, and skipping degenerate triangles during output on the fly
+static const unsigned char kTriangleCountPure[256] = {
+    0, 1, 1, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 3, 1, 2, 3, 3, 2, 3, 2, 3, 1,
+    1, 2, 2, 2, 2, 3, 3, 2, 2, 3, 2, 1, 3, 3, 2, 1, 2, 2, 2, 2, 3, 2, 3, 1, 3, 3, 2, 1, 4, 2, 2, 0,
+    1, 2, 2, 3, 2, 2, 3, 2, 2, 3, 3, 3, 2, 1, 2, 1, 2, 2, 3, 2, 2, 2, 3, 1, 3, 3, 4, 2, 2, 1, 2, 0,
+    2, 3, 3, 3, 3, 3, 4, 2, 3, 4, 3, 2, 3, 2, 2, 0, 2, 1, 2, 1, 2, 1, 2, 0, 3, 2, 2, 0, 2, 0, 0, 0,
+    1, 2, 2, 3, 2, 3, 3, 3, 2, 3, 2, 2, 2, 2, 1, 1, 2, 3, 3, 3, 3, 3, 4, 2, 3, 4, 3, 2, 3, 2, 2, 0,
+    2, 3, 2, 2, 3, 4, 3, 2, 2, 3, 2, 1, 2, 2, 1, 0, 2, 2, 1, 1, 3, 2, 2, 0, 2, 2, 1, 0, 2, 0, 0, 0,
+    2, 3, 3, 4, 2, 2, 3, 2, 2, 3, 2, 2, 2, 1, 1, 0, 2, 2, 3, 2, 1, 1, 2, 0, 2, 2, 2, 0, 1, 0, 0, 0,
+    2, 3, 2, 2, 2, 2, 2, 0, 1, 2, 1, 0, 1, 0, 0, 0, 2, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0};
+
+struct Voxel
+{
+	float px, py, pz;
+	float w;
+
+	// a00*x^2 + a11*y^2 + a22*z^2 + 2*a10*xy + 2*a20*xz + 2*a21*yz + 2*b0*x + 2*b1*y + 2*b2*z
+	float a00, a11, a22;
+	float a10, a20, a21;
+	float b0, b1, b2;
+};
+
+static void voxelAccumulate(Voxel& vox, float px, float py, float pz, float w)
+{
+	vox.px += px * w;
+	vox.py += py * w;
+	vox.pz += pz * w;
+	vox.w += w;
+}
+
+static void voxelAccumulateQ(Voxel& vox, float a, float b, float c, float d, float w)
+{
+	float aw = a * w;
+	float bw = b * w;
+	float cw = c * w;
+	float dw = d * w;
+
+	vox.a00 += a * aw;
+	vox.a11 += b * bw;
+	vox.a22 += c * cw;
+	vox.a10 += a * bw;
+	vox.a20 += a * cw;
+	vox.a21 += b * cw;
+	vox.b0 += a * dw;
+	vox.b1 += b * dw;
+	vox.b2 += c * dw;
+}
+
+static bool voxelSolve(float& rx, float& ry, float& rz, const Voxel& vox, float lambda)
+{
+	// solve A*p = -b where A is the quadric matrix and b is the linear term
+	float rw = lambda * vox.w;
+	float a00 = rw + vox.a00, a11 = rw + vox.a11, a22 = rw + vox.a22;
+	float a10 = vox.a10, a20 = vox.a20, a21 = vox.a21;
+	float x0 = lambda * vox.px - vox.b0, x1 = lambda * vox.py - vox.b1, x2 = lambda * vox.pz - vox.b2;
+
+	float eps = 1e-6f * vox.w;
+
+	// LDL decomposition: A = LDL^T
+	float d0 = a00;
+	float l10 = a10 / d0;
+	float l20 = a20 / d0;
+
+	float d1 = a11 - a10 * l10;
+	float dl21 = a21 - a20 * l10;
+	float l21 = dl21 / d1;
+
+	float d2 = a22 - a20 * l20 - dl21 * l21;
+
+	// solve L*y = x
+	float y0 = x0;
+	float y1 = x1 - l10 * y0;
+	float y2 = x2 - l20 * y0 - l21 * y1;
+
+	// solve D*z = y
+	float z0 = y0 / d0;
+	float z1 = y1 / d1;
+	float z2 = y2 / d2;
+
+	// substitute L^T*p = z
+	rz = z2;
+	ry = z1 - l21 * rz;
+	rx = z0 - l10 * ry - l20 * rz;
+
+	return fabsf(d0) > eps && fabsf(d1) > eps && fabsf(d2) > eps;
+}
+
+static float measureGrid(const float* vertex_positions_data, size_t vertex_count, size_t vertex_positions_stride, int resolution, float* out_offset)
+{
+	size_t vertex_stride_float = vertex_positions_stride / sizeof(float);
+
+	float minv[3] = {FLT_MAX, FLT_MAX, FLT_MAX};
+	float maxv[3] = {-FLT_MAX, -FLT_MAX, -FLT_MAX};
+
+	for (size_t i = 0; i < vertex_count; ++i)
+	{
+		const float* v = vertex_positions_data + i * vertex_stride_float;
+
+		for (int j = 0; j < 3; ++j)
+		{
+			float vj = v[j];
+
+			minv[j] = minv[j] > vj ? vj : minv[j];
+			maxv[j] = maxv[j] < vj ? vj : maxv[j];
+		}
+	}
+
+	float extent = 0.f;
+
+	extent = (maxv[0] - minv[0]) < extent ? extent : (maxv[0] - minv[0]);
+	extent = (maxv[1] - minv[1]) < extent ? extent : (maxv[1] - minv[1]);
+	extent = (maxv[2] - minv[2]) < extent ? extent : (maxv[2] - minv[2]);
+
+	// note: we rescale model extents to [0..resolution - 2], because the first and last voxel are used as empty padding
+	float scale = extent == 0 ? 0.f : (resolution - 2) / extent;
+
+	out_offset[0] = minv[0];
+	out_offset[1] = minv[1];
+	out_offset[2] = minv[2];
+
+	return scale;
+}
+
+static void voxelize(unsigned char* grid, Voxel* voxels, const unsigned int* voxel_rows, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, int resolution, float scale, const float offset[3], unsigned int options)
+{
+	(void)vertex_count;
+
+	size_t vertex_stride_float = vertex_positions_stride / sizeof(float);
+
+	for (size_t i = 0; i < index_count; i += 3)
+	{
+		unsigned int a = indices[i + 0], b = indices[i + 1], c = indices[i + 2];
+		assert(a < vertex_count && b < vertex_count && c < vertex_count);
+
+		const float* va = vertex_positions + a * vertex_stride_float;
+		const float* vb = vertex_positions + b * vertex_stride_float;
+		const float* vc = vertex_positions + c * vertex_stride_float;
+
+		float ex = vb[0] - va[0], ey = vb[1] - va[1], ez = vb[2] - va[2];
+		float fx = vc[0] - va[0], fy = vc[1] - va[1], fz = vc[2] - va[2];
+		float gx = vc[0] - vb[0], gy = vc[1] - vb[1], gz = vc[2] - vb[2];
+
+		// use maximum edge length to establish sampling rate
+		// TODO: this is wasteful for thin triangles
+		float el = sqrtf(ex * ex + ey * ey + ez * ez);
+		float fl = sqrtf(fx * fx + fy * fy + fz * fz);
+		float gl = sqrtf(gx * gx + gy * gy + gz * gz);
+
+		float max_edge = el > fl ? el : fl;
+		max_edge = max_edge > gl ? max_edge : gl;
+
+		// we target 2 samples per voxel edge which should be enough to hit all voxels at any rotation
+		int samples = int(max_edge * scale * 2.f);
+		samples = samples > 1 ? samples : 1;
+		samples = samples < resolution * 2 ? samples : resolution * 2;
+
+		// normal is used to compute area for weighting as well as for the quadric
+		float nx = ey * fz - ez * fy, ny = ez * fx - ex * fz, nz = ex * fy - ey * fx;
+		float area = sqrtf(nx * nx + ny * ny + nz * nz);
+
+		float ns = area == 0.f ? 0.f : 1.f / area;
+		nx *= ns;
+		ny *= ns;
+		nz *= ns;
+
+		float sx = va[0] - offset[0], sy = va[1] - offset[1], sz = va[2] - offset[2];
+		float sr = 1.f / float(samples);
+		float weight = area / float((samples + 1) * (samples + 2));
+
+		// skip degenerate triangles; they don't contribute to voxelization and may result in NaN when computing voxel centroid
+		if (weight == 0.f)
+			continue;
+
+		for (int u = 0; u <= samples; ++u)
+			for (int v = 0; v <= samples - u; ++v)
+			{
+				float su = float(u) * sr, sv = float(v) * sr;
+				float px = sx + su * ex + sv * fx;
+				float py = sy + su * ey + sv * fy;
+				float pz = sz + su * ez + sv * fz;
+
+				int x = int(px * scale);
+				int y = int(py * scale);
+				int z = int(pz * scale);
+
+				// safety: rounding errors and non-finite inputs may produce out of bounds coordinates, so we clamp them
+				int cutoff = resolution - 3;
+				x = unsigned(x) < unsigned(cutoff) ? x : cutoff;
+				y = unsigned(y) < unsigned(cutoff) ? y : cutoff;
+				z = unsigned(z) < unsigned(cutoff) ? z : cutoff;
+
+				size_t row = (y + 1) + size_t(resolution) * (z + 1);
+				size_t idx = (x + 1) + size_t(resolution) * row;
+
+				if (voxels)
+				{
+					assert(grid[idx] != 0 && grid[idx] != 0xff);
+					Voxel& vox = voxels[voxel_rows[row] + (grid[idx] - 1)];
+
+					voxelAccumulate(vox, px, py, pz, weight);
+
+					if (options & meshopt_RemeshSolve)
+					{
+						float distance = nx * px + ny * py + nz * pz;
+						voxelAccumulateQ(vox, nx, ny, nz, -distance, weight);
+					}
+				}
+				else
+				{
+					grid[idx] = 1;
+				}
+			}
+	}
+}
+
+static size_t rowpack(unsigned char* grid, unsigned int* voxel_rows, int resolution)
+{
+	size_t result = 0;
+	size_t slice = size_t(resolution) * size_t(resolution);
+
+	for (size_t i = 0; i < slice; ++i)
+	{
+		unsigned char* data = grid + i * size_t(resolution);
+
+		int count = 0;
+
+		for (int x = 0; x < resolution; ++x)
+		{
+			assert(data[x] <= 1); // voxelize only produces 0/1 values
+
+			count += data[x];
+			data[x] = (data[x] != 0) ? (unsigned char)count : 0;
+		}
+
+		assert(count < 255); // we store offsets in a single byte, with 0 reserved for empty voxels and 0xff reserved for interior voxels
+
+		voxel_rows[i] = unsigned(result);
+		result += count;
+	}
+
+	return result;
+}
+
+static void solidifyQueue(unsigned int row, unsigned int* worklist, unsigned char* queued, size_t& pending)
+{
+	if (queued[row])
+		return;
+
+	queued[row] = 1;
+	worklist[pending++] = row;
+}
+
+static void solidify(unsigned char* grid, unsigned int* worklist, unsigned char* queued, int resolution)
+{
+	size_t pending = 0;
+	memset(queued, 0, size_t(resolution) * size_t(resolution));
+
+	// mark the interior empty voxels as 'inside'; we will propagate 'empty' state from the boundary
+	for (int z = 1; z < resolution - 1; ++z)
+		for (int y = 1; y < resolution - 1; ++y)
+		{
+			unsigned char* data = grid + size_t(resolution) * (y + size_t(resolution) * z);
+
+			for (int x = 1; x < resolution - 1; ++x)
+				data[x] = (data[x] == 0) ? 0xff : data[x];
+		}
+
+	// queue all rows for processing; note that boundary rows are always empty but we need them to propagate into neighboring rows
+	for (int z = 0; z < resolution; ++z)
+		for (int y = 0; y < resolution; ++y)
+			solidifyQueue(y + size_t(resolution) * z, worklist, queued, pending);
+
+	while (pending)
+	{
+		unsigned int row = worklist[--pending];
+		assert(queued[row]);
+		queued[row] = 0;
+
+		unsigned char* data = grid + size_t(resolution) * row;
+
+		// propagate outside state to the interior within row
+		for (int x = 1; x < resolution - 1; ++x)
+			data[x] = (data[x] == 0xff && data[x - 1] == 0) ? 0 : data[x];
+
+		for (int x = resolution - 2; x >= 1; --x)
+			data[x] = (data[x] == 0xff && data[x + 1] == 0) ? 0 : data[x];
+
+		// propagate outside state to the interior into neighboring rows
+		int y = row % resolution, z = row / resolution;
+
+		for (int k = 0; k < 4; ++k)
+		{
+			int yn = y + (k == 0 ? -1 : (k == 1 ? 1 : 0));
+			int zn = z + (k == 2 ? -1 : (k == 3 ? 1 : 0));
+
+			if (yn < 1 || yn >= resolution - 1 || zn < 1 || zn >= resolution - 1)
+				continue;
+
+			unsigned char* datan = grid + size_t(resolution) * (yn + size_t(resolution) * zn);
+			unsigned char changed = 0;
+
+			for (int x = 1; x < resolution - 1; ++x)
+			{
+				unsigned char rep = (data[x] == 0 && datan[x] == 0xff) ? 0 : datan[x];
+				changed |= rep ^ datan[x];
+				datan[x] = rep;
+			}
+
+			if (changed)
+				solidifyQueue(yn + size_t(resolution) * zn, worklist, queued, pending);
+		}
+	}
+}
+
+static void solve(Voxel* voxels, size_t voxel_count, float scale, unsigned int options)
+{
+	// cutoff is a squared distance in model space; sqrt(3)/scale is the voxel diagonal
+	float factor = 2e-2f;
+	float cutoff = 3.f / (scale * scale);
+
+	size_t solved = 0;
+
+	for (size_t i = 0; i < voxel_count; ++i)
+	{
+		Voxel& vox = voxels[i];
+		float px = vox.px / vox.w, py = vox.py / vox.w, pz = vox.pz / vox.w;
+
+		if (options & meshopt_RemeshSolve)
+		{
+			// compute minimizing point; this includes regularization to stabilize the solve
+			float sx, sy, sz;
+			if (voxelSolve(sx, sy, sz, vox, factor))
+			{
+				float d = (sx - px) * (sx - px) + (sy - py) * (sy - py) + (sz - pz) * (sz - pz);
+
+				// reject solutions that move the vertex too far from voxel centroid; this is a safety net in case regularization is insufficient
+				if (d < cutoff)
+				{
+					px = sx;
+					py = sy;
+					pz = sz;
+					solved++;
+				}
+			}
+		}
+
+		vox.px = px;
+		vox.py = py;
+		vox.pz = pz;
+	}
+
+	(void)solved;
+
+#if TRACE
+	if (options & meshopt_RemeshSolve)
+		printf("remesher: solved %zu/%zu voxels\n", solved, voxel_count);
+#endif
+}
+
+static size_t emitVertex(float* destination, size_t index, int x, int y, int z, int edge, const unsigned char* grid, const Voxel* voxels, const unsigned int* voxel_rows, int resolution, float scale, const float offset[3], unsigned int options)
+{
+	int a = edge >> 4, b = edge & 0xf;
+	int ax = a & 1, ay = (a >> 1) & 1, az = (a >> 2) & 1;
+	int bx = b & 1, by = (b >> 1) & 1, bz = (b >> 2) & 1;
+
+	// our edges are directional and always go from occupied (a) to empty (b) voxel
+	assert(grid[(x + ax) + size_t(resolution) * ((y + ay) + size_t(resolution) * (z + az))] != 0);
+	assert(grid[(x + bx) + size_t(resolution) * ((y + by) + size_t(resolution) * (z + bz))] == 0);
+
+	int oc = 0;
+	float os = 0.1f / scale;
+
+	if (options & meshopt_RemeshThicken)
+	{
+		// look at the opposite voxel to see if we have a thin sheet; the lookup is in bounds by construction since a->b is occupied->empty edge
+		int ox = bx - ax, oy = by - ay, oz = bz - az;
+		unsigned char og = grid[(x + ax - ox) + size_t(resolution) * ((y + ay - oy) + size_t(resolution) * (z + az - oz))];
+
+		oc = (ox + oy + oz > 0 && og == 0) ? (ox & 1) | ((oy & 1) << 1) | ((oz & 1) << 2) : 0;
+	}
+
+	size_t row = (y + ay) + size_t(resolution) * (z + az);
+	size_t idx = (x + ax) + size_t(resolution) * row;
+
+	if (destination)
+	{
+		assert(grid[idx] != 0 && grid[idx] != 0xff);
+		const Voxel& vox = voxels[voxel_rows[row] + (grid[idx] - 1)];
+
+		if (options & meshopt_RemeshInternalDebug)
+		{
+			// -0.5 emits voxel center because grid coordinates are padded by 1, so we need to offset by -1+0.5
+			destination[index * 3 + 0] = (x + ax - 0.5f) / scale + offset[0];
+			destination[index * 3 + 1] = (y + ay - 0.5f) / scale + offset[1];
+			destination[index * 3 + 2] = (z + az - 0.5f) / scale + offset[2];
+		}
+		else
+		{
+			destination[index * 3 + 0] = vox.px + float((oc >> 0) & 1) * os + offset[0];
+			destination[index * 3 + 1] = vox.py + float((oc >> 1) & 1) * os + offset[1];
+			destination[index * 3 + 2] = vox.pz + float((oc >> 2) & 1) * os + offset[2];
+		}
+	}
+
+	return idx * 8 + oc;
+}
+
+static size_t polygonize(float* destination, size_t max_triangle_count, const unsigned char* grid, const Voxel* voxels, const unsigned int* voxel_rows, int resolution, float scale, const float offset[3], unsigned int options)
+{
+	size_t result = 0;
+	size_t slice = size_t(resolution) * size_t(resolution);
+
+	for (int z = 0; z < resolution - 1; ++z)
+		for (int y = 0; y < resolution - 1; ++y)
+		{
+			const unsigned char* data = grid + size_t(resolution) * (y + size_t(resolution) * z);
+
+			// we track each slice as a 8-bit code (matching cube indexing) as we iterate through the row to avoid extra lookups
+			int last = (data[0] == 0) | ((data[resolution] == 0) << 2) | ((data[slice] == 0) << 4) | ((data[slice + resolution] == 0) << 6);
+
+			for (int x = 0; x < resolution - 1; ++x)
+			{
+				int next = (data[x + 1] == 0) | ((data[x + 1 + resolution] == 0) << 2) | ((data[x + 1 + slice] == 0) << 4) | ((data[x + 1 + slice + resolution] == 0) << 6);
+
+				// next slice bits are in position for the next iteration so we need to shift them to retrieve current cube code
+				int cube = last | (next << 1);
+				last = next;
+
+				if (cube == 0 || cube == 0xff)
+					continue;
+
+				if (!destination && (options & meshopt_RemeshThicken) == 0)
+				{
+					// fast path: when in pure dual mode, we can statically determine the number of triangles the loop below will output based on cube configuration
+					result += kTriangleCountPure[cube];
+					continue;
+				}
+
+				const unsigned char* tris = kTriangleTable[cube];
+
+				for (int i = 0; tris[i]; i += 3)
+				{
+					int ea = tris[i + 0], eb = tris[i + 1], ec = tris[i + 2];
+
+					// note: we only emit the triangle if we have space for it, but we reject degenerate triangles purely based on vertex codes
+					// this results in consistent capacity estimation, as result advances the same way regardless of whether triangle data is written
+					float* target = (destination && result < max_triangle_count) ? destination : NULL;
+
+					size_t ca = emitVertex(target, result * 3 + 0, x, y, z, ea, grid, voxels, voxel_rows, resolution, scale, offset, options);
+					size_t cb = emitVertex(target, result * 3 + 1, x, y, z, eb, grid, voxels, voxel_rows, resolution, scale, offset, options);
+					size_t cc = emitVertex(target, result * 3 + 2, x, y, z, ec, grid, voxels, voxel_rows, resolution, scale, offset, options);
+
+					result += (ca != cb) && (cb != cc) && (cc != ca); // degenerate triangle
+				}
+			}
+		}
+
+	return result;
+}
+
+} // namespace meshopt
+
+size_t meshopt_remesh(float* destination, size_t max_triangle_count, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, int resolution, unsigned int options)
+{
+	using namespace meshopt;
+
+	assert(index_count % 3 == 0);
+	assert(vertex_positions_stride >= 12 && vertex_positions_stride <= 256);
+	assert(vertex_positions_stride % sizeof(float) == 0);
+	assert(resolution >= 4 && resolution <= 256);
+
+	meshopt_Allocator allocator;
+
+	// measure voxel grid to compute position => voxel mapping
+	float offset[3] = {};
+	float scale = measureGrid(vertex_positions, vertex_count, vertex_positions_stride, resolution, offset);
+
+	// rasterize triangles into the voxel grid: in the first pass, this simply tags occupied voxels
+	unsigned char* grid = allocator.allocate<unsigned char>(size_t(resolution) * size_t(resolution) * size_t(resolution));
+	memset(grid, 0, size_t(resolution) * size_t(resolution) * size_t(resolution));
+
+	voxelize(grid, NULL, NULL, indices, index_count, vertex_positions, vertex_count, vertex_positions_stride, resolution, scale, offset, options);
+
+	// allocate additional voxel data for each occupied voxel; this can be filled in the second pass to compute positions
+	// note that we only do this if we need to compute output triangles; counting runs skip it for performance
+	Voxel* voxels = NULL;
+	unsigned int* voxel_rows = NULL;
+	size_t voxel_count = 0;
+
+	if (destination)
+	{
+		voxel_rows = allocator.allocate<unsigned int>(size_t(resolution) * size_t(resolution));
+		voxel_count = rowpack(grid, voxel_rows, resolution);
+
+		voxels = allocator.allocate<Voxel>(voxel_count);
+		memset(voxels, 0, voxel_count * sizeof(Voxel));
+
+#if TRACE
+		printf("remesher: %zu voxels occupied\n", voxel_count);
+#endif
+	}
+
+	// fill in empty voxels that are not reachable from the grid boundary; the inside empty voxels are marked with 0xff
+	// note that these voxels do *not* have the associated Voxel data as they were never voxelized
+	if ((options & meshopt_RemeshShell) == 0)
+	{
+		unsigned int* worklist = allocator.allocate<unsigned int>(size_t(resolution) * size_t(resolution));
+		unsigned char* queued = allocator.allocate<unsigned char>(size_t(resolution) * size_t(resolution));
+
+		solidify(grid, worklist, queued, resolution);
+
+#if TRACE
+		size_t inside_count = 0, occupied_count = 0;
+		for (size_t i = 0; i < size_t(resolution) * size_t(resolution) * size_t(resolution); ++i)
+		{
+			inside_count += (grid[i] == 0xff);
+			occupied_count += (grid[i] != 0 && grid[i] != 0xff);
+		}
+
+		printf("remesher: %zu voxels occupied, %zu voxels inside\n", occupied_count, inside_count);
+#endif
+	}
+
+	// accumulate voxel positions: in the second pass, this computes enough data in each voxel to calculate positions
+	if (voxels)
+		voxelize(grid, voxels, voxel_rows, indices, index_count, vertex_positions, vertex_count, vertex_positions_stride, resolution, scale, offset, options);
+
+	// compute final voxel positions; each voxel has a single resulting position that may be adjusted during polygonization
+	if (voxels)
+		solve(voxels, voxel_count, scale, options);
+
+	// output triangles from the voxel grid; if destination is NULL, this still counts the number of triangles that would be generated
+	size_t result = polygonize(destination, max_triangle_count, grid, voxels, voxel_rows, resolution, scale, offset, options);
+
+#if TRACE
+	printf("remesher: %zu triangles (%zu capacity)\n", result, max_triangle_count);
+#endif
+
+	return result;
+}