In case Flash no longer exists; a copy of this site is included in the Flashpoint archive's "ultimate" collection.

Dead Code Preservation :: Archived AS3 works from wonderfl.net

Bunker

Hide from pesky zombies in the bunker :)
Use arrows or wasd if your browser srolls the page.

Most of assets come from original bunker demo (great art, but unfortunately the example of how not to texture levels)
See http://wiki.alternativaplatform.com/Demo_Bunker

The character is from alternativa3d "demo" example
See http://github.com/AlternativaPlatform/Alternativa3DExamples/tree/master/src/demoexample

The corpse and the box are by W. Sitters
See http://www.md2.sitters-electronics.nl/models.html

Submachine guns by Elias Tsiantas
See http://telias.free.fr/Guns.html

Microscope by Iwan Gabovitch
See http://opengameart.org/content/microscope-blend-low-poly

Zombie sounds by Cyberkineticfilms
See http://freesound.org/people/Cyberkineticfilms/
Get Adobe Flash player
by makc3d 03 Jan 2013
    Embed
//
// Hide from pesky zombies in the bunker :)
// Use arrows or wasd if your browser srolls the page.
//
// Most of assets come from original bunker demo (great art, but unfortunately the example of how not to texture levels)
// See http://wiki.alternativaplatform.com/Demo_Bunker
//
// The character is from alternativa3d "demo" example
// See http://github.com/AlternativaPlatform/Alternativa3DExamples/tree/master/src/demoexample
//
// The corpse and the box are by W. Sitters
// See http://www.md2.sitters-electronics.nl/models.html
//
// Submachine guns by Elias Tsiantas
// See http://telias.free.fr/Guns.html
//
// Microscope by Iwan Gabovitch
// See http://opengameart.org/content/microscope-blend-low-poly
//
// Zombie sounds by Cyberkineticfilms
// See http://freesound.org/people/Cyberkineticfilms/
//
package {
	import alternativa.engine3d.animation.*;
	import alternativa.engine3d.collisions.EllipsoidCollider;
	import alternativa.engine3d.core.*;
	import alternativa.engine3d.lights.AmbientLight;
	import alternativa.engine3d.lights.DirectionalLight;
	import alternativa.engine3d.loaders.Parser3DS;
	import alternativa.engine3d.loaders.ParserCollada;
	import alternativa.engine3d.objects.*;
	import flash.display.*;
	import flash.events.Event;
	import flash.events.KeyboardEvent;
	import flash.geom.*;
	import flash.media.Sound;
	import flash.net.*;
	import flash.utils.*;
	
	[SWF(width=465,height=465)]
	public class Bunker extends Sprite {
		
		public var camera:Camera3D;
		public var stage3D:Stage3D;
		public var bunker:LoadUtil;
		
		private var zips:Array = [
			"http://assets.wonderfl.net/images/related_images/f/fc/fc10/fc1049583cec9b836ed25a4288f6d581884104d0",//"01.gif",
			"http://assets.wonderfl.net/images/related_images/d/df/dfd8/dfd8cd039f24c03b41ed9fbc079101e01078ff2b",//"02.gif",
			"http://assets.wonderfl.net/images/related_images/1/1a/1a6e/1a6e7ef46b83cb9125ccfd624b9638aee4853ee3",//"03.gif",
			"http://assets.wonderfl.net/images/related_images/9/99/99c2/99c22ac5e14baeae8f8b02efc2712d3bdd0c4b7e",//"04.gif",
			"http://assets.wonderfl.net/images/related_images/c/c0/c085/c0854f24aada0188de43f05cdb56483253f19631",//"05.gif",
			"http://assets.wonderfl.net/images/related_images/5/59/593d/593dbfe37a345edc4d9f75c947805ab5c88774d9",//"06.gif",
			"http://assets.wonderfl.net/images/related_images/e/e8/e8f9/e8f90c169180a7b2dd7981b880c7dd77d4ca8a70",//"07.gif",
			"http://assets.wonderfl.net/images/related_images/9/96/96ff/96ff91d47a6d8ee4628cce97b22a461fb13aab0b",//"08.gif",
			"http://assets.wonderfl.net/images/related_images/a/af/afff/afffce04f0826de1c51d1deeec251e9c1efe1498",//"09.gif",
			"http://assets.wonderfl.net/images/related_images/0/0b/0b63/0b63bcd0a8a9a0f6f2ac830e6fde4f67985613d0",//"10.gif",
			"http://assets.wonderfl.net/images/related_images/e/e2/e263/e26325b717734a319233745d5f70af514e33efab" //"11.gif"
		];
		
		public function Bunker () {
			stage.align = "TL";
			stage.scaleMode = "noScale";
			addEventListener (Event.ENTER_FRAME, preloader);
			loadNextZip ();
		}
		
		private function loadNextZip (...fu):void {
			if (zips.length < 1) {
				init ();
			} else {
				var loader:URLLoader = new URLLoader;
				loader.dataFormat = "binary";
				loader.addEventListener (Event.COMPLETE, onZipLoaded);
				loader.load (new URLRequest (zips.shift ()));
			}
		}
		
		private function onZipLoaded (e:Event):void {
			var offset:int = 5930;
			var bytes:ByteArray = new ByteArray;
			bytes.writeBytes (e.target.data, offset, e.target.data.length - offset);
			bytes.position = 0;
			FileUtil.AddZip (bytes);
			loadNextZip ();
		}
		
		private var preloaderCountdown:int = -1;
		
		private function preloader (...fu):void {
			graphics.clear ();
			if (preloaderCountdown > 0) {
				preloaderCountdown--;
			} else if (preloaderCountdown == 0) {
				removeEventListener (Event.ENTER_FRAME, preloader);
				return;
			}
			// todo: bytesLoaded and shit
			PreloaderGraphics.draw (graphics, 1 - zips.length / 12, 232, 400, 300);
		}
		
		private var keys:Object = { }, walking:uint = 0;
		
		private function onKeyDown (e:KeyboardEvent):void {
			keys [e.keyCode] = true;
			if ((e.keyCode == 38) || (e.keyCode == 87)) {
				if (walking == 0) {
					walking = setInterval (playRandomStepSound, 500);
					playRandomStepSound ();
					animationSwitcher.activate (run, 0.1);
				}
			}
		}
		
		private function onKeyUp (e:KeyboardEvent):void {
			keys [e.keyCode] = false;
			if ((e.keyCode == 38) || (e.keyCode == 87)) {
				clearInterval (walking); walking = 0;
				animationSwitcher.activate (idle, 0.1);
			}
			
			if (e.keyCode == 32) {
				trace ("add" + new Vector3D (char.x, char.y, char.z + collider.radiusZ));
			}
		}
		
		private var steps:Vector.<Sound>;
		
		private function playRandomStepSound ():void {
			if (steps) {
				steps [int (steps.length * Math.random ()) % steps.length].play ();
			}
		}
		
		private function onResize (e:Event):void {
			camera.view.width = stage.stageWidth;
			camera.view.height = stage.stageHeight;
		}
		
		private var characterCoords:Vector3D = new Vector3D, lastCharacterCoords:Vector3D = new Vector3D,
			collisionPoint:Vector3D = new Vector3D,
			collisionPlane:Vector3D = new Vector3D,
			displacement:Vector3D = new Vector3D,
			gravity:Vector3D = new Vector3D (0, 0, -6);
		
		private function onFrame (e:Event):void {
			// upload new resources
			for each (var resource:Resource in char.parent.getResources (true)) {
				if (!resource.isUploaded) {
					resource.upload (stage3D.context3D);
				}
			}
			
			// calculate displacement
			displacement.setTo (0, 0, 0);
			if (keys [37] || keys [65]) { char.rotationZ += 0.07; camera.parent.rotationZ -= 0.07; } else
			if (keys [39] || keys [68]) { char.rotationZ -= 0.07; camera.parent.rotationZ += 0.07; }
			
			if (keys [38] || keys [87]) {
				displacement.x = -5 * Math.sin (char.rotationZ);
				displacement.y = +5 * Math.cos (char.rotationZ);
			}
			
			// collision handling needs improvement, somebody
			var feetAt:Number = 0;
			characterCoords.setTo (char.x, char.y, char.z + collider.radiusZ);
			collisionPoint.setTo (0, 0, 0); collisionPlane.setTo (0, 0, 0);
			var onGround:Boolean = collider.getCollision(characterCoords, gravity, collisionPoint, collisionPlane, bunker.parent, excluded);
			if (onGround) {
				if (collisionPlane.z < 0.8) {
					// do not climb walls, please
					displacement.copyFrom (collisionPlane);
					displacement.scaleBy (9);
				} else {
					// still go towards the ground, but don't slide down the slope
					collisionPoint.decrementBy (characterCoords);
					displacement.incrementBy (collisionPoint);
					
					// hack: extra height to character feet so they do not get buried in slopes
					// real deal would be something like runevision for unity
					feetAt = 25 * (1 - collisionPlane.z);
				}
			} else {
				// increment should grow with time to act like real
				// gravity but we have no jumps so can ignore that
				displacement.incrementBy (gravity);
			}
			var destination:Vector3D = collider.calculateDestination(characterCoords, displacement, bunker.parent, excluded);
			char.x = destination.x;
			char.y = destination.y;
			char.z = destination.z - collider.radiusZ;
			
			var scaler:Object3D = char.getChildAt (0); scaler.z = 0.8 * scaler.z + 0.2 * feetAt;
			
			if (keys [40] || keys [83]) {
				camera.parent.rotationX *= 0.3;
				camera.parent.rotationX += 0.4 * 0.4 * Math.PI;
			}
			
			// Setting sound properties
			// The right ear's normal is used to calculate sound panning
			var normal:Point3D = new Point3D(Math.cos(char.rotationZ), Math.sin(char.rotationZ), 0);
			var cameraCoords:Point3D = new Point3D (char.x, char.y, char.z);
			entranceAmbient.checkVolume(cameraCoords, normal);
			bunkerAmbient.checkVolume(cameraCoords, normal);
			reactorAmbient.checkVolume(cameraCoords, normal);
			zombiesAmbient.checkVolume(cameraCoords, normal);
			ventilatorSound1.checkVolume(cameraCoords, normal);
			ventilatorSound2.checkVolume(cameraCoords, normal);
			ventilatorSound3.checkVolume(cameraCoords, normal);
			
			// Rotation of the lightning plane to the camera
			if (energy) {
				energy.redraw ();
				energy.rotationZ = -Math.atan2(energy.x - cameraCoords.x, energy.y - cameraCoords.y);
			}
			
			// lighting the character
			var lx:Number = char.x * 0.25 + 350;
			var ly:Number = char.y * 0.1  + 230;
			var lv:Vector3D = sampleLightmap (lx, ly);
			light.color = lv.x * 0x10000 + lv.y * 0x100 + lv.z;
			
			animationController.update ();
			
			camera.render (stage3D);
			
			// put camera back behind the character
			camera.parent.rotationX *= 0.8;
			camera.parent.rotationZ *= 0.9;
			
//			// log the route
//			if (characterCoords.subtract (lastCharacterCoords).length > 100) {
//				lastCharacterCoords.copyFrom (characterCoords); trace ("add" + characterCoords);
//			}
		}
		
		private function init ():void {
			var loader:Loader = new Loader;
			loader.contentLoaderInfo.addEventListener (Event.COMPLETE, onLightmapLoaded);
			loader.loadBytes (FileUtil.GetFile ("lightmap.png"));
		}
		
		private var light:AmbientLight;
		private var lightmap:BitmapData;
		
		private var lightmapResult:Vector3D = new Vector3D;
		private function sampleLightmap (lx:Number, ly:Number):Vector3D {
			// nearest, todo linear
			var c:uint = lightmap.getPixel (lx, ly);
			lightmapResult.x = (c & 0xFF0000) >> 16;
			lightmapResult.y = (c & 0xFF00) >> 8;
			lightmapResult.z = (c & 0xFF);
			return lightmapResult;
		}
		
		private function onLightmapLoaded (e:Event):void {
			var info:LoaderInfo = e.target as LoaderInfo;
			info.removeEventListener (Event.COMPLETE, onLightmapLoaded);
			
			lightmap = info.content["bitmapData"];
			
			stage.addEventListener (Event.RESIZE, onResize);
			stage3D = stage.stage3Ds [0];
			stage3D.addEventListener (Event.CONTEXT3D_CREATE, onContext);
			camera = new Camera3D (1, 2300);
			addChild (camera.view = new View (1, 1));
			camera.view.hideLogo (/* sorry, too distracting */);
			onResize (null);
			bunker = new LoadUtil (new Object3D);
			entranceAmbient = new Sound3D(new Point3D(362, -1945, 0), 370, 690, 50/5, "entrance.mp3", "Loading entrance ambient",3);
			bunkerAmbient = new Sound3D(new Point3D(0, -315, 0), 770, 1270, 50/5, "bunker.mp3", "Loading bunker ambient", 3);
			reactorAmbient = new Sound3D(new Point3D(0, 2323, -250), 607, 1615, 50/2, "reactor.mp3", "Loading reactor ambient", 1);
			zombiesAmbient = new Sound3D(new Point3D(362, -2300, 0), 100, 200, 5, "zombies.mp3", "These are going to moan behind the door", 1);
			ventilatorSound1 = new Sound3D(new Point3D(472, 2322, -470), 150, 650, 10, "ventilator.mp3", "Loading ventilator sound", 3);
			ventilatorSound2 = new Sound3D(new Point3D(-472, 2322, -470), 150, 650, 10, "ventilator.mp3", "Loading ventilator sound", 3);
			ventilatorSound3 = new Sound3D(new Point3D(0, 2795, -470), 150, 650, 10, "ventilator.mp3", "Loading ventilator sound", 3);
			steps = new Vector.<Sound> ();
			for (var i:int = 1; i < 4; i++) {
				var ba:ByteArray = FileUtil.GetFile ("step" + i + ".mp3"); ba.position = 0;
				steps[i - 1] = new Sound ();
				steps[i - 1].loadCompressedDataFromByteArray (ba, ba.length);
			}
			light = new AmbientLight (0); light.intensity = 1.5; bunker.parent.addChild (light);
			stage3D.requestContext3D ();
			stage.addEventListener (KeyboardEvent.KEY_DOWN, onKeyDown);
			stage.addEventListener (KeyboardEvent.KEY_UP, onKeyUp);
		}
		
		private var dae:ParserCollada;
		private var char:Object3D;
		private var excluded:Dictionary;
		private var collider:EllipsoidCollider = new EllipsoidCollider (25, 25, 45);
		private var animationController:AnimationController = new AnimationController;
		private var animationSwitcher:AnimationSwitcher = new AnimationSwitcher;
		private var run:AnimationClip, idle:AnimationClip;
		private var energy:Energy;
		private var entranceAmbient:Sound3D;
		private var bunkerAmbient:Sound3D;
		private var reactorAmbient:Sound3D;
		private var zombiesAmbient:Sound3D;
		private var ventilatorSound1:Sound3D;
		private var ventilatorSound2:Sound3D;
		private var ventilatorSound3:Sound3D;
		
		private function onContext (e:Event):void {
			dae = new ParserCollada;
			dae.parse (XML (FileUtil.GetFile ("character.dae")));
			
			var skin:Skin = dae.getObjectByName ("character") as Skin;
			bunker.addMesh (skin, "character.jxr", null, false);
			bunker.parent.removeChild (skin);
			
			// set up a kind of 3rd person view
			char = new Object3D;
			var scaler:Object3D = new Object3D;
			scaler.rotationZ = Math.PI;
			scaler.scaleX = scaler.scaleY = scaler.scaleZ = 0.5;
			char.addChild (scaler); scaler.addChild (skin);
			var mount:Object3D = new Object3D;
			char.addChild (mount); mount.addChild (camera);
			bunker.parent.addChild (char);
			char.x = 362; char.y = -1800; char.z = 1;
			camera.rotationX = -0.6 * Math.PI;
			camera.y = -90; camera.z = 90;
			
			excluded = new Dictionary (true);
			excluded [char] = true;
			
			// animation
			var animation:AnimationClip = dae.getAnimationByObject (skin);
			idle = animation.slice (0, 40/30); run = animation.slice (41/30, 61/30);
			animationSwitcher.addAnimation (idle);
			animationSwitcher.addAnimation (run);
			animationSwitcher.activate (idle, 0.1);
			animationSwitcher.speed = 0.7;
			animationController.root = animationSwitcher;
			
			// entrance room
			bunker.addMesh (new Entrance, "entrance.jxr", null, false);
			bunker.addColoredMesh (new EntranceWindows, 0xFFFFFF);
			bunker.addColoredMesh (new ScreenLight, 0xFFE7AF);
			bunker.addMesh (new Screen, "table.jxr", null, false);
			
			// add the touch of zombocalypse :)
			var microscope:Mesh = add3dsMesh ("microscope.3ds", 2.7, "microscope.jxr");
			microscope.x = 410; microscope.y = -1980; microscope.z = 27; microscope.rotationZ = 4;
			excluded [microscope] = true;
			
			var corpse:Mesh = add3dsMesh ("hang2.3ds", 24, "hang2.jxr");
			corpse.x = 360; corpse.y = -2035; corpse.z = 27; corpse.rotationX = -1.57; corpse.rotationZ = -4.5;
			excluded [corpse] = true;
			
			var gun1:Mesh = add3dsMesh ("hk53_n.3ds", 1, "hk53_n.jxr");
			gun1.x = 350; gun1.y = -1933; gun1.z = 32; gun1.rotationX = 0.3; gun1.rotationY = -1.1;
			excluded [gun1] = true;
			
			var gun2:Mesh = add3dsMesh ("hk53_n.3ds", 1, "hk53_n.jxr?2");
			gun2.x = 340; gun2.y = -1955; gun2.z = 30; gun2.rotationY = -1.57; gun2.rotationZ = -0.5;
			excluded [gun2] = true;
			
			var box1:Mesh = add3dsMesh ("box1.3ds", 0.3, "box1.jxr");
			box1.x = 660; box1.y = -1900; box1.rotationZ = -0.3;
			
			var box2:Mesh = add3dsMesh ("box1.3ds", 0.3, "box1.jxr?2");
			box2.x = box1.x; box2.y = box1.y; box2.z = box1.z + box1.boundBox.maxZ; box2.rotationZ = -0.1;
			excluded [box2] = true;
			
			var box3:Mesh = add3dsMesh ("box1.3ds", 0.3, "box1.jxr?3");
			box3.x = 675; box3.y = -1960; box3.rotationZ = 0.5;
			
			bunker.addMesh (new Passage, "passage.jxr", null, false);
			
			// give it some time to load entrance textures
			setTimeout (addEventListener, 1000, Event.ENTER_FRAME, onFrame);
			
			// delay the rest
			setTimeout (onContext2, 1500);
		}
		
		private function onContext2 ():void {
			bunker.addMesh (new BunkerMesh, "bunker.jxr");
			bunker.addColoredMesh (new BunkerWindows, 0xFFFFFF);
			bunker.addMesh (new Grid, "grid.jpg", "gridalpha.gif");
			
			setTimeout (onContext3, 1500);
		}
		
		private function onContext3 ():void {
			bunker.addMesh (new Slope, "slope.jxr");
			bunker.addColoredMesh (new ReactorLight, 0xFFFFFF);
			bunker.addMultitexturedMesh (new Reactor, [
				"reactorbottom1.jxr", "reactorbottom2.jxr",
				"reactortop1.jxr", "reactortop2.jxr"
			]);
			bunker.addColoredMesh (new Core, 0x1DFF1D, 0.25, true);

			bunker.addMesh (new Ventilation, "ventilation.jxr", "ventilationalpha.jxr");
			
			setTimeout (onContext4, 1500);
		}
		
		private function onContext4 ():void {
			preloaderCountdown = 60;
			
			for (var i:int = 0; i < 3; i++) bunker.addMesh (new Ventilators (i), "ventilator.jpg?" + i);
			
			bunker.parent.addChild (energy = new Energy);
		}
		
		private function add3dsMesh (model:String, scale:Number, texture:String):Mesh {
			var parser:Parser3DS = new Parser3DS;
			parser.parse (FileUtil.GetFile (model), "", scale);
			var mesh:Mesh = parser.objects [0] as Mesh;
			bunker.addMesh (mesh, texture, null, false);
			return mesh;
		}
	}
}

import alternativa.engine3d.primitives.GeoSphere;
import flash.utils.*;
import nochump.util.zip.*;
class FileUtil {
    public static var Zips:Dictionary = new Dictionary;
    public static function AddZip (data:ByteArray):void {
        var zip:ZipFile = new ZipFile (data);
        for (var i:int = 0; i < zip.entries.length; i++) {
            var entry:ZipEntry = zip.entries [i];
            var finfo:FileInfo = new FileInfo;
            finfo.zip = zip;
            finfo.entry = entry;
            Zips [entry.name] = finfo;
        }
    }
    public static function GetFile (name:String):ByteArray {
		name = name.split ("?") [0];
        var finfo:FileInfo = FileInfo (Zips [name]);
        if (finfo == null) return null;
        return finfo.zip.getInput (finfo.entry);
    }
}

import nochump.util.zip.*;
class FileInfo {
    public var zip:ZipFile;
    public var entry:ZipEntry;
}

import flash.display.Loader;
import flash.events.Event;
import flash.system.*;
import flash.utils.setTimeout;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.materials.*;
import alternativa.engine3d.objects.*;
import alternativa.engine3d.resources.BitmapTextureResource;
/** This is dirty way to get things done quickly - do not copy */
class LoadUtil {
	public var parent:Object3D;
	public var context:LoaderContext;
	public function LoadUtil (parent:Object3D) {
		this.parent = parent;
		this.context = new LoaderContext;
		this.context.imageDecodingPolicy = ImageDecodingPolicy.ON_LOAD;
	}
	
	private var meshes:Object = { }, opacities:Object = { }, surfaces:Object = { };
	private var textures:Dictionary = new Dictionary ( );
	
	public function addColoredMesh (mesh:Mesh, color:uint, alpha:Number = 1, blendAdd:Boolean = false):void {
		parent.addChild (mesh);
		mesh.setMaterialToAllSurfaces (new FillMaterial2 (color, alpha, blendAdd));
	}
	
	public function addMultitexturedMesh (mesh:Mesh, textureNames:Array):void {
		for (var i:int = 0; i < textureNames.length; i++) {
			var texture:String = textureNames [i];
			surfaces [texture] = i;
			addMesh (mesh, texture);
		}
	}
	
	public function addMesh (mesh:Mesh, texture:String, opacity:String = null, delay:Boolean = true):void {
		
		if (mesh.parent == null) {
			parent.addChild (mesh);
		}
		
		meshes [texture] = mesh;
		opacities [texture] = opacity;
		
		var loader:Loader = new Loader;
		textures [loader.contentLoaderInfo] = texture;
		loader.contentLoaderInfo.addEventListener (Event.COMPLETE, (texture == "character.jxr") ? onTextureLoadedSpecial : onTextureLoaded);
		loader.loadBytes (FileUtil.GetFile (texture), delay ? context : null);
	}
	
	private function onTextureLoadedSpecial (e:Event):void {
		e.target.removeEventListener (Event.COMPLETE, onTextureLoaded);
		
		var texture:String = textures [e.target];
		
		var mesh:Mesh = meshes [texture];
		
		var material:StandardMaterial = new StandardMaterial (
			new BitmapTextureResource (e.target.content.bitmapData),
			new BitmapTextureResource (new BitmapData (1, 1, false, 0x7F7FFF))
		);
		
//		var wires:WireFrame = WireFrame.createNormals (mesh, 0x00ff00, 1, 1, 10);
//		mesh.parent.addChild (wires);
//var s:GeoSphere = new GeoSphere (40, 6, false, material);
//mesh.parent.addChild (s);
		
		mesh.setMaterialToAllSurfaces (material);
	}
	
	private function onTextureLoaded (e:Event):void {
		e.target.removeEventListener (Event.COMPLETE, onTextureLoaded);
		
		var texture:String = textures [e.target];
		
		var mesh:Mesh = meshes [texture];
		
		var material:TextureMaterial2 = new TextureMaterial2 (
			new BitmapTextureResource2 (e.target.content.bitmapData)
		);
		
		if (surfaces [texture] !== undefined) {
			mesh.getSurface (surfaces [texture]).material = material;
		} else {
			mesh.setMaterialToAllSurfaces (material);
		}
		
		if (opacities [texture]) {
			var loader:Loader = new Loader;
			textures [loader.contentLoaderInfo] = texture;
			loader.contentLoaderInfo.addEventListener (Event.COMPLETE, onOpacityLoaded);
			loader.loadBytes (FileUtil.GetFile (opacities [texture]), context);
		}
	}
	
	private function onOpacityLoaded(e:Event):void {
		e.target.removeEventListener (Event.COMPLETE, onOpacityLoaded);
		
		var texture:String = textures [e.target];
		
		var mesh:Mesh = meshes [texture];
		// this assumes semi-transparent objects have 1 surface
		var material:TextureMaterial2 = mesh.getSurface (0).material as TextureMaterial2;
		if (material != null) {
			material.opacityMap = new BitmapTextureResource2 (e.target.content.bitmapData, true);
			material.alphaThreshold = 0.5;
		}
	}
}


import flash.display.BitmapData;
import flash.display.Graphics;
import flash.geom.Matrix;
import flash.utils.getTimer;
class PreloaderGraphics {
	private static const m:Matrix = new Matrix;
	private static const bd:BitmapData = new BitmapData (2, 2, false, 0xFFFFFF); {
		bd.setPixel (0, 0, 0); bd.setPixel (1, 1, 0);
	}
	public static function draw (g:Graphics, p:Number, x:int, y:int, w:int):void {
		var x0:int = x - w / 2, y0:int = y - 4;
		g.beginFill (0);
		g.drawRect (x0, y0, w, 8);
		g.beginFill (0xFFFFFF);
		g.drawRect (x0 + 1, y0 + 1, w - 2, 6);
		g.beginFill (0);
		g.drawRect (x0 + 2, y0 + 2, int ((w - 4) * p), 4);
		g.endFill ();
		
		g.beginFill (0);
		g.drawCircle (x, y, 11);
		
		g.beginFill (0xFFFFFF);
		g.drawCircle (x, y, 9);
		
		m.identity ();
		m.translate ( -1, -1);
		m.rotate (getTimer () * 0.005);
		m.translate (x, y);
		
		g.beginBitmapFill (bd, m, false);
		g.drawCircle (x, y, 8);
		
		g.beginFill (0xFFFFFF);
		g.drawCircle (x, y, 3);
		
		g.beginFill (0);
		g.drawCircle (x, y, 2);
	}
}


// standard alternativa bitmap resource has convolution filter
// with large images like bunker textures it is CPU killer, so
// we clone it here, but without the filter

import alternativa.engine3d.resources.TextureResource;
	import alternativa.engine3d.alternativa3d;

	import flash.display.BitmapData;
	import flash.display3D.Context3D;
	import flash.display3D.Context3DTextureFormat;
	import flash.display3D.textures.Texture;
	import flash.geom.Matrix;
	import flash.geom.Point;
	import flash.geom.Rectangle;

	use namespace alternativa3d;
	
	/**
	 * Texture resource, that allows user to upload textures from <code>BitmapData</code> to GPU.
	 * Size of texture must be power of two (e.g., 256х256, 128*512, 256* 32).
	 * @see alternativa.engine3d.resources.TextureResource
	 * @see alternativa.engine3d.resources.ATFTextureResource
	 * @see alternativa.engine3d.resources.ExternalTextureResource
	 */
	class BitmapTextureResource2 extends TextureResource {

		static private const rect:Rectangle = new Rectangle();
		static private const matrix:Matrix = new Matrix(0.5, 0, 0, 0.5);
		static private const resizeMatrix:Matrix = new Matrix(1, 0, 0, 1);
		static private const point:Point = new Point();
		/**
		 * BitmapData
		 */
		public var data:BitmapData;

		public var resizeForGPU:Boolean = false;

        /**
         * Uploads textures from <code>BitmapData</code> to GPU.
         */
		public function BitmapTextureResource2(data:BitmapData, resizeForGPU:Boolean = false) {
			this.data = data;
			this.resizeForGPU = resizeForGPU;
		}

		/**
		 * @inheritDoc 
		 */
		override public function upload(context3D:Context3D):void {
			if (_texture != null) _texture.dispose();
			if (data != null) {
				var source:BitmapData = data;
				if (resizeForGPU) {
					var wLog2Num:Number = Math.log(data.width)/Math.LN2;
					var hLog2Num:Number = Math.log(data.height)/Math.LN2;
					var wLog2:int = Math.ceil(wLog2Num);
					var hLog2:int = Math.ceil(hLog2Num);
					if (wLog2 != wLog2Num || hLog2 != hLog2Num || wLog2 > 11 || hLog2 > 11) {
						// Resize bitmap
						wLog2 = (wLog2 > 11) ? 11 : wLog2;
						hLog2 = (hLog2 > 11) ? 11 : hLog2;
						source = new BitmapData(1 << wLog2, 1 << hLog2, data.transparent, 0x0);
						resizeMatrix.a = (1 << wLog2)/data.width;
						resizeMatrix.d = (1 << hLog2)/data.height;
						source.draw(data, resizeMatrix, null, null, null, true);
					}
				}
				_texture = context3D.createTexture(source.width, source.height, Context3DTextureFormat.BGRA, false);
				Texture(_texture).uploadFromBitmapData(source, 0);
				var level:int = 1;
				var bmp:BitmapData = new BitmapData(source.width, source.height, source.transparent, 0);
				var current:BitmapData = source;
				rect.width = source.width;
				rect.height = source.height;
				while (rect.width % 2 == 0 || rect.height % 2 == 0) {
					bmp.copyPixels (current, rect, point);
					rect.width >>= 1;
					rect.height >>= 1;
					if (rect.width == 0) rect.width = 1;
					if (rect.height == 0) rect.height = 1;
					if (current != source) current.dispose();
					current = new BitmapData(rect.width, rect.height, source.transparent, 0);
					current.draw(bmp, matrix, null, null, null, true);
					Texture(_texture).uploadFromBitmapData(current, level++);
				}
				if (current != source) current.dispose();
				bmp.dispose();
			} else {
				_texture = null;
				throw new Error("Cannot upload without data");
			}
		}
		
		public var mip1:BitmapData, mip1rect:Rectangle, mip1matrix:Matrix;
		
		/** mip level 0 and 1 for animated texture in the reactor */
		public function reupload ():void {
			if ((_texture != null) && (data != null)) {
				Texture(_texture).uploadFromBitmapData(data, 0);
				if (mip1 == null) {
					mip1 = new BitmapData (data.width / 2, data.height / 2, data.transparent, 0);
					mip1rect = mip1.rect;
					mip1matrix = new Matrix (0.5, 0, 0, 0.5);
				}
				mip1.fillRect (mip1rect, 0);
				mip1.draw (data, mip1matrix, null, null, null, true);
				Texture(_texture).uploadFromBitmapData(mip1, 1);
			}
		}
	}

// using private classes for resources breaks poor code in TextureMaterial

import alternativa.engine3d.materials.*;
class TextureMaterial2 extends TextureMaterial {
	public function TextureMaterial2 (diffuseMap:TextureResource = null, opacityMap:TextureResource = null) {
		super (diffuseMap, opacityMap, 1);
	}
	override alternativa3d function fillResources (resources:Dictionary, resourceType:Class):void {
		// hopefully this is not polled for geometry - we will not check resourceType
		if (diffuseMap != null) resources[diffuseMap] = true;
		if (opacityMap != null) resources[opacityMap] = true;
	}
}

// while at that, let's extend fill material to support "add" blendmode

import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.core.Light3D;
import alternativa.engine3d.core.Renderer;
import alternativa.engine3d.objects.Surface;
import alternativa.engine3d.resources.Geometry;
import flash.display3D.Context3DBlendFactor;
class FillMaterial2 extends FillMaterial {
	public var blendModeAdd:Boolean = false;
	public function FillMaterial2 (color:uint = 0x7F7F7F, alpha:Number = 1, blendModeAdd:Boolean = false) {
		super (color, alpha); this.blendModeAdd = blendModeAdd;
	}
	override alternativa3d function collectDraws(camera:Camera3D, surface:Surface, geometry:Geometry, lights:Vector.<Light3D>, lightsLength:int, useShadow:Boolean, objectRenderPriority:int = -1):void {
		super.collectDraws (camera, surface, geometry, lights, lightsLength, useShadow, objectRenderPriority);
		if (blendModeAdd) {
			var priority:int = (objectRenderPriority >= 0) ? objectRenderPriority : ((alpha < 1) ? Renderer.TRANSPARENT_SORT : Renderer.OPAQUE);
			camera.renderer.drawUnits [priority].blendSource = Context3DBlendFactor.SOURCE_ALPHA;
			camera.renderer.drawUnits [priority].blendDestination = Context3DBlendFactor.ONE;
		}
	}
}


// then, we need to replicate some of v5 api to use bunker models

class Point3D {
	public var x:Number, y:Number, z:Number;
	public function Point3D (x:Number = 0, y:Number = 0, z:Number = 0) {
		this.x = x; this.y = y; this.z = z;
	}
}

import flash.geom.*;
import alternativa.engine3d.core.VertexAttributes;
import alternativa.engine3d.objects.Mesh;
import alternativa.engine3d.resources.Geometry;
class Mesh5 extends Mesh {
	private var vertices:Object = { };
	private var faces:Object = { };
	private var surfaces:Array = [ ];
	
	protected function set coords (p:Point3D):void {
		x = p.x; y = p.y; z = p.z;
	}
	
	protected function createVertex (x:Number, y:Number, z:Number, id:*):Vector3D {
		return (vertices [id] = new Vector3D (x, y, z));
	}
	
	protected function createFace (vertexIds:Array, id:*):void {
		faces [id] = vertexIds;
	}
	
	protected function setUVsToFace (aUV:Point, bUV:Point, cUV:Point, id:*):void {
		var face:Array = faces [id];
		var v1:Vector3D = vertices [face [0]];
		var v2:Vector3D = vertices [face [1]];
		var v3:Vector3D = vertices [face [2]];

		// we want to use Matrix3D to find u and v from x, y and z:
		//   u       x
		//   v = M * y
		//   ?       z
		//   ?       ?
		//
		// the equation could be, for example,
		//   u1 u2 u3 0       x1 x2 x3 0
		//   v1 v2 v3 0 = M * y1 y2 y3 0
		//    1  1  1 0       z1 z2 z3 0
		//    0  0  0 1        0  0  0 1
		//
		// solving for M:
		//    M = UV * (XYZ ^-1)
		var UV:Matrix3D = new Matrix3D (new <Number> [
			aUV.x, bUV.x, cUV.x, 0,
			aUV.y, bUV.y, cUV.y, 0,
			1, 1, 1, 0,
			0, 0, 0, 1
		]); UV.transpose ();
		
		// XYZ matrix above will not always be invertible
		// to work around that, we shift XYZ plane sideways
		var offset:Vector3D = v3.subtract (v1).crossProduct (v2.subtract (v1));
		var XYZ:Matrix3D = new Matrix3D (new <Number> [
			v1.x + offset.x, v2.x + offset.x, v3.x + offset.x, 0,
			v1.y + offset.y, v2.y + offset.y, v3.y + offset.y, 0,
			v1.z + offset.z, v2.z + offset.z, v3.z + offset.z, 0,
			0, 0, 0, 1
		]); XYZ.transpose ();
		
		XYZ.invert (); UV.prepend (XYZ);
		
		// we can now calculate all UVs in the face
		var uv:Vector3D, xyz:Vector3D = new Vector3D;
		for (var i:int = 0, n:int = face.length; i < n; i++) {
			var vertex:Vector3D = vertices [face [i]];
			xyz.x = vertex.x + offset.x;
			xyz.y = vertex.y + offset.y;
			xyz.z = vertex.z + offset.z;
			uv = UV.transformVector (xyz);
			// overwrite face [i] with compound vertex data
			face [i] = [vertex.x, vertex.y, vertex.z, uv.x, uv.y];
		}
	}
	
	protected function createSurface (faceIds:Array, ignore:*):void {
		surfaces.push (faceIds);
	}
	
	protected function build ():void {
		if (surfaces.length == 0) {
			var all:Array = [];
			for (var id:* in faces) {
				all.push (id);
			}
			surfaces.push (all);
		}
		
		var attributes:Array = [
			VertexAttributes.POSITION,
			VertexAttributes.POSITION,
			VertexAttributes.POSITION,
			VertexAttributes.TEXCOORDS [0],
			VertexAttributes.TEXCOORDS [0]
		];
		var dummy:Array = [0, 0, 0, 0, 0];
		var vs:Vector.<Number> = new <Number> [];
		var uvs:Vector.<Number> = new <Number> [];
		var indices:Vector.<uint> = new <uint> [];
		// let us not eliminate duplicate vertices and just dump them all into vertex buffer
		for (var s:int = 0; s < surfaces.length; s++) {
			var surface:Array = surfaces [s];
			var indexBegin:uint = indices.length;
			for (var p:int = 0, q:int = surface.length; p < q; p++) {
				var face:Array = faces [surface [p]];
				var j:uint = uvs.length >> 1;
				for (var i:int = 0, n:int = face.length; i < n; i++) {
					var v:Array = face [i] as Array;
					if (v == null) {
						// no UVs in this face
						var vertex:Vector3D = vertices [face [i]];
						dummy [0] = vertex.x; dummy [1] = vertex.y; dummy [2] = vertex.z; v = dummy;
					}
				
					vs.push (v [0], v [1], v [2]); uvs.push (v [3], 1 - v [4]);
					if (i > 1) {
						indices.push (j, j + i - 1, j + i);
					}
				}
			}
			addSurface (null, indexBegin, (indices.length - indexBegin) / 3);
		}
		
		geometry = new Geometry;
		geometry.numVertices = uvs.length >> 1;
		geometry.indices = indices;
		geometry.addVertexStream (attributes);
		geometry.setAttributeValues (VertexAttributes.POSITION, vs);
		geometry.setAttributeValues (VertexAttributes.TEXCOORDS [0], uvs);
		calculateBoundBox ();
	}
}

// bunker aux classes

	import flash.media.Sound;
	import flash.media.SoundChannel;
	import flash.media.SoundLoaderContext;
	import flash.media.SoundTransform;
	import flash.utils.ByteArray;
	import flash.utils.clearInterval;
	import flash.utils.setInterval;
	
	/**
	 * The class represents a sound used in the demo.
	 */
	class Sound3D {

		private var fadeInned:Boolean = false;
		
		private var coords:Point3D;
		private var nearRadius:Number;
		private var farRadius:Number;
		private var maxVolume:Number;
		private var farDelimiter:Number;
		
		private var sound:Sound = new Sound();
		private var channel:SoundChannel;
		private var transform:SoundTransform = new SoundTransform(0);
		private var intervalId:int;
		
		private var volume:Number = 1;
		
		/**
		 * The method calculates sound properties according to the relative position of sound source and an object.
		 * 
		 * @param objectCoords object's coordinates
		 * @param soundCoords sound source's coordinates
		 * @param normal right ear's normal of the object
		 * @param nearRadius inside near radius the sound has full strengh and panning is equal to zero. Outside the near radius the sound's strength is
		 *   dereased inversely proportional to square of the distance.
		 * @param farRadius at the far radius the sounds's strength is "delimiter" times less than full strength
		 * @param delimiter the coefficient shows how much times is the sound strength less at far radius than at near radius
		 * @param soundTransform calculated sound properties are stored here
		 */
		public static function getSoundProperties(objectCoords:Point3D, soundCoords:Point3D, normal:Point3D, nearRadius:Number, farRadius:Number, delimiter:Number, soundTransform:SoundTransform):void {
			var vector:Point3D = new Point3D (soundCoords.x - objectCoords.x, soundCoords.y - objectCoords.y, soundCoords.z - objectCoords.z);
			var len:Number = Math.sqrt (vector.x * vector.x + vector.y * vector.y + vector.z * vector.z);
			if (len < nearRadius) {
				// Within the near radius limits the sound strength is at maximum, panning equals zero
				soundTransform.volume = 1;
				soundTransform.pan = 0;
			} else {
				delimiter = Math.sqrt(delimiter);
				var k:Number = 1 + (delimiter - 1) * (len - nearRadius) / (farRadius - nearRadius);
				k *= k;
				soundTransform.volume = 1 / k;
				// Calculating sound panning
				vector.x /= len; vector.y /= len; vector.z /= len;
				soundTransform.pan = (vector.x * normal.x + vector.y * normal.y + vector.z * normal.z) * (1 - 1 / k);
			}				
		}
		
		/**
		 * The constructor creates a new instance of the classs.
		 * 
		 * @param coords coordinates of the sound
		 * @param near Near radius. Inside near radius the sound has full strengh and panning is equal to zero. Outside the near radius the sound's strength is
		 *   dereased inversely proportional to square of the distance.
		 * @param far Far radius. At the far radius the sounds's strength is "delimiter" times less than full strength
		 * @param delimiter the coefficient shows how much times is the sound strength less at far radius than at near radius
		 * @param url URL URL of the sound file 
		 * @param info status string
		 * @param multiplier maximum sound strength
		 */
		public function Sound3D(coords:Point3D, near:Number, far:Number, delimiter:Number, url:String, info:String, maxVolume:Number = 1) {
			this.coords = new Point3D (coords.x, coords.y, coords.z);
			this.nearRadius = near;
			this.farRadius = far;
			farDelimiter = delimiter;
			this.maxVolume = maxVolume;
			
			// this is wonderfl - load right away
			var ba:ByteArray = FileUtil.GetFile (url); ba.position = 0;
			sound.loadCompressedDataFromByteArray (ba, ba.length);
			
			channel = sound.play(0, 1000000, transform);
			// Starting method which gradually increases volume
			intervalId = setInterval(addVolume, 100);
		}
		
		/**
		 * 
		 */
		private function addVolume():void {
			transform.volume += 0.05;
			if (transform.volume >= volume) {
				transform.volume = volume;
				clearInterval(intervalId);
				fadeInned = true;
			}
			channel.soundTransform = transform;
		}
		
		/**
		 * The method sets new sound properties according to the relative position of the sound source and the given object.
		 * 
		 * @param coords the object's coordinates
		 * @param normal right ear's normal of the object
		 */
		public function checkVolume(coords:Point3D, normal:Point3D):void {
			var v:Number = transform.volume;
			getSoundProperties(coords, this.coords, normal, nearRadius, farRadius, farDelimiter, transform);
			volume = transform.volume * maxVolume;
			if (fadeInned) {
				transform.volume = volume;
				channel.soundTransform = transform;
			} else {
				transform.volume = v;
			}
		}
	}

	import alternativa.engine3d.primitives.Plane;
	import flash.display.Shape;
	import flash.events.Event;
	import flash.filters.GlowFilter;
	import flash.geom.Matrix;
	
	class Energy extends Plane {
		
		private static const bitmapWidth:uint = 64;//was:90;
		private static const bitmapHeight:uint = 256;//was:307;
		private static const glowSize:Number = 20;
		private static const xd:Number = bitmapWidth*0.5 - glowSize;
		private static const texture:BitmapTextureResource2 = new BitmapTextureResource2(new BitmapData(bitmapWidth, bitmapHeight, true, 0x000000));
		
		public var material:TextureMaterial2 = new TextureMaterial2(texture);
		private var shape:Shape = new Shape();
		private var gfx:Graphics = shape.graphics;
		private var drawMatrix:Matrix = new Matrix(1, 0, 0, 1, bitmapWidth*0.5);
		
		/**
		 * 
		 */
		public function Energy() {
			super(120, 450, 1, 1, false);
			
			rotationX = Math.PI / 2;
			
			y = 2322.835;
			z = -228.346;
			
			material.alphaThreshold = 0.95;
			setMaterialToAllSurfaces (material);
			
			shape.filters = [new GlowFilter(0xEEEE33, 1, glowSize, glowSize, 2, 1)];
		}
		
		/**
		 * Method draws an image of the lightning.
		 */
		public function redraw():void {
			// Drawing image to Shape object
			gfx.clear();
			var n:uint = 3 + Math.random() * 3;
			for (var i:uint = 0; i < n; i++) {
				var strength:Number = Math.random();
				var ex:Number = (Math.random() * 2 - 1) * xd*(1-strength);
				var ey:Number = glowSize;
				gfx.moveTo(ex, ey);
				gfx.lineStyle(strength*8, 0xFFFFFF, strength);
				while (ey < bitmapHeight - glowSize - bitmapHeight/10) {
					ey += Math.random() * (bitmapHeight / 10 - 5) + 5;
					ex += (Math.random() * 2 - 1) * (1-strength)*15;
					ex = (ex < -xd) ? -xd : ((ex > xd) ? xd : ex);
					gfx.lineTo(ex, ey);
				}
				ex += Math.random() * 20 -10;
				gfx.lineTo(ex, bitmapHeight - 10);
			}
			// Copying image to the texture
			texture.data.fillRect(texture.data.rect, 0);
			texture.data.draw(shape, drawMatrix);
			texture.reupload();
		}
	}


// bunker demo models

class BunkerMesh extends Mesh5 {
	public function BunkerMesh () {
		createVertex(-39.37008721928578, 314.9606699218275, 157.48032324214, 2051);
		createVertex(-39.37007958989125, 393.7008127440931, 157.48030798335094, 2052);
		createVertex(-23.62204225163441, 330.7089304198744, 157.47876684565563, 2053);
		createVertex(-196.8503652344225, -236.22045190434437, 31.49618475337047, 1030);
		createVertex(275.5905222167494, 78.74017279047985, 62.992186950636096, 7);
		createVertex(228.3505624999525, 259.8425363769056, 181.1064676513197, 8);
		createVertex(181.10236303706188, 236.2204813231947, 15.748047279310413, 13);
		createVertex(-39.37008721928578, 236.22049658198375, 157.48033850092907, 2054);
		createVertex(-181.10234887700062, -236.22045190434437, 15.748138832044788, 1040);
		createVertex(-118.11023767094593, -236.22045190434437, 0.0001068115234375, 1041);
		createVertex(-39.37008721928578, 0.000030517578125, 157.48038427729625, 2066);
		createVertex(-39.37008721928578, 78.74017279047985, 157.48038427729625, 2067);
		createVertex(-118.1102300415514, -157.48033959965687, 0.000091552734375, 1044);
		createVertex(-196.8503652344225, -157.48033959965687, 31.49616949458141, 1037);
		createVertex(192.91339819331188, 314.9606394042494, 47.24410192866344, 23);
		createVertex(-283.4645314941881, -157.48033959965687, 165.35442297358532, 1048);
		createVertex(299.2125925292494, 314.9606394042494, 102.36220495600719, 26);
		createVertex(299.2125925292494, 236.22049658198375, 102.36222021479625, 27);
		createVertex(-181.10234887700062, -157.48033959965687, 15.748131202650256, 1045);
		createVertex(-267.7164846191881, -157.48033959965687, 94.48828833003063, 1054);
		createVertex(-267.7164846191881, -236.22045190434437, 94.48830358881969, 1055);
		createVertex(283.4645456542494, 236.22051184077282, 165.35434667964, 24);
		createVertex(-251.98030908207875, -157.48033959965687, 157.48041479487438, 1050);
		createVertex(251.98032324214, 314.9606699218275, 157.48033850092907, 18);
		createVertex(-275.59053857426625, -393.7007985840319, 62.99226324458141, 2034);
		createVertex(-181.10234887700062, -181.10234887700062, 196.85047094721813, 1064);
		createVertex(-78.74016625981312, -181.10234887700062, 196.85050146479625, 1065);
		createVertex(-49.212601257371716, -181.10234887700062, 167.32294409174938, 1066);
		createVertex(-228.35054833989125, -181.10234887700062, 181.106543945265, 1068);
		createVertex(-23.62204225163441, -377.9527517090319, 157.47888891596813, 2089);
		createVertex(283.4645456542494, 0.000030517578125, 165.35437719721813, 50);
		createVertex(299.2125925292494, 78.74017279047985, 102.36225836176891, 52);
		createVertex(299.2125925292494, 0.000030517578125, 102.36227362055797, 53);
		createVertex(-39.370071960496716, -157.48033959965687, 157.48041479487438, 2075);
		createVertex(-39.37008721928578, -866.14174707036, 157.48052160639782, 2103);
		createVertex(-39.37008721928578, -708.661522460985, 157.48050634760875, 2104);
		createVertex(-39.37008721928578, -944.88198144536, 157.48053686518688, 2097);
		createVertex(78.74016516108532, 23.622069763136096, 196.85045568842907, 58);
		createVertex(-228.35054833989125, -212.59838159184437, 181.10655920405407, 1083);
		createVertex(-181.10234887700062, -417.3228688965319, 196.85051672358532, 1085);
		createVertex(49.21260015864391, 23.62203924555797, 167.32291357417125, 62);
		createVertex(78.74016516108532, 55.118102477979846, 196.85044042964, 55);
		createVertex(39.37008612055797, 0.000030517578125, 157.48038427729625, 59);
		createVertex(-78.74016625981312, 23.622069763136096, 196.85045568842907, 1093);
		createVertex(78.74016516108532, -181.10234887700062, 196.85050146479625, 70);
		createVertex(228.3505624999525, -212.59838159184437, 181.10655920405407, 71);
		createVertex(-39.37008721928578, -393.7007985840319, 157.48047583003063, 2120);
		createVertex(-275.59053857426625, -157.48033959965687, 62.99222509760875, 1098);
		createVertex(-228.35054833989125, 354.3307565917494, 181.10645239253063, 2124);
		createVertex(-251.98030908207875, 0.000030517578125, 157.48038427729625, 1101);
		createVertex(-275.5905690918444, 0.000030517578125, 62.99219839472789, 1095);
		createVertex(-181.10234887700062, -212.59838159184437, 196.8504862060072, 1087);
		createVertex(267.7164987792494, -157.48033959965687, 94.48828833003063, 81);
		createVertex(-39.370071960496716, -472.4409108887194, 157.48047583003063, 2122);
		createVertex(-39.37008721928578, 0.000030517578125, 0.00006866455078125, 1108);
		createVertex(299.2125925292494, -157.48033959965687, 102.3623041381361, 85);
		createVertex(299.2125925292494, -236.22045190434437, 102.36231939692516, 86);
		createVertex(-251.98030908207875, 402.88022558589, 157.48032324214, 2127);
		createVertex(23.622046874952503, 299.212500976515, -31.496048522996716, 1113);
		createVertex(-23.62204225163441, -614.173241210985, 157.47893469233532, 2111);
		createVertex(39.37007086176891, -157.48033959965687, 0.0001068115234375, 1118);
		createVertex(23.622041152906604, -141.73229272465687, 157.47885839839, 95);
		createVertex(-251.98030908207875, 314.9606699218275, 157.48033850092907, 2129);
		createVertex(39.37008612055797, 314.9606394042494, 0.0000152587890625, 1125);
		createVertex(62.992125915479846, 393.8266672362806, 23.110221313429065, 102);
		createVertex(-228.35054833989125, 55.118102477979846, 181.10651342768688, 2143);
		createVertex(15.74803202052135, -244.09447534184437, 165.3544687499525, 106);
		createVertex(251.98032324214, 402.88022558589, 157.48032324214, 108);
		createVertex(228.3505624999525, 354.3307565917494, 181.10645239253063, 109);
		createVertex(181.10236303706188, 315.44925634760875, 196.85037939448375, 110);
		createVertex(-251.98030908207875, 78.74017279047985, 157.48038427729625, 2142);
		createVertex(39.37007849116344, 393.7008127440931, 157.48030798335094, 112);
		createVertex(31.49606268305797, 393.700782226515, 125.98423712153453, 114);
		createVertex(-116.20962579350453, 419.97202246089, 23.1102174987318, 115);
		createVertex(-228.35054833989125, -417.3228688965319, 181.1065897216322, 2164);
		createVertex(-56.44607598881703, 409.448829101515, 149.60628454585094, 1142);
		createVertex(-251.98030908207875, -1032.80141503911, 157.48055212397594, 2167);
		createVertex(-263.7634511719225, 409.44425146479625, 110.2362055053236, 121);
		createVertex(-275.59053857426625, 314.9606394042494, 62.99214880366344, 122);
		createVertex(-181.10234887700062, 315.44925634760875, 196.85037939448375, 1139);
		createVertex(-228.35054833989125, -984.25209863286, 181.1066660155775, 2166);
		createVertex(-139.15033776860218, 420.22757666010875, 135.70255224604625, 1155);
		createVertex(-228.35054833989125, -685.0393300781725, 181.10663549799938, 2180);
		createVertex(-31.49606378178578, 393.700782226515, 125.98423712153453, 1160);
		createVertex(-181.10234887700062, 78.74017279047985, 15.748077796888538, 137);
		createVertex(-196.8503652344225, 236.2204813231947, 31.496085571241565, 139);
		createVertex(-62.992127014207654, 393.8266672362806, 23.110221313429065, 1164);
		createVertex(-251.98030908207875, -472.4409108887194, 157.48046057124157, 2191);
		createVertex(-251.98030908207875, -629.921288085985, 157.4804910888197, 2185);
		createVertex(-228.35054833989125, -448.8189016113756, 181.10660498042125, 2196);
		createVertex(-49.212601257371716, 259.8425363769056, 167.32286779780407, 151);
		createVertex(-228.35054833989125, -653.543358398485, 181.10662023921032, 2193);
		createVertex(-78.74016625981312, 259.8425363769056, 196.85040991206188, 154);
		createVertex(-181.10234887700062, 259.8425363769056, 196.85039465327282, 155);
		createVertex(-15.74803502659779, 322.8346933593275, 165.35434667964, 156);
		createVertex(-78.74016625981312, 55.118102477979846, 196.85044042964, 162);
		createVertex(-192.91338403325062, -629.921288085985, 47.244262145948596, 2211);
		createVertex(-192.91338403325062, -708.661522460985, 47.24427740473766, 2212);
		createVertex(-118.11023767094593, -629.921288085985, 0.0001678466796875, 2216);
		createVertex(-118.11023767094593, 0.000030517578125, 0.00006103515625, 163);
		createVertex(-192.91338403325062, 0.000030517578125, 47.244159149122424, 1196);
		createVertex(-267.7164846191881, 78.74017279047985, 94.48823492426891, 173);
		createVertex(-192.91338403325062, 78.74017279047985, 47.24414770503063, 174);
		createVertex(-192.91338403325062, -944.88198144536, 47.244307922315784, 2224);
		createVertex(-192.91338403325062, -866.14174707036, 47.24429647822399, 2226);
		createVertex(-299.2125783691881, 78.74017279047985, 102.36225836176891, 179);
		createVertex(-299.2125783691881, 0.000030517578125, 102.36227362055797, 180);
		createVertex(-228.35054833989125, 23.622069763136096, 181.10651342768688, 181);
		createVertex(-181.10234887700062, 23.622069763136096, 196.85044042964, 182);
		createVertex(-23.62204797368031, 299.212500976515, -31.496048522996716, 1169);
		createVertex(-192.91338403325062, -472.4409108887194, 47.244246887159534, 2234);
		createVertex(-49.212601257371716, 23.62203924555797, 167.32291357417125, 187);
		createVertex(-192.91338403325062, 236.22049658198375, 47.2441171874525, 1205);
		createVertex(-192.91338403325062, -236.22045190434437, 47.24420874018688, 1214);
		createVertex(-192.91338403325062, 314.9606394042494, 47.24410192866344, 1207);
		createVertex(-15.748031211900525, -7.8740235100267455, 165.35440771479625, 192);
		createVertex(-23.62204225163441, -251.96849877934437, 157.47888891596813, 2203);
		createVertex(-192.91338403325062, -157.48033959965687, 47.24419729609508, 1219);
		createVertex(-267.7164846191881, 236.22049658198375, 94.48820440669078, 1213);
		createVertex(-275.59053857426625, -236.22045190434437, 62.99223654170055, 198);
		createVertex(-15.748031211900525, 86.61416571040172, 165.35440771479625, 191);
		createVertex(-267.7164846191881, -472.4409108887194, 94.48834173579235, 2231);
		createVertex(-283.4645314941881, -236.22045190434437, 165.35443823237438, 204);
		createVertex(-299.2125783691881, -157.48033959965687, 102.3623041381361, 207);
		createVertex(-299.2125783691881, -236.22045190434437, 102.36231939692516, 208);
		createVertex(-49.212601257371716, -212.59838159184437, 167.32295935053844, 209);
		createVertex(-39.37008721928578, -236.22045190434437, 157.4804453124525, 212);
		createVertex(171.11023657221813, -1055.46010644536, 81.86556188960094, 1231);
		createVertex(-15.748031211900525, -149.60631616215687, 165.35443823237438, 216);
		createVertex(-192.91338403325062, -393.7007985840319, 47.24423544306774, 2238);
		createVertex(-23.62204225163441, -141.73229272465687, 157.47885839839, 219);
		createVertex(-23.62204797368031, 15.747986244154163, -31.495987487840466, 222);
		createVertex(-23.62204797368031, -173.22838647465687, -31.49594934086781, 225);
		createVertex(39.37007849116344, -1023.6220937500475, 157.48053686518688, 1250);
		createVertex(181.10236303706188, -944.88198144536, 15.748238014173694, 231);
		createVertex(196.85037939448375, -708.661522460985, 31.49624578852672, 1256);
		createVertex(47.24409429926891, -1023.621971679735, 0.000213623046875, 233);
		createVertex(196.85037939448375, -944.88198144536, 31.49627249140758, 235);
		createVertex(275.5905527343275, -944.88198144536, 62.99235098261852, 237);
		createVertex(251.98032324214, -1032.80141503911, 157.48055212397594, 238);
		createVertex(181.10236303706188, -708.661522460985, 15.748207496595569, 1255);
		createVertex(78.74016516108532, -959.7636953125475, 196.85059301753063, 1249);
		createVertex(196.85037939448375, -866.14174707036, 31.49626486201305, 1267);
		createVertex(228.3505624999525, -984.25209863286, 181.1066660155775, 244);
		createVertex(228.3505624999525, -921.260155273485, 181.1066660155775, 243);
		createVertex(251.98032324214, -866.14174707036, 157.48053686518688, 1276);
		createVertex(251.98032324214, -944.88198144536, 157.48053686518688, 1279);
		createVertex(275.5905527343275, -866.14174707036, 62.99233953852672, 256);
		createVertex(267.7164987792494, -944.88198144536, 94.48839514155407, 1283);
		createVertex(299.2125925292494, -944.88198144536, 102.36241094965953, 1284);
		createVertex(283.4645456542494, -944.88198144536, 165.35452978510875, 263);
		createVertex(299.2125925292494, -866.14174707036, 102.362403320265, 265);
		createVertex(283.4645456542494, -866.14174707036, 165.35452978510875, 1290);
		createVertex(181.10236303706188, -866.14174707036, 15.748230384779163, 251);
		createVertex(39.37008612055797, -944.88198144536, 157.48053686518688, 1294);
		createVertex(15.748035835218616, -952.75600488286, 165.35456030268688, 271);
		createVertex(15.74803202052135, -858.26772363286, 165.35454504389782, 272);
		createVertex(23.622041152906604, -850.39370019536, 157.47896520991344, 273);
		createVertex(181.10236303706188, -921.260155273485, 196.85059301753063, 1299);
		createVertex(78.74016516108532, -921.260155273485, 196.85059301753063, 1300);
		createVertex(49.21260015864391, -921.260155273485, 167.32306616206188, 1301);
		createVertex(181.10236303706188, -629.921288085985, 15.748199867201038, 279);
		createVertex(181.10236303706188, -472.4409108887194, 15.748176979017444, 280);
		createVertex(49.21260015864391, -889.76381738286, 167.32305090327282, 1308);
		createVertex(275.5905527343275, -472.4409108887194, 62.992274688673206, 285);
		createVertex(267.7164987792494, -708.661522460985, 94.48836462397594, 288);
		createVertex(192.91339819331188, -708.661522460985, 47.24427740473766, 289);
		createVertex(283.4645456542494, -629.921288085985, 165.35449926753063, 291);
		createVertex(283.4645456542494, -708.661522460985, 165.35449926753063, 292);
		createVertex(181.10236303706188, -889.76381738286, 196.85057775874157, 1317);
		createVertex(299.2125925292494, -708.661522460985, 102.36238043208141, 294);
		createVertex(299.2125925292494, -629.921288085985, 102.36237280268688, 295);
		createVertex(23.622041152906604, -960.630272460985, 157.4789804687025, 1313);
		createVertex(181.10236303706188, -448.8189016113756, 196.85053198237438, 298);
		createVertex(78.74016516108532, -653.543358398485, 196.8505624999525, 300);
		createVertex(49.21260015864391, -653.543358398485, 167.3230203856947, 302);
		createVertex(49.21260015864391, -685.0393300781725, 167.32303564448375, 303);
		createVertex(196.85037939448375, -629.921288085985, 31.49623815913219, 1330);
		createVertex(275.5905222167494, -708.661522460985, 62.99231283564586, 1332);
		createVertex(23.622041152906604, -724.4094472656725, 157.47894995112438, 309);
		createVertex(181.10236303706188, -393.7007985840319, 15.748169349622913, 311);
		createVertex(78.74016516108532, -889.76381738286, 196.85059301753063, 1319);
		createVertex(192.91339819331188, -472.4409108887194, 47.244246887159534, 317);
		createVertex(228.3505624999525, -889.76381738286, 181.10665075678844, 1316);
		createVertex(283.4645456542494, -472.4409108887194, 165.3544687499525, 320);
		createVertex(39.37008612055797, -866.14174707036, 157.48052160639782, 1295);
		createVertex(49.21260015864391, -417.3228688965319, 167.32298986811657, 324);
		createVertex(49.21260015864391, -448.8189016113756, 167.32300512690563, 325);
		createVertex(39.37007086176891, -472.4409108887194, 157.48047583003063, 326);
		createVertex(251.98032324214, -708.661522460985, 157.48050634760875, 1349);
		createVertex(267.7164987792494, -629.921288085985, 94.48835699458141, 1359);
		createVertex(23.622046874952503, -929.1338125000475, -31.495850158738904, 338);
		createVertex(181.10236303706188, -653.543358398485, 196.85054724116344, 1364);
		createVertex(62.992125915479846, -1023.747948242235, 23.110454009962268, 343);
		createVertex(31.49606268305797, -1023.6220937500475, 125.98446600337047, 344);
		createVertex(181.10236303706188, -685.0393300781725, 196.8505624999525, 1372);
		createVertex(78.74016516108532, -685.0393300781725, 196.8505624999525, 1373);
		createVertex(228.3505624999525, -653.543358398485, 181.10662023921032, 1376);
		createVertex(228.3505624999525, -685.0393300781725, 181.10663549799938, 1378);
		createVertex(-49.212601257371716, -921.260155273485, 167.32306616206188, 363);
		createVertex(-181.10234887700062, -708.661522460985, 15.748207496595569, 367);
		createVertex(-275.59053857426625, -866.14174707036, 62.99233953852672, 372);
		createVertex(267.7164987792494, -866.14174707036, 94.48838751215953, 1400);
		createVertex(-283.4645314941881, -944.88198144536, 165.35452978510875, 377);
		createVertex(-283.4645314941881, -866.14174707036, 165.35452978510875, 378);
		createVertex(-299.2125783691881, -944.88198144536, 102.36241094965953, 379);
		createVertex(-181.10234887700062, -889.76381738286, 196.85057775874157, 384);
		createVertex(-23.62204225163441, -960.630272460985, 157.4789804687025, 387);
		createVertex(118.11023657221813, -236.22045190434437, 0.0001068115234375, 1416);
		createVertex(196.85037939448375, -393.7007985840319, 31.49621145625133, 1417);
		createVertex(-181.10234887700062, -472.4409108887194, 15.748176979017444, 395);
		createVertex(-181.10234887700062, -629.921288085985, 15.748199867201038, 396);
		createVertex(-196.8503652344225, -472.4409108887194, 31.496219085645862, 397);
		createVertex(-275.59053857426625, -472.4409108887194, 62.992274688673206, 399);
		createVertex(267.7164987792494, -393.7007985840319, 94.48832647700328, 1419);
		createVertex(39.37008612055797, -708.661522460985, 157.48050634760875, 1411);
		createVertex(196.85037939448375, -472.4409108887194, 31.496219085645862, 1429);
		createVertex(-251.98030908207875, -708.661522460985, 157.48050634760875, 406);
		createVertex(-283.4645314941881, -629.921288085985, 165.35449926753063, 408);
		createVertex(118.11023657221813, -393.7007985840319, 0.0001373291015625, 1428);
		createVertex(275.5905527343275, -393.7007985840319, 62.99226324458141, 1420);
		createVertex(267.7164987792494, -472.4409108887194, 94.48834173579235, 1439);
		createVertex(-78.74016625981312, -653.543358398485, 196.8505624999525, 416);
		createVertex(-39.37008721928578, -629.921288085985, 157.4804910888197, 418);
		createVertex(-15.748031211900525, -716.5354238281725, 165.35452978510875, 421);
		createVertex(299.2125925292494, -393.7007985840319, 102.36234228510875, 1446);
		createVertex(283.4645456542494, -393.7007985840319, 165.3544687499525, 1447);
		createVertex(251.98032324214, -472.4409108887194, 157.48046057124157, 1440);
		createVertex(-118.11023767094593, -393.7007985840319, 0.0001373291015625, 425);
		createVertex(299.2125925292494, -472.4409108887194, 102.36234991450328, 1442);
		createVertex(-267.7164846191881, -393.7007985840319, 94.48832647700328, 429);
		createVertex(228.3505624999525, -448.8189016113756, 181.10660498042125, 1455);
		createVertex(78.74016516108532, -448.8189016113756, 196.85053198237438, 1458);
		createVertex(-299.2125783691881, -472.4409108887194, 102.36234991450328, 437);
		createVertex(78.74016516108532, -417.3228688965319, 196.85053198237438, 1467);
		createVertex(39.37008612055797, -393.7007985840319, 157.48047583003063, 1453);
		createVertex(-23.62204225163441, -488.1889577637194, 157.47891943354625, 447);
		createVertex(23.622041152906604, -377.9527517090319, 157.47888891596813, 1472);
		createVertex(-39.37008721928578, -944.88198144536, 0.00022125244140625, 450);
		createVertex(181.10236303706188, -417.3228688965319, 196.85051672358532, 1476);
		createVertex(-39.370071960496716, -472.4409108887194, 0.000152587890625, 454);
		createVertex(-139.15033776860218, -1050.148827148485, 135.70279638667125, 456);
		createVertex(181.10236303706188, 314.9606394042494, 15.74803202052135, 462);
		createVertex(39.37008612055797, -629.921288085985, 157.4804910888197, 1487);
		createVertex(228.3505624999525, -417.3228688965319, 181.1065897216322, 1480);
		createVertex(275.5905527343275, 314.9606394042494, 62.99214880366344, 467);
		createVertex(275.5905832519056, -629.921288085985, 62.992301391554065, 1492);
		createVertex(251.98032324214, -629.921288085985, 157.4804910888197, 1498);
		createVertex(78.74016516108532, 329.8424143065931, 196.85037939448375, 476);
		createVertex(181.10236303706188, 78.74017279047985, 15.748077796888538, 479);
		createVertex(275.5905527343275, 236.22049658198375, 62.99215643305797, 484);
		createVertex(23.622046874952503, -456.6928640137194, -31.495903564500622, 1509);
		createVertex(23.622046874952503, -173.22838647465687, -31.49594934086781, 1508);
		createVertex(196.85037939448375, 236.2204813231947, 31.496085571241565, 494);
		createVertex(118.11023657221813, 314.9606394042494, 0, 497);
		createVertex(196.85037939448375, 314.9606394042494, 31.496066497755237, 499);
		createVertex(23.622041152906604, -614.173241210985, 157.47893469233532, 1524);
		createVertex(15.74803202052135, -622.047264648485, 165.3545145263197, 1525);
		createVertex(267.7164987792494, 314.9606394042494, 94.48818914790172, 502);
		createVertex(283.4645456542494, 314.9606699218275, 165.35433142085094, 503);
		createVertex(15.74803202052135, -480.3149343262194, 165.35449926753063, 1530);
		createVertex(15.74803202052135, -385.8267751465319, 165.35449926753063, 1532);
		createVertex(251.98032324214, 236.22051184077282, 157.48035375971813, 510);
		createVertex(263.76346533198375, -1039.365624023485, 110.23643438715953, 1537);
		createVertex(78.74016516108532, 291.3388437499525, 196.85040991206188, 516);
		createVertex(181.10236303706188, 291.3388437499525, 196.85037939448375, 517);
		createVertex(139.15035192866344, -1050.148827148485, 135.70279638667125, 1542);
		createVertex(49.21260015864391, 259.8425363769056, 167.32286779780407, 521);
		createVertex(49.21260015864391, 291.3388437499525, 167.322852539015, 522);
		createVertex(181.10236303706188, -945.370506835985, 196.85059301753063, 1547);
		createVertex(181.10236303706188, 259.8425363769056, 196.85039465327282, 529);
		createVertex(181.10236303706188, 55.118102477979846, 196.85044042964, 533);
		createVertex(56.44607489008922, -1039.3701406250475, 149.60651342768688, 1559);
		createVertex(181.10236303706188, 0.000030517578125, 15.7480930556776, 537);
		createVertex(181.10236303706188, -157.48033959965687, 15.748131202650256, 538);
		createVertex(116.20962469477672, -1049.8933339844225, 23.110457824659534, 1563);
		createVertex(196.85037939448375, -157.48033959965687, 31.49616949458141, 541);
		createVertex(275.5905832519056, 0.000030517578125, 62.99219839472789, 543);
		createVertex(196.85037939448375, 0.000030517578125, 31.496135162306018, 544);
		createVertex(118.11024420161266, 236.22046606440563, 0.0000152587890625, 1570);
		createVertex(39.37008612055797, 0.000030517578125, 0.00006866455078125, 1575);
		createVertex(47.24409429926891, 393.7007517089369, -0.0000152587890625, 1568);
		createVertex(196.85037939448375, 78.74017279047985, 31.49611608881969, 556);
		createVertex(251.98032324214, 78.74017279047985, 157.48038427729625, 557);
		createVertex(283.4645456542494, 78.74017279047985, 165.35437719721813, 559);
		createVertex(118.11023657221813, 0.000030517578125, 0.00006103515625, 1585);
		createVertex(267.7164987792494, 0.000030517578125, 94.4882578124525, 565);
		createVertex(251.98032324214, 0.000030517578125, 157.48038427729625, 566);
		createVertex(181.10236303706188, -181.10234887700062, 196.85047094721813, 571);
		createVertex(181.10236303706188, 23.622069763136096, 196.85044042964, 572);
		createVertex(118.11023657221813, -708.661522460985, 0.00017547607421875, 1601);
		createVertex(228.3505624999525, 55.118102477979846, 181.10651342768688, 578);
		createVertex(49.21260015864391, 55.11807196040172, 167.32291357417125, 579);
		createVertex(118.11024420161266, -866.14174707036, 0.0001983642578125, 1604);
		createVertex(15.74803202052135, -716.5354238281725, 165.35452978510875, 1618);
		createVertex(-23.62204225163441, -724.4094472656725, 157.47894995112438, 1621);
		createVertex(-23.62204225163441, -850.39370019536, 157.47896520991344, 1622);
		createVertex(267.7164987792494, 78.74017279047985, 94.48823492426891, 601);
		createVertex(78.74016516108532, 259.8425363769056, 196.85040991206188, 606);
		createVertex(196.85037939448375, -236.22045190434437, 31.49618475337047, 609);
		createVertex(118.11023657221813, -629.921288085985, 0.0001678466796875, 1636);
		createVertex(275.5905527343275, -236.22045190434437, 62.99223654170055, 613);
		createVertex(192.91339819331188, -629.921288085985, 47.244262145948596, 1638);
		createVertex(275.5905527343275, -157.48033959965687, 62.99222509760875, 616);
		createVertex(23.622041152906604, -488.1889577637194, 157.47891943354625, 1625);
		createVertex(181.10236303706188, -236.22045190434437, 15.748138832044788, 619);
		createVertex(192.91339819331188, -866.14174707036, 47.24429647822399, 1647);
		createVertex(118.1102289428236, -157.48033959965687, 0.000091552734375, 624);
		createVertex(118.11023657221813, -944.88198144536, 0.00020599365234375, 1649);
		createVertex(251.98032324214, -157.48033959965687, 157.48041479487438, 626);
		createVertex(283.4645456542494, -157.48033959965687, 165.35442297358532, 628);
		createVertex(192.91339819331188, -944.88198144536, 47.244307922315784, 1654);
		createVertex(267.7164987792494, -236.22045190434437, 94.48830358881969, 634);
		createVertex(283.4645456542494, -236.22045190434437, 165.35443823237438, 636);
		createVertex(118.1102289428236, -472.4409108887194, 0.0001373291015625, 1663);
		createVertex(49.21260015864391, -181.10234887700062, 167.32294409174938, 640);
		createVertex(192.91339819331188, -393.7007985840319, 47.24423544306774, 1668);
		createVertex(49.21260015864391, -212.59838159184437, 167.32295935053844, 646);
		createVertex(-181.10234887700062, -944.88198144536, 15.748238014173694, 1673);
		createVertex(-171.11022241215687, -1055.46010644536, 81.86556188960094, 1674);
		createVertex(78.74016516108532, -212.59838159184437, 196.85050146479625, 654);
		createVertex(181.10236303706188, -212.59838159184437, 196.8504862060072, 655);
		createVertex(-181.10234887700062, -945.370506835985, 196.85059301753063, 1682);
		createVertex(-275.59053857426625, -944.88198144536, 62.99235098261852, 1678);
		createVertex(-78.74016625981312, -959.7636953125475, 196.85059301753063, 1687);
		createVertex(-181.10234887700062, -866.14174707036, 15.748230384779163, 1689);
		createVertex(-196.8503652344225, -866.14174707036, 31.49626486201305, 1696);
		createVertex(23.622046874952503, 15.747986244154163, -31.495987487840466, 676);
		createVertex(15.748035835218616, 322.8346933593275, 165.35434667964, 677);
		createVertex(15.74803202052135, 228.34647314448375, 165.35437719721813, 680);
		createVertex(-15.748031211900525, 228.34647314448375, 165.35437719721813, 682);
		createVertex(15.74803202052135, 86.61416571040172, 165.35440771479625, 686);
		createVertex(15.74803202052135, -7.8740235100267455, 165.35440771479625, 687);
		createVertex(23.622041152906604, -15.748046470689587, 157.47882788081188, 688);
		createVertex(15.74803202052135, -149.60631616215687, 165.35443823237438, 691);
		createVertex(-267.7164846191881, -944.88198144536, 94.48839514155407, 1716);
		createVertex(-196.8503652344225, -944.88198144536, 31.49627249140758, 1710);
		createVertex(-251.98030908207875, -944.88198144536, 157.48053686518688, 1711);
		createVertex(-15.748031211900525, -244.09447534184437, 165.3544687499525, 696);
		createVertex(-251.98030908207875, -866.14174707036, 157.48053686518688, 1721);
		createVertex(263.76346533198375, 409.44425146479625, 110.2362055053236, 700);
		createVertex(-78.74016625981312, -921.260155273485, 196.85059301753063, 1727);
		createVertex(-267.7164846191881, -866.14174707036, 94.48838751215953, 1720);
		createVertex(-181.10234887700062, -921.260155273485, 196.85059301753063, 1729);
		createVertex(139.15035192866344, 420.22757666010875, 135.70255224604625, 708);
		createVertex(-228.35054833989125, -921.260155273485, 181.1066660155775, 1735);
		createVertex(-49.212601257371716, -889.76381738286, 167.32305090327282, 1739);
		createVertex(-15.748031211900525, -858.26772363286, 165.35454504389782, 1740);
		createVertex(-299.2125783691881, -866.14174707036, 102.362403320265, 1724);
		createVertex(171.11023657221813, 425.53891699214, 81.86531774897594, 720);
		createVertex(-228.35054833989125, -889.76381738286, 181.10665075678844, 1745);
		createVertex(56.44607489008922, 409.448829101515, 149.60628454585094, 723);
		createVertex(-78.74016625981312, -889.76381738286, 196.85059301753063, 1749);
		createVertex(116.20962469477672, 419.97202246089, 23.1102174987318, 726);
		createVertex(23.622041152906604, 94.48818914790172, 157.47879736323375, 732);
		createVertex(-275.5905690918444, -629.921288085985, 62.992301391554065, 1758);
		createVertex(-23.62204225163441, 94.48818914790172, 157.47879736323375, 735);
		createVertex(-23.62204225163441, 220.47244970698375, 157.47879736323375, 736);
		createVertex(-275.5905080566881, -708.661522460985, 62.99231283564586, 1761);
		createVertex(-196.8503652344225, -629.921288085985, 31.49623815913219, 1759);
		createVertex(-118.11023767094593, -708.661522460985, 0.00017547607421875, 1769);
		createVertex(-196.8503652344225, -708.661522460985, 31.49624578852672, 1771);
		createVertex(-283.4645314941881, -708.661522460985, 165.35449926753063, 1774);
		createVertex(251.98032324214, -236.22045190434437, 157.48041479487438, 751);
		createVertex(-299.2125783691881, -708.661522460985, 102.36238043208141, 1778);
		createVertex(23.622041152906604, -251.96849877934437, 157.47888891596813, 757);
		createVertex(-299.2125783691881, -629.921288085985, 102.36237280268688, 1784);
		createVertex(23.622041152906604, 330.7089304198744, 157.47876684565563, 762);
		createVertex(39.37008612055797, 314.9606699218275, 157.48032324214, 763);
		createVertex(39.37008612055797, 236.22049658198375, 157.48033850092907, 764);
		createVertex(23.622041152906604, 220.47244970698375, 157.47879736323375, 765);
		createVertex(-181.10234887700062, -685.0393300781725, 196.8505624999525, 1792);
		createVertex(-181.10234887700062, -448.8189016113756, 196.85053198237438, 1786);
		createVertex(-49.212601257371716, -685.0393300781725, 167.32303564448375, 1789);
		createVertex(-49.212601257371716, -653.543358398485, 167.3230203856947, 1801);
		createVertex(39.37008612055797, 78.74017279047985, 157.48038427729625, 770);
		createVertex(-181.10234887700062, -653.543358398485, 196.85054724116344, 1803);
		createVertex(-15.748031211900525, -622.047264648485, 165.3545145263197, 1807);
		createVertex(39.37008612055797, -236.22045190434437, 157.4804453124525, 786);
		createVertex(39.37007086176891, -157.48033959965687, 157.48041479487438, 788);
		createVertex(251.98032324214, -393.7007985840319, 157.4804453124525, 789);
		createVertex(-267.7164846191881, -708.661522460985, 94.48836462397594, 1816);
		createVertex(228.3505624999525, 291.3388437499525, 181.10645239253063, 798);
		createVertex(-78.74016625981312, -685.0393300781725, 196.8505624999525, 1829);
		createVertex(-196.8503652344225, -393.7007985840319, 31.49621145625133, 1830);
		createVertex(-181.10234887700062, -393.7007985840319, 15.748169349622913, 1837);
		createVertex(228.3505624999525, 23.622069763136096, 181.10651342768688, 823);
		createVertex(228.3505624999525, -181.10234887700062, 181.106543945265, 826);
		createVertex(192.91339819331188, 0.000030517578125, 47.244159149122424, 831);
		createVertex(-283.4645314941881, -393.7007985840319, 165.3544687499525, 1856);
		createVertex(-299.2125783691881, -393.7007985840319, 102.36234228510875, 1857);
		createVertex(-49.212601257371716, -448.8189016113756, 167.32300512690563, 1859);
		createVertex(192.91339819331188, 78.74017279047985, 47.24414770503063, 836);
		createVertex(118.11023657221813, 78.74017279047985, 0.0000457763671875, 839);
		createVertex(-283.4645314941881, -472.4409108887194, 165.3544687499525, 1847);
		createVertex(-49.212601257371716, -417.3228688965319, 167.32298986811657, 1865);
		createVertex(267.7164987792494, 236.22049658198375, 94.48820440669078, 844);
		createVertex(192.91339819331188, 236.22049658198375, 47.2441171874525, 849);
		createVertex(-15.748031211900525, -480.3149343262194, 165.35449926753063, 1878);
		createVertex(-15.748031211900525, -385.8267751465319, 165.35449926753063, 1882);
		createVertex(192.91339819331188, -157.48033959965687, 47.24419729609508, 860);
		createVertex(192.91339819331188, -236.22045190434437, 47.24420874018688, 861);
		createVertex(-78.74016625981312, -448.8189016113756, 196.85053198237438, 1886);
		createVertex(-267.7164846191881, -629.921288085985, 94.48835699458141, 1894);
		createVertex(-171.11022241215687, 425.53891699214, 81.86531774897594, 871);
		createVertex(-23.62204797368031, -645.669334960985, -31.49588067631703, 1901);
		createVertex(-78.74016625981312, 291.3388437499525, 196.85040991206188, 881);
		createVertex(23.622046874952503, -645.669334960985, -31.49588067631703, 1906);
		createVertex(-78.74016625981312, 329.8424143065931, 196.85037939448375, 883);
		createVertex(39.37008612055797, -629.921288085985, 0.00017547607421875, 1910);
		createVertex(39.37007086176891, -472.4409108887194, 0.000152587890625, 1917);
		createVertex(-23.62204797368031, -456.6928640137194, -31.495903564500622, 1919);
		createVertex(-196.8503652344225, 314.9606394042494, 31.496066497755237, 897);
		createVertex(-181.10234887700062, 236.2204813231947, 15.748047279310413, 900);
		createVertex(-39.370071960496716, -157.48033959965687, 0.0001068115234375, 1925);
		createVertex(-47.244095397996716, -1023.621971679735, 0.000213623046875, 1926);
		createVertex(-181.10234887700062, 314.9606394042494, 15.74803202052135, 905);
		createVertex(-283.4645314941881, 314.9606699218275, 165.35433142085094, 909);
		createVertex(-267.7164846191881, 314.9606394042494, 94.48818914790172, 910);
		createVertex(-299.2125783691881, 314.9606394042494, 102.36220495600719, 913);
		createVertex(-299.2125783691881, 236.22049658198375, 102.36222021479625, 917);
		createVertex(-283.4645314941881, 236.22051184077282, 165.35434667964, 918);
		createVertex(-251.98030908207875, 236.22051184077282, 157.48035375971813, 920);
		createVertex(-228.35054833989125, 291.3388437499525, 181.10645239253063, 923);
		createVertex(-181.10234887700062, 291.3388437499525, 196.85037939448375, 924);
		createVertex(-263.7634511719225, -1039.365624023485, 110.23643438715953, 1933);
		createVertex(-39.37007958989125, -1023.6220937500475, 157.48053686518688, 1954);
		createVertex(-49.212601257371716, 291.3388437499525, 167.322852539015, 931);
		createVertex(-116.20962579350453, -1049.8933339844225, 23.110457824659534, 1960);
		createVertex(-228.35054833989125, 259.8425363769056, 181.1064676513197, 940);
		createVertex(-31.49606378178578, -1023.6220937500475, 125.98446600337047, 1965);
		createVertex(-62.992127014207654, -1023.747948242235, 23.110454009962268, 1966);
		createVertex(-56.44607598881703, -1039.3701406250475, 149.60651342768688, 1969);
		createVertex(-181.10234887700062, 0.000030517578125, 15.7480930556776, 948);
		createVertex(-196.8503652344225, 0.000030517578125, 31.496135162306018, 951);
		createVertex(-118.11023767094593, 314.9606394042494, 0, 1978);
		createVertex(-118.11024530034047, 236.22046606440563, 0.0000152587890625, 1979);
		createVertex(-196.8503652344225, 78.74017279047985, 31.49611608881969, 956);
		createVertex(-39.37008721928578, 314.9606394042494, 0.0000152587890625, 1981);
		createVertex(-47.244095397996716, 393.7007517089369, -0.0000152587890625, 1975);
		createVertex(-118.11023767094593, 78.74017279047985, 0.0000457763671875, 965);
		createVertex(-283.4645314941881, 78.74017279047985, 165.35437719721813, 969);
		createVertex(-118.1102300415514, -472.4409108887194, 0.0001373291015625, 2000);
		createVertex(-39.37008721928578, -629.921288085985, 0.00017547607421875, 2002);
		createVertex(-283.4645314941881, 0.000030517578125, 165.35437719721813, 979);
		createVertex(-267.7164846191881, 0.000030517578125, 94.4882578124525, 981);
		createVertex(-49.212601257371716, 55.11807196040172, 167.32291357417125, 985);
		createVertex(-181.10234887700062, 55.118102477979846, 196.85044042964, 987);
		createVertex(-118.11023767094593, -944.88198144536, 0.00020599365234375, 2013);
		createVertex(-118.11024530034047, -866.14174707036, 0.0001983642578125, 2009);
		createVertex(39.37008612055797, -944.88198144536, 0.00022125244140625, 2019);
		createVertex(-23.62204797368031, -929.1338125000475, -31.495850158738904, 2021);
		createVertex(-15.74803502659779, -952.75600488286, 165.35456030268688, 2022);
		createVertex(-23.62204225163441, -15.748046470689587, 157.47882788081188, 1004);
		createVertex(-275.5905080566881, 78.74017279047985, 62.992186950636096, 1010);
		createVertex(-275.59053857426625, 236.22049658198375, 62.99215643305797, 1013);
		createVertex(-251.98030908207875, -236.22045190434437, 157.48041479487438, 2041);
		createVertex(-251.98030908207875, -393.7007985840319, 157.4804453124525, 2042);
		createVertex(-78.74016625981312, -212.59838159184437, 196.85050146479625, 2046);
		createVertex(-78.74016625981312, -417.3228688965319, 196.85053198237438, 2047);

		createFace([1349, 1498, 291, 292], 0);
		setUVsToFace(new Point(0.32717257738113403, 0.8598208427429199), new Point(0.28341108560562134, 0.8598208427429199), new Point(0.28341108560562134, 0.8417840003967285), 0);
		createFace([624, 1118, 1917, 1663, 1428, 1416], 1);
		setUVsToFace(new Point(0.4823759876619577, 0.001000008277120143), new Point(0.4823759876619577, 0.044761471181633025), new Point(0.3073301911354065, 0.04476147145032883), 1);
		createFace([1004, 735, 191, 192], 2);
		setUVsToFace(new Point(0.47378742694854736, 0.5306512117385864), new Point(0.4125213623046875, 0.5306512117385864), new Point(0.41689749131393655, 0.5244617852630017), 2);
		createFace([1801, 416, 1886, 1859, 2122, 418], 3);
		setUVsToFace(new Point(0.20667884078418935, 0.20647280600368062), new Point(0.2066788524389267, 0.18326479196548462), new Point(0.32045865058898926, 0.1832648366689682), 3);
		createFace([1055, 198, 1030, 1214], 4);
		setUVsToFace(new Point(0.7406474351882935, 0.6497978568077087), new Point(0.7451763153076172, 0.6323320865631104), new Point(0.7919800281524658, 0.6378893852233887), 4);
		createFace([1508, 1118, 1925, 225], 5);
		setUVsToFace(new Point(0.07543957891263639, 0.15025852620601654), new Point(0.08419188112020493, 0.16982926428318024), new Point(0.04043043404817581, 0.16982926428318024), 5);
		createFace([450, 2002, 1769, 2009, 2013, 1926], 6);
		setUVsToFace(new Point(0.04476136714220047, 0.08852294087409973), new Point(0.21980728796501559, 0.08852292391333969), new Point(0.17604577383776115, 0.13228439012672327), 6);
		createFace([1856, 1857, 429, 2042], 7);
		setUVsToFace(new Point(0.0835447907447815, 0.9837418794631958), new Point(0.047468531876802444, 0.9828768372535706), new Point(0.04790104553103447, 0.9648387432098389), 7);
		createFace([251, 1255, 1601, 1604], 8);
		setUVsToFace(new Point(0.001000017044134438, 0.8027954697608948), new Point(0.088522898266094, 0.8027955845995011), new Point(0.08852288126945496, 0.8388821482658386), 8);
		createFace([1621, 418, 2122, 447, 2111], 9);
		setUVsToFace(new Point(0.6224127700172396, 0.17090299725532532), new Point(0.5698990203985942, 0.17965529216987994), new Point(0.4823760688304901, 0.1796552836894989), 9);
		createFace([1965, 1969, 1559, 344], 10);
		setUVsToFace(new Point(0.9452301263809204, 0.490400493144989), new Point(0.9313636422157288, 0.47462210059165955), new Point(0.9941058405403216, 0.47462210059165955), 10);
		createFace([1618, 309, 1621, 421], 11);
		setUVsToFace(new Point(0.08061851561069489, 0.8415892124176025), new Point(0.08499465882778168, 0.8477786779403687), new Point(0.05873778462409973, 0.8477786779403687), 11);
		createFace([786, 788, 640, 646], 12);
		setUVsToFace(new Point(0.3510916531085968, 0.24786029756069183), new Point(0.30733020397697214, 0.24786029156414097), new Point(0.32045865058898926, 0.24012428522109985), 12);
		createFace([646, 654, 1467, 324, 1453, 786], 13);
		setUVsToFace(new Point(0.3379632234573364, 0.24012428522109985), new Point(0.3379632234573364, 0.2169162929058075), new Point(0.45174287925861867, 0.21691647401902325), 13);
		createFace([1301, 1308, 1316, 243], 14);
		setUVsToFace(new Point(0.9011762738227844, 0.27184581756591797), new Point(0.9011762738227844, 0.28935056924819946), new Point(0.8016166687011719, 0.28935056924819946), 14);
		createFace([1376, 302, 300, 1364], 15);
		setUVsToFace(new Point(0.9007460979643651, 0.8673339765071628), new Point(0.8009626269340515, 0.8710854649543762), new Point(0.8180039525032043, 0.8553308248519897), 15);
		createFace([225, 1925, 454, 1919], 16);
		setUVsToFace(new Point(0.3038844163099216, 0.5769700972867791), new Point(0.2951321005821228, 0.557399332523346), new Point(0.47017791867256165, 0.5573992729187012), 16);
		createFace([416, 1801, 2193, 1803], 17);
		setUVsToFace(new Point(0.7196225942618693, 0.9331190813193276), new Point(0.7020046710968018, 0.9180121421813965), new Point(0.8018586039543152, 0.9180334210395813), 17);
		createFace([940, 920, 2129, 923], 18);
		setUVsToFace(new Point(0.0804961621761322, 0.2718459665775299), new Point(0.09362462514053066, 0.29041701555252075), new Point(0.04986310377717018, 0.29041701555252075), 18);
		createFace([1716, 1678, 1710, 2224], 19);
		setUVsToFace(new Point(0.7579806447029114, 0.7024614214897156), new Point(0.7625094652175903, 0.684995710849762), new Point(0.8093132972717285, 0.6905529499053955), 19);
		createFace([1065, 1066, 1068, 1064], 20);
		setUVsToFace(new Point(0.8218893756829452, 0.8080758764073872), new Point(0.804271399974823, 0.7929689288139343), new Point(0.9041252732276917, 0.7929902076721191), 20);
		createFace([1279, 238, 244, 243, 1316, 1276], 22);
		setUVsToFace(new Point(0.04986303299665451, 0.2691385746002197), new Point(0.0010000000474974513, 0.26913854479789734), new Point(0.027982283177020603, 0.25056750427265495), 22);
		createFace([831, 1585, 537, 544], 23);
		setUVsToFace(new Point(0.9093998670578003, 0.6559502482414246), new Point(0.9585524797439575, 0.6572906374931335), new Point(0.9239837527275085, 0.6676468849182129), 23);
		createFace([95, 688, 788, 786, 757], 24);
		setUVsToFace(new Point(0.2985779643058777, 0.14464612305164337), new Point(0.22855962812900543, 0.14464612305164337), new Point(0.30733028054237366, 0.1358938366174698), 24);
		createFace([871, 1155, 2127, 121], 25);
		setUVsToFace(new Point(0.4126462258074805, 0.7492944511601256), new Point(0.4238095283508301, 0.7823795676231384), new Point(0.3592209815979004, 0.7823007702827454), 25);
		createFace([1919, 1509, 1508, 225], 26);
		setUVsToFace(new Point(0.7914134860038757, 0.24317298829555511), new Point(0.7914134860038757, 0.21691612899303436), new Point(0.9489546418190002, 0.21691612899303436), 26);
		createFace([1601, 289, 1638, 1636], 27);
		setUVsToFace(new Point(0.09123000502586365, 0.5351214408874512), new Point(0.14040084183216095, 0.5351214408874512), new Point(0.14040082693099976, 0.5788829326629639), 27);
		createFace([696, 2203, 219, 216], 28);
		setUVsToFace(new Point(0.6924687027931213, 0.3404949903488159), new Point(0.6968448374491707, 0.3466843952971681), new Point(0.6355787515640259, 0.34668442606925964), 28);
		createFace([2000, 454, 1925, 1044, 1041, 425], 29);
		setUVsToFace(new Point(0.3073301911354065, 0.13228438794612882), new Point(0.3073301911354065, 0.08852292597293854), new Point(0.4823759876619577, 0.08852296861682832), 29);
		createFace([109, 108, 18, 798], 30);
		setUVsToFace(new Point(0.7719271779060364, 0.2505677044391632), new Point(0.7989095449447632, 0.26913875341415405), new Point(0.7500464779626397, 0.26913875341415405), 30);
		createFace([110, 708, 108, 109], 31);
		setUVsToFace(new Point(0.12793456271914372, 0.7907370526754862), new Point(0.09122999757528305, 0.7295427322387695), new Point(0.15580986440181732, 0.7306028604507446), 31);
		createFace([609, 619, 311, 1417], 32);
		setUVsToFace(new Point(0.7567290663719177, 0.5655072927474976), new Point(0.7567290663719177, 0.5778847932815552), new Point(0.6692062616348267, 0.5778847932815552), 32);
		createFace([786, 1453, 1625, 1472, 757], 33);
		setUVsToFace(new Point(0.3510916829109192, 0.1358938217163086), new Point(0.43861463871923545, 0.1358938217163086), new Point(0.49112836913601826, 0.14464612305164337), 33);
		createFace([948, 163, 1196, 951], 34);
		setUVsToFace(new Point(0.7194398045539856, 0.6870526075363159), new Point(0.7543715230083795, 0.6961104922189039), new Point(0.7053030133247375, 0.6992858648300171), 34);
		createFace([379, 1716, 1720, 1724], 35);
		setUVsToFace(new Point(0.40212273597717285, 0.8100952506065369), new Point(0.40212273597717285, 0.8281385898590088), new Point(0.35836121439933777, 0.8281386494636536), 35);
		createFace([1419, 1420, 1417, 1668], 36);
		setUVsToFace(new Point(0.7105781435966492, 0.7328470945358276), new Point(0.7151070237159729, 0.7153814435005188), new Point(0.7619107365608215, 0.7209386825561523), 36);
		createFace([1476, 1467, 654, 655], 37);
		setUVsToFace(new Point(0.9060957431793213, 0.061499327421188354), new Point(0.9060957431793213, 0.11838921904563904), new Point(0.7923157811164856, 0.11838921904563904), 37);
		createFace([1299, 243, 244, 1547], 38);
		setUVsToFace(new Point(0.9875731468200684, 0.18326473236083984), new Point(0.9875731468200684, 0.21094335615634918), new Point(0.9525640606880188, 0.21094335615634918), 38);
		createFace([23, 849, 844, 502], 39);
		setUVsToFace(new Point(0.5827984809875488, 0.33688557147979736), new Point(0.5827984809875488, 0.29312410950660706), new Point(0.6319693326950073, 0.29312410950660706), 39);
		createFace([2075, 1004, 219, 2203, 212], 40);
		setUVsToFace(new Point(0.3073302701237703, 0.17965529011027281), new Point(0.22855966685079157, 0.17090299725532532), new Point(0.2985779643058777, 0.17090299725532532), 40);
		createFace([502, 18, 108, 700, 467], 41);
		setUVsToFace(new Point(0.4555281219898059, 0.7929695258745587), new Point(0.49160975217819214, 0.7929707169532776), new Point(0.49160817265510554, 0.841833770275116), 41);
		createFace([1400, 1276, 1349, 288], 42);
		setUVsToFace(new Point(0.0010000000474974513, 0.6280419230461121), new Point(0.0010000000474974513, 0.5919569134712219), new Point(0.08852288126945496, 0.5919569134712219), 42);
		createFace([1816, 1761, 1771, 2212], 43);
		setUVsToFace(new Point(0.8133054375648499, 0.7716408967971802), new Point(0.8178340464331815, 0.7541751755191034), new Point(0.8646379709243774, 0.7597324252128601), 43);
		createFace([900, 137, 965, 1979], 44);
		setUVsToFace(new Point(0.8759232759475708, 0.535121500492096), new Point(0.9634460891650312, 0.5351214365167535), new Point(0.9634461402893066, 0.5712080597877502), 44);
		createFace([2167, 456, 1674, 1933], 45);
		setUVsToFace(new Point(0.1401860932161454, 0.05634259385060406), new Point(0.2047327309846878, 0.05385627970099449), new Point(0.1948196142911911, 0.08734090626239777), 45);
		createFace([494, 484, 844, 849], 46);
		setUVsToFace(new Point(0.6488752961158752, 0.8653133511543274), new Point(0.6023117303848267, 0.8726151585578918), new Point(0.5971336364746094, 0.8553308248519897), 46);
		createFace([521, 764, 763, 522], 47);
		setUVsToFace(new Point(0.07539449376010164, 0.2401243912740588), new Point(0.08852291107177734, 0.24786041676998138), new Point(0.04476147145032883, 0.24786043167114258), 47);
		createFace([1524, 326, 1487, 1411, 309], 48);
		setUVsToFace(new Point(0.5611466370951733, 0.14464612305164337), new Point(0.48237597070117466, 0.13589383019669585), new Point(0.5698990225791931, 0.1358938217163086), 48);
		createFace([628, 636, 751, 626], 49);
		setUVsToFace(new Point(0.9538511037826538, 0.897118330001831), new Point(0.9976125359535217, 0.897118330001831), new Point(0.9976125955581665, 0.915155291557312), 49);
		createFace([764, 770, 765, 762], 50);
		setUVsToFace(new Point(0.08852291107177734, 0.1358938217163086), new Point(0.17604582382814976, 0.1358938217163086), new Point(0.09727521240711212, 0.14464612305164337), 50);
		createFace([789, 1480, 71, 826, 626, 751], 51);
		setUVsToFace(new Point(0.3561932444572448, 0.2691386342048645), new Point(0.3430648148059845, 0.25056758522987366), new Point(0.45684465765953064, 0.25056761503219604), 51);
		createFace([1682, 456, 2167, 2166], 52);
		setUVsToFace(new Point(0.22988560999865068, 0.7433660523429783), new Point(0.19318105280399323, 0.6821717619895935), new Point(0.2577609419822693, 0.6832319498062134), 52);
		createFace([565, 543, 616, 81], 53);
		setUVsToFace(new Point(0.9972281455993652, 0.03708503395318985), new Point(0.9972281455993652, 0.05512835239386396), new Point(0.9097051024436951, 0.05512833967804909), 53);
		createFace([1575, 1125, 1113, 676], 54);
		setUVsToFace(new Point(0.2951321005821228, 0.5351214408874512), new Point(0.47017791867256165, 0.535121500492096), new Point(0.4614256024360657, 0.5546922087669373), 54);
		createFace([292, 294, 288, 1349], 55);
		setUVsToFace(new Point(0.8977380394935608, 0.9957460761070251), new Point(0.8616617321968079, 0.9948810338973999), new Point(0.8620942358571202, 0.976842953643431), 55);
		createFace([2196, 1859, 1886, 1786], 56);
		setUVsToFace(new Point(0.8003098964691162, 0.9091214537620544), new Point(0.7005264759063721, 0.9128729701042175), new Point(0.717567849622276, 0.8971183629403402), 56);
		createFace([708, 110, 476, 723], 57);
		setUVsToFace(new Point(0.8986900448799133, 0.3400954604148865), new Point(0.8277598023414612, 0.3477441668510437), new Point(0.8471836118294173, 0.2936779141371606), 57);
		createFace([1933, 1674, 1710, 1678], 58);
		setUVsToFace(new Point(0.7578198909759521, 0.4141228199005127), new Point(0.7660261988639832, 0.4680941700935364), new Point(0.6971573198586646, 0.462932640943056), 58);
		createFace([883, 1139, 1155, 1142], 59);
		setUVsToFace(new Point(0.6730543376088278, 0.41411709124454604), new Point(0.694484293460846, 0.4674200415611267), new Point(0.6233178973197937, 0.46242642402648926), 59);
		createFace([1004, 2075, 2066, 2067, 2054, 736, 735], 60);
		setUVsToFace(new Point(0.22855962491861825, 0.17090299725532532), new Point(0.3073302714412346, 0.17965529011027284), new Point(0.2198073079072622, 0.1796552985906601), 60);
		createFace([1673, 2013, 2224, 1710], 61);
		setUVsToFace(new Point(0.8211855888366699, 0.6870526075363159), new Point(0.8561170697212219, 0.6961102485656738), new Point(0.8070489807943082, 0.6992857741691556), 61);
		createFace([1376, 1455, 1440, 1498], 62);
		setUVsToFace(new Point(0.21178045868873596, 0.25056758522987366), new Point(0.32556024193763733, 0.25056758522987366), new Point(0.31243184208869934, 0.2691386342048645), 62);
		createFace([823, 62, 579, 578], 63);
		setUVsToFace(new Point(0.8290969729423523, 0.47462213039398193), new Point(0.9286565780639648, 0.47462210059165955), new Point(0.9286565780639648, 0.4921266734600067), 63);
		createFace([1359, 1498, 1440, 1439], 64);
		setUVsToFace(new Point(0.9097051024436951, 0.09758436679840088), new Point(0.9097051024436951, 0.061499327421188354), new Point(0.9972281455993652, 0.061499349772930145), 64);
		createFace([1313, 1250, 1954, 387], 65);
		setUVsToFace(new Point(0.7536973357200623, 0.14464611749100592), new Point(0.7887063026428223, 0.1358938217163086), new Point(0.7887063026428223, 0.1796552985906601), 65);
		createFace([338, 2019, 1910, 1906], 66);
		setUVsToFace(new Point(0.6600964069366455, 0.49419283866882324), new Point(0.6513440234222779, 0.474622089905885), new Point(0.8263899087905884, 0.47462213039398193), 66);
		createFace([139, 1013, 1010, 956], 67);
		setUVsToFace(new Point(0.09123004227876663, 0.7268357872962952), new Point(0.09123000502586365, 0.6797031760215759), new Point(0.17875291510089764, 0.6797031346842607), 67);
		createFace([1729, 1727, 1687, 1682], 68);
		setUVsToFace(new Point(0.41525110602378845, 0.8073880403667877), new Point(0.35836121439933777, 0.8073880672454834), new Point(0.35836121439933777, 0.7859890460968018), 68);
		createFace([216, 219, 95, 691], 69);
		setUVsToFace(new Point(0.7803823351860046, 0.6756850481033325), new Point(0.7847585082054138, 0.6818745136260986), new Point(0.7585015892982483, 0.6818745136260986), 69);
		createFace([688, 1004, 192, 687], 70);
		setUVsToFace(new Point(0.7842375870520926, 0.7122603058815002), new Point(0.7579806447029114, 0.7122603058815002), new Point(0.7623568177223206, 0.7060708403587341), 70);
		createFace([497, 1568, 1975, 1978, 1981, 1125], 71);
		setUVsToFace(new Point(0.7449448704719543, 0.0010000102039992376), new Point(0.7887062430381775, 0.04038532078266144), new Point(0.7887062430381775, 0.09289907664060593), 71);
		createFace([517, 516, 476, 110], 72);
		setUVsToFace(new Point(0.0010000000474974513, 0.8977106809616089), new Point(0.057889893651008606, 0.8977106809616089), new Point(0.057889893651008606, 0.9191098981975385), 72);
		createFace([1040, 1041, 1214, 1030], 73);
		setUVsToFace(new Point(0.803852379322052, 0.6343890428543091), new Point(0.838783860206604, 0.6434466242790222), new Point(0.7897156476974487, 0.6466221809387207), 73);
		createFace([1284, 265, 1400, 1283], 74);
		setUVsToFace(new Point(0.905904233455658, 0.8762246370315552), new Point(0.9496657848358154, 0.8762246966362), new Point(0.9496657848358154, 0.8942679762840271), 74);
		createFace([1429, 285, 1439, 317], 75);
		setUVsToFace(new Point(0.5469607710838318, 0.886207103729248), new Point(0.500397264957428, 0.8935089111328125), new Point(0.4952191710472107, 0.8762246370315552), 75);
		createFace([2211, 2212, 1769, 2216], 76);
		setUVsToFace(new Point(0.4654093384742737, 0.3536234498023987), new Point(0.46540936827659607, 0.3973849415779114), new Point(0.4162385165691376, 0.3973849415779114), 76);
		createFace([2142, 940, 2143, 181, 1101], 77);
		setUVsToFace(new Point(0.18114749705870184, 0.29041698575019836), new Point(0.08049609881514767, 0.2718459367752075), new Point(0.19427594542503357, 0.2718459367752075), 77);
		createFace([826, 640, 70, 571], 78);
		setUVsToFace(new Point(0.8467844866351828, 0.6248812539287864), new Point(0.7470011115074158, 0.6286327242851257), new Point(0.7640424370765686, 0.612878143787384), 78);
		createFace([1359, 1638, 289, 288], 79);
		setUVsToFace(new Point(0.18957161903381348, 0.5788829326629639), new Point(0.14040082693099976, 0.5788829326629639), new Point(0.14040084183216095, 0.5351214408874512), 79);
		createFace([1373, 303, 1378, 1372], 80);
		setUVsToFace(new Point(0.7196932448113373, 0.9711994994143633), new Point(0.7020752429962158, 0.9560925364494324), new Point(0.8019291758537292, 0.956113874912262), 80);
		createFace([2196, 2191, 2042, 2164], 81);
		setUVsToFace(new Point(0.4743492901325226, 0.27184587717056274), new Point(0.48747768998146057, 0.2904168963432312), new Point(0.4437162408498162, 0.2904168963432312), 81);
		createFace([1113, 1125, 1981, 1169], 82);
		setUVsToFace(new Point(0.335680485643959, 0.15025851130485535), new Point(0.3444327712059021, 0.16982926428318024), new Point(0.3006712794303894, 0.16982926428318024), 82);
		createFace([378, 1724, 1720, 1721], 83);
		setUVsToFace(new Point(0.6048744916915894, 0.16982926428318024), new Point(0.5687982439994812, 0.16896425187587738), new Point(0.5692307353019714, 0.15092609822750092), 83);
		createFace([50, 566, 557, 559], 84);
		setUVsToFace(new Point(0.9518917798995972, 0.9560925364494324), new Point(0.9518917798995972, 0.9741294384002686), new Point(0.9081302285194397, 0.9741294384002686), 84);
		createFace([1524, 2111, 447, 1625], 85);
		setUVsToFace(new Point(0.5611467361450195, 0.14464612305164337), new Point(0.5611467361450195, 0.17090299725532532), new Point(0.4911283850669861, 0.17090299725532532), 85);
		createFace([497, 1125, 1575, 839, 1570], 86);
		setUVsToFace(new Point(0.7449447661033229, 0.0010000043123107628), new Point(0.7449447040732597, 0.04476146037294023), new Point(0.5698989629745483, 0.04476146027445793), 86);
		createFace([1196, 965, 174, 173, 981], 87);
		setUVsToFace(new Point(0.24235188961029053, 0.5788829326629639), new Point(0.19318103761467822, 0.5351215600967772), new Point(0.24235187470912933, 0.535121500492096), 87);
		createFace([235, 237, 1283, 1654], 88);
		setUVsToFace(new Point(0.8523668646812439, 0.8231630325317383), new Point(0.8058032989501953, 0.8304648399353027), new Point(0.8006252646446228, 0.8131805062294006), 88);
		createFace([1601, 1910, 2019, 233, 1649, 1604], 89);
		setUVsToFace(new Point(0.17604577383776115, 0.0010000043861723013), new Point(0.2198072879650156, 0.04476146047142235), new Point(0.04476136714220047, 0.04476146027445793), 89);
		createFace([1044, 1219, 1214, 1041], 90);
		setUVsToFace(new Point(0.7923158407211304, 0.13589385151863098), new Point(0.8414866924285889, 0.1358938366174698), new Point(0.8414866924285889, 0.1796552836894989), 90);
		createFace([1837, 1040, 1030, 1830], 91);
		setUVsToFace(new Point(0.9914062023162842, 0.26294511556625366), new Point(0.9038833379745483, 0.26294514536857605), new Point(0.9038833379745483, 0.2505675256252289), 91);
		createFace([174, 965, 137, 956], 92);
		setUVsToFace(new Point(0.7482005233282836, 0.856671116211086), new Point(0.7973532676696777, 0.8580114841461182), new Point(0.7627846002578735, 0.8683677911758423), 92);
		createFace([2226, 2009, 1689, 1696], 93);
		setUVsToFace(new Point(0.7480319738388062, 0.8355960249900818), new Point(0.7971845269203186, 0.8369364142417908), new Point(0.7626158595085144, 0.8472926616668701), 93);
		createFace([1400, 256, 1267, 1647], 94);
		setUVsToFace(new Point(0.596964955329895, 0.8306462168693542), new Point(0.601493775844574, 0.8131805062294006), new Point(0.6482974886894226, 0.8187378644943237), 94);
		createFace([897, 871, 121, 122], 95);
		setUVsToFace(new Point(0.8544498126712288, 0.4047739392252045), new Point(0.7854315042495728, 0.4072316586971283), new Point(0.7957474589347839, 0.3536234498023987), 95);
		createFace([1276, 1316, 1378, 1376, 1498, 1349], 96);
		setUVsToFace(new Point(0.09362454712390901, 0.2691385746002197), new Point(0.08049608767032623, 0.2505675256252289), new Point(0.194275900491982, 0.2505675643682849), 96);
		createFace([1250, 1313, 1295, 1294], 97);
		setUVsToFace(new Point(0.7887063026428223, 0.1358938217163086), new Point(0.7536973357200623, 0.14464612305164337), new Point(0.7011834896673801, 0.1358938259565092), 97);
		createFace([1428, 311, 619, 1416], 98);
		setUVsToFace(new Point(0.19318105280399323, 0.8286206722259521), new Point(0.1931810826063156, 0.7925341129302979), new Point(0.28070399165153503, 0.7925342321395874), 98);
		createFace([1559, 1563, 343, 344], 99);
		setUVsToFace(new Point(0.5277113318443298, 0.7546671032905579), new Point(0.6056835651397705, 0.7541751265525818), new Point(0.5921858258092845, 0.7842264882512721), 99);
		createFace([1524, 309, 1618, 1525], 100);
		setUVsToFace(new Point(0.9247541143319886, 0.6274756769220813), new Point(0.863487958908081, 0.6274756789207458), new Point(0.8678640723228455, 0.6212862133979797), 100);
		createFace([71, 1480, 1476, 655], 101);
		setUVsToFace(new Point(0.666499137878418, 0.5628001689910889), new Point(0.5527192950248718, 0.5628001093864441), new Point(0.5527192950248718, 0.5351214408874512), 101);
		createFace([985, 187, 181, 2143], 102);
		setUVsToFace(new Point(0.5539683103561401, 0.6721144914627075), new Point(0.5539683103561401, 0.6546099185943604), new Point(0.6535279154777527, 0.6546099185943604), 102);
		createFace([2120, 212, 2089, 447, 2122], 103);
		setUVsToFace(new Point(0.4386146366596222, 0.1796552985906601), new Point(0.35109170447483834, 0.1796553114322329), new Point(0.42986235289056124, 0.17090300624442328), 103);
		createFace([1256, 1332, 288, 289], 104);
		setUVsToFace(new Point(0.6488752365112305, 0.886207103729248), new Point(0.6023117303848267, 0.8935089111328125), new Point(0.5971336364746094, 0.8762246370315552), 104);
		createFace([13, 479, 556, 494], 105);
		setUVsToFace(new Point(0.6958343982696533, 0.7479705810546875), new Point(0.6083114743232727, 0.7479705810546875), new Point(0.6083114743232727, 0.7355930209159851), 105);
		createFace([1054, 981, 1101, 1050], 106);
		setUVsToFace(new Point(0.32330143451690674, 0.3897084593772888), new Point(0.23577851057052612, 0.3897084593772888), new Point(0.23577851057052612, 0.3536234498023987), 106);
		createFace([1301, 1294, 1295, 1308], 107);
		setUVsToFace(new Point(0.7318165302276611, 0.24012413620948792), new Point(0.7449447100710995, 0.24786015908819597), new Point(0.7011833190917969, 0.24786017835140228), 107);
		createFace([789, 1440, 1455, 1480], 108);
		setUVsToFace(new Point(0.3561932912203437, 0.2691386342048645), new Point(0.31243184208869934, 0.2691386342048645), new Point(0.32556024193763733, 0.25056758522987366), 108);
		createFace([861, 860, 624, 1416], 109);
		setUVsToFace(new Point(0.4771304130554199, 0.4141227900981903), new Point(0.47713038325309753, 0.4578842222690582), new Point(0.42795953154563904, 0.4578842222690582), 109);
		createFace([849, 1570, 13, 494], 110);
		setUVsToFace(new Point(0.6462861895561218, 0.856671154499054), new Point(0.695438802242279, 0.8580114841461182), new Point(0.6608700752258301, 0.8683677911758423), 110);
		createFace([235, 1231, 1537, 237], 111);
		setUVsToFace(new Point(0.9718059301376343, 0.34424519538879395), new Point(0.9028207659721375, 0.3467322885990143), new Point(0.913169085357581, 0.29315312015290407), 111);
		createFace([156, 677, 680, 682], 112);
		setUVsToFace(new Point(0.9140697121620178, 0.7328860206090559), new Point(0.9140697121620178, 0.7153814435005188), new Point(0.9665835499763489, 0.7153814435005188), 112);
		createFace([1213, 920, 2142, 173], 113);
		setUVsToFace(new Point(0.0010000085458159447, 0.5712065100669861), new Point(0.001000000065431203, 0.5351214408874495), new Point(0.08852292597293854, 0.5351214408874512), 113);
		createFace([272, 273, 1313, 271], 114);
		setUVsToFace(new Point(0.3674603998661041, 0.521993100643158), new Point(0.3718365430831909, 0.5281824469566345), new Point(0.31057029962539673, 0.5281824469566345), 114);
		createFace([1213, 910, 913, 917], 115);
		setUVsToFace(new Point(0.9511440992355347, 0.915161669254303), new Point(0.907382607460022, 0.9151617884635925), new Point(0.9073825478553772, 0.8971184492111206), 115);
		createFace([2193, 1801, 1789, 2180], 116);
		setUVsToFace(new Point(0.7379403710365295, 0.6498365998268127), new Point(0.638380765914917, 0.6498365998268127), new Point(0.638380765914917, 0.6323320269584656), 116);
		createFace([765, 732, 735, 736], 117);
		setUVsToFace(new Point(0.09727521240711212, 0.14464612305164337), new Point(0.16729356348514557, 0.14464612305164337), new Point(0.16729356348514557, 0.17090299725532532), 117);
		createFace([1364, 300, 1458, 298], 118);
		setUVsToFace(new Point(0.11477981507778168, 0.47462210059165955), new Point(0.11477981507778168, 0.5315120220184326), new Point(0.0010000000474974513, 0.5315120220184326), 118);
		createFace([1882, 2089, 1472, 1532], 119);
		setUVsToFace(new Point(0.9880339943054575, 0.5351214408874512), new Point(0.9924101829528809, 0.5413109064102173), new Point(0.9661532640457153, 0.5413109064102173), 119);
		createFace([1098, 1095, 981, 1054], 120);
		setUVsToFace(new Point(0.32330143451690674, 0.40775176882743835), new Point(0.23577851057052612, 0.4077517666420934), new Point(0.23577851057052612, 0.3897084593772888), 120);
		createFace([1213, 917, 918, 920], 121);
		setUVsToFace(new Point(0.319768488407135, 0.9293885827064514), new Point(0.31949353218078613, 0.947429895401001), new Point(0.28341108560562134, 0.9468798637390137), 121);
		createFace([566, 626, 823, 578, 557], 122);
		setUVsToFace(new Point(0.575000524520874, 0.2691386938095093), new Point(0.48747737420236964, 0.2691386938095093), new Point(0.5881289497372603, 0.25056764483451843), 122);
		createFace([1411, 273, 1622, 309], 123);
		setUVsToFace(new Point(0.6136605066621911, 0.13589382210998083), new Point(0.6924310922622681, 0.14464612305164337), new Point(0.6924310922622681, 0.17090299725532532), 123);
		createFace([1300, 1301, 243, 1299], 124);
		setUVsToFace(new Point(0.6162298965300528, 0.989915894315639), new Point(0.5986120104789734, 0.974808931350708), new Point(0.698465883731842, 0.9748302698135376), 124);
		createFace([395, 2000, 2234, 397], 125);
		setUVsToFace(new Point(0.7747645378112793, 0.7562320828437805), new Point(0.8096960186958313, 0.7652897238731384), new Point(0.7606277882287708, 0.7684652411840968), 125);
		createFace([1066, 209, 1083, 1068], 126);
		setUVsToFace(new Point(0.5539683103561401, 0.7025003433227539), new Point(0.5539683103561401, 0.684995710849762), new Point(0.6535279154777527, 0.684995710849762), 126);
		createFace([2120, 2122, 1859, 1865], 127);
		setUVsToFace(new Point(0.3510916531085968, 0.21420887112617493), new Point(0.3073302209377289, 0.21420885622501373), new Point(0.32045865058898926, 0.20647285878658295), 127);
		createFace([216, 691, 106, 696], 128);
		setUVsToFace(new Point(0.805538535118103, 0.9735971689224243), new Point(0.805538535118103, 0.9560925364494324), new Point(0.8580523729324341, 0.9560925364494324), 128);
		createFace([1830, 2034, 429, 2238], 129);
		setUVsToFace(new Point(0.6487064957618713, 0.8442382216453552), new Point(0.6021429896354675, 0.8515400290489197), new Point(0.596964955329895, 0.8342556953430176), 129);
		createFace([102, 726, 723, 114], 130);
		setUVsToFace(new Point(0.5400218963623047, 0.7459490299224854), new Point(0.5277113914489746, 0.7153814435005188), new Point(0.6056034858836703, 0.7189212506853685), 130);
		createFace([447, 2089, 1882, 1878], 131);
		setUVsToFace(new Point(0.6814067363739014, 0.4096525311470032), new Point(0.6201406504888185, 0.4096525899002279), new Point(0.6245167851448059, 0.40346312522888184), 131);
		createFace([1048, 207, 1054, 1050], 132);
		setUVsToFace(new Point(0.9442064762115479, 0.9957396388053894), new Point(0.9081302285194397, 0.9948746562004089), new Point(0.9085627999813457, 0.9768365781980181), 132);
		createFace([723, 726, 720, 708], 133);
		setUVsToFace(new Point(0.19318105280399323, 0.7479536533355713), new Point(0.2711492768992102, 0.746960922748824), new Point(0.2554696500301361, 0.7889247536659241), 133);
		createFace([2053, 2052, 112, 762], 134);
		setUVsToFace(new Point(0.036009032279253006, 0.17090299725532532), new Point(0.0010000000474974513, 0.1796552985906601), new Point(0.0010000000474974513, 0.1358938217163086), 134);
		createFace([700, 720, 499, 467], 135);
		setUVsToFace(new Point(0.6404306888580322, 0.47462210059165955), new Point(0.6486369967460632, 0.5285935401916504), new Point(0.5797680150805379, 0.5234320144629487), 135);
		createFace([1745, 1739, 363, 1735], 136);
		setUVsToFace(new Point(0.9011762738227844, 0.2680722177028656), new Point(0.8016166687011719, 0.2680722177028656), new Point(0.8016166687011719, 0.2505675256252289), 136);
		createFace([1917, 1118, 1508, 1509], 137);
		setUVsToFace(new Point(0.7687332034111023, 0.4141227900981903), new Point(0.9437789916992188, 0.4141228199005127), new Point(0.9350267385563094, 0.43369355784185504), 137);
		createFace([1472, 2089, 212, 2203], 138);
		setUVsToFace(new Point(0.4298623204231262, 0.14464612305164337), new Point(0.4298623204231262, 0.17090299725532532), new Point(0.35109166697995137, 0.1796552981969879), 138);
		createFace([317, 1439, 1419, 1668], 139);
		setUVsToFace(new Point(0.5673604011535645, 0.3536234498023987), new Point(0.616531252861023, 0.3536234498023987), new Point(0.616531252861023, 0.3973848521709442), 139);
		createFace([2142, 1101, 979, 969], 140);
		setUVsToFace(new Point(0.044761452823877335, 0.982875645160675), new Point(0.0010000000474974513, 0.982875645160675), new Point(0.0010000000474974513, 0.9648387432098389), 140);
		createFace([114, 723, 1142, 1160], 141);
		setUVsToFace(new Point(0.4897741675376892, 0.6205487251281738), new Point(0.47590771317481995, 0.6047702431678772), new Point(0.53864985704422, 0.6047702431678772), 141);
		createFace([372, 1696, 1771, 1761], 142);
		setUVsToFace(new Point(0.08852288126945496, 0.6487922668457031), new Point(0.08852288976777674, 0.6959248367830968), new Point(0.0010000085458159447, 0.6959249377250671), 142);
		createFace([687, 192, 191, 686], 143);
		setUVsToFace(new Point(0.9675650000572205, 0.7541751265525818), new Point(0.9675650000572205, 0.7716797590255737), new Point(0.9150511622428894, 0.7716797590255737), 143);
		createFace([1055, 208, 204, 2041], 144);
		setUVsToFace(new Point(0.08382594585418701, 0.9223604798316956), new Point(0.08355095982551575, 0.9404017329216003), new Point(0.047468531876802444, 0.9398517608642578), 144);
		createFace([279, 1636, 1638, 1330], 145);
		setUVsToFace(new Point(0.5584241151809692, 0.8152374625205994), new Point(0.5933554988228206, 0.824294856169375), new Point(0.5442873239517212, 0.8274706602096558), 145);
		createFace([1045, 948, 951, 1037], 146);
		setUVsToFace(new Point(0.9972281455993652, 0.1307123899459839), new Point(0.9097051024436951, 0.13071241974830627), new Point(0.9097051024436951, 0.1183348000049591), 146);
		createFace([2211, 2216, 396, 1759], 147);
		setUVsToFace(new Point(0.9088789820671082, 0.6863359808921814), new Point(0.9580315351486206, 0.6876763701438904), new Point(0.9234628677368164, 0.6980326175689697), 147);
		createFace([544, 537, 538, 541], 148);
		setUVsToFace(new Point(0.6402422785758972, 0.5655072927474976), new Point(0.6402422785758972, 0.5778848558844556), new Point(0.5527192950248718, 0.5778847932815552), 148);
		createFace([1231, 1563, 1559, 1542], 149);
		setUVsToFace(new Point(0.10525160282850266, 0.8368780612945557), new Point(0.0912291096116459, 0.7943320115936974), new Point(0.16909855604171753, 0.7983804941177368), 149);
		createFace([2041, 2042, 2034, 198, 1055], 150);
		setUVsToFace(new Point(0.11838924139738083, 0.47462210059165955), new Point(0.20591217279434204, 0.47462210059165955), new Point(0.20591217279434204, 0.5287504196166992), 150);
		createFace([1856, 2042, 2191, 1847], 151);
		setUVsToFace(new Point(0.4812428057193756, 0.9002265334129333), new Point(0.4812428057193756, 0.9182634353637695), new Point(0.4374814033508301, 0.9182634353637695), 151);
		createFace([280, 1663, 1636, 279], 152);
		setUVsToFace(new Point(0.5250043272972107, 0.7153814987344809), new Point(0.5250043272972107, 0.7514680624008179), new Point(0.4374814033508301, 0.7514680027961731), 152);
		createFace([2041, 204, 1048, 1050], 153);
		setUVsToFace(new Point(0.35836121439933777, 0.8488825559616089), new Point(0.35836121439933777, 0.8308456540107727), new Point(0.4021226763725281, 0.8308456540107727), 153);
		createFace([987, 155, 154, 162], 154);
		setUVsToFace(new Point(0.3495582938194275, 0.35001397132873535), new Point(0.23577852547168732, 0.35001397132873535), new Point(0.23577852547168732, 0.29312407970428467), 154);
		createFace([981, 180, 979, 1101], 155);
		setUVsToFace(new Point(0.3197684586048126, 0.9719724059104919), new Point(0.31949350237846375, 0.990013599395752), new Point(0.28341108560562134, 0.9894636273384094), 155);
		createFace([881, 931, 923, 924], 156);
		setUVsToFace(new Point(0.8200589418411255, 0.8913315534591675), new Point(0.8024410009384155, 0.8762246370315552), new Point(0.9022948178836006, 0.8762459516861492), 156);
		createFace([1710, 1674, 1960, 1673], 157);
		setUVsToFace(new Point(0.19318105280399323, 0.884347677230835), new Point(0.2607245400341116, 0.8701125378715169), new Point(0.2602778971195221, 0.9149174690246582), 157);
		createFace([476, 112, 723], 158);
		setUVsToFace(new Point(0.13928982615470886, 0.08575607091188431), new Point(0.09797382354736328, 0.06317060440778732), new Point(0.10048788785934448, 0.049772877246141434), 158);
		createFace([1568, 726, 102], 159);
		setUVsToFace(new Point(0.2515966296195984, 0.5323848724365234), new Point(0.20861925184726715, 0.5319300889968872), new Point(0.2400387078523636, 0.521993100643158), 159);
		createFace([883, 881, 924, 1139], 160);
		setUVsToFace(new Point(0.28341108560562134, 0.8167992406963178), new Point(0.28341108560562134, 0.7954000234603882), new Point(0.340300977230072, 0.7954000234603882), 160);
		createFace([1279, 1276, 1290, 263], 161);
		setUVsToFace(new Point(0.9945854544639587, 0.8733677268028259), new Point(0.9508240222930908, 0.8733677268028259), new Point(0.9508240222930908, 0.8553308248519897), 161);
		createFace([1530, 1625, 447, 1878], 162);
		setUVsToFace(new Point(0.8821280598640442, 0.675503671169281), new Point(0.8865042328834534, 0.6816931366920471), new Point(0.8602473799412176, 0.6816931366920471), 162);
		createFace([1083, 2164, 2042, 2041, 1050, 1068], 163);
		setUVsToFace(new Point(0.3430648744106293, 0.27184590697288513), new Point(0.45684475070187397, 0.27184590697288513), new Point(0.443716316931383, 0.290416955947876), 163);
		createFace([251, 1604, 1647, 1267], 164);
		setUVsToFace(new Point(0.6601698398590088, 0.8152374625205994), new Point(0.6951012280918367, 0.8242948388739556), new Point(0.6460330486297607, 0.8274706602096558), 164);
		createFace([1696, 372, 1720, 2226], 165);
		setUVsToFace(new Point(0.7506210803985596, 0.8442382216453552), new Point(0.7040575858004334, 0.8515401073508413), new Point(0.6988794207572937, 0.8342556953430176), 165);
		createFace([271, 1313, 387, 2022], 166);
		setUVsToFace(new Point(0.48107653856277466, 0.07503356390857394), new Point(0.47488704323768616, 0.07940970361232758), new Point(0.47488704323768616, 0.05315282940864563), 166);
		createFace([1759, 1758, 1894, 2211], 167);
		setUVsToFace(new Point(0.9114680886268616, 0.6949782371520996), new Point(0.8649044632911682, 0.7022799849510193), new Point(0.8597264885902405, 0.684995710849762), 167);
		createFace([1919, 454, 1917, 1509], 168);
		setUVsToFace(new Point(0.009752288460731506, 0.9413875937461853), new Point(0.0010000000474974513, 0.9218169450759888), new Point(0.044761452823877335, 0.9218169450759888), 168);
		createFace([52, 601, 565, 53], 169);
		setUVsToFace(new Point(0.9479482173919678, 0.8342558145523071), new Point(0.9479482173919678, 0.8522990942001343), new Point(0.9041867852210999, 0.8522989749908447), 169);
		createFace([181, 187, 1093, 182], 170);
		setUVsToFace(new Point(0.9005774220343429, 0.8462588154219292), new Point(0.8007939457893372, 0.8500102758407593), new Point(0.81783527135849, 0.8342556953430176), 170);
		createFace([2180, 1745, 1721, 406, 2185, 2193], 171);
		setUVsToFace(new Point(0.605633556842804, 0.27184584736824036), new Point(0.7194134593009949, 0.27184581756591797), new Point(0.706285053897366, 0.29041684361606734), 171);
		createFace([521, 606, 55, 579, 770, 764], 172);
		setUVsToFace(new Point(0.07539454604748934, 0.24012448289096713), new Point(0.07539454810708743, 0.21691647567449301), new Point(0.18917427957057953, 0.21691633760929108), 172);
		createFace([1169, 1981, 1108, 222], 173);
		setUVsToFace(new Point(0.36711356043815613, 0.6519027948379517), new Point(0.3583611839229229, 0.6323320776084908), new Point(0.5334070324897766, 0.6323320865631104), 173);
		createFace([2166, 2167, 1711, 1721, 1745, 1735], 174);
		setUVsToFace(new Point(0.7719273072889903, 0.27184581756591797), new Point(0.7989095644807862, 0.2904168367385864), new Point(0.7500464916229248, 0.2904168367385864), 174);
		createFace([931, 151, 940, 923], 176);
		setUVsToFace(new Point(0.5361142158508301, 0.6498368382453918), new Point(0.5361142158508301, 0.6323320865631104), new Point(0.6356737613677979, 0.6323320865631104), 176);
		createFace([871, 115, 1142, 1155], 177);
		setUVsToFace(new Point(0.9082885384559631, 0.17844101786613464), new Point(0.8942660552671183, 0.13589486704859188), new Point(0.9721354246139526, 0.1399434357881546), 177);
		createFace([1739, 1749, 1829, 1789, 2104, 2103], 178);
		setUVsToFace(new Point(0.07539448158592028, 0.20647276505653034), new Point(0.0753944815859203, 0.1832647429389156), new Point(0.1891743242740631, 0.18326477706432343), 178);
		createFace([1279, 1283, 1537, 238], 179);
		setUVsToFace(new Point(0.9922612905502319, 0.4061338007450104), new Point(0.9561762809753418, 0.4061349332332611), new Point(0.9651983380317688, 0.3536234498023987), 179);
		createFace([1400, 265, 1290, 1276], 180);
		setUVsToFace(new Point(0.319768488407135, 0.9506804943084717), new Point(0.3194935023253846, 0.9687216777622298), new Point(0.28341108560562134, 0.9681717157363892), 180);
		createFace([763, 112, 476, 516, 522], 181);
		setUVsToFace(new Point(0.04476147145032883, 0.24786043167114258), new Point(0.0010000228212425286, 0.24786050732733225), new Point(0.03649063691710826, 0.21691640147486355), 181);
		createFace([2097, 1954, 1687, 1727, 363], 182);
		setUVsToFace(new Point(0.04476143792271614, 0.21420875191688538), new Point(0.0010000000474974513, 0.21420875191688538), new Point(0.03649061545729637, 0.18326473236083984), 182);
		createFace([2224, 2013, 2009, 2226], 183);
		setUVsToFace(new Point(0.37517926598423423, 0.457884281873703), new Point(0.32600849866867065, 0.457884281873703), new Point(0.32600849866867065, 0.4141227900981903), 183);
		createFace([325, 324, 1480, 1455], 184);
		setUVsToFace(new Point(0.5947787761688232, 0.7929689288139343), new Point(0.5947787761688232, 0.8104735016822815), new Point(0.4952191710472107, 0.8104735016822815), 184);
		createFace([367, 1769, 2212, 1771], 185);
		setUVsToFace(new Point(0.8765103220939636, 0.7562320828437805), new Point(0.9114418029785156, 0.7652897238731384), new Point(0.8623735724575563, 0.7684652449770677), 185);
		createFace([1066, 1065, 1093, 187, 2066, 2075], 186);
		setUVsToFace(new Point(0.4692476279370558, 0.2064729087357377), new Point(0.46924763917922974, 0.18326488137245178), new Point(0.5830274224281311, 0.18326494097709656), 186);
		createFace([948, 1045, 1044, 163], 187);
		setUVsToFace(new Point(0.7856931686401367, 0.535121500492096), new Point(0.8732160925865101, 0.5351213769121081), new Point(0.8732161521911621, 0.5712080597877502), 187);
		createFace([2216, 2000, 395, 396], 188);
		setUVsToFace(new Point(0.17875295877456304, 0.9144654826326359), new Point(0.09123001992702484, 0.9144655466079712), new Point(0.09122999012470245, 0.8783789277076721), 188);
		createFace([2191, 2196, 2193, 2185], 189);
		setUVsToFace(new Point(0.48747768998146057, 0.2904168963432312), new Point(0.47434929984866103, 0.27184584736824036), new Point(0.5881290435791016, 0.27184584736824036), 189);
		createFace([1711, 377, 378, 1721], 190);
		setUVsToFace(new Point(0.9523728489875793, 0.8942614793777466), new Point(0.9523728489875793, 0.8762246370315552), new Point(0.996134340763092, 0.8762246370315552), 190);
		createFace([396, 395, 397, 1759], 191);
		setUVsToFace(new Point(0.798101007938385, 0.7488340705452936), new Point(0.7105781435966492, 0.7488340735435486), new Point(0.7105781435966492, 0.7364565134048462), 191);
		createFace([2053, 762, 677, 156], 192);
		setUVsToFace(new Point(0.18567620435857402, 0.7357321977615356), new Point(0.15941931307315826, 0.7357321977615356), new Point(0.16379544138908386, 0.7295427322387695), 192);
		createFace([1878, 1882, 1532, 1530], 193);
		setUVsToFace(new Point(0.5477328896522522, 0.9742447137832642), new Point(0.4952191710472107, 0.9742447137832642), new Point(0.4952191710472107, 0.956740140914917), 193);
		createFace([918, 909, 2129, 920], 194);
		setUVsToFace(new Point(0.9490082859992981, 0.8131805658340454), new Point(0.9927697777748108, 0.8131805658340454), new Point(0.9927697777748108, 0.8312174677848816), 194);
		createFace([18, 510, 8, 798], 195);
		setUVsToFace(new Point(0.75004643201828, 0.26913872361183167), new Point(0.7062848806381226, 0.26913872361183167), new Point(0.7194133996963501, 0.2505677044391632), 195);
		createFace([1716, 379, 377, 1711], 196);
		setUVsToFace(new Point(0.4337831437587738, 0.8971583843231201), new Point(0.43350815773010254, 0.9151996374130249), new Point(0.39742574101013883, 0.9146496753625107), 196);
		createFace([2164, 1083, 1087, 1085], 197);
		setUVsToFace(new Point(0.7442941665649414, 0.6101710796356201), new Point(0.6305142641067505, 0.6101710796356201), new Point(0.6305141448974609, 0.582492470741272), 197);
		createFace([1636, 1663, 1917, 1910, 1601], 198);
		setUVsToFace(new Point(0.21980728209018707, 0.001000004238449037), new Point(0.3073302445612175, 0.0010000084786417653), new Point(0.3073302445612175, 0.04476146875484338), 198);
		createFace([462, 497, 23, 499], 199);
		setUVsToFace(new Point(0.875528872013092, 0.717438280582428), new Point(0.910460352897644, 0.7264959216117859), new Point(0.8613921168230726, 0.7296715895697904), 199);
		createFace([1673, 1960, 1926, 2013], 200);
		setUVsToFace(new Point(0.43387195467948914, 0.6973220705986023), new Point(0.36514395475387573, 0.6970512270927429), new Point(0.35836121439933777, 0.6546099185943604), 200);
		createFace([387, 1622, 1740, 2022], 201);
		setUVsToFace(new Point(0.4892257750034332, 0.4676830768585205), new Point(0.4279595299699178, 0.4676831096292991), new Point(0.4323357045650482, 0.46149370074272156), 201);
		createFace([263, 1284, 1283, 1279], 202);
		setUVsToFace(new Point(0.3194873631000519, 0.8814311623573303), new Point(0.2834111154079437, 0.8805661797523499), new Point(0.2838436190656325, 0.8625280398699504), 202);
		createFace([1207, 910, 1213, 1205], 203);
		setUVsToFace(new Point(0.14040082693099976, 0.5824925303459167), new Point(0.18957163393497467, 0.582492470741272), new Point(0.18957164883613586, 0.6262539029121399), 203);
		createFace([844, 484, 7, 601], 204);
		setUVsToFace(new Point(0.44069063663482666, 0.3292090892791748), new Point(0.44069063663482666, 0.34725242853164673), new Point(0.35316771268844604, 0.34725242853164673), 204);
		createFace([1207, 1978, 905, 897], 205);
		setUVsToFace(new Point(0.5443716645240784, 0.8984586596488953), new Point(0.5935243368148804, 0.8997990489006042), new Point(0.5589556286753095, 0.9101553651549296), 205);
		createFace([59, 788, 688, 732, 765, 770], 206);
		setUVsToFace(new Point(0.21980731189250946, 0.1358938217163086), new Point(0.3073302833969816, 0.13589383019669588), new Point(0.22855963049796624, 0.1446461230516434), 206);
		createFace([387, 2103, 2104, 418, 1621, 1622], 207);
		setUVsToFace(new Point(0.7536973445044536, 0.17090299725532532), new Point(0.701183461924569, 0.1796552985906601), new Point(0.6136605739593506, 0.1796552985906601), 207);
		createFace([1064, 1068, 181, 182], 208);
		setUVsToFace(new Point(0.5512612164020538, 0.6546099185943604), new Point(0.5512612462043762, 0.6822885274887085), new Point(0.43748143315315247, 0.6822885274887085), 208);
		createFace([2164, 1865, 1859, 2196], 209);
		setUVsToFace(new Point(0.7078710794448853, 0.732886016368866), new Point(0.6083114743232727, 0.732886016368866), new Point(0.6083114743232727, 0.7153814435005188), 209);
		createFace([1663, 317, 1668, 1428], 210);
		setUVsToFace(new Point(0.518189549446106, 0.3536234498023987), new Point(0.5673604011535645, 0.3536234498023987), new Point(0.5673604011535645, 0.3973848521709442), 210);
		createFace([897, 122, 910, 1207], 211);
		setUVsToFace(new Point(0.5469607710838318, 0.9071009159088135), new Point(0.500397264957428, 0.9144026637077332), new Point(0.4952191710472107, 0.897118330001831), 211);
		createFace([1966, 1960, 1969, 1965], 212);
		setUVsToFace(new Point(0.8966283798217773, 0.5274675488471985), new Point(0.8843178153038025, 0.49689990282058716), new Point(0.9622097848231168, 0.5004397344751504), 212);
		createFace([940, 151, 154, 155], 213);
		setUVsToFace(new Point(0.6969171127196151, 0.9091214818616005), new Point(0.5971336364746094, 0.9128729701042175), new Point(0.6141749620437622, 0.897118330001831), 213);
		createFace([162, 154, 151, 2054, 2067, 985], 214);
		setUVsToFace(new Point(0.6005320298114021, 0.1832649275660478), new Point(0.7143118381500244, 0.18326498568058014), new Point(0.7143118188466353, 0.20647302105003107), 214);
		createFace([616, 543, 544, 541], 215);
		setUVsToFace(new Point(0.09123001992702484, 0.629863440990448), new Point(0.17875298857688904, 0.6298635005950928), new Point(0.17875297367572207, 0.6769960705324795), 215);
		createFace([325, 326, 1453, 324], 216);
		setUVsToFace(new Point(0.46924763917922974, 0.24012424051761627), new Point(0.4823760390281677, 0.24786023795604706), new Point(0.4386146068572998, 0.24786025285720825), 216);
		createFace([2021, 450, 2019, 338], 217);
		setUVsToFace(new Point(0.7299848198890686, 0.15025849640369415), new Point(0.7387371063232422, 0.16982926428318024), new Point(0.6949756145477295, 0.16982926428318024), 217);
		createFace([162, 985, 2143, 987], 218);
		setUVsToFace(new Point(0.8231564576343954, 0.9524830722305662), new Point(0.805538535118103, 0.9373761415481567), new Point(0.9053924679756165, 0.9373974204063416), 218);
		createFace([1969, 1960, 1674, 456], 219);
		setUVsToFace(new Point(0.0010000000474974513, 0.7582150101661682), new Point(0.07896745949983597, 0.7572212815284729), new Point(0.0632886067032814, 0.7991860508918762), 219);
		createFace([163, 1044, 1925, 1118, 1108, 965], 220);
		setUVsToFace(new Point(0.5698989629745483, 0.13228440284729004), new Point(0.48237593186539834, 0.13228439860709676), new Point(0.48237593186539834, 0.08852293239371313), 220);
		createFace([1758, 1759, 397, 399], 221);
		setUVsToFace(new Point(0.28070399165153503, 0.6323321461677551), new Point(0.28070399165153503, 0.6794646978378296), new Point(0.19318105280399323, 0.6794647574424744), 221);
		createFace([789, 751, 613, 1420, 1419], 222);
		setUVsToFace(new Point(0.23577848076820374, 0.4141227900981903), new Point(0.32330140471458435, 0.4141235947608948), new Point(0.32330140471458435, 0.46825110912323), 222);
		createFace([826, 823, 626], 223);
		setUVsToFace(new Point(0.4743492305278778, 0.25056761503219604), new Point(0.5881289839744568, 0.25056764483451843), new Point(0.4874776303768158, 0.2691386640071869), 223);
		createFace([155, 987, 2143, 940], 224);
		setUVsToFace(new Point(0.6513440608978271, 0.49689996242523193), new Point(0.7651237845420837, 0.49689990282058716), new Point(0.7651237845420837, 0.5245785713195801), 224);
		createFace([606, 529, 533, 55], 225);
		setUVsToFace(new Point(0.11838927119970322, 0.410513311624527), new Point(0.11838927119970322, 0.3536234498023987), new Point(0.23216907680034637, 0.3536234498023987), 225);
		createFace([981, 1095, 951, 1196], 226);
		setUVsToFace(new Point(0.6562349200248718, 0.7024614214897156), new Point(0.6607636213302612, 0.684995710849762), new Point(0.7075673937797546, 0.6905529499053955), 226);
		createFace([2127, 1155, 1139, 2124], 227);
		setUVsToFace(new Point(0.038445331156253815, 0.6986319422721863), new Point(0.07234072685241699, 0.7536118030548096), new Point(0.000983375569858301, 0.753310517621809), 227);
		createFace([1786, 1803, 2193, 2196], 228);
		setUVsToFace(new Point(0.7470011711120605, 0.582492470741272), new Point(0.8607809543609619, 0.582492470741272), new Point(0.8607809543609619, 0.6101710796356201), 228);
		createFace([272, 271, 2022, 1740], 229);
		setUVsToFace(new Point(0.9464861154556274, 0.4141227900981903), new Point(0.9989998936653137, 0.4141227900981903), new Point(0.9989998936653137, 0.4316273970090571), 229);
		createFace([1066, 2075, 212, 209], 230);
		setUVsToFace(new Point(0.46924763917922974, 0.20647290349006653), new Point(0.4823760390281677, 0.2142089307308197), new Point(0.4386146068572998, 0.21420890092849731), 230);
		createFace([798, 522, 516, 517], 231);
		setUVsToFace(new Point(0.7302975654602051, 0.6248812675476074), new Point(0.6305141448974609, 0.6286327838897705), new Point(0.6475555147382546, 0.6128782434292), 231);
		createFace([58, 62, 823, 572], 232);
		setUVsToFace(new Point(0.6162298971788139, 0.9524830810336957), new Point(0.5986120104789734, 0.9373761415481567), new Point(0.698465883731842, 0.9373974204063416), 232);
		createFace([2129, 2127, 2124, 923], 233);
		setUVsToFace(new Point(0.04986307742860243, 0.29041701555252075), new Point(0.0010000000474974513, 0.29041701555252075), new Point(0.027982383966445923, 0.2718459665775299), 233);
		createFace([1458, 300, 302, 1487, 326, 325], 234);
		setUVsToFace(new Point(0.46924763917922974, 0.21691623330116272), new Point(0.5830273137192622, 0.21691613828322892), new Point(0.5830273137192622, 0.24012414549968247), 234);
		createFace([2127, 2129, 910, 122, 121], 235);
		setUVsToFace(new Point(0.3375414584216466, 0.7429256024649832), new Point(0.3375409936877625, 0.7917886802805438), new Point(0.3014543950557709, 0.7917900085449219), 235);
		createFace([2103, 2097, 363, 1739], 236);
		setUVsToFace(new Point(0.08852294832468033, 0.21420878171920776), new Point(0.04476142696098094, 0.2142087624559668), new Point(0.057889752089977264, 0.2064727544784546), 236);
		createFace([956, 1010, 173, 174], 237);
		setUVsToFace(new Point(0.7507897019386292, 0.8653133511543274), new Point(0.7042262554168701, 0.8726151585578918), new Point(0.6990481615066528, 0.8553308248519897), 237);
		createFace([883, 2052, 2051, 931, 881], 238);
		setUVsToFace(new Point(0.7532156618290536, 0.18326501845239254), new Point(0.7887063464206335, 0.21420907758112578), new Point(0.7449448108673096, 0.21420903503894806), 238);
		createFace([233, 1563, 231, 1649], 239);
		setUVsToFace(new Point(0.9354258179664612, 0.3536234498023987), new Point(0.9269854792617767, 0.3957736180959113), new Point(0.858298659324646, 0.39334243535995483), 239);
		createFace([1359, 288, 294, 295], 240);
		setUVsToFace(new Point(0.23694255948066711, 0.9973769187927246), new Point(0.19318105280399323, 0.9973768591880798), new Point(0.19318105280399323, 0.9793334603309631), 240);
		createFace([1778, 1816, 1894, 1784], 241);
		setUVsToFace(new Point(0.4812428951263428, 0.8794761300086975), new Point(0.4812428951263428, 0.8975194692611694), new Point(0.4374814033508301, 0.8975195288658142), 241);
		createFace([1575, 1118, 624, 1585, 839], 242);
		setUVsToFace(new Point(0.5698989629745483, 0.04476146290276893), new Point(0.48237600922584534, 0.04476147145032883), new Point(0.48237600922584534, 0.0010000085458159447), 242);
		createFace([1933, 1716, 1711, 2167], 243);
		setUVsToFace(new Point(0.028065474703907967, 0.8941013216972351), new Point(0.019046727296669685, 0.8415897833405159), new Point(0.055128343403339386, 0.841590940952301), 243);
		createFace([1249, 1250, 1294, 1301, 1300], 244);
		setUVsToFace(new Point(0.7532156705856323, 0.21691612899303436), new Point(0.7887062430381775, 0.2478601336479187), new Point(0.7449448704719543, 0.2478601485490799), 244);
		createFace([836, 839, 1585, 831], 245);
		setUVsToFace(new Point(0.35974112153053284, 0.5183836221694946), new Point(0.31057029962539673, 0.5183836221694946), new Point(0.3105703592300415, 0.47462213039398193), 245);
		createFace([1458, 325, 1455, 298], 246);
		setUVsToFace(new Point(0.7196932448113373, 0.989915894315639), new Point(0.7020752429962158, 0.974808931350708), new Point(0.8019291758537292, 0.9748302698135376), 246);
		createFace([1250, 1559, 1969, 1954], 247);
		setUVsToFace(new Point(0.6271010041236877, 0.07404644787311554), new Point(0.6301137804985046, 0.08734090626239777), new Point(0.576684296131134, 0.0546603798866272), 247);
		createFace([2052, 1142, 723, 112], 249);
		setUVsToFace(new Point(0.061585232615470886, 0.08734090626239777), new Point(0.04831651598215103, 0.08442657440900803), new Point(0.10048794156559038, 0.04977288015365048), 249);
		createFace([861, 1416, 619, 609], 250);
		setUVsToFace(new Point(0.5443716645240784, 0.856671154499054), new Point(0.5935243368148804, 0.8580114841461182), new Point(0.5589556097984314, 0.8683677911758423), 250);
		createFace([2103, 387, 1954, 2097], 251);
		setUVsToFace(new Point(0.7011833786964417, 0.1796552985906601), new Point(0.7536973357200623, 0.17090299725532532), new Point(0.788706413613578, 0.17965529435046645), 251);
		createFace([900, 1979, 1205, 139], 252);
		setUVsToFace(new Point(0.5584241151809692, 0.8363126516342163), new Point(0.5933554925186671, 0.8453702329181583), new Point(0.5442873239517212, 0.8485457897186279), 252);
		createFace([454, 2000, 2216, 1769, 2002], 253);
		setUVsToFace(new Point(0.3073301911354065, 0.08852292597293854), new Point(0.3073301911354065, 0.13228438794612885), new Point(0.21980728209018707, 0.13228440284729004), 253);
		createFace([969, 179, 173, 2142], 254);
		setUVsToFace(new Point(0.47355762124061584, 0.9398736953735352), new Point(0.4374814033508301, 0.9390087127685547), new Point(0.43791390291945276, 0.9209706313852611), 254);
		createFace([81, 626, 566, 565], 255);
		setUVsToFace(new Point(0.9097051024436951, 0.03708501486107707), new Point(0.9097051024436951, 0.0010000000474974513), new Point(0.9972281455993652, 0.001000019139610231), 255);
		createFace([2051, 2054, 151, 931], 256);
		setUVsToFace(new Point(0.7449448108673096, 0.21420903503894806), new Point(0.7011833786964417, 0.21420902013778687), new Point(0.714311765460733, 0.20647300954303932), 256);
		createFace([2053, 736, 2054, 2051, 2052], 257);
		setUVsToFace(new Point(0.036009032279253006, 0.17090299725532532), new Point(0.09727518004320598, 0.17090299725532532), new Point(0.08852291107177734, 0.1796552985906601), 257);
		createFace([115, 871, 897, 905], 258);
		setUVsToFace(new Point(0.34931913018226624, 0.6909213662147522), new Point(0.35143932795876287, 0.7356783182291071), new Point(0.28341108560562134, 0.7239764332771301), 258);
		createFace([640, 826, 71, 646], 259);
		setUVsToFace(new Point(0.7088525891304016, 0.7716797590255737), new Point(0.6092929840087891, 0.7716797590255737), new Point(0.6092929840087891, 0.7541751265525818), 259);
		createFace([1429, 280, 279, 1330], 260);
		setUVsToFace(new Point(0.6968158483505249, 0.7743867605744228), new Point(0.6968158483505249, 0.78676438331604), new Point(0.6092929840087891, 0.78676438331604), 260);
		createFace([762, 765, 680, 677], 261);
		setUVsToFace(new Point(0.5948939323425293, 0.34668445587158203), new Point(0.533627663846672, 0.346684425099478), new Point(0.5380038022994995, 0.3404950201511383), 261);
		createFace([479, 839, 836, 556], 262);
		setUVsToFace(new Point(0.9055981636047363, 0.6343889832496643), new Point(0.9405296444892883, 0.6434465646743774), new Point(0.8914614108651776, 0.6466221188577822), 262);
		createFace([7, 484, 494, 556], 263);
		setUVsToFace(new Point(0.5299106240272522, 0.4141227900981903), new Point(0.6174336075782776, 0.4141228199005127), new Point(0.6174335990978864, 0.46125533023323384), 263);
		createFace([1865, 2047, 2046, 209, 212, 2120], 264);
		setUVsToFace(new Point(0.33796321729281825, 0.2064728597019788), new Point(0.3379632234573364, 0.1832648366689682), new Point(0.45174306631088257, 0.18326488137245178), 264);
		createFace([1373, 1319, 1308, 1295, 1411, 303], 265);
		setUVsToFace(new Point(0.6005314074888222, 0.2169164111029914), new Point(0.7143118381500244, 0.21691614389419556), new Point(0.7143118381500244, 0.2401241511106491), 265);
		createFace([1378, 1316, 1317, 1372], 266);
		setUVsToFace(new Point(0.7829861044883728, 0.5628001093864441), new Point(0.6692062616348267, 0.5628001093864441), new Point(0.6692063212394714, 0.5351214408874512), 266);
		createFace([421, 1621, 2111, 1807], 267);
		setUVsToFace(new Point(0.6108582019805908, 0.6748216152191162), new Point(0.615234375, 0.6810110807418823), new Point(0.5539682891148366, 0.6810110787432178), 267);
		createFace([1101, 181, 1068, 1050], 268);
		setUVsToFace(new Point(0.22490896477690303, 0.29041697887274637), new Point(0.21178051829338074, 0.2718459367752075), new Point(0.3255603015422821, 0.27184590697288513), 268);
		createFace([1332, 256, 1400, 288], 269);
		setUVsToFace(new Point(0.08852288126945496, 0.6460852026939392), new Point(0.0010000000474974513, 0.6460852026939392), new Point(0.0010000000474974513, 0.6280419848360917), 269);
		createFace([557, 578, 8, 510], 270);
		setUVsToFace(new Point(0.6187620759010315, 0.2691386938095093), new Point(0.6056337573542996, 0.2505676656961454), new Point(0.7194133996963501, 0.2505677044391632), 270);
		createFace([1807, 2111, 1524, 1525], 271);
		setUVsToFace(new Point(0.9867986284378427, 0.49689990282058716), new Point(0.9911747574806213, 0.5030893087387085), new Point(0.9649178385734558, 0.5030893087387085), 271);
		createFace([1654, 1649, 231, 235], 272);
		setUVsToFace(new Point(0.8497778244606515, 0.814520819823514), new Point(0.8989302515983582, 0.8158612251281738), new Point(0.8643616437911987, 0.8262174725532532), 272);
		createFace([1142, 115, 1164, 1160], 273);
		setUVsToFace(new Point(0.09123000502586365, 0.9660698771476746), new Point(0.16920222342014313, 0.9655779600143433), new Point(0.15570442008440993, 0.9956293919736638), 273);
		createFace([1901, 2021, 338, 1906], 274);
		setUVsToFace(new Point(0.9489546418190002, 0.2095216065645218), new Point(0.7914134860038757, 0.2095216065645218), new Point(0.7914134860038757, 0.18326473236083984), 274);
		createFace([384, 1745, 2180, 1792], 275);
		setUVsToFace(new Point(0.9989999532699585, 0.4364005923271179), new Point(0.9990000128746033, 0.46407920122146606), new Point(0.8852201700210571, 0.46407920122146606), 275);
		createFace([1256, 1267, 256, 1332], 276);
		setUVsToFace(new Point(0.37093397974967957, 0.6296250820159912), new Point(0.28341108560562134, 0.6296251002833336), new Point(0.28341108560562134, 0.582492470741272), 276);
		createFace([682, 736, 2053, 156], 279);
		setUVsToFace(new Point(0.4731285274028778, 0.4009943902492523), new Point(0.4775046706199646, 0.40718379616737366), new Point(0.4162384867668152, 0.40718385577201843), 279);
		createFace([1440, 789, 1447, 320], 280);
		setUVsToFace(new Point(0.5854490995407104, 0.9958910346031189), new Point(0.5416876673698425, 0.9958910346031189), new Point(0.5416876673698425, 0.9778540730476379), 280);
		createFace([222, 676, 1113, 1169], 281);
		setUVsToFace(new Point(0.31644344329833984, 0.07940970361232758), new Point(0.31644344329833984, 0.05315282195806503), new Point(0.4739846885204315, 0.05315282195806503), 281);
		createFace([636, 86, 634, 751], 282);
		setUVsToFace(new Point(0.47355765104293823, 0.9623862504959106), new Point(0.43748143425539243, 0.9615212495945745), new Point(0.4379139244556427, 0.9434831738471985), 282);
		createFace([1108, 1981, 1978, 1979, 965], 284);
		setUVsToFace(new Point(0.5698989629745483, 0.08852294087409973), new Point(0.7449447040732597, 0.0885229323937121), new Point(0.7449447661033229, 0.13228439648699905), 284);
		createFace([831, 565, 601, 836], 285);
		setUVsToFace(new Point(0.3597411811351776, 0.47462213039398193), new Point(0.4089120030403137, 0.47462213039398193), new Point(0.40891194343566895, 0.5183836221694946), 285);
		createFace([1419, 1446, 1447, 789], 287);
		setUVsToFace(new Point(0.9846040606498718, 0.977380096912384), new Point(0.984329104423523, 0.995421290397644), new Point(0.9482466578483582, 0.9948713183403015), 287);
		createFace([408, 1784, 1894, 2185], 288);
		setUVsToFace(new Point(0.3944374918937683, 0.8704928159713745), new Point(0.3583612236673167, 0.8696277577171113), new Point(0.3587937355041504, 0.8515896797180176), 288);
		createFace([222, 1108, 1575, 676], 291);
		setUVsToFace(new Point(0.2921634188512767, 0.8390769362449646), new Point(0.2834111154079437, 0.8195062279701233), new Point(0.32717257738113403, 0.8195062279701233), 291);
		createFace([1231, 1542, 238, 1537], 293);
		setUVsToFace(new Point(0.24747231602668762, 0.9185268878936768), new Point(0.25862935185432434, 0.9516178369522095), new Point(0.19403488240169284, 0.9515445004920416), 293);
		createFace([1749, 1739, 1745, 384], 294);
		setUVsToFace(new Point(0.7196932499904565, 0.9524830806860879), new Point(0.7020752429962158, 0.9373761415481567), new Point(0.8019291758537292, 0.9373974204063416), 294);
		createFace([1055, 1054, 207, 208], 295);
		setUVsToFace(new Point(0.5951038002967834, 0.9747834205627441), new Point(0.5513424277305603, 0.9747834801673889), new Point(0.5513424277305603, 0.9567402005195618), 295);
		createFace([609, 613, 634, 861], 296);
		setUVsToFace(new Point(0.5469607710838318, 0.8653133511543274), new Point(0.500397264957428, 0.8726151585578918), new Point(0.4952191710472107, 0.8553308248519897), 296);
		createFace([1083, 209, 2046, 1087], 297);
		setUVsToFace(new Point(0.7988316377516586, 0.888227725329609), new Point(0.6990481615066528, 0.8919791579246521), new Point(0.7160894870758057, 0.8762246370315552), 297);
		createFace([1682, 2166, 1735, 1729], 298);
		setUVsToFace(new Point(0.9659639596939087, 0.21691612899303436), new Point(0.9875731468200684, 0.2445947527885437), new Point(0.9525638821474948, 0.2445947527885437), 298);
		createFace([624, 538, 537, 1585], 300);
		setUVsToFace(new Point(0.09122999757528305, 0.8756717443466187), new Point(0.09123002737760544, 0.8395851254463196), new Point(0.17875300347805023, 0.8395852446556091), 300);
		createFace([1317, 1319, 1373, 1372], 301);
		setUVsToFace(new Point(0.11477985233068466, 0.29312407970428467), new Point(0.11477985233068466, 0.35001397132873535), new Point(0.0010000000474974513, 0.35001397132873535), 301);
		createFace([502, 26, 503, 18], 302);
		setUVsToFace(new Point(0.39471861720085144, 0.9397421479225159), new Point(0.3944436311721802, 0.9577834010124207), new Point(0.3583612144523981, 0.957233438961864), 302);
		createFace([1010, 1013, 1213, 173], 303);
		setUVsToFace(new Point(0.08852292597293854, 0.5892497897148132), new Point(0.0010000085458159447, 0.5892497897148132), new Point(0.0010000085458159447, 0.5712065100669861), 303);
		createFace([924, 923, 2124, 1139], 304);
		setUVsToFace(new Point(0.47249045968055725, 0.8490903973579407), new Point(0.47249045968055725, 0.8767690658569336), new Point(0.4374814033508301, 0.8767690658569336), 304);
		createFace([1735, 363, 1727, 1729], 305);
		setUVsToFace(new Point(0.6983954585183546, 0.930015271993235), new Point(0.5986120104789734, 0.9337667226791382), new Point(0.6156532764434814, 0.9180121421813965), 305);
		createFace([289, 1601, 1255, 1256], 306);
		setUVsToFace(new Point(0.6462861895561218, 0.8775649070739746), new Point(0.6954386830329895, 0.8789052963256836), new Point(0.6608700342684195, 0.8892615373972765), 306);
		createFace([18, 503, 24, 510], 308);
		setUVsToFace(new Point(0.9506552815437317, 0.8522927761077881), new Point(0.9506552815437317, 0.8342558145523071), new Point(0.9944168329238892, 0.8342556953430176), 308);
		createFace([81, 85, 628, 626], 309);
		setUVsToFace(new Point(0.3947186089932455, 0.8971583962649212), new Point(0.3944436311721802, 0.9151996374130249), new Point(0.35836121439933777, 0.9146496653556824), 309);
		createFace([1532, 1472, 1625, 1530], 311);
		setUVsToFace(new Point(0.7944197058677673, 0.3429638147354126), new Point(0.7987958788871765, 0.34915319085121155), new Point(0.7375298142433167, 0.34915316104888916), 311);
		createFace([2067, 2066, 187, 985], 312);
		setUVsToFace(new Point(0.6136602797499224, 0.2142089605331421), new Point(0.5698989629745483, 0.2142089605331421), new Point(0.5830274224281311, 0.2064729481935501), 312);
		createFace([421, 1807, 1525, 1618], 313);
		setUVsToFace(new Point(0.9966527819633484, 0.6498366594314575), new Point(0.9441389441490173, 0.6498366594314575), new Point(0.9441389441490173, 0.6323320865631104), 313);
		createFace([951, 1095, 1098, 1037], 314);
		setUVsToFace(new Point(0.19318108260632716, 0.6296250406786587), new Point(0.19318105280399323, 0.582492470741272), new Point(0.28070399165153503, 0.582492470741272), 314);
		createFace([191, 735, 732, 686], 315);
		setUVsToFace(new Point(0.1842685043811798, 0.9171726703643799), new Point(0.1886446624994278, 0.923362135887146), new Point(0.16238780955719206, 0.923362135887146), 315);
		createFace([1563, 1231, 235, 231], 316);
		setUVsToFace(new Point(0.4242691993713379, 0.7009315490722656), new Point(0.4263892065335051, 0.7456885361720538), new Point(0.35836121439933777, 0.7339865565299988), 316);
		createFace([956, 137, 900, 139], 317);
		setUVsToFace(new Point(0.9914062023162842, 0.27184581756591797), new Point(0.9914062023162842, 0.28422340750694275), new Point(0.9038833379745483, 0.28422340750694275), 317);
		createFace([317, 1663, 280, 1429], 318);
		setUVsToFace(new Point(0.5443716645240784, 0.8775649070739746), new Point(0.5935243368148804, 0.8789052963256836), new Point(0.5589556285523648, 0.8892615394636456), 318);
		createFace([425, 1041, 1040, 1837], 319);
		setUVsToFace(new Point(0.9510109424591064, 0.6185791492462158), new Point(0.8634880185127258, 0.6185791492462158), new Point(0.863487958908081, 0.582492470741272), 319);
		createFace([1758, 399, 2231, 1894], 322);
		setUVsToFace(new Point(0.41353145241737366, 0.40775176882743835), new Point(0.32600852847099304, 0.40775176882743835), new Point(0.32600852847099304, 0.3897084528212523), 322);
		createFace([823, 826, 571, 572], 324);
		setUVsToFace(new Point(0.8816107511520386, 0.5245786309242249), new Point(0.7678309679031372, 0.5245785713195801), new Point(0.7678309679031372, 0.49689990282058716), 324);
		createFace([1249, 1547, 1542, 1559], 325);
		setUVsToFace(new Point(0.5556510090827942, 0.47462207078933716), new Point(0.5770951509475708, 0.527919352054596), new Point(0.5059451520844382, 0.5229191249026098), 325);
		createFace([557, 510, 844, 601], 326);
		setUVsToFace(new Point(0.35316771268844604, 0.29312407970428467), new Point(0.44069066643714905, 0.29312407970428467), new Point(0.44069063663482666, 0.3292090892791748), 326);
		createFace([1769, 367, 1689, 2009], 327);
		setUVsToFace(new Point(0.4374814033508301, 0.7902618646621704), new Point(0.4374814033508301, 0.7541751861572266), new Point(0.5250042676925659, 0.7541751265525818), 327);
		createFace([2238, 2234, 2000, 425], 329);
		setUVsToFace(new Point(0.6847495436668396, 0.29312407970428467), new Point(0.6847495436668396, 0.3368855118751526), new Point(0.6355787515640259, 0.3368855118751526), 329);
		createFace([571, 70, 58, 572], 330);
		setUVsToFace(new Point(0.23216907680034637, 0.29312407970428467), new Point(0.23216907680034637, 0.35001397132873535), new Point(0.11838927119970322, 0.35001397132873535), 330);
		createFace([408, 2185, 406, 1774], 331);
		setUVsToFace(new Point(0.04476150870323181, 0.944094717502594), new Point(0.044761501252651215, 0.9621316194534302), new Point(0.0010000010952353477, 0.9621316194534302), 331);
		createFace([1093, 1065, 1064, 182], 332);
		setUVsToFace(new Point(0.11838924139738083, 0.4141227900981903), new Point(0.232169046998024, 0.4141227900981903), new Point(0.232169046998024, 0.4710126519203186), 332);
		createFace([429, 2231, 2234, 2238], 333);
		setUVsToFace(new Point(0.7339203953742981, 0.29312407970428467), new Point(0.7339203953742981, 0.3368855118751526), new Point(0.6847495436668396, 0.3368855118751526), 333);
		createFace([1376, 1364, 298, 1455], 336);
		setUVsToFace(new Point(0.4374814033508301, 0.7126743197441101), new Point(0.4374814033508301, 0.684995710849762), new Point(0.5512612462043762, 0.684995710849762), 336);
		createFace([50, 53, 565, 566], 337);
		setUVsToFace(new Point(0.3194873332977295, 0.9039437174797058), new Point(0.2834111030531533, 0.9030786614796116), new Point(0.28384360671043396, 0.8850405812263489), 337);
		createFace([110, 109, 798, 517], 338);
		setUVsToFace(new Point(0.9671178460121155, 0.582492470741272), new Point(0.9887270331382751, 0.6101710796356201), new Point(0.9537178740519662, 0.6101710796356201), 338);
		createFace([601, 52, 559, 557], 339);
		setUVsToFace(new Point(0.47383884013503796, 0.9665393323928274), new Point(0.4735638499259949, 0.9845805168151855), new Point(0.4374814033508301, 0.9840304851531982), 339);
		createFace([462, 726, 1568, 497], 340);
		setUVsToFace(new Point(0.6269047260284424, 0.6252046227455139), new Point(0.5581767559051514, 0.6249337196350098), new Point(0.551393985748291, 0.582492470741272), 340);
		createFace([1906, 1910, 2002, 1901], 341);
		setUVsToFace(new Point(0.46974390745162964, 0.15025852620601654), new Point(0.4784962236881256, 0.16982926428318024), new Point(0.4347347617149353, 0.16982926428318024), 341);
		createFace([1087, 2046, 2047, 1085], 342);
		setUVsToFace(new Point(0.7923157811164856, 0.057889893651008606), new Point(0.7923157811164856, 0.0010000000474974513), new Point(0.9060957431793213, 0.0010000000474974513), 342);
		createFace([106, 757, 2203, 696], 343);
		setUVsToFace(new Point(0.6781156659126282, 0.6748214960098267), new Point(0.6824917793273926, 0.6810110211372375), new Point(0.6562349200248718, 0.6810110211372375), 343);
		createFace([418, 2104, 1789, 1801], 344);
		setUVsToFace(new Point(0.21980731189250946, 0.21420882642269135), new Point(0.17604580521583557, 0.21420879662036896), new Point(0.1891743242740631, 0.20647279918193817), 344);
		createFace([1376, 1378, 303, 302], 345);
		setUVsToFace(new Point(0.6562349200248718, 0.6721144914627075), new Point(0.6562349200248718, 0.6546099185943604), new Point(0.7557945251464844, 0.6546099185943604), 345);
		createFace([24, 27, 844, 510], 346);
		setUVsToFace(new Point(0.21057017147541046, 0.16982926428318024), new Point(0.17449392632955696, 0.1689642679222478), new Point(0.17492642998695374, 0.15092609822750092), 346);
		createFace([1420, 613, 609, 1417], 347);
		setUVsToFace(new Point(0.4125213623046875, 0.47462213039398193), new Point(0.5000443458557129, 0.47462213039398193), new Point(0.5000443458557129, 0.5217546820640564), 347);
		createFace([499, 720, 726, 462], 348);
		setUVsToFace(new Point(0.09122999012470245, 0.9313986301422119), new Point(0.1587783545255661, 0.9171726703643799), new Point(0.15832683444023132, 0.9619684815406799), 348);
		createFace([1316, 1308, 1319, 1317], 349);
		setUVsToFace(new Point(0.5950025457930938, 0.9300152620557118), new Point(0.4952191710472107, 0.9337667226791382), new Point(0.5122604966163635, 0.9180121421813965), 349);
		createFace([686, 732, 688, 687], 350);
		setUVsToFace(new Point(0.5868005156517029, 0.46396246552467346), new Point(0.5911766886711121, 0.4701519012451172), new Point(0.5299106058335188, 0.47015184249200637), 350);
		createFace([58, 70, 640, 788, 59, 62], 351);
		setUVsToFace(new Point(0.2066788524389267, 0.21691632270812988), new Point(0.32045865058898926, 0.2169162929058075), new Point(0.3204586407689469, 0.24012431167226703), 351);
		createFace([1816, 1778, 1774, 406], 353);
		setUVsToFace(new Point(0.4337831437587738, 0.9184502959251404), new Point(0.43350815773010254, 0.9364915490150452), new Point(0.39742574101013883, 0.9359415273572635), 353);
		createFace([1249, 1300, 1299, 1547], 354);
		setUVsToFace(new Point(0.2500709295272827, 0.9552272725013666), new Point(0.2500709295272827, 0.9766263365745544), new Point(0.19318105280399323, 0.9766263365745544), 354);
		createFace([1979, 1978, 1207, 1205], 355);
		setUVsToFace(new Point(0.09123000502586365, 0.6262539625167847), new Point(0.09122999757528305, 0.582492470741272), new Point(0.14040083939666115, 0.5824924877020535), 355);
		createFace([1689, 367, 1771, 1696], 356);
		setUVsToFace(new Point(0.8998468518257141, 0.7488340705452929), new Point(0.8123239278793335, 0.7488340735435486), new Point(0.8123239278793335, 0.7364565134048462), 356);
		createFace([85, 81, 634, 86], 358);
		setUVsToFace(new Point(0.5389806032180786, 0.9778541326522827), new Point(0.5389806032180786, 0.9958974719047546), new Point(0.4952191710472107, 0.9958974123001099), 358);
		createFace([238, 1542, 1547, 244], 360);
		setUVsToFace(new Point(0.32085639238357544, 0.6323320865631104), new Point(0.3547518253326416, 0.6873118877410889), new Point(0.2833944315081859, 0.6870106973047847), 360);
		createFace([1480, 324, 1467, 1476], 361);
		setUVsToFace(new Point(0.6972692835271138, 0.8049720486882497), new Point(0.5974858403205872, 0.808723509311676), new Point(0.6145271062850952, 0.7929689288139343), 361);
		createFace([311, 1428, 1668, 1417], 362);
		setUVsToFace(new Point(0.7737830877304077, 0.717438280582428), new Point(0.8087145686149597, 0.7264959216117859), new Point(0.7596463561058044, 0.7296715378761292), 362);
		createFace([601, 7, 556, 836], 367);
		setUVsToFace(new Point(0.8423932194709778, 0.649797797203064), new Point(0.8469219465347076, 0.6323321969962904), new Point(0.8937258124351501, 0.6378893256187439), 367);
		createFace([456, 1682, 1687, 1969], 368);
		setUVsToFace(new Point(0.7813007831573486, 0.4005948305130005), new Point(0.7103705406188965, 0.4082435369491577), new Point(0.7297943265617792, 0.3541772116831643), 368);
		createFace([1256, 1255, 251, 1267], 369);
		setUVsToFace(new Point(0.7990825176239014, 0.7752503156661987), new Point(0.7990825176239014, 0.7876278758049011), new Point(0.7115596532821655, 0.7876278728066455), 369);
		createFace([1439, 285, 1492, 1359], 370);
		setUVsToFace(new Point(0.9972281455993652, 0.09758437514352288), new Point(0.9972281455993652, 0.1156276986002922), new Point(0.9097051024436951, 0.11562768369913101), 370);
		createFace([764, 762, 112, 763], 371);
		setUVsToFace(new Point(0.08852295981393096, 0.1358938259565043), new Point(0.036009032279253006, 0.14464612305164337), new Point(0.0010000000474974513, 0.1358938217163086), 371);
		createFace([23, 497, 1570, 849], 372);
		setUVsToFace(new Point(0.5827984809875488, 0.336885541677475), new Point(0.5336276292800903, 0.336885541677475), new Point(0.5336276342951701, 0.29312409254584376), 372);
		createFace([654, 646, 71, 655], 373);
		setUVsToFace(new Point(0.8215371743682568, 0.9122253333572226), new Point(0.80391925573349, 0.897118330001831), new Point(0.9037731885910034, 0.8971397280693054), 373);
		createFace([2231, 399, 397, 2234], 374);
		setUVsToFace(new Point(0.7115595936775208, 0.7716408967971802), new Point(0.7160884141921997, 0.7541751265525818), new Point(0.7628921866416931, 0.7597324252128601), 374);
		createFace([538, 624, 860, 541], 375);
		setUVsToFace(new Point(0.8217065334320068, 0.6566668748855591), new Point(0.8566379547119141, 0.665724515914917), new Point(0.807569754474682, 0.6689000341735679), 375);
		createFace([1829, 1749, 384, 1792], 376);
		setUVsToFace(new Point(0.0010000000474974513, 0.3536234498023987), new Point(0.11477985233068466, 0.3536234498023987), new Point(0.11477985233068466, 0.410513311624527), 376);
		createFace([2238, 425, 1837, 1830], 377);
		setUVsToFace(new Point(0.6461174488067627, 0.8355960249900818), new Point(0.6952700614929199, 0.8369364142417908), new Point(0.660701334476471, 0.8472926616668701), 377);
		createFace([544, 543, 565, 831], 379);
		setUVsToFace(new Point(0.9119889736175537, 0.664592444896698), new Point(0.8654254078865051, 0.6718942523002625), new Point(0.8602473735809326, 0.6546099185943604), 379);
		createFace([578, 533, 529, 8], 380);
		setUVsToFace(new Point(0.7687332034111023, 0.46407920122146606), new Point(0.7687332034111023, 0.4364005923271179), new Point(0.8825129270553589, 0.4364006519317627), 380);
		createFace([909, 913, 910, 2129], 381);
		setUVsToFace(new Point(0.2757258713245392, 0.9982365965843201), new Point(0.23964962363243103, 0.9973716139793396), new Point(0.2400821272899399, 0.9793335337226974), 381);
		createFace([1118, 1575, 1108], 383);
		setUVsToFace(new Point(0.48237600922584534, 0.04476147145032883), new Point(0.5698989629745483, 0.04476146027445793), new Point(0.5698989629745483, 0.08852294087409973), 383);
		createFace([1219, 1044, 1045, 1037], 384);
		setUVsToFace(new Point(0.7478632926940918, 0.8145208358764648), new Point(0.7970158457756042, 0.8158612251281738), new Point(0.7624469947401735, 0.8262174658732733), 384);
		createFace([2034, 1830, 1030, 198], 385);
		setUVsToFace(new Point(0.8250527381896973, 0.29312407970428467), new Point(0.825052797794342, 0.34025663137435913), new Point(0.7375298738479614, 0.3402566611766815), 385);
		createFace([1037, 1098, 1054, 1219], 386);
		setUVsToFace(new Point(0.7504522204399109, 0.8231630325317383), new Point(0.7038887739181519, 0.8304648399353027), new Point(0.6987107396125793, 0.8131805062294006), 386);
		createFace([2231, 437, 1847, 2191], 387);
		setUVsToFace(new Point(0.39471858739852905, 0.9184502959251404), new Point(0.3944436311721802, 0.9364915490150452), new Point(0.3583612318598479, 0.9359415302537966), 387);
		createFace([1359, 1492, 1330, 1638], 388);
		setUVsToFace(new Point(0.4952191710472107, 0.8306462168693542), new Point(0.49974799361409666, 0.8131805892674719), new Point(0.5465517640113831, 0.8187378644943237), 388);
		createFace([273, 1411, 1295, 1313], 389);
		setUVsToFace(new Point(0.6924310922622681, 0.14464612305164337), new Point(0.6136605032803065, 0.1358938217163086), new Point(0.7011833786964417, 0.1358938217163086), 389);
		createFace([1446, 1419, 1439, 1442], 390);
		setUVsToFace(new Point(0.8493000268936157, 0.9772065877914429), new Point(0.849299967288971, 0.9952499270439148), new Point(0.805538535118103, 0.99524986743927), 390);
		createFace([861, 634, 81, 860], 391);
		setUVsToFace(new Point(0.4771304130554199, 0.4141227900981903), new Point(0.526301234960556, 0.4141227900981903), new Point(0.5263012051582336, 0.4578842222690582), 391);
		createFace([1429, 1330, 1492, 285], 393);
		setUVsToFace(new Point(0.7076635360717773, 0.40075597167015076), new Point(0.6201406121253967, 0.40075597167015076), new Point(0.6201407313346863, 0.3536234498023987), 393);
		createFace([883, 1142, 2052], 394);
		setUVsToFace(new Point(0.8133054375648499, 0.776271402835846), new Point(0.8662141561508179, 0.7752503156661987), new Point(0.8591713905334473, 0.7869215607643127), 394);
		createFace([1975, 1164, 115], 395);
		setUVsToFace(new Point(0.7923157811164856, 0.13281495869159698), new Point(0.8034775257110596, 0.12199866026639938), new Point(0.8352462649345398, 0.13075506687164307), 395);
		createFace([8, 521, 522, 798], 398);
		setUVsToFace(new Point(0.3736410439014435, 0.6047702431678772), new Point(0.47320064902305603, 0.6047702431678772), new Point(0.47320064902305603, 0.6222750544548035), 398);
		createFace([2224, 2226, 1720, 1716], 399);
		setUVsToFace(new Point(0.375179260969162, 0.457884281873703), new Point(0.375179260969162, 0.4141227900981903), new Point(0.4243500828742981, 0.4141227900981903), 399);
		createFace([2231, 429, 1857, 437], 400);
		setUVsToFace(new Point(0.9054232239723206, 0.9741358757019043), new Point(0.8616617918014526, 0.9741359353065491), new Point(0.8616617321968079, 0.9560926556587219), 400);
		createFace([578, 579, 55, 533], 401);
		setUVsToFace(new Point(0.5950025454112093, 0.949379271155398), new Point(0.4952191710472107, 0.9531307220458984), new Point(0.5122604966163635, 0.9373761415481567), 401);
		createFace([2047, 1865, 2164, 1085], 402);
		setUVsToFace(new Point(0.6162299017091125, 0.971199507522292), new Point(0.5986120104789734, 0.9560925364494324), new Point(0.698465883731842, 0.956113874912262), 402);
		createFace([1740, 1622, 273, 272], 403);
		setUVsToFace(new Point(0.5758490008794428, 0.705207347869873), new Point(0.5802251696586609, 0.7113968133926392), new Point(0.5539683103561401, 0.7113968133926392), 403);
		createFace([1359, 295, 291, 1498], 404);
		setUVsToFace(new Point(0.319768488407135, 0.9080967307090759), new Point(0.31949353218078613, 0.9261379837989807), new Point(0.28341108560562134, 0.9255879521369934), 404);
		createFace([454, 2002, 1910, 1917], 405);
		setUVsToFace(new Point(0.3073301911354065, 0.08852293508919512), new Point(0.21980728209018707, 0.08852294087409973), new Point(0.21980728209018707, 0.04476146027445793), 405);
		createFace([1604, 1649, 1654, 1647], 406);
		setUVsToFace(new Point(0.20861925184726715, 0.5183836221694946), new Point(0.20861926674842834, 0.47462210059165955), new Point(0.25779010856980444, 0.47462210059165955), 406);
		createFace([62, 59, 770, 579], 407);
		setUVsToFace(new Point(0.206678865814525, 0.24012433886528473), new Point(0.21980729699134827, 0.24786034226417542), new Point(0.17604583501815796, 0.2478603571653366), 407);
		createFace([108, 708, 720, 700], 408);
		setUVsToFace(new Point(0.6684406531902322, 0.05634256904179427), new Point(0.7329872846603394, 0.053856268525123596), new Point(0.723074197769165, 0.08734090626239777), 408);
		createFace([1720, 372, 1761, 1816], 409);
		setUVsToFace(new Point(0.5309205651283264, 0.3292090892791748), new Point(0.5309205651283264, 0.34725242853164673), new Point(0.4433977007865906, 0.34725243071699635), 409);
		createFace([1196, 163, 965], 410);
		setUVsToFace(new Point(0.24235188961029053, 0.5788829326629639), new Point(0.1931810826063156, 0.5788829326629639), new Point(0.19318105280399323, 0.535121500492096), 410);
		createFace([1886, 416, 1803, 1786], 411);
		setUVsToFace(new Point(0.0010000000474974513, 0.4141227900981903), new Point(0.11477981507778168, 0.4141227900981903), new Point(0.11477981507778168, 0.4710126519203186), 411);
		createFace([81, 616, 541, 860], 412);
		setUVsToFace(new Point(0.7585015892982483, 0.6720756888389587), new Point(0.763030426760235, 0.6546100693490728), new Point(0.8098341822624207, 0.6601672172546387), 412);
		createFace([320, 1442, 1439, 1440], 414);
		setUVsToFace(new Point(0.3944374918937683, 0.8930054306983948), new Point(0.35836121439933777, 0.8921403884887695), new Point(0.35879370051162474, 0.8741022519899267), 414);
		createFace([26, 502, 844, 27], 417);
		setUVsToFace(new Point(0.9481168985366821, 0.8553308844566345), new Point(0.9481168985366821, 0.8733742833137512), new Point(0.9043554663658142, 0.8733742237091064), 417);
		createFace([1524, 1625, 1453, 326], 418);
		setUVsToFace(new Point(0.5611467361450195, 0.14464612305164337), new Point(0.4911283850669861, 0.14464612305164337), new Point(0.4386146354483407, 0.13589382813708875), 418);
		createFace([1054, 1055, 1214, 1219], 419);
		setUVsToFace(new Point(0.8906575441360474, 0.1358938366174698), new Point(0.8906575441360474, 0.1796552836894989), new Point(0.8414866924285889, 0.1796552836894989), 419);
		createFace([839, 479, 13, 1570], 420);
		setUVsToFace(new Point(0.19318105280399323, 0.8674144744873047), new Point(0.1931810975074768, 0.8313278555870056), new Point(0.28070399165153503, 0.8313279151916504), 420);
		createFace([406, 1721, 1720, 1816], 421);
		setUVsToFace(new Point(0.4433977007865906, 0.29312407970428467), new Point(0.5309205651283264, 0.29312407970428467), new Point(0.5309205651283264, 0.3292090892791748), 421);
		createFace([2212, 2211, 1894, 1816], 422);
		setUVsToFace(new Point(0.46540939807891846, 0.3973849415779114), new Point(0.4654093384742737, 0.3536234498023987), new Point(0.5145801305770874, 0.3536234498023987), 422);
		createFace([95, 757, 106, 691], 424);
		setUVsToFace(new Point(0.5794556140899658, 0.40718376636505127), new Point(0.518189528204821, 0.407183735592979), new Point(0.5225656628608704, 0.40099430084228516), 424);
		createFace([2191, 2185, 1894, 2231], 425);
		setUVsToFace(new Point(0.32600852847099304, 0.3536234498023987), new Point(0.41353145241737366, 0.3536234410614076), new Point(0.41353145241737366, 0.3897084593772888), 425);
		createFace([1213, 1013, 139, 1205], 426);
		setUVsToFace(new Point(0.4952191710472107, 0.851721465587616), new Point(0.49974799156188965, 0.8342556953430176), new Point(0.5465517640113831, 0.8398129940032959), 426);
		createFace([1283, 237, 1537], 428);
		setUVsToFace(new Point(0.9561762809753418, 0.4061349332332611), new Point(0.9381328821182251, 0.4061354994773865), new Point(0.9651983380317688, 0.3536234498023987), 428);
		createFace([1975, 115, 905, 1978], 429);
		setUVsToFace(new Point(0.5500122308731079, 0.5351214408874512), new Point(0.5415720046441016, 0.5772716449422152), new Point(0.47288501262664795, 0.5748405456542969), 429);
		createFace([606, 521, 8, 529], 430);
		setUVsToFace(new Point(0.8230859095231743, 0.9331190816669355), new Point(0.8054680228233337, 0.9180121421813965), new Point(0.9053218960762024, 0.9180334210395813), 430);
		createFace([2002, 450, 2021, 1901], 432);
		setUVsToFace(new Point(0.3736410439014435, 0.582492470741272), new Point(0.5486869215965271, 0.582492470741272), new Point(0.539934515953064, 0.6020631790161133), 432);
		createFace([1400, 1647, 1654, 1283], 433);
		setUVsToFace(new Point(0.3069608807563782, 0.5183836221694946), new Point(0.25779008865356445, 0.5183836221694946), new Point(0.25779008865356445, 0.47462210059165955), 433);
		createFace([502, 467, 499, 23], 434);
		setUVsToFace(new Point(0.8123239278793335, 0.7328470945358276), new Point(0.81685263599195, 0.7153813744552492), new Point(0.8636565208435059, 0.7209386825561523), 434);
		createFace([2180, 1789, 1829, 1792], 435);
		setUVsToFace(new Point(0.800662096010838, 0.8049720586257728), new Point(0.7008786201477051, 0.808723509311676), new Point(0.7179199457168579, 0.7929689288139343), 435);
		createFace([688, 95, 219, 1004], 436);
		setUVsToFace(new Point(0.22855962812900543, 0.14464612305164337), new Point(0.2985779643058777, 0.14464612305164337), new Point(0.2985779643058777, 0.17090299725532532), 436);
		createFace([303, 1411, 1487, 302], 438);
		setUVsToFace(new Point(0.6005319356918335, 0.2401241958141327), new Point(0.6136604157412651, 0.24786022614347253), new Point(0.5698989629745483, 0.24786020815372467), 438);
		createFace([450, 1926, 233, 2019], 439);
		setUVsToFace(new Point(0.04476136714220047, 0.08852293196979771), new Point(0.0010000000474974513, 0.09289907664060593), new Point(0.0010000000474974513, 0.04038532078266144), 439);
		createFace([680, 765, 736, 682], 440);
		setUVsToFace(new Point(0.6781156659126282, 0.7060708999633789), new Point(0.6824917793273926, 0.712260365486145), new Point(0.6562349200248718, 0.712260365486145), 440);
		createFace([1249, 1559, 1250], 582);
		setUVsToFace(new Point(0.667544424533844, 0.0499332919716835), new Point(0.6301137804985046, 0.08734090626239777), new Point(0.6271010041236877, 0.07404644787311554), 582);
		createFace([233, 343, 1563], 583);
		setUVsToFace(new Point(0.9077346920967102, 0.8037851452827454), new Point(0.9188963770866394, 0.7929689288139343), new Point(0.9506651759147644, 0.8017253279685974), 583);
		createFace([1622, 1621, 309], 610);
		setUVsToFace(new Point(0.6924310922622681, 0.17090299725532532), new Point(0.6224127411842346, 0.17090299725532532), new Point(0.6224127411842346, 0.14464612305164337), 610);
		createFace([1933, 1678, 1716], 636);
		setUVsToFace(new Point(0.028065474703907967, 0.8941013216972351), new Point(0.0010000000474974513, 0.8415892124176025), new Point(0.01904331147670746, 0.8415898084640503), 636);
		createFace([1687, 1954, 1969], 778);
		setUVsToFace(new Point(0.9111267328262329, 0.40156790614128113), new Point(0.8648784160614014, 0.41041168570518494), new Point(0.8582987189292908, 0.39847323298454285), 778);
		createFace([1926, 1960, 1966], 779);
		setUVsToFace(new Point(0.3689858913421631, 0.47188547253608704), new Point(0.32600849866867065, 0.47143077850341797), new Point(0.3574279248714447, 0.46149373054504395), 779);
		createFace([2142, 920, 940], 848);
		setUVsToFace(new Point(0.181147500872612, 0.29041698575019836), new Point(0.09362457692623138, 0.29041701555252075), new Point(0.0804961621761322, 0.2718459665775299), 848);
		createFace([2203, 757, 1472], 871);
		setUVsToFace(new Point(0.3598439693450928, 0.17090299725532532), new Point(0.3598439693450928, 0.14464612305164337), new Point(0.4298623204231262, 0.14464612305164337), 871);
		createFace([981, 173, 179, 180], 884);
		setUVsToFace(new Point(0.9463012218475342, 0.8312239050865173), new Point(0.9025397896766663, 0.8312239646911621), new Point(0.9025397300720215, 0.8131805658340454), 884);

		build ();
	}
}

class Entrance extends Mesh5 {
	public function Entrance () {
		coords = new Point3D(362.20477294921875, -1921.260009765625, 78.74015808105469);

		createVertex(354.3306884765625, -141.7320556640625, 62.99212646484375, "256");
		createVertex(-47.24412536621094, -307.0865478515625, -78.73993682861328, "762");
		createVertex(338.5826416015625, 62.9923095703125, -78.74015808105469, "3");
		createVertex(338.5826416015625, 78.7403564453125, -62.99212646484375, "260");
		createVertex(343.1951904296875, -168.6156005859375, -62.99212646484375, "5");
		createVertex(354.3306884765625, 62.9923095703125, 62.99212646484375, "262");
		createVertex(174.15609741210938, 272.643310546875, -11.811019897460938, "8");
		createVertex(217.85205078125, 144.4136962890625, -11.81103515625, "9");
		createVertex(217.85205078125, 144.4136962890625, 11.81103515625, "10");
		createVertex(354.3306884765625, -141.7320556640625, -62.99212646484375, "267");
		createVertex(195.4051513671875, 137.0673828125, 11.811019897460938, "12");
		createVertex(195.4051513671875, 137.0673828125, -11.81103515625, "13");
		createVertex(-338.58270263671875, 62.9923095703125, -78.74015808105469, "518");
		createVertex(102.3621826171875, 314.9608154296875, 62.99212646484375, "783");
		createVertex(-354.33074951171875, 62.9923095703125, 62.99212646484375, "528");
		createVertex(338.58270263671875, -150.9571533203125, -78.74015808105469, "265");
		createVertex(-207.98602294921875, -303.8250732421875, -62.99212646484375, "515");
		createVertex(43.1441650390625, 314.9608154296875, 62.99235534667969, "781");
		createVertex(212.598388671875, 78.7403564453125, -62.99212646484375, "22");
		createVertex(-62.992156982421875, -307.0865478515625, -55.62969207763672, "774");
		createVertex(-338.58270263671875, -150.9571533203125, -78.74015808105469, "536");
		createVertex(123.22830200195313, 299.6064453125, -62.99212646484375, "281");
		createVertex(-343.19525146484375, -168.6156005859375, 62.99212646484375, "541");
		createVertex(354.3306884765625, 62.9923095703125, -62.99212646484375, "261");
		createVertex(-43.14422607421875, 314.9608154296875, 62.99235534667969, "801");
		createVertex(106.7596435546875, 299.2127685546875, 78.74015808105469, "290");
		createVertex(343.1951904296875, -168.6156005859375, 62.99212646484375, "35");
		createVertex(212.598388671875, 78.7403564453125, 62.99212646484375, "293");
		createVertex(191.73226928710938, 94.0946044921875, 63.4461669921875, "294");
		createVertex(-190.32742309570313, -299.2125244140625, 78.74015808105469, "544");
		createVertex(-338.58270263671875, 78.7403564453125, -62.99212646484375, "517");
		createVertex(-106.75970458984375, 299.2127685546875, -78.74015808105469, "556");
		createVertex(-102.36224365234375, 314.9608154296875, 62.99212646484375, "797");
		createVertex(-62.992156982421875, -299.2125244140625, -55.62968444824219, "765");
		createVertex(191.73226928710938, 94.0946044921875, -62.99212646484375, "306");
		createVertex(186.30709838867188, 109.9361572265625, -50.23408508300781, "308");
		createVertex(128.379150390625, 283.6737060546875, -50.234588623046875, "309");
		createVertex(-191.7322998046875, 94.0946044921875, -62.99212646484375, "566");
		createVertex(7.87396240234375, 7.8741455078125, 35.433074951171875, "55");
		createVertex(76.14981079101563, -137.7508544921875, 35.43309020996094, "57");
		createVertex(-102.36224365234375, 314.9608154296875, -62.99212646484375, "570");
		createVertex(84.0238037109375, -124.1126708984375, 35.43309020996094, "60");
		createVertex(-47.24412536621094, 299.2130126953125, -78.73992919921875, "812");
		createVertex(-181.10244750976563, -314.9605712890625, 62.99212646484375, "822");
		createVertex(190.32736206054688, -299.2125244140625, 78.74015808105469, "823");
		createVertex(-123.22836303710938, 299.6064453125, -62.99212646484375, "576");
		createVertex(88.78988647460938, -108.3538818359375, -43.30708312988281, "65");
		createVertex(64.90576171875, -149.6063232421875, -51.18110656738281, "67");
		createVertex(-31.49609375, -307.0865478515625, 47.24432373046875, "773");
		createVertex(-11.81103515625, -74.8031005859375, 43.30711364746094, "829");
		createVertex(28.454071044921875, 11.8111572265625, 43.30708312988281, "70");
		createVertex(14.391738891601563, -79.364501953125, 43.30711364746094, "831");
		createVertex(69.44540405273438, -157.4803466796875, 43.30708312988281, "72");
		createVertex(-185.4998779296875, 62.9923095703125, -78.74015808105469, "841");
		createVertex(186.5814208984375, 110.02734375, 50.6900634765625, "313");
		createVertex(-2.580780029296875, -99.82177734375, 43.30711364746094, "835");
		createVertex(116.09210205078125, -108.3602294921875, -78.74015808105469, "332");
		createVertex(80.26370239257813, -314.9605712890625, -58.249351501464844, "77");
		createVertex(-128.653564453125, 283.7647705078125, 50.70512390136719, "591");
		createVertex(123.22830200195313, 299.6064453125, 63.464569091796875, "328");
		createVertex(47.24406433105469, -299.2125244140625, -78.73992919921875, "849");
		createVertex(-191.73233032226563, 94.0946044921875, 63.4461669921875, "586");
		createVertex(15.832778930664063, -84.7425537109375, 39.37010192871094, "339");
		createVertex(31.49603271484375, 299.212890625, 47.24432373046875, "84");
		createVertex(77.03179931640625, 314.960693359375, -62.992156982421875, "85");
		createVertex(7.958770751953125, -98.3807373046875, 39.37010192871094, "336");
		createVertex(-123.22836303710938, 299.6064453125, 63.464569091796875, "594");
		createVertex(-207.98602294921875, -303.8250732421875, 62.99212646484375, "91");
		createVertex(78.548583984375, -173.2281494140625, 78.74015808105469, "604");
		createVertex(102.43417358398438, -108.3599853515625, -47.24409484863281, "333");
		createVertex(-212.59844970703125, 78.7403564453125, -62.99212646484375, "96");
		createVertex(69.44540405273438, -157.4803466796875, -43.30708312988281, "354");
		createVertex(71.71524047851563, -161.4173583984375, 47.24409484863281, "603");
		createVertex(-354.33074951171875, 62.9923095703125, -62.99212646484375, "100");
		createVertex(-354.33074951171875, -141.7320556640625, -62.99212646484375, "101");
		createVertex(71.71524047851563, -161.4173583984375, -47.24409484863281, "606");
		createVertex(-102.4342041015625, -108.35986328125, 47.24409484863281, "615");
		createVertex(97.88604736328125, -108.35791015625, -43.30708312988281, "352");
		createVertex(-195.40521240234375, 137.0673828125, 11.811019897460938, "105");
		createVertex(-354.33074951171875, -141.7320556640625, 62.99212646484375, "98");
		createVertex(-186.30715942382813, 109.9361572265625, -50.23408508300781, "107");
		createVertex(-128.37921142578125, 283.6737060546875, -50.234588623046875, "109");
		createVertex(-217.85211181640625, 144.4136962890625, 11.81103515625, "111");
		createVertex(-116.0921630859375, -108.3602294921875, -78.74015808105469, "624");
		createVertex(23.909713745117188, 3.9371337890625, -43.30708312988281, "369");
		createVertex(-195.40521240234375, 137.0673828125, -11.81103515625, "106");
		createVertex(23.909713745117188, 3.9371337890625, -51.18110656738281, "371");
		createVertex(-37.58404541015625, 27.5592041015625, -78.74015808105469, "630");
		createVertex(88.78988647460938, -108.3538818359375, -51.18110656738281, "367");
		createVertex(-174.1561279296875, 272.643310546875, -11.811019897460938, "113");
		createVertex(30.726242065429688, 15.7481689453125, 47.24409484863281, "378");
		createVertex(102.43414306640625, -108.35986328125, 47.24409484863281, "379");
		createVertex(7.87396240234375, -70.8660888671875, 39.37010192871094, "636");
		createVertex(37.583984375, 27.5592041015625, -78.74015808105469, "893");
		createVertex(-30.726303100585938, 15.7481689453125, 47.24409484863281, "600");
		createVertex(77.59085083007813, -143.1290283203125, 43.30711364746094, "383");
		createVertex(11.81097412109375, 11.8111572265625, 43.30711364746094, "640");
		createVertex(-78.54864501953125, -173.2283935546875, -78.74015808105469, "625");
		createVertex(-23.909774780273438, 3.9371337890625, -43.30708312988281, "370");
		createVertex(30.726242065429688, 15.7481689453125, -47.24409484863281, "627");
		createVertex(89.40185546875, -122.671630859375, 43.30711364746094, "389");
		createVertex(185.49981689453125, 62.9923095703125, -78.74015808105469, "896");
		createVertex(-7.8740234375, 7.8741455078125, 35.433074951171875, "643");
		createVertex(78.548583984375, -173.2283935546875, -78.74015808105469, "900");
		createVertex(-30.726303100585938, 15.7481689453125, -47.24409484863281, "142");
		createVertex(-76.14987182617188, -137.7508544921875, 35.43309020996094, "655");
		createVertex(-64.90582275390625, -149.6063232421875, -51.18110656738281, "144");
		createVertex(-88.78994750976563, -108.3538818359375, -51.18110656738281, "145");
		createVertex(-11.81103515625, 11.8111572265625, 43.30711364746094, "147");
		createVertex(11.81097412109375, -74.8031005859375, 43.30711364746094, "404");
		createVertex(-7.8740234375, -70.8660888671875, 39.37010192871094, "149");
		createVertex(-71.71530151367188, -161.4173583984375, -47.24409484863281, "662");
		createVertex(-78.54862976074219, -173.2281494140625, 78.74015808105469, "911");
		createVertex(-102.43423461914063, -108.3599853515625, -47.24409484863281, "664");
		createVertex(-7.958831787109375, -98.3807373046875, 39.37010192871094, "153");
		createVertex(-14.391799926757813, -79.364501953125, 43.30711364746094, "155");
		createVertex(-15.832839965820313, -84.7425537109375, 39.37010192871094, "156");
		createVertex(-28.454132080078125, 11.8111572265625, -43.30708312988281, "669");
		createVertex(-84.02386474609375, -124.1126708984375, 35.43309020996094, "158");
		createVertex(43.1441650390625, -314.9605712890625, 62.99235534667969, "415");
		createVertex(106.7596435546875, 299.2127685546875, -78.74015808105469, "890");
		createVertex(28.454071044921875, 11.8111572265625, -43.30708312988281, "673");
		createVertex(-64.90580749511719, -149.6063232421875, -43.30708312988281, "162");
		createVertex(-88.78994750976563, -108.3538818359375, -43.30708312988281, "163");
		createVertex(97.88604736328125, -108.35791015625, 43.30708312988281, "403");
		createVertex(-338.58270263671875, 62.9923095703125, 78.74015808105469, "917");
		createVertex(-69.44546508789063, -157.4803466796875, 43.30708312988281, "167");
		createVertex(77.03179931640625, -314.9605712890625, -62.992164611816406, "424");
		createVertex(-69.44546508789063, -157.4803466796875, -43.30708312988281, "681");
		createVertex(-97.8861083984375, -108.35791015625, -43.30708312988281, "682");
		createVertex(-31.49609375, -299.2125244140625, 47.24432373046875, "171");
		createVertex(181.10238647460938, -314.9605712890625, -62.99212646484375, "411");
		createVertex(-80.26376342773438, -314.9605712890625, -58.249351501464844, "174");
		createVertex(-31.49609375, 299.212890625, 47.24432373046875, "176");
		createVertex(-77.0318603515625, 314.960693359375, -62.992156982421875, "177");
		createVertex(-80.26376342773438, 314.960693359375, -58.249359130859375, "178");
		createVertex(-62.992156982421875, 299.2127685546875, -55.62968444824219, "179");
		createVertex(62.992095947265625, -307.0865478515625, -55.62969207763672, "436");
		createVertex(47.24406433105469, -307.0865478515625, -78.73993682861328, "430");
		createVertex(31.49603271484375, -299.2125244140625, 47.24432373046875, "439");
		createVertex(-23.909774780273438, 3.9371337890625, -51.18110656738281, "696");
		createVertex(64.90574645996094, -149.6063232421875, -43.30708312988281, "689");
		createVertex(116.09210205078125, -108.3602294921875, 78.74015808105469, "946");
		createVertex(62.992095947265625, -299.2125244140625, -55.62968444824219, "435");
		createVertex(-37.58404541015625, 27.5592041015625, 78.74015808105469, "929");
		createVertex(-106.75970458984375, 299.2127685546875, 78.74015808105469, "930");
		createVertex(102.3621826171875, 314.9608154296875, -62.99212646484375, "446");
		createVertex(-185.4998779296875, 62.9923095703125, 78.74015808105469, "921");
		createVertex(80.26370239257813, 314.960693359375, -58.249359130859375, "448");
		createVertex(37.583984375, 27.5592041015625, 78.74015808105469, "934");
		createVertex(128.65350341796875, 283.7647705078125, 50.70512390136719, "194");
		createVertex(62.992095947265625, 299.2127685546875, -55.62968444824219, "451");
		createVertex(47.24406433105469, 299.2130126953125, -78.73992919921875, "452");
		createVertex(-338.58270263671875, -150.9571533203125, 78.74015808105469, "915");
		createVertex(-77.59091186523438, -143.1290283203125, 43.30711364746094, "710");
		createVertex(-71.71530151367188, -161.4173583984375, 47.24409484863281, "712");
		createVertex(-186.58148193359375, 110.02734375, 50.6900634765625, "457");
		createVertex(338.5826416015625, -150.9571533203125, 78.74015808105469, "945");
		createVertex(-116.0921630859375, -108.3602294921875, 78.74015808105469, "910");
		createVertex(-151.709228515625, 265.2969970703125, -11.811019897460938, "463");
		createVertex(-89.40191650390625, -122.671630859375, 43.30711364746094, "657");
		createVertex(-28.454132080078125, 11.8111572265625, 43.30708312988281, "721");
		createVertex(151.70916748046875, 265.2969970703125, 11.81103515625, "210");
		createVertex(151.70916748046875, 265.2969970703125, -11.811019897460938, "211");
		createVertex(-151.709228515625, 265.2969970703125, 11.81103515625, "469");
		createVertex(174.15609741210938, 272.643310546875, 11.81103515625, "214");
		createVertex(-97.8861083984375, -108.35791015625, 43.30708312988281, "720");
		createVertex(-217.85211181640625, 144.4136962890625, -11.81103515625, "476");
		createVertex(-174.1561279296875, 272.643310546875, 11.81103515625, "480");
		createVertex(2.580718994140625, -99.82177734375, 43.30711364746094, "738");
		createVertex(-190.32742309570313, -299.2125244140625, -78.74015808105469, "740");
		createVertex(190.32736206054688, -299.2125244140625, -78.74015808105469, "229");
		createVertex(-77.0318603515625, -314.9605712890625, -62.992164611816406, "743");
		createVertex(338.58270263671875, 78.7403564453125, 62.99212646484375, "233");
		createVertex(185.49981689453125, 62.9923095703125, 78.74015808105469, "235");
		createVertex(-338.58270263671875, 78.7403564453125, 62.99212646484375, "492");
		createVertex(-43.14422607421875, -314.9605712890625, 62.99235534667969, "752");
		createVertex(181.10238647460938, -314.9605712890625, 62.99212646484375, "241");
		createVertex(-343.19525146484375, -168.6156005859375, -62.99212646484375, "498");
		createVertex(207.9859619140625, -303.8250732421875, 62.99212646484375, "243");
		createVertex(207.9859619140625, -303.8250732421875, -62.99212646484375, "244");
		createVertex(-212.59844970703125, 78.7403564453125, 62.99212646484375, "505");
		createVertex(-181.10244750976563, -314.9605712890625, -62.99212646484375, "745");
		createVertex(-47.24412536621094, -299.2125244140625, -78.73992919921875, "755");
		createVertex(338.58270263671875, 62.9923095703125, 78.74015808105469, "253");
		createVertex(31.49603271484375, -307.0865478515625, 47.24432373046875, "767");

		createFace(["439", "415", "77", "435"], "0");
		setUVsToFace(new Point(0.3477509021759033, 0.717860758304596), new Point(0.36331042647361755, 0.7048853039741516), new Point(0.38493695855140686, 0.8047817945480347), "0");
		createFace(["745", "515", "91", "822"], "1");
		setUVsToFace(new Point(0.17470115423202515, 0.6714317202568054), new Point(0.15124483406543732, 0.6714317202568054), new Point(0.15124483406543732, 0.5698760151863098), "1");
		createFace(["505", "921", "917", "492"], "2");
		setUVsToFace(new Point(0.9467286467552185, 0.8782298453172483), new Point(0.9287760257720947, 0.9000739455223083), new Point(0.9287760257720947, 0.776674211025238), "2");
		createFace(["371", "369", "370", "696"], "3");
		setUVsToFace(new Point(0.015081843361258507, 0.6383571624755859), new Point(0.015081843361258507, 0.6320099830627441), new Point(0.05362905189394951, 0.6320099830627441), "3");
		createFace(["256", "945", "253", "262"], "4");
		setUVsToFace(new Point(0.8870423436164856, 0.990766704082489), new Point(0.8690897822380066, 0.9982030429035269), new Point(0.8690897822380066, 0.8257386684417725), "4");
		createFace(["603", "604", "911", "712"], "5");
		setUVsToFace(new Point(0.6222934722900391, 0.8296864032745361), new Point(0.5951780676841736, 0.8351947069168091), new Point(0.5951780676841736, 0.708558976650238), "5");
		createFace(["383", "72", "167", "710", "835", "738"], "6");
		setUVsToFace(new Point(0.5032482743263245, 0.6902562975883484), new Point(0.4916796386241913, 0.6836902499198914), new Point(0.49167929665998616, 0.5717304373025085), "6");
		createFace(["801", "797", "570", "178"], "7");
		setUVsToFace(new Point(0.6662298440933228, 0.8192738890647888), new Point(0.7139654159545898, 0.8192740678787231), new Point(0.7139654159545898, 0.920829713344574), "7");
		createFace(["294", "235", "290", "328"], "8");
		setUVsToFace(new Point(0.8073247075080872, 0.9343220591545105), new Point(0.7896414188593377, 0.9565187704306463), new Point(0.7896236777305603, 0.7558016777038574), "8");
		createFace(["896", "890", "893", "332"], "9");
		setUVsToFace(new Point(0.19141709804534912, 0.42346203327178955), new Point(0.0010002737422279695, 0.3599897147824182), new Point(0.21997970342636108, 0.3042273223400116), "9");
		createFace(["712", "911", "910", "615"], "10");
		setUVsToFace(new Point(0.4841204285621643, 0.969141960144043), new Point(0.45699942111968994, 0.9746221899986267), new Point(0.45700088143348694, 0.91420578956604), "10");
		createFace(["142", "630", "624", "664"], "11");
		setUVsToFace(new Point(0.8400216698646545, 0.656810462474823), new Point(0.8671410937235509, 0.6513218333735058), new Point(0.8671442270278931, 0.7778598070144653), "11");
		createFace(["591", "457", "105", "469"], "12");
		setUVsToFace(new Point(0.7337356805801392, 0.7989602088928223), new Point(0.7339685984455092, 0.6510022705192866), new Point(0.7677855491638184, 0.6697217226028442), "12");
		createFace(["457", "107", "106", "105"], "13");
		setUVsToFace(new Point(0.41077902913093567, 0.7048853039741516), new Point(0.4108564761086022, 0.7862399129710175), new Point(0.3878510892391205, 0.7552673816680908), "13");
		createFace(["624", "625", "662", "664"], "14");
		setUVsToFace(new Point(0.3754691481590271, 0.9378259778022766), new Point(0.3754706382751465, 0.9982423782348633), new Point(0.3483522801492104, 0.9927574735852978), "14");
		createFace(["451", "448", "781", "84"], "15");
		setUVsToFace(new Point(0.2980172634124756, 0.9070931673049927), new Point(0.27918142080307007, 0.9092515707015991), new Point(0.30080786787707936, 0.8093550792672105), "15");
		createFace(["934", "930", "290", "235", "946"], "16");
		setUVsToFace(new Point(0.7550897598266602, 0.3042273223400116), new Point(0.9740691197104606, 0.18787211840969684), new Point(0.9740691895107934, 0.3599897147824182), "16");
		createFace(["174", "765", "755", "743"], "17");
		setUVsToFace(new Point(0.01828637532889843, 0.8607620000839233), new Point(0.0159843061119318, 0.8419431447982788), new Point(0.03629280449946459, 0.8321575475361063), "17");
		createFace(["294", "328", "194", "313"], "18");
		setUVsToFace(new Point(0.0010147601133212447, 0.8831828832626343), new Point(0.0009998418160202267, 0.70855427653404), new Point(0.011285954155027866, 0.72205650806427), "18");
		createFace(["332", "265", "3", "896"], "19");
		setUVsToFace(new Point(0.3295440673828125, 0.367512583732605), new Point(0.36388131976127625, 0.5468618273735046), new Point(0.19141706595380567, 0.5468618066628242), "19");
		createFace(["643", "147", "640", "55"], "20");
		setUVsToFace(new Point(0.09898325800895691, 0.626598060131073), new Point(0.09188682585954666, 0.6297716498374939), new Point(0.09188682585954666, 0.610729992389679), "20");
		createFace(["243", "823", "945", "35"], "21");
		setUVsToFace(new Point(0.4351612329483032, 0.9709293246269226), new Point(0.41720841037026357, 0.9783654533035574), new Point(0.41720855236053467, 0.8093551397323608), "21");
		createFace(["244", "229", "411"], "22");
		setUVsToFace(new Point(0.5951780676841736, 0.8371374607086182), new Point(0.6106715202331543, 0.8488656878471375), new Point(0.5951780676841736, 0.8605937957763672), "22");
		createFace(["306", "896", "22"], "23");
		setUVsToFace(new Point(0.45979487895965576, 0.6516152024269104), new Point(0.4489820599555969, 0.6780357956886292), new Point(0.43891167640686035, 0.6516152024269104), "23");
		createFace(["241", "823", "243"], "24");
		setUVsToFace(new Point(0.12036619335412979, 0.8605939149856567), new Point(0.10487274825572968, 0.8488657474517822), new Point(0.12036619335412979, 0.8371375799179077), "24");
		createFace(["293", "235", "294"], "25");
		setUVsToFace(new Point(0.6300880312919617, 0.9955418705940247), new Point(0.6394017338752747, 0.9688451290130615), new Point(0.6509602665901184, 0.99477219581604), "25");
		createFace(["890", "281", "446"], "26");
		setUVsToFace(new Point(0.9438472986221313, 0.9838953614234924), new Point(0.9287760257720947, 0.9943997859954834), new Point(0.9287760257720947, 0.9735164642333984), "26");
		createFace(["783", "328", "290"], "27");
		setUVsToFace(new Point(0.45224153995513916, 0.934697687625885), new Point(0.45178744196891785, 0.9555795192718506), new Point(0.4371039867401123, 0.9449795484542847), "27");
		createFace(["3", "261", "260"], "28");
		setUVsToFace(new Point(0.6107257604598999, 0.9889758229255676), new Point(0.5951783061027527, 0.9979521036148071), new Point(0.5951783061027527, 0.9799994826316833), "28");
		createFace(["233", "262", "253"], "29");
		setUVsToFace(new Point(0.9642189741134644, 0.9783000946044922), new Point(0.9642189741134644, 0.996252715587616), new Point(0.9486714601516724, 0.9872764348983765), "29");
		createFace(["5", "267", "265"], "30");
		setUVsToFace(new Point(0.9088805913925171, 0.9710837602615356), new Point(0.9088805913925171, 0.9476273655891418), new Point(0.9243741035461426, 0.9593555331230164), "30");
		createFace(["945", "256", "35"], "31");
		setUVsToFace(new Point(0.8400216698646545, 0.9659376740455627), new Point(0.85551518201828, 0.9542094469070435), new Point(0.85551518201828, 0.9776657819747925), "31");
		createFace(["822", "544", "823", "752"], "32");
		setUVsToFace(new Point(0.9939646124839783, 0.30040889978408813), new Point(0.9760119915008545, 0.3078451454639435), new Point(0.9760119915008545, 0.0010000000474974513), "32");
		createFace(["163", "162", "144", "145"], "33");
		setUVsToFace(new Point(0.8203779458999634, 0.9989999532699585), new Point(0.8203779458999634, 0.9605751037597656), new Point(0.82672518491745, 0.9605751037597656), "33");
		createFace(["98", "541", "498", "101"], "34");
		setUVsToFace(new Point(0.5951783061027527, 0.8755296468734741), new Point(0.6186345815658569, 0.8755296468734741), new Point(0.6186345815658569, 0.9770854711532593), "34");
		createFace(["781", "783", "290"], "291");
		setUVsToFace(new Point(0.9069376587867737, 0.7721688151359558), new Point(0.9069377779960632, 0.8199043869972229), new Point(0.8889851570129395, 0.8234492540359497), "291");
		createFace(["12", "313", "194", "210"], "36");
		setUVsToFace(new Point(0.6642870903015137, 0.9485122561454773), new Point(0.6300880312919617, 0.9669023752212524), new Point(0.6302371025085449, 0.819273829460144), "36");
		createFace(["70", "403", "389", "831", "404", "640"], "37");
		setUVsToFace(new Point(0.6281452775001526, 0.6506472229957581), new Point(0.5312771797180176, 0.706616222858429), new Point(0.5197388940297405, 0.6997771400039463), "37");
		createFace(["100", "528", "98", "101"], "38");
		setUVsToFace(new Point(0.7316437363624573, 0.7138325572013855), new Point(0.6300880312919617, 0.7138325572013855), new Point(0.6300880312919617, 0.5488045811653137), "38");
		createFace(["492", "528", "100", "517"], "39");
		setUVsToFace(new Point(0.9724687933921814, 0.7561821937561035), new Point(0.9904213547706604, 0.7561823129653931), new Point(0.9904213547706604, 0.8577380180358887), "39");
		createFace(["171", "439", "767", "773"], "40");
		setUVsToFace(new Point(0.6281452775001526, 0.6266041994094849), new Point(0.5773674249649048, 0.6266041994094849), new Point(0.5773674249649048, 0.6202569603919983), "40");
		createFace(["849", "435", "77", "424"], "41");
		setUVsToFace(new Point(0.17470115423202515, 0.7010075449943542), new Point(0.15439267456531525, 0.6912218928337097), new Point(0.15669474576162917, 0.6724030858861494), "41");
		createFace(["606", "900", "332", "333"], "42");
		setUVsToFace(new Point(0.3192814886569977, 0.9433063268661499), new Point(0.34640252590179443, 0.9378260374069214), new Point(0.34640434772393436, 0.9982481532632168), "42");
		createFace(["774", "762", "755", "765"], "43");
		setUVsToFace(new Point(0.49565252661705017, 0.6917092800140381), new Point(0.5181956887245178, 0.6917094588279724), new Point(0.5181956887245178, 0.698056697845459), "43");
		createFace(["627", "893", "630", "142"], "44");
		setUVsToFace(new Point(0.6662298440933228, 0.9292718904875005), new Point(0.6933452486991882, 0.9237438440322876), new Point(0.6933452486991882, 0.9843366146087646), "44");
		createFace(["415", "241", "411", "77"], "45");
		setUVsToFace(new Point(0.4916796386241913, 0.9867375493049622), new Point(0.491679847240448, 0.8755296468734741), new Point(0.5932355521284453, 0.8755296998606577), "45");
		createFace(["586", "566", "107", "457"], "46");
		setUVsToFace(new Point(0.13942313194274902, 0.5488045811653137), new Point(0.24133828282356262, 0.5488045811653137), new Point(0.23105608195772132, 0.562224566961153), "46");
		createFace(["369", "673", "669", "370"], "47");
		setUVsToFace(new Point(0.007347237318754196, 0.6469840616940037), new Point(0.0010000000474974513, 0.6506472229957581), new Point(0.0010000000474974513, 0.6047735810279846), "47");
		createFace(["8", "211", "13", "9"], "48");
		setUVsToFace(new Point(0.3820027709007263, 0.5488045811653137), new Point(0.40009722113609314, 0.5547264218330383), new Point(0.3648739457130432, 0.6580921411514282), "48");
		createFace(["823", "415", "752"], "305");
		setUVsToFace(new Point(0.9760119915008545, 0.0010000000474974513), new Point(0.9939644932746887, 0.11964411288499832), new Point(0.9939644932746887, 0.18920104205608368), "305");
		createFace(["265", "229", "244", "5"], "50");
		setUVsToFace(new Point(0.9069378972053528, 0.825391948223114), new Point(0.9069378972053528, 0.9944024085998535), new Point(0.8889849826452945, 0.9869662948813652), "50");
		createFace(["253", "235", "293", "233"], "51");
		setUVsToFace(new Point(0.9088805913925171, 0.9456845084032377), new Point(0.9088805913925171, 0.8222846984863281), new Point(0.9268332123756409, 0.8441288471221924), "51");
		createFace(["194", "309", "211", "210"], "52");
		setUVsToFace(new Point(0.8599258065223694, 0.5488045811653137), new Point(0.8602091624291095, 0.6301717345094101), new Point(0.8361135721206665, 0.5991988182067871), "52");
		createFace(["370", "163", "145", "696"], "53");
		setUVsToFace(new Point(0.8599171042442322, 0.8843430280685425), new Point(0.8599171042442322, 0.7798025608062744), new Point(0.8662644028663635, 0.7798025608062744), "53");
		createFace(["171", "752", "415", "439"], "54");
		setUVsToFace(new Point(0.45265185832977295, 0.7650526762008667), new Point(0.4346991181373596, 0.774442195892334), new Point(0.4346991181373596, 0.7048853039741516), "54");
		createFace(["411", "229", "849", "424"], "55");
		setUVsToFace(new Point(0.9685670733451843, 0.8684543371200562), new Point(0.9865198731422424, 0.8610181212425232), new Point(0.9865197911937365, 0.9763573654742963), "55");
		createFace(["261", "267", "256", "262"], "56");
		setUVsToFace(new Point(0.5932353138923645, 0.708558976650238), new Point(0.5932353138923645, 0.8735869526863098), new Point(0.4916796386241913, 0.8735869526863098), "56");
		createFace(["921", "930", "934", "929"], "57");
		setUVsToFace(new Point(0.7836523338642811, 0.12439981859853289), new Point(0.9740692973136902, 0.18787214159965515), new Point(0.7550897598266602, 0.3042273223400116), "57");
		createFace(["174", "743", "745"], "276");
		setUVsToFace(new Point(0.09873273968696594, 0.9150475859642029), new Point(0.10255590826272964, 0.9124423265457153), new Point(0.10255588591098785, 0.9963335394859314), "276");
		createFace(["194", "328", "281", "309"], "59");
		setUVsToFace(new Point(0.011285954155027866, 0.72205650806427), new Point(0.0010000000474974513, 0.708558976650238), new Point(0.10292667433510679, 0.7084614035606852), "59");
		createFace(["841", "556", "576", "566"], "60");
		setUVsToFace(new Point(0.9939646124839783, 0.3097878694534302), new Point(0.9939646124839783, 0.510504961013794), new Point(0.9760119915008545, 0.5066079497337341), "60");
		createFace(["332", "893", "627", "333"], "61");
		setUVsToFace(new Point(0.7607090473175049, 0.8009029030799866), new Point(0.7607118487358093, 0.9274309873580933), new Point(0.7335865497589111, 0.9219522476196289), "61");
		createFace(["624", "536", "740", "755", "625"], "62");
		setUVsToFace(new Point(0.3295440673828125, 0.18034924566745758), new Point(0.36388131976127625, 0.0010000000474974513), new Point(0.48338979482650757, 0.1205083355307579), "62");
		createFace(["379", "603", "72", "383", "389", "403"], "63");
		setUVsToFace(new Point(0.04116084776218783, 0.8585163440142571), new Point(0.09058183431625366, 0.8588133454322815), new Point(0.0887521132826805, 0.8633010983467101), "63");
		createFace(["657", "720", "721", "147", "829", "155"], "64");
		setUVsToFace(new Point(0.5197391128763353, 0.5556436019240183), new Point(0.5312774130228978, 0.5488044990028398), new Point(0.6281452775001526, 0.6047735810279846), "64");
		createFace(["446", "783", "781", "448"], "65");
		setUVsToFace(new Point(0.7697283029556274, 0.7528875470161438), new Point(0.7697283029556274, 0.6513318419456482), new Point(0.8174638748168945, 0.6513316631317139), "65");
		createFace(["452", "890", "446", "85"], "66");
		setUVsToFace(new Point(0.22899012633493476, 0.6980871078132717), new Point(0.1810147911310196, 0.6980875730514526), new Point(0.18455958366394043, 0.6801348924636841), "66");
		createFace(["155", "829", "404", "831", "738", "835"], "67");
		setUVsToFace(new Point(0.5546486973762512, 0.616109182277606), new Point(0.5583255887031555, 0.6181895732879639), new Point(0.5583255887031555, 0.6372312903404236), "67");
		createFace(["367", "65", "369", "371"], "68");
		setUVsToFace(new Point(0.8156147003173828, 0.8603421449661255), new Point(0.8092674612998962, 0.8603421449661255), new Point(0.8092674612998962, 0.7558016777038574), "68");
		createFace(["541", "91", "515", "498"], "69");
		setUVsToFace(new Point(0.24328111112117767, 0.7029425501823425), new Point(0.24328111112117767, 0.5488045811653137), new Point(0.3448368012905121, 0.5488045811653137), "69");
		createFace(["8", "214", "210", "211"], "70");
		setUVsToFace(new Point(0.901602029800415, 0.5678462982177734), new Point(0.901602029800415, 0.5488045811653137), new Point(0.920640766620636, 0.5488045811653137), "70");
		createFace(["10", "9", "13", "12"], "71");
		setUVsToFace(new Point(0.4760381877422333, 0.9765648718856951), new Point(0.4760381877422333, 0.9956066012382507), new Point(0.45699942111968994, 0.9956066012382507), "71");
		createFace(["162", "681", "354", "689"], "72");
		setUVsToFace(new Point(0.13111835718154907, 0.5753899812698364), new Point(0.13746561110019684, 0.5717305541038513), new Point(0.13746561110019684, 0.6836902499198914), "72");
		createFace(["774", "773", "767", "436", "430", "762"], "35");
		setUVsToFace(new Point(0.24328111112117767, 0.787811815738678), new Point(0.26867024095013736, 0.7048852255821466), new Point(0.31944808603480457, 0.7048852255821466), "35");
		createFace(["640", "404", "636"], "74");
		setUVsToFace(new Point(0.30577731132507324, 0.9819764494895935), new Point(0.3051626980304718, 0.9121657013893127), new Point(0.3095914125442505, 0.915288507938385), "74");
		createFace(["636", "55", "640"], "75");
		setUVsToFace(new Point(0.3095914125442505, 0.915288507938385), new Point(0.3127908408641815, 0.978752851486206), new Point(0.30577731132507324, 0.9819764494895935), "75");
		createFace(["383", "738", "336"], "76");
		setUVsToFace(new Point(0.6959025859832764, 0.9935545921325684), new Point(0.6952879428863525, 0.9237438440322876), new Point(0.6997166275978088, 0.9268666505813599), "76");
		createFace(["336", "57", "383"], "77");
		setUVsToFace(new Point(0.6997166275978088, 0.9268666505813599), new Point(0.7029160857200623, 0.9903310537338257), new Point(0.6959025859832764, 0.9935545921325684), "77");
		createFace(["448", "451", "452", "85"], "78");
		setUVsToFace(new Point(0.025024812668561935, 0.6130321025848389), new Point(0.0438435859978199, 0.610729992389679), new Point(0.05362908007594082, 0.6310387104088252), "78");
		createFace(["518", "536", "624", "630", "841"], "79");
		setUVsToFace(new Point(0.19141704800195875, 0.0009999964082696433), new Point(0.3638812916466961, 0.0009999964721852383), new Point(0.3295440673828125, 0.18034924566745758), "79");
		createFace(["831", "389", "60"], "80");
		setUVsToFace(new Point(0.8920311331748962, 0.6186153888702393), new Point(0.8926457762718201, 0.5488045811653137), new Point(0.899659276008606, 0.552028238773346), "80");
		createFace(["60", "339", "831"], "81");
		setUVsToFace(new Point(0.899659276008606, 0.552028238773346), new Point(0.8964598178863525, 0.615492582321167), new Point(0.8920311331748962, 0.6186153888702393), "81");
		createFace(["106", "107", "109", "463"], "82");
		setUVsToFace(new Point(0.24328111112117767, 0.8277439475059509), new Point(0.2768489685637457, 0.8090271094414128), new Point(0.2770736515522003, 0.9569836258888245), "82");
		createFace(["682", "664", "662", "681"], "83");
		setUVsToFace(new Point(0.7626446485519409, 0.93120938539505), new Point(0.7671327590942383, 0.9293738603591919), new Point(0.7671327590942383, 0.9787945747375488), "83");
		createFace(["378", "934", "946", "379"], "84");
		setUVsToFace(new Point(0.34640143083041336, 0.9303954002548658), new Point(0.3192814886569977, 0.9358832240104675), new Point(0.3192843198776245, 0.8093551397323608), "84");
		createFace(["12", "210", "214", "10"], "85");
		setUVsToFace(new Point(0.15750277562603887, 0.8814519047736965), new Point(0.1927260458469391, 0.984817624092102), new Point(0.17463161051273346, 0.9907394647598267), "85");
		createFace(["517", "518", "841", "96"], "86");
		setUVsToFace(new Point(0.4371039867401123, 0.8093552105108461), new Point(0.45505669713020325, 0.8093551397323608), new Point(0.45505669713020325, 0.9327548742294312), "86");
		createFace(["106", "476", "111", "105"], "87");
		setUVsToFace(new Point(0.882006049156189, 0.630205512046814), new Point(0.8629673719406128, 0.630205512046814), new Point(0.8629673719406128, 0.6111638422989416), "87");
		createFace(["463", "109", "591", "469"], "88");
		setUVsToFace(new Point(0.1292193979024887, 0.6277797818183899), new Point(0.1052798181772232, 0.6587531566619873), new Point(0.10540729761123657, 0.5773855447769165), "88");
		createFace(["167", "712", "615", "720", "657", "710"], "89");
		setUVsToFace(new Point(0.18139904501503465, 0.7032177779545288), new Point(0.17956928010940806, 0.6987035770136926), new Point(0.22899021208286285, 0.6990588903427124), "89");
		createFace(["256", "267", "5", "35"], "90");
		setUVsToFace(new Point(0.036292788572609425, 0.7296304106712341), new Point(0.03629279136657715, 0.8311861157417297), new Point(0.012836485169827938, 0.8311861157417297), "90");
		createFace(["900", "625", "755", "849", "229"], "91");
		setUVsToFace(new Point(0.38183414936065674, 0.337248831987381), new Point(0.38183414936065674, 0.21061300659564025), new Point(0.4833897054195404, 0.23584753274917603), "91");
		createFace(["662", "606", "354", "681"], "92");
		setUVsToFace(new Point(0.7671427130699158, 0.8009027883927742), new Point(0.7671427130699158, 0.9165219068527222), new Point(0.7626546025276184, 0.9146922826766968), "92");
		createFace(["662", "625", "900", "606"], "93");
		setUVsToFace(new Point(0.10487274825572968, 0.7140673398971558), new Point(0.13198810815811157, 0.708558976650238), new Point(0.13198810815811157, 0.8351947069168091), "93");
		createFace(["281", "306", "308", "309"], "350");
		setUVsToFace(new Point(0.10293000191450119, 0.708558976650238), new Point(0.10293009430604912, 0.88318746070885), new Point(0.09264510124921799, 0.8696853518486023), "350");
		createFace(["281", "328", "783", "446"], "95");
		setUVsToFace(new Point(0.9486714601516724, 0.7532682034492333), new Point(0.9486714601516724, 0.6513316631317139), new Point(0.9695548415184021, 0.6517124772071838), "95");
		createFace(["96", "566", "586", "505"], "96");
		setUVsToFace(new Point(0.9695546931373521, 0.8581039620473206), new Point(0.9486714601516724, 0.8581039905548096), new Point(0.9486714601516724, 0.7561823725700378), "96");
		createFace(["636", "404", "829", "149"], "97");
		setUVsToFace(new Point(0.5023276805877686, 0.5606116056442261), new Point(0.4991540312767029, 0.5561234354972839), new Point(0.5181956887245178, 0.5561234354972839), "97");
		createFace(["13", "308", "313", "12"], "98");
		setUVsToFace(new Point(0.30224859714508057, 0.9625478982925415), new Point(0.27924321027559884, 0.9935208203640643), new Point(0.2793206572532654, 0.9121657013893127), "98");
		createFace(["436", "435", "849", "430"], "99");
		setUVsToFace(new Point(0.49565252661705017, 0.5551521182060242), new Point(0.49565252661705017, 0.5488048195838928), new Point(0.5181956887245178, 0.5488045811653137), "99");
		createFace(["378", "70", "640"], "100");
		setUVsToFace(new Point(0.6281452775001526, 0.6275755763053894), new Point(0.6263136863708496, 0.6320637464523315), new Point(0.6128976941108704, 0.6320638060569763), "100");
		createFace(["147", "721", "600"], "101");
		setUVsToFace(new Point(0.5938559770584106, 0.6320638060569763), new Point(0.580440104007721, 0.6320637464523315), new Point(0.578608512878418, 0.6275755763053894), "101");
		createFace(["930", "921", "586", "594"], "102");
		setUVsToFace(new Point(0.8203779458999634, 0.8520487546920776), new Point(0.8203837871551514, 0.6513316631317139), new Point(0.8380789160728455, 0.6735283732414246), "102");
		createFace(["370", "669", "682", "163"], "103");
		setUVsToFace(new Point(0.007347237318754196, 0.6084368228912354), new Point(0.0010000000474974513, 0.6047735810279846), new Point(0.09786812961101532, 0.5488045811653137), "103");
		createFace(["762", "430", "849", "755"], "104");
		setUVsToFace(new Point(0.489736944437027, 0.23584753274917603), new Point(0.489736944437027, 0.31201431155204773), new Point(0.4833897054195404, 0.31201431155204773), "104");
		createFace(["570", "177", "178"], "298");
		setUVsToFace(new Point(0.7139654159545898, 0.920829713344574), new Point(0.6935466527938843, 0.9208297729492188), new Point(0.696151852607727, 0.9170066714286804), "298");
		createFace(["336", "738", "831", "339"], "108");
		setUVsToFace(new Point(0.5023276805877686, 0.7035163044929504), new Point(0.4991540312767029, 0.6990280747413635), new Point(0.5181956619972854, 0.6990280822736933), "108");
		createFace(["570", "556", "812", "177"], "110");
		setUVsToFace(new Point(0.08703706607162962, 0.8398892689482742), new Point(0.09058183431625366, 0.857841968536377), new Point(0.042606424540281296, 0.8578416705131531), "110");
		createFace(["773", "774", "765", "171"], "111");
		setUVsToFace(new Point(0.7232268452644304, 0.8192737634236764), new Point(0.7232269048690796, 0.9059998393058777), new Point(0.7168796062469482, 0.9059998393058777), "111");
		createFace(["378", "379", "403", "70"], "112");
		setUVsToFace(new Point(0.8092674612998962, 0.9778268337249756), new Point(0.809267415032257, 0.8622850890908075), new Point(0.8137555718421936, 0.8641205430030823), "112");
		createFace(["544", "915", "910", "911"], "113");
		setUVsToFace(new Point(0.4916796386241913, 0.1205083355307579), new Point(0.6111885568434312, 0.0010000475323807267), new Point(0.6455253958702087, 0.18034924566745758), "113");
		createFace(["294", "306", "22", "293"], "114");
		setUVsToFace(new Point(0.9933520555496216, 0.6513316941261719), new Point(0.9933520555496216, 0.7532533407211304), new Point(0.972468912601471, 0.7532533407211304), "114");
		createFace(["309", "308", "13", "211"], "115");
		setUVsToFace(new Point(0.4368038475513458, 0.5488045811653137), new Point(0.43657916456309454, 0.6967611783697777), new Point(0.4030113220214844, 0.6780442595481873), "115");
		createFace(["682", "681", "162", "163"], "116");
		setUVsToFace(new Point(0.09786813658821716, 0.5488046102987338), new Point(0.13746561110019684, 0.5717305541038513), new Point(0.13111835718154907, 0.5753899812698364), "116");
		createFace(["528", "917", "915", "98"], "117");
		setUVsToFace(new Point(0.8579742908477783, 0.9522666972521512), new Point(0.8400216698646545, 0.9522668123245239), new Point(0.8400216698646545, 0.7798026204109192), "117");
		createFace(["755", "740", "745", "743"], "118");
		setUVsToFace(new Point(0.9666241407394409, 0.8610181212425232), new Point(0.9666243195533752, 0.9763572812080383), new Point(0.9486715902106759, 0.9689210636447054), "118");
		createFace(["229", "265", "332", "900"], "119");
		setUVsToFace(new Point(0.48338979482650757, 0.42735347151756287), new Point(0.36388131976127625, 0.5468618273735046), new Point(0.32954400200987877, 0.36751259554263876), "119");
		createFace(["604", "946", "823"], "349");
		setUVsToFace(new Point(0.5932353138923645, 0.337248831987381), new Point(0.6455253958702087, 0.367512583732605), new Point(0.4916796386241913, 0.42735347151756287), "349");
		createFace(["556", "841", "630", "893", "890", "452", "812"], "58");
		setUVsToFace(new Point(0.0010001968488671797, 0.1878721193924777), new Point(0.19141713342042227, 0.12439977908587911), new Point(0.21997970342636106, 0.24363449358504016), "58");
		createFace(["910", "915", "917", "921", "929"], "105");
		setUVsToFace(new Point(0.6455254599914337, 0.18034924396624244), new Point(0.6111881732940674, 0.0010000000474974513), new Point(0.7836523652076721, 0.0010000000474974513), "105");
		createFace(["945", "823", "946", "235", "253"], "73");
		setUVsToFace(new Point(0.6111881732940674, 0.5468618273735046), new Point(0.4916796386241913, 0.42735347151756287), new Point(0.6455253958702087, 0.367512583732605), "73");
		createFace(["411", "424", "77"], "124");
		setUVsToFace(new Point(0.5932355523109436, 0.8755296468734741), new Point(0.5932355523109436, 0.9594208002090454), new Point(0.5894123911857605, 0.9568156003952026), "124");
		createFace(["96", "505", "492", "517"], "125");
		setUVsToFace(new Point(0.835142195224762, 0.5488045811653137), new Point(0.835142195224762, 0.6503602862358093), new Point(0.7335865497589111, 0.6503602862358093), "125");
		createFace(["604", "823", "544", "911"], "126");
		setUVsToFace(new Point(0.5932353138923645, 0.337248831987381), new Point(0.4916796386241913, 0.42735347151756287), new Point(0.4916796386241913, 0.1205083355307579), "126");
		createFace(["469", "480", "113", "463"], "127");
		setUVsToFace(new Point(0.46416547894477844, 0.7048853039741516), new Point(0.4832042157649994, 0.7048853039741516), new Point(0.4832042157649994, 0.7239269614219666), "127");
		createFace(["910", "929", "600", "615"], "128");
		setUVsToFace(new Point(0.34834650319784133, 0.9358931725564393), new Point(0.34834957122802734, 0.8093551397323608), new Point(0.3754749298095703, 0.8148338794708252), "128");
		createFace(["946", "604", "603", "379"], "129");
		setUVsToFace(new Point(0.8629688620567322, 0.6092210412025452), new Point(0.8629673719406128, 0.5488045811653137), new Point(0.8900884389877319, 0.5542848706245422), "129");
		createFace(["745", "822", "752", "174"], "131");
		setUVsToFace(new Point(0.10255588276372285, 0.9963334864987479), new Point(0.001000184565782547, 0.9963335394859314), new Point(0.0010000000474974513, 0.8851256370544434), "131");
		createFace(["22", "896", "3", "260"], "132");
		setUVsToFace(new Point(0.9287760257720947, 0.6731758117675781), new Point(0.9467286467552185, 0.6513317227363586), new Point(0.9467286467552185, 0.7747315168380737), "132");
		createFace(["174", "752", "171", "765"], "133");
		setUVsToFace(new Point(0.19564016163349152, 0.9813483357429504), new Point(0.21726664900779724, 0.8814519047737122), new Point(0.23282620310783386, 0.8944274187088013), "133");
		createFace(["352", "333", "627", "673"], "134");
		setUVsToFace(new Point(0.9884625011673657, 0.8628537929274427), new Point(0.9929506778717041, 0.8610181212425232), new Point(0.9929506778717041, 0.9765599966049194), "134");
		createFace(["469", "105", "111", "480"], "135");
		setUVsToFace(new Point(0.03726416453719139, 0.8329960703849792), new Point(0.07248742878437042, 0.7296304106712341), new Point(0.09058183431625366, 0.7355522513389587), "135");
		createFace(["720", "615", "600", "721"], "136");
		setUVsToFace(new Point(0.8331561088562012, 0.9676977396011353), new Point(0.8286678924410054, 0.9695331339081508), new Point(0.828667938709259, 0.8539913892745972), "136");
		createFace(["448", "85", "446"], "137");
		setUVsToFace(new Point(0.7875418066978455, 0.7490643858909607), new Point(0.7901471257209778, 0.7528875470161438), new Point(0.7697283029556274, 0.7528875470161438), "137");
		createFace(["233", "260", "261", "262"], "138");
		setUVsToFace(new Point(0.43178504705429077, 0.7048853039741516), new Point(0.43178504705429077, 0.8064409494400024), new Point(0.41383233666419983, 0.8064409494400024), "138");
		createFace(["260", "233", "293", "22"], "139");
		setUVsToFace(new Point(0.7316437363624573, 0.8173310160636902), new Point(0.6300880312919617, 0.8173310160636902), new Point(0.6300880312919617, 0.7157753109931946), "139");
		createFace(["673", "627", "142", "669"], "140");
		setUVsToFace(new Point(0.9933356046676636, 0.7580138444900513), new Point(0.9978238940238953, 0.7561823129653931), new Point(0.9978238940238953, 0.8057191442155754), "140");
		createFace(["389", "383", "57", "60"], "141");
		setUVsToFace(new Point(0.01695701666176319, 0.6297717094421387), new Point(0.01695701666176319, 0.6107298787661242), new Point(0.024053441360592842, 0.6139035820960999), "141");
		createFace(["801", "178", "179", "176"], "142");
		setUVsToFace(new Point(0.45447105169296265, 0.5488045811653137), new Point(0.47609755396842957, 0.6487010717391968), new Point(0.4572618476045395, 0.6465426080078374), "142");
		createFace(["435", "436", "767", "439"], "143");
		setUVsToFace(new Point(0.48535895347595215, 0.6355306506156921), new Point(0.4790117144584656, 0.6355307102203369), new Point(0.47901180386543935, 0.5488046343381356), "143");
		createFace(["67", "144", "162", "689"], "144");
		setUVsToFace(new Point(0.82672518491745, 0.8539913646744227), new Point(0.82672518491745, 0.9586322903633118), new Point(0.8203779458999634, 0.9586322903633118), "144");
		createFace(["812", "179", "178", "177"], "146");
		setUVsToFace(new Point(0.08249084556855749, 0.6409221719658995), new Point(0.0621822364628315, 0.6311365962028503), new Point(0.06448432803153992, 0.6123178005218506), "146");
		createFace(["576", "594", "591", "109"], "147");
		setUVsToFace(new Point(0.2413350216328345, 0.7235260008330585), new Point(0.13940836489200592, 0.7234284281730652), new Point(0.1496943235397339, 0.709930956363678), "147");
		createFace(["107", "566", "576", "109"], "148");
		setUVsToFace(new Point(0.23105347156524658, 0.5623020529747009), new Point(0.24133846734736614, 0.5487998736058719), new Point(0.2413383573293686, 0.7234284281730652), "148");
		createFace(["689", "354", "352", "65"], "149");
		setUVsToFace(new Point(0.1311183630409391, 0.6800308578927297), new Point(0.13746561110019684, 0.6836902499198914), new Point(0.09786812961101532, 0.706616222858429), "149");
		createFace(["67", "689", "65", "367"], "150");
		setUVsToFace(new Point(0.13721631467342377, 0.9235504865646362), new Point(0.1308690756559372, 0.9235504865646362), new Point(0.1308690756559372, 0.8851256370544434), "150");
		createFace(["101", "536", "518", "100"], "152");
		setUVsToFace(new Point(0.8690897822380066, 0.6587679940816196), new Point(0.8870423436164856, 0.6513316631317139), new Point(0.8870423436164856, 0.8237958550453186), "152");
		createFace(["915", "544", "91", "541"], "153");
		setUVsToFace(new Point(0.3973131477832794, 0.9783654808998108), new Point(0.39731311798095703, 0.8093551397323608), new Point(0.415265828371048, 0.8167913556098938), "153");
		createFace(["290", "930", "801", "781"], "154");
		setUVsToFace(new Point(0.8889851570129395, 0.8234490163813224), new Point(0.8889851570129395, 0.6513316631317139), new Point(0.9069376587867737, 0.7026119828224182), "154");
		createFace(["463", "113", "476", "106"], "155");
		setUVsToFace(new Point(0.1756725311279297, 0.5757977962493896), new Point(0.19376695156097412, 0.5698760151863098), new Point(0.22899021208286285, 0.6732416749000549), "155");
		createFace(["591", "594", "586", "457"], "156");
		setUVsToFace(new Point(0.1496943235397339, 0.709930956363678), new Point(0.13940822245913412, 0.7234332584024964), new Point(0.13942313194274902, 0.5488045811653137), "156");
		createFace(["155", "835", "153", "156"], "157");
		setUVsToFace(new Point(0.05672268941998482, 0.6313595175743103), new Point(0.05672268941998482, 0.6123178005218506), new Point(0.061210868313714105, 0.6154913326735488), "157");
		createFace(["142", "664", "682", "669"], "158");
		setUVsToFace(new Point(0.6260368756281779, 0.8755297396973831), new Point(0.6260368824005127, 0.9910715818405151), new Point(0.6215487122535706, 0.9892359375953674), "158");
		createFace(["35", "5", "244", "243"], "159");
		setUVsToFace(new Point(0.13940836489200592, 0.725371241569519), new Point(0.24096405506134033, 0.725371241569519), new Point(0.24096405506134033, 0.8795091509819031), "159");
		createFace(["72", "603", "712", "167"], "160");
		setUVsToFace(new Point(0.24022845923900604, 0.9952412310312548), new Point(0.2357403188943863, 0.9970709681510925), new Point(0.2357403188943863, 0.8814519047737122), "160");
		createFace(["261", "3", "265", "267"], "161");
		setUVsToFace(new Point(0.3774176836013794, 0.8093551397323608), new Point(0.39537036418914795, 0.8093550763935007), new Point(0.39537036418914795, 0.9818194508552551), "161");
		createFace(["797", "594", "576", "570"], "162");
		setUVsToFace(new Point(0.45699942111968994, 0.8097359538078308), new Point(0.4778827130794525, 0.8093551397323608), new Point(0.4778827130794525, 0.9112917398780431), "162");
		createFace(["781", "801", "176", "84"], "163");
		setUVsToFace(new Point(0.9287760257720947, 0.9715737748275401), new Point(0.9287760257720947, 0.9020167589187622), new Point(0.9467286467552185, 0.9114062786102295), "163");
		createFace(["147", "600", "378", "640"], "164");
		setUVsToFace(new Point(0.5938559770584106, 0.6320638060569763), new Point(0.578608512878418, 0.6275755763053894), new Point(0.6281454495321128, 0.6275755763053894), "164");
		createFace(["243", "244", "411", "241"], "165");
		setUVsToFace(new Point(0.12795495986938477, 0.8851255178451538), new Point(0.12795495986938477, 0.9866812825202942), new Point(0.10449865460395813, 0.9866812825202942), "165");
		createFace(["515", "745", "740"], "166");
		setUVsToFace(new Point(0.7697283029556274, 0.9819177985191345), new Point(0.7697283029556274, 0.9584614634513855), new Point(0.7852217555046082, 0.97018963098526), "166");
		createFace(["566", "96", "841"], "167");
		setUVsToFace(new Point(0.24328111112117767, 0.9589263796806335), new Point(0.2641643285751343, 0.9589263796806335), new Point(0.2540939450263977, 0.9853470921516418), "167");
		createFace(["822", "91", "544"], "168");
		setUVsToFace(new Point(0.1292193979024887, 0.6752179265022278), new Point(0.10576309263706207, 0.6752179265022278), new Point(0.11749124526977539, 0.6597245335578918), "168");
		createFace(["505", "586", "921"], "169");
		setUVsToFace(new Point(0.3676517605781555, 0.687703013420105), new Point(0.3467795252799988, 0.6869332790374756), new Point(0.35833802819252014, 0.6610062122344971), "169");
		createFace(["556", "570", "576"], "170");
		setUVsToFace(new Point(0.7295010089874268, 0.9342482089996338), new Point(0.7144297957420349, 0.9446271061897278), new Point(0.7144297957420349, 0.9237438440322876), "170");
		createFace(["797", "930", "594"], "171");
		setUVsToFace(new Point(0.44983670115470886, 0.7972667813301086), new Point(0.4346991181373596, 0.7869848012924194), new Point(0.44938260316848755, 0.7763849496841431), "171");
		createFace(["518", "517", "100"], "172");
		setUVsToFace(new Point(0.41286060214042664, 0.9892846345901489), new Point(0.39731311798095703, 0.9982609152793884), new Point(0.39731311798095703, 0.9803082346916199), "172");
		createFace(["492", "917", "528"], "173");
		setUVsToFace(new Point(0.4327560365200043, 0.9982609152793884), new Point(0.41720855236053467, 0.9892846345901489), new Point(0.4327560365200043, 0.9803082346916199), "173");
		createFace(["498", "536", "101"], "174");
		setUVsToFace(new Point(0.9760119915008545, 0.5124476552009583), new Point(0.99150550365448, 0.524175763130188), new Point(0.9760119915008545, 0.5359039306640625), "174");
		createFace(["915", "541", "98"], "175");
		setUVsToFace(new Point(0.7896236777305603, 0.97018963098526), new Point(0.8051171898841858, 0.9584614634513855), new Point(0.8051171898841858, 0.9819177985191345), "175");
		createFace(["930", "797", "801"], "289");
		setUVsToFace(new Point(0.8889851570129395, 0.6513316631317139), new Point(0.9069377779960632, 0.6548764705657959), new Point(0.9069376587867737, 0.7026119828224182), "289");
		createFace(["655", "710", "657", "158"], "178");
		setUVsToFace(new Point(0.975663423538208, 0.9941681623458862), new Point(0.9685670137405396, 0.9973418358730061), new Point(0.9685670137405396, 0.9783000946044922), "178");
		createFace(["890", "896", "306", "281"], "179");
		setUVsToFace(new Point(0.787680983543396, 0.7558016777038574), new Point(0.787680983543396, 0.9565187096595764), new Point(0.7697283000952337, 0.9343225427255575), "179");
		createFace(["929", "934", "378", "600"], "181");
		setUVsToFace(new Point(0.7335865497589111, 0.9899667934788027), new Point(0.7335865497589111, 0.9293738603591919), new Point(0.7607018947601318, 0.934901773929596), "181");
		createFace(["606", "333", "352", "354"], "184");
		setUVsToFace(new Point(0.8644052743911743, 0.8862857818603516), new Point(0.8644053350389365, 0.9357064775043974), new Point(0.8599171042442322, 0.9338709712028503), "184");
		createFace(["308", "306", "294", "313"], "185");
		setUVsToFace(new Point(0.09264510124921799, 0.8696853518486023), new Point(0.10292992740869522, 0.8831828832626343), new Point(0.0010180786766289807, 0.8832805884432353), "185");
		createFace(["823", "241", "415"], "304");
		setUVsToFace(new Point(0.9760119915008545, 0.0010000000474974513), new Point(0.9939646124839783, 0.008436237461864948), new Point(0.9939644932746887, 0.11964411288499832), "304");
		createFace(["515", "740", "536", "498"], "49");
		setUVsToFace(new Point(0.9088804618969619, 0.6587677994817649), new Point(0.9268332719802856, 0.6513316631317139), new Point(0.9268332719802856, 0.8203420639038086), "49");
		createFace(["352", "673", "369", "65"], "121");
		setUVsToFace(new Point(0.09786812961101532, 0.706616222858429), new Point(0.0010000000474974513, 0.6506472229957581), new Point(0.007347237318754196, 0.6469839811325073), "121");
		createFace(["147", "643", "149"], "226");
		setUVsToFace(new Point(0.4814114570617676, 0.8093551397323608), new Point(0.48842495679855347, 0.8125786781311035), new Point(0.48522549867630005, 0.8760430216789246), "226");
		createFace(["149", "829", "147"], "227");
		setUVsToFace(new Point(0.48522549867630005, 0.8760430216789246), new Point(0.48079684376716614, 0.8791658878326416), new Point(0.4814114570617676, 0.8093551397323608), "227");
		createFace(["710", "655", "153"], "232");
		setUVsToFace(new Point(0.4552091956138611, 0.7048853039741516), new Point(0.4622226655483246, 0.7081089019775391), new Point(0.45902323722839355, 0.7715732455253601), "232");
		createFace(["153", "835", "710"], "233");
		setUVsToFace(new Point(0.45902323722839355, 0.7715732455253601), new Point(0.45459455251693726, 0.7746961116790771), new Point(0.4552091956138611, 0.7048853039741516), "233");
		createFace(["155", "156", "158"], "236");
		setUVsToFace(new Point(0.7048588395118713, 0.9237438440322876), new Point(0.7092875242233276, 0.9268666505813599), new Point(0.712486982345581, 0.9903310537338257), "236");
		createFace(["158", "657", "155"], "237");
		setUVsToFace(new Point(0.712486982345581, 0.9903310537338257), new Point(0.7054734826087952, 0.9935545921325684), new Point(0.7048588395118713, 0.9237438440322876), "237");
		
		build ();
	}
}

class EntranceWindows extends Mesh5 {
	public function EntranceWindows () {
		x = 539.3701171875;
		y = -1921.2598876953125;

		createVertex(-3.00927734375, 272.6431884765625, 90.55119323730469, "0");
		createVertex(-3.00927734375, 272.6431884765625, 66.92913818359375, "1");
		createVertex(40.68670654296875, 144.41357421875, 66.92911529541016, "2");
		createVertex(40.68670654296875, 144.41357421875, 90.55119323730469, "3");
		createVertex(-351.32147216796875, 272.6431884765625, 90.55119323730469, "4");
		createVertex(-395.0174560546875, 144.41357421875, 90.55119323730469, "5");
		createVertex(-395.0174560546875, 144.41357421875, 66.92911529541016, "6");
		createVertex(-351.32147216796875, 272.6431884765625, 66.92913818359375, "7");

		createFace(["5", "6", "7", "4"], "0");
		createFace(["1", "2", "3", "0"], "4");
		
		build ();
	}
}

class Passage extends Mesh5 {
	public function Passage () {
		y = -1023.6220703125;

		createVertex(62.9925537109375, -362.2042236328125, 23.108043670654297, "101");
		createVertex(47.2440299987793, 0.0003662109375, -0.00194549560546875, "1");
		createVertex(314.9605712890625, -598.4248046875, -0.00255584716796875, "177");
		createVertex(31.495990753173828, -236.22021484375, 125.98204040527344, "4");
		createVertex(47.244022369384766, -236.2200927734375, -0.0022125244140625, "69");
		createVertex(-31.496129989624023, 0.000244140625, 125.98231506347656, "6");
		createVertex(-47.24416732788086, -236.2200927734375, -0.0022125244140625, "7");
		createVertex(299.213134765625, -267.7158203125, 125.9822998046875, "136");
		createVertex(-31.496135711669922, -236.22021484375, 125.98204040527344, "75");
		createVertex(51.85915756225586, -247.353271484375, -0.00223541259765625, "12");
		createVertex(377.1595458984375, -284.2578125, -0.00196075439453125, "133");
		createVertex(310.3463134765625, -351.071044921875, -0.00203704833984375, "142");
		createVertex(-26.08969497680664, -325.3021240234375, 23.10793685913086, "16");
		createVertex(62.993003845214844, -236.2193603515625, 23.10816192626953, "81");
		createVertex(299.213134765625, -330.7080078125, 125.98223876953125, "21");
		createVertex(62.9925537109375, -330.7081298828125, 125.98210906982422, "22");
		createVertex(299.213134765625, -251.9676513671875, -0.00194549560546875, "24");
		createVertex(62.9925537109375, -251.968017578125, -0.00208282470703125, "25");
		createVertex(299.213134765625, -236.2198486328125, 23.10831069946289, "26");
		createVertex(366.0240478515625, -295.3934326171875, 125.9822769165039, "155");
		createVertex(321.4818115234375, -339.9354248046875, 125.98223876953125, "29");
		createVertex(388.2950439453125, -273.122314453125, 23.108287811279297, "31");
		createVertex(330.708984375, -362.2044677734375, 125.98210144042969, "33");
		createVertex(393.7010192871094, -362.2044677734375, 125.98210144042969, "34");
		createVertex(62.9925537109375, -346.4560546875, -0.00217437744140625, "100");
		createVertex(425.19775390625, -598.424072265625, 23.107818603515625, "37");
		createVertex(40.72341537475586, -258.4888916015625, 125.98202514648438, "85");
		createVertex(330.7086181640625, -598.4249267578125, 125.98169708251953, "39");
		createVertex(393.70074462890625, -598.4249267578125, 125.98169708251953, "40");
		createVertex(-3.8185768127441406, -303.0311279296875, 125.98197937011719, "97");
		createVertex(409.44903564453125, -362.204345703125, -0.00215911865234375, "153");
		createVertex(299.21221923828125, -362.2049560546875, 23.10806655883789, "43");
		createVertex(31.495996475219727, 0.000244140625, 125.98231506347656, "45");
		createVertex(425.19708251953125, -362.2044677734375, 23.108078002929688, "166");
		createVertex(62.992061614990234, 0.000244140625, 23.108280181884766, "47");
		createVertex(314.9609375, -362.204345703125, -0.002166748046875, "149");
		createVertex(409.4487609863281, -598.4248046875, -0.00255584716796875, "169");
		createVertex(299.2125549316406, -598.4249267578125, 23.107681274414063, "178");
		createVertex(-14.95407485961914, -314.16650390625, -0.00229644775390625, "90");
		createVertex(-47.24415969848633, 0.0003662109375, -0.00194549560546875, "54");
		createVertex(62.9925537109375, -267.7161865234375, 125.98216247558594, "119");
		createVertex(-62.992191314697266, 0.000244140625, 23.108280181884766, "57");
		createVertex(299.213134765625, -346.455810546875, -0.00203704833984375, "123");
		createVertex(-62.9921989440918, -236.22021484375, 23.108020782470703, "61");

		createFace(["85", "97", "75", "4"], "0");
		setUVsToFace(new Point(0.2696896493434906, 0.564177930355072), new Point(0.26825469732284546, 0.6373642683029175), new Point(0.19125904325539997, 0.6036926905421388), "0");
		createFace(["61", "7", "54", "57"], "1");
		setUVsToFace(new Point(0.830142617225647, 0.96650230884552), new Point(0.8301424384117126, 0.9990000128746033), new Point(0.5556408762931946, 0.998999644518249), "1");
		createFace(["43", "123", "100", "101"], "2");
		setUVsToFace(new Point(0.830141544342041, 0.9311846494674683), new Point(0.8301426082365831, 0.9636823117763681), new Point(0.5556409358978271, 0.9636828899383545), "2");
		createFace(["81", "25", "24", "26"], "3");
		setUVsToFace(new Point(0.5528215765953064, 0.9311845302581787), new Point(0.5528220534324646, 0.9636827111244202), new Point(0.27832040190696716, 0.9636821746826172), "3");
		createFace(["57", "6", "75", "61"], "4");
		setUVsToFace(new Point(0.5556409358978271, 0.8930479473541131), new Point(0.5556409358978271, 0.7680252194404602), new Point(0.8301424384117126, 0.7680255770683289), "4");
		createFace(["136", "119", "81", "26"], "5");
		setUVsToFace(new Point(0.27832040190696716, 0.7680252194404602), new Point(0.5528220534324646, 0.7680253386497498), new Point(0.552821530351021, 0.8930480619274993), "5");
		createFace(["101", "16", "97", "22"], "6");
		setUVsToFace(new Point(0.862769245721628, 0.11304949418421759), new Point(0.8627692461013794, 0.0010000000474974513), new Point(0.9870050549507141, 0.015005256049335003), "6");
		createFace(["22", "97", "85", "119"], "7");
		setUVsToFace(new Point(0.3465109905553838, 0.6067361934364731), new Point(0.26825469732284546, 0.6373642683029175), new Point(0.2696896493434906, 0.564177930355072), "7");
		createFace(["61", "16", "90", "7"], "8");
		setUVsToFace(new Point(0.06858833134174347, 0.007950528524816036), new Point(0.18063722550868988, 0.0079504931345582), new Point(0.17363464832305908, 0.03968494012951851), "8");
		createFace(["7", "69", "1", "54"], "9");
		setUVsToFace(new Point(0.18373450438957661, 0.04361265152692795), new Point(0.2656702697277069, 0.1167064681649208), new Point(0.08293576538562775, 0.32154586911201477), "9");
		createFace(["133", "31", "26", "24"], "10");
		setUVsToFace(new Point(0.7549039125442505, 0.3302651643753052), new Point(0.7479011673053197, 0.2985312417481875), new Point(0.8599503040313721, 0.2985309958457947), "10");
		createFace(["153", "133", "142", "149"], "11");
		setUVsToFace(new Point(0.6772159934043884, 0.28765198588371277), new Point(0.5889184474945068, 0.3302651643753052), new Point(0.582666277885437, 0.22064274549484253), "11");
		createFace(["69", "12", "81"], "12");
		setUVsToFace(new Point(0.8074218034744263, 0.6373642683029175), new Point(0.8074218034744263, 0.6233592629432678), new Point(0.8391558527946472, 0.6303566694259644), "12");
		createFace(["6", "45", "4", "75"], "13");
		setUVsToFace(new Point(0.000999998301267624, 0.4058222472667694), new Point(0.05376536771655083, 0.3550865352153778), new Point(0.24402442574501038, 0.5529567003250122), "13");
		createFace(["119", "136", "21", "22"], "14");
		setUVsToFace(new Point(0.2957753539085388, 0.5539709329605103), new Point(0.49364519119262695, 0.36371147632598877), new Point(0.5443809508704434, 0.41647687143169054), "14");
		createFace(["81", "85", "4"], "15");
		setUVsToFace(new Point(0.8419747352600098, 0.46289241313934326), new Point(0.9662100672721863, 0.4488915503025055), new Point(0.966210126876831, 0.47690266370773315), "15");
		createFace(["1", "69", "81", "47"], "16");
		setUVsToFace(new Point(0.552821934223175, 0.9283649921417236), new Point(0.2783204222183775, 0.9283651417425676), new Point(0.27832117676734924, 0.895867109298706), "16");
		createFace(["136", "155", "29", "21"], "18");
		setUVsToFace(new Point(0.49364519119262695, 0.36371147632598877), new Point(0.5719017386436462, 0.3330840766429901), new Point(0.5704664202838681, 0.40627034843234006), "18");
		createFace(["142", "133", "24", "123"], "19");
		setUVsToFace(new Point(0.582666277885437, 0.22064274549484253), new Point(0.5889186042569691, 0.330265136200692), new Point(0.496348112821579, 0.29796820878982544), "19");
		createFace(["22", "21", "43", "101"], "76");
		setUVsToFace(new Point(0.2783203810939921, 0.6401831613666158), new Point(0.5528219938278198, 0.64018315076828), new Point(0.5528209805488586, 0.7652062773704529), "76");
		createFace(["25", "81", "12"], "22");
		setUVsToFace(new Point(0.4550020098686218, 0.33950483798980713), new Point(0.4867357611656189, 0.34651198983192444), new Point(0.4550018012523651, 0.3535098135471344), "22");
		createFace(["100", "123", "24", "25"], "23");
		setUVsToFace(new Point(0.36460250113707804, 0.03329770421562356), new Point(0.5694418549537659, 0.2160325050354004), new Point(0.496348112821579, 0.29796820878982544), "23");
		createFace(["81", "4", "45", "47"], "24");
		setUVsToFace(new Point(0.5556418096567664, 0.7652057892721), new Point(0.5556408762931824, 0.6401832699775696), new Point(0.8301423788070679, 0.64018315076828), "24");
		createFace(["81", "119", "85"], "25");
		setUVsToFace(new Point(0.060425881296396255, 0.6233627796173096), new Point(0.1846613734960556, 0.6093526482582092), new Point(0.18466120958328247, 0.6373642683029175), "25");
		createFace(["100", "25", "12"], "26");
		setUVsToFace(new Point(0.36460259556770325, 0.03329767286777496), new Point(0.29150885343551636, 0.11523330211639404), new Point(0.2782846689224243, 0.11062246561050415), "26");
		createFace(["166", "31", "133", "153"], "27");
		setUVsToFace(new Point(0.5874268412590027, 0.5039498805999756), new Point(0.5874272584915161, 0.6159988045692444), new Point(0.5556929111480713, 0.6089962124824524), "27");
		createFace(["153", "169", "37", "166"], "28");
		setUVsToFace(new Point(0.2755015194416046, 0.9283652901649475), new Point(0.0010000014992021522, 0.9283655428819058), new Point(0.0010008156532421708, 0.8958675265312195), "28");
		createFace(["177", "169", "153", "149"], "29");
		setUVsToFace(new Point(0.7780145804913574, 0.009718578266321748), new Point(0.8599503040313721, 0.08281239122152328), new Point(0.6772159934043884, 0.28765198588371277), "29");
		createFace(["90", "16", "101", "100"], "30");
		setUVsToFace(new Point(0.26200932264328003, 0.446856290102005), new Point(0.29374372959136963, 0.43985357880592346), new Point(0.2937437891960144, 0.5519026517868042), "30");
		createFace(["155", "31", "166", "34"], "31");
		setUVsToFace(new Point(0.9662106037139893, 0.43112778663635254), new Point(0.8419748544692993, 0.4451330602169037), new Point(0.8419744862805268, 0.333083663806535), "31");
		createFace(["37", "40", "34", "166"], "32");
		setUVsToFace(new Point(0.0010009752586483955, 0.8930485844612122), new Point(0.0010000000474974513, 0.7680256962776184), new Point(0.2755014775938818, 0.7680249836665834), "32");
		createFace(["177", "149", "43", "178"], "33");
		setUVsToFace(new Point(0.8301424384117126, 0.9283657670021057), new Point(0.5556409049292076, 0.9283649867769802), new Point(0.5556416511535645, 0.8958671689033508), "33");
		createFace(["26", "31", "155", "136"], "34");
		setUVsToFace(new Point(0.8329615592956543, 0.8800740838050842), new Point(0.8329613208770752, 0.7680252194404602), new Point(0.9571968843988442, 0.7820304609014567), "34");
		createFace(["29", "155", "34", "33"], "35");
		setUVsToFace(new Point(0.5704663991928101, 0.4062703847885132), new Point(0.5719017386436462, 0.3330840766429901), new Point(0.6488971043833921, 0.3667564893342934), "35");
		createFace(["90", "100", "12", "69", "7"], "20");
		setUVsToFace(new Point(0.27203252185546656, 0.0010000829958404511), new Point(0.3646026495191752, 0.033297788551947455), new Point(0.2782846689224243, 0.11062246561050415), "20");
		createFace(["43", "33", "39", "178"], "38");
		setUVsToFace(new Point(0.001000549760647118, 0.7652060985565186), new Point(0.0010000000474974513, 0.64018315076828), new Point(0.2755015073365038, 0.6401835315759526), "38");
		createFace(["97", "16", "61", "75"], "39");
		setUVsToFace(new Point(0.9571971893310547, 0.7382271885871887), new Point(0.8329613208770752, 0.752232015132904), new Point(0.8329612444740497, 0.6401825989286906), "39");
		createFace(["123", "43", "142"], "44");
		setUVsToFace(new Point(0.42232823371887207, 0.3395048677921295), new Point(0.45406216382980347, 0.3465123474597931), new Point(0.42232823371887207, 0.3535098135471344), "44");
		createFace(["40", "39", "33", "34"], "37");
		setUVsToFace(new Point(0.8391557506698204, 0.5646267391955023), new Point(0.7863904237747192, 0.6153625249862671), new Point(0.5961317420005798, 0.41749221086502075), "37");
		createFace(["43", "21", "29"], "47");
		setUVsToFace(new Point(0.8627691864967346, 0.13081775605678558), new Point(0.9870048761367798, 0.11680760979652405), new Point(0.9870048761367798, 0.14481870830059052), "47");
		createFace(["149", "142", "43"], "54");
		setUVsToFace(new Point(0.7747482061386108, 0.6373642683029175), new Point(0.7747483253479004, 0.6233594417572021), new Point(0.806482195854187, 0.630357563495636), "54");
		createFace(["43", "29", "33"], "57");
		setUVsToFace(new Point(0.714920163154602, 0.3517085313796997), new Point(0.8391558527946472, 0.3377072513103485), new Point(0.8391556143760681, 0.3657186031341553), "57");

		build ();
	}
}

class BunkerWindows extends Mesh5 {
	public function BunkerWindows () {
		createVertex(283.4645456542494, 236.22051184077282, 165.35434667964, "0");
		createVertex(283.4645456542494, 314.9606699218275, 165.35434667964, "1");
		createVertex(299.2125925292494, 314.9606394042494, 102.36222021479625, "2");
		createVertex(299.2125925292494, 236.22049658198375, 102.36223547358532, "3");
		createVertex(283.4645456542494, 0.000030517578125, 165.35440771479625, "4");
		createVertex(283.4645456542494, 78.74017279047985, 165.3543924560072, "5");
		createVertex(299.2125925292494, 78.74017279047985, 102.36227362055797, "6");
		createVertex(299.2125925292494, 0.000030517578125, 102.36228887934703, "7");
		createVertex(283.4645456542494, -236.22045190434437, 165.35443823237438, "8");
		createVertex(283.4645456542494, -157.48033959965687, 165.35443823237438, "9");
		createVertex(299.2125925292494, -157.48033959965687, 102.36231939692516, "10");
		createVertex(299.2125925292494, -236.22045190434437, 102.36233465571422, "11");
		createVertex(-283.4645314941881, 236.22051184077282, 165.35434667964, "12");
		createVertex(-283.4645314941881, 314.9606699218275, 165.35434667964, "13");
		createVertex(-299.2125783691881, 314.9606394042494, 102.36222021479625, "14");
		createVertex(-299.2125783691881, 236.22049658198375, 102.36223547358532, "15");
		createVertex(-283.4645314941881, 0.000030517578125, 165.35440771479625, "16");
		createVertex(-283.4645314941881, 78.74017279047985, 165.3543924560072, "17");
		createVertex(-299.2125783691881, 78.74017279047985, 102.36227362055797, "18");
		createVertex(-299.2125783691881, 0.000030517578125, 102.36228887934703, "19");
		createVertex(-283.4645314941881, -236.22045190434437, 165.35443823237438, "20");
		createVertex(-283.4645314941881, -157.48033959965687, 165.35443823237438, "21");
		createVertex(-299.2125783691881, -157.48033959965687, 102.36231939692516, "22");
		createVertex(-299.2125783691881, -236.22045190434437, 102.36233465571422, "23");
		createVertex(283.4645456542494, -866.14174707036, 165.35452978510875, "24");
		createVertex(283.4645456542494, -944.88198144536, 165.35456030268688, "25");
		createVertex(299.2125925292494, -944.88198144536, 102.3624262084486, "26");
		createVertex(299.2125925292494, -866.14174707036, 102.36241857905407, "27");
		createVertex(283.4645456542494, -629.921288085985, 165.35449926753063, "28");
		createVertex(283.4645456542494, -708.661522460985, 165.35452978510875, "29");
		createVertex(299.2125925292494, -708.661522460985, 102.36239569087047, "30");
		createVertex(299.2125925292494, -629.921288085985, 102.36238806147594, "31");
		createVertex(283.4645456542494, -393.7007985840319, 165.3544687499525, "32");
		createVertex(283.4645456542494, -472.4409108887194, 165.35448400874157, "33");
		createVertex(299.2125925292494, -472.4409108887194, 102.36236517329235, "34");
		createVertex(299.2125925292494, -393.7007985840319, 102.36235754389782, "35");
		createVertex(-283.4645314941881, -944.88198144536, 165.35456030268688, "36");
		createVertex(-283.4645314941881, -866.14174707036, 165.35452978510875, "37");
		createVertex(-299.2125783691881, -944.88198144536, 102.3624262084486, "38");
		createVertex(-299.2125783691881, -866.14174707036, 102.36241857905407, "39");
		createVertex(-283.4645314941881, -708.661522460985, 165.35452978510875, "40");
		createVertex(-283.4645314941881, -629.921288085985, 165.35449926753063, "41");
		createVertex(-299.2125783691881, -708.661522460985, 102.36239569087047, "42");
		createVertex(-299.2125783691881, -629.921288085985, 102.36238806147594, "43");
		createVertex(-283.4645314941881, -472.4409108887194, 165.35448400874157, "44");
		createVertex(-283.4645314941881, -393.7007985840319, 165.3544687499525, "45");
		createVertex(-299.2125783691881, -472.4409108887194, 102.36236517329235, "46");
		createVertex(-299.2125783691881, -393.7007985840319, 102.36235754389782, "47");

		createFace(["9", "10", "11", "8"], "16");
		createFace(["37", "36", "38", "39"], "1");
		createFace(["30", "29", "28", "31"], "2");
		createFace(["45", "44", "46", "47"], "3");
		createFace(["6", "7", "4", "5"], "4");
		createFace(["26", "25", "24", "27"], "5");
		createFace(["0", "1", "2", "3"], "6");
		createFace(["23", "22", "21", "20"], "0");
		createFace(["34", "33", "32", "35"], "24");
		createFace(["41", "40", "42", "43"], "12");
		createFace(["17", "16", "19", "18"], "13");
		createFace(["14", "13", "12", "15"], "8");

		build ();
	}
}

class Grid extends Mesh5 {
	public function Grid () {
		createVertex(39.37008612055797, 314.9606394042494, 0.0000152587890625, "0");
		createVertex(39.37008612055797, 0.000030517578125, 0.00006866455078125, "1");
		createVertex(-39.37008721928578, 0.000030517578125, 0.00006866455078125, "2");
		createVertex(-39.37008721928578, 314.9606394042494, 0.0000152587890625, "3");
		createVertex(-39.370071960496716, -157.48033959965687, 0.0001068115234375, "4");
		createVertex(39.37007086176891, -157.48033959965687, 0.0001068115234375, "5");
		createVertex(39.37008612055797, -944.88198144536, 0.00022125244140625, "6");
		createVertex(39.37008612055797, -629.921288085985, 0.00017547607421875, "7");
		createVertex(-39.37008721928578, -629.921288085985, 0.00017547607421875, "8");
		createVertex(39.37007086176891, -472.4409108887194, 0.000152587890625, "9");
		createVertex(-39.37008721928578, -944.88198144536, 0.00022125244140625, "10");
		createVertex(-39.370071960496716, -472.4409108887194, 0.000152587890625, "11");

		createFace(["7", "8", "10", "6"], "0");
		setUVsToFace(new Point(0.2524999976158142, 0.9950000047683716), new Point(0.004999999888241291, 0.9950000047683716), new Point(0.004999999888241291, 0.004999999888241291), "0");
		createFace(["4", "11", "9", "5"], "1");
		setUVsToFace(new Point(0.26226165890693665, 0.9949997067451477), new Point(0.26226165890693665, 0.004999999888241291), new Point(0.5097615718841553, 0.004999999888241291), "1");
		createFace(["0", "3", "2", "1"], "6");
		setUVsToFace(new Point(0.5202288627624512, 0.004999999888241291), new Point(0.7677289247512817, 0.004999999888241291), new Point(0.7677289247512817, 0.9949998259544373), "6");

		build ();
	}
}

class Slope extends Mesh5 {
	public function Slope () {
		y = 393.7008056640625;

		createVertex(47.244102478027344, 236.22052001953125, -0.000030517578125, "1");
		createVertex(31.496068954467773, 236.22052001953125, 125.9842300415039, "2");
		createVertex(-31.496057510375977, 236.2205810546875, 125.9842300415039, "5");
		createVertex(62.9921875, 1417.322998046875, -606.8110961914063, "72");
		createVertex(-47.24409484863281, 0, -0.000030517578125, "9");
		createVertex(47.24415588378906, 1417.322998046875, -629.9213256835938, "76");
		createVertex(62.99217987060547, 1181.1025390625, -606.8109741210938, "73");
		createVertex(-62.9920654296875, 1417.322998046875, -606.8110961914063, "82");
		createVertex(-31.49600601196289, 1417.322998046875, -503.93695068359375, "84");
		createVertex(31.49612045288086, 1417.322998046875, -503.93695068359375, "22");
		createVertex(47.24414825439453, 1181.1025390625, -629.9212646484375, "87");
		createVertex(-47.24403381347656, 1417.322998046875, -629.9213256835938, "25");
		createVertex(47.2441520690918, 1118.118408203125, -612.9890747070313, "94");
		createVertex(62.99213409423828, 236.22052001953125, 23.110198974609375, "34");
		createVertex(62.99212646484375, 0.000030517578125, 23.110206604003906, "36");
		createVertex(-47.244041442871094, 1181.1025390625, -629.9212646484375, "101");
		createVertex(-62.99207305908203, 1181.1025390625, -606.8109741210938, "102");
		createVertex(47.24409484863281, 0, -0.000030517578125, "40");
		createVertex(-62.99207305908203, 1129.78271484375, -593.0379638671875, "107");
		createVertex(-62.99212646484375, 0.000030517578125, 23.110206604003906, "44");
		createVertex(31.496063232421875, 0.000030517578125, 125.98422241210938, "37");
		createVertex(-47.24403762817383, 1118.118408203125, -612.9890747070313, "30");
		createVertex(-31.496063232421875, 0.000030517578125, 125.98422241210938, "48");
		createVertex(31.496116638183594, 1181.1025390625, -503.93707275390625, "114");
		createVertex(-31.496009826660156, 1181.1025390625, -503.93707275390625, "108");
		createVertex(-31.496055603027344, 298.64886474609375, 109.06181335449219, "117");
		createVertex(-62.99211883544922, 247.32086181640625, 19.907367706298828, "111");
		createVertex(62.99217987060547, 1129.78271484375, -593.0379638671875, "121");
		createVertex(31.496070861816406, 298.64886474609375, 109.06181335449219, "123");
		createVertex(62.99213409423828, 247.32086181640625, 19.907367706298828, "124");
		createVertex(-47.24408721923828, 236.22052001953125, -0.000030517578125, "61");
		createVertex(-62.99211883544922, 236.22052001953125, 23.110198974609375, "62");

		createFace(["123", "117", "108", "114"], "0");
		setUVsToFace(new Point(0.3302437365055084, 0.0010000000474974513), new Point(0.38816511631011963, 0.0010000000474974513), new Point(0.38816505670547485, 0.9889799952507019), "0");
		createFace(["73", "87", "94", "121"], "1");
		setUVsToFace(new Point(0.6157415192379595, 0.711591593226423), new Point(0.6409277319908142, 0.7063648700714111), new Point(0.6402363777160645, 0.766331136226654), "1");
		createFace(["30", "101", "102", "107"], "2");
		setUVsToFace(new Point(0.8317267894744873, 0.0010000000474974513), new Point(0.8300666809082031, 0.06094730272889137), new Point(0.8051131367683411, 0.05473734810948372), "2");
		createFace(["124", "121", "94", "1"], "3");
		setUVsToFace(new Point(0.4820057153701782, 0.0010000000474974513), new Point(0.47064870595932007, 0.9888929128646851), new Point(0.4449699819087982, 0.9902541637420654), "3");
		createFace(["76", "25", "101", "87"], "4");
		setUVsToFace(new Point(0.688416063785553, 0.0010000000474974513), new Point(0.7752981185913086, 0.0010000000474974513), new Point(0.7752981185913086, 0.21820518374443054), "4");
		createFace(["44", "9", "61", "62"], "5");
		setUVsToFace(new Point(0.6482304930686951, 0.4866994023323059), new Point(0.6739450693130493, 0.4866994023323059), new Point(0.6739450608238818, 0.7039045972099762), "5");
		createFace(["111", "117", "5", "62"], "6");
		setUVsToFace(new Point(0.5862088203430176, 0.22841201722621918), new Point(0.4993443787097931, 0.2756081819534302), new Point(0.48455460589019833, 0.21820515474722219), "6");
		createFace(["82", "102", "101", "25"], "7");
		setUVsToFace(new Point(0.7777584791183472, 0.21820518374443054), new Point(0.7777582919955469, 0.0010000000474974513), new Point(0.8034729957580566, 0.0010000000474974513), "7");
		createFace(["114", "22", "72", "73"], "8");
		setUVsToFace(new Point(0.5878490209579468, 0.21820515394210815), new Point(0.5878489017486572, 0.0010000000474974513), new Point(0.6867759227752686, 0.0010000000474974513), "8");
		createFace(["94", "30", "61", "1"], "10");
		setUVsToFace(new Point(0.327783465385437, 0.9885552525520325), new Point(0.2409014105796814, 0.9885552525520325), new Point(0.240901380777359, 0.0010000000474974513), "10");
		createFace(["123", "2", "5", "117"], "11");
		setUVsToFace(new Point(0.7487977147102356, 0.2801399230957031), new Point(0.7487976551055908, 0.22066539525985718), new Point(0.8067190647125244, 0.22066539525985718), "11");
		createFace(["34", "124", "1"], "12");
		setUVsToFace(new Point(0.5878489017486572, 0.925210177898407), new Point(0.5982017517089844, 0.9275912046432495), new Point(0.5879798531532288, 0.9509244561195374), "12");
		createFace(["2", "123", "124", "34"], "13");
		setUVsToFace(new Point(0.48446589708328247, 0.33465123176574707), new Point(0.4993443787097931, 0.2772482633590698), new Point(0.5862088203430176, 0.3244444727897644), "13");
		createFace(["30", "107", "111", "61"], "14");
		setUVsToFace(new Point(0.4175948446098475, 0.0009964667704072117), new Point(0.44332990050315857, 0.0033670556731522083), new Point(0.4159489870071411, 0.9909456968307495), "14");
		createFace(["124", "123", "114", "121"], "15");
		setUVsToFace(new Point(0.22369489073753357, 0.9888353943824768), new Point(0.12497834116220474, 0.9952840209007263), new Point(0.1405918283846165, 0.007427451064364932), "15");
		createFace(["87", "73", "72", "76"], "16");
		setUVsToFace(new Point(0.6135635375976563, 0.9235700368881226), new Point(0.5878489017486572, 0.9235700368881226), new Point(0.5878490888712781, 0.7063648700714111), "16");
		createFace(["61", "111", "62"], "17");
		setUVsToFace(new Point(0.6816145777702332, 0.48669934272766113), new Point(0.686208188533783, 0.5117558240890503), new Point(0.6755852103233337, 0.5116970539093018), "17");
		createFace(["62", "5", "48", "44"], "18");
		setUVsToFace(new Point(0.5833927989006042, 0.21820521354675293), new Point(0.48446589708328247, 0.21820521354675293), new Point(0.4844659117566156, 0.0009999439255573006), "18");
		createFace(["87", "101", "30", "94"], "19");
		setUVsToFace(new Point(0.5444361567497253, 0.8195305466651917), new Point(0.5444361567497253, 0.9064126014709473), new Point(0.48446589708328247, 0.9064126014709473), "19");
		createFace(["108", "117", "111", "107"], "20");
		setUVsToFace(new Point(0.0010000000474974513, 0.9887092709541321), new Point(0.024130282923579216, 0.0010000000474974513), new Point(0.1225181370973587, 0.01131364330649376), "20");
		createFace(["102", "82", "84", "108"], "21");
		setUVsToFace(new Point(0.5833927989006042, 0.6006852388381958), new Point(0.5833929144646266, 0.8178904056549072), new Point(0.48446589708328247, 0.8178904056549072), "21");
		createFace(["1", "40", "36", "34"], "22");
		setUVsToFace(new Point(0.7141306400299072, 0.44033077359199524), new Point(0.7141306485190775, 0.657535998272001), new Point(0.688416063785553, 0.657535970211029), "22");
		createFace(["1", "61", "9", "40"], "23");
		setUVsToFace(new Point(0.5878489017486572, 0.2670339345932007), new Point(0.6747309565544128, 0.2670339345932007), new Point(0.6747309565544128, 0.4842391610145569), "23");
		createFace(["37", "2", "34", "36"], "28");
		setUVsToFace(new Point(0.48446589708328247, 0.5518564581871033), new Point(0.48446589708328247, 0.33465123176574707), new Point(0.5833927989006042, 0.33465123176574707), "28");
		createFace(["73", "121", "114"], "34");
		setUVsToFace(new Point(0.6867758631706238, 0.21820515394210815), new Point(0.6746663451194763, 0.26539385318756104), new Point(0.5878490209579468, 0.21820515394210815), "34");
		createFace(["114", "108", "84", "22"], "37");
		setUVsToFace(new Point(0.6884161233901978, 0.22066539525985718), new Point(0.7463375329971313, 0.22066539525985718), new Point(0.7463374733924866, 0.437870591878891), "37");
		createFace(["108", "107", "102"], "39");
		setUVsToFace(new Point(0.484466016292572, 0.6006852388381958), new Point(0.5712833404541016, 0.5534965395927429), new Point(0.5833927989006042, 0.6006852388381958), "39");
		createFace(["48", "5", "2", "37"], "52");
		setUVsToFace(new Point(0.6457703709602356, 0.4866994023323059), new Point(0.6457703113555908, 0.7039045691490173), new Point(0.5878489017486572, 0.7039045691490173), "52");

		build ();
	}
}

class Reactor extends Mesh5 {
	public function Reactor () {
		coords = new Point3D(6.017908068568778e-13, 2322.834716796875, -629.9212646484375);

		createVertex(-236.22047424316466, -551.18115234375, 141.7322998046875, "0");
		createVertex(55.11806488037049, -141.73193359375, 173.22833251953125, "1");
		createVertex(551.1810913085932, -236.220458984375, 141.7322998046875, "2");
		createVertex(-118.11024475097716, -551.18115234375, 141.7322998046875, "4");
		createVertex(62.99219131469666, -511.8109130859375, 23.11016845703125, "5");
		createVertex(-141.7322540283209, -55.117919921875, 173.22836303710938, "6");
		createVertex(551.1810913085932, -236.220458984375, 236.2205810546875, "7");
		createVertex(551.1810302734369, -118.1103515625, 236.2205810546875, "8");
		createVertex(-551.1810913085943, -236.220458984375, 236.2205810546875, "9");
		createVertex(-551.1810913085943, -236.220458984375, 141.7322998046875, "10");
		createVertex(393.7008666992181, -118.1103515625, 78.740234375, "11");
		createVertex(-236.22048950195372, -85.494873046875, 0, "12");
		createVertex(-85.4949951171881, -236.220458984375, 0, "13");
		createVertex(-118.11024475097716, -551.18115234375, 236.22061157226563, "14");
		createVertex(118.11023712158143, -551.18115234375, 141.7322998046875, "16");
		createVertex(62.992187499999396, -359.157958984375, 23.11016845703125, "17");
		createVertex(-62.99206161499084, -511.8109130859375, 23.11016845703125, "18");
		createVertex(31.496122360228892, -511.81103515625, 125.98431396484375, "19");
		createVertex(62.07326507568299, -393.700927734375, 78.740234375, "20");
		createVertex(-118.1102294921881, -393.700927734375, 78.74017333984375, "21");
		createVertex(-62.07314682006896, -393.700927734375, 78.740234375, "22");
		createVertex(-118.11024475097716, -314.960693359375, 0, "23");
		createVertex(64.72502136230409, -314.9605712890625, -0.00006103515625, "24");
		createVertex(-23.62204360961974, -520.2474365234375, 149.6064453125, "25");
		createVertex(-23.62204360961974, -525.871826171875, 165.3544921875, "26");
		createVertex(-417.7784423828131, 78.740234375, 102.826171875, "27");
		createVertex(-529.1338500976568, 78.740234375, 214.18167114257813, "28");
		createVertex(-529.1338500976568, -78.739990234375, 214.181640625, "29");
		createVertex(-417.77835083007875, -78.739990234375, 102.826171875, "30");
		createVertex(-31.496004104614858, -511.81103515625, 125.98431396484375, "31");
		createVertex(39.37004089355408, -102.362060546875, 196.85040283203125, "32");
		createVertex(102.36212158203065, -39.369873046875, 196.85040283203125, "33");
		createVertex(-102.36233520507872, 39.369873046875, 196.850341796875, "34");
		createVertex(-102.36215209960997, -39.369873046875, 196.85040283203125, "35");
		createVertex(47.244159698485724, -335.389892578125, -0.00006103515625, "40");
		createVertex(-64.72489166259825, -314.9605712890625, -0.00006103515625, "42");
		createVertex(-79.52899169921935, -336.685546875, 21.7249755859375, "43");
		createVertex(-55.11812591552795, -141.73193359375, 173.2283935546875, "44");
		createVertex(-41.513069152832635, -430.015380859375, 93.26605224609375, "46");
		createVertex(41.51318740844666, -430.015380859375, 93.26605224609375, "47");
		createVertex(-47.24403381347717, -335.389892578125, -0.00006103515625, "48");
		createVertex(236.22047424316347, -551.18115234375, 141.7322998046875, "49");
		createVertex(-551.1810302734381, 118.1103515625, 236.2205810546875, "50");
		createVertex(118.11024475097597, -314.960693359375, 0, "51");
		createVertex(-23.62204360961974, -513.0888671875, 164.718994140625, "52");
		createVertex(118.11026000976503, -393.700927734375, 78.74017333984375, "53");
		createVertex(-62.992065429688104, -359.157958984375, 23.11016845703125, "54");
		createVertex(23.622047424315806, -513.0888671875, 164.718994140625, "55");
		createVertex(-393.7008666992194, -118.110107421875, 78.740234375, "56");
		createVertex(23.622047424315806, -525.871826171875, 165.3544921875, "57");
		createVertex(23.622047424315806, -520.2474365234375, 149.6064453125, "58");
		createVertex(79.52912139892518, -336.685546875, 21.7249755859375, "59");
		createVertex(-314.96060180664125, -118.110107421875, 0, "60");
		createVertex(-47.2440299987799, -511.8109130859375, -0.00006103515625, "62");
		createVertex(85.4949951171869, -236.220458984375, 0, "63");
		createVertex(-141.73236083984435, 55.1181640625, 173.22830200195313, "64");
		createVertex(47.244159698485724, -511.8109130859375, -0.00006103515625, "67");
		createVertex(551.1810913085932, 236.220458984375, 141.7322998046875, "68");
		createVertex(-551.1810913085943, 236.220458984375, 141.7322998046875, "69");
		createVertex(-236.22047424316466, 551.180908203125, 141.7322998046875, "70");
		createVertex(236.22047424316347, 551.180908203125, 141.7322998046875, "71");
		createVertex(551.1810913085932, 118.110107421875, 236.2205810546875, "72");
		createVertex(-39.37008666992248, -102.362060546875, 196.85040283203125, "74");
		createVertex(102.36227416992128, 39.369873046875, 196.850341796875, "76");
		createVertex(39.370048522948615, 102.36181640625, 196.85040283203125, "77");
		createVertex(55.11808776855408, 141.732177734375, 173.22833251953125, "80");
		createVertex(-55.118103027344354, 141.732177734375, 173.2283935546875, "81");
		createVertex(141.73220825195253, -55.117919921875, 173.22836303710938, "83");
		createVertex(-314.96060180664125, 118.110107421875, 0, "84");
		createVertex(118.1102294921869, 314.96044921875, 0, "85");
		createVertex(314.9606323242181, -118.1103515625, 0, "86");
		createVertex(314.9606323242181, 118.109619140625, 0, "87");
		createVertex(-118.1099853515631, 314.96044921875, 0, "88");
		createVertex(-118.11013793945372, 393.70068359375, 78.740234375, "89");
		createVertex(-236.22047424316466, 85.49462890625, 0, "90");
		createVertex(236.22048950195253, -85.4951171875, 0, "91");
		createVertex(236.22047424316347, 85.49462890625, 0, "92");
		createVertex(-118.11016845703185, 551.180908203125, 236.22052001953125, "95");
		createVertex(-85.49496459960997, 236.22021484375, 0, "96");
		createVertex(529.1339111328119, 78.739990234375, 214.181640625, "97");
		createVertex(529.1339111328119, -78.740234375, 214.18167114257813, "98");
		createVertex(141.7322998046869, 55.1181640625, 173.22830200195313, "99");
		createVertex(417.7785034179681, -78.740234375, 102.826171875, "100");
		createVertex(78.74028778076112, 417.7783203125, 102.826171875, "101");
		createVertex(85.49496459960878, 236.22021484375, 0, "102");
		createVertex(-78.73999786377013, 529.1337890625, 214.181640625, "103");
		createVertex(-78.73993682861388, 417.7783203125, 102.826171875, "104");
		createVertex(-39.37007904052795, 102.36181640625, 196.85040283203125, "105");
		createVertex(393.7008666992181, 118.110107421875, 78.740234375, "106");
		createVertex(-236.22047424316466, 551.180908203125, 236.22048950195313, "108");
		createVertex(78.740257263183, 529.1337890625, 214.18167114257813, "109");
		createVertex(118.11026000976503, 393.70068359375, 78.740234375, "111");
		createVertex(417.77847290039, 78.739990234375, 102.826171875, "113");
		createVertex(-393.7008056640631, 118.110107421875, 78.740234375, "116");
		createVertex(228.34638977050722, 86.6142578125, 984.2520141601563, "117");
		createVertex(228.34645080566347, -86.6142578125, 984.2520751953125, "118");
		createVertex(102.36227416992128, -39.369873046875, 606.2992553710938, "119");
		createVertex(39.37004089355408, -102.36181640625, 606.2991943359375, "120");
		createVertex(-55.118110656738885, 141.73193359375, 629.9212036132813, "121");
		createVertex(-39.37007904052795, 102.362060546875, 606.2991943359375, "123");
		createVertex(314.9607543945306, -118.1103515625, 984.2513427734375, "125");
		createVertex(-86.61417388916075, 228.34619140625, 984.2520141601563, "126");
		createVertex(141.73220825195253, 55.117919921875, 629.9212036132813, "127");
		createVertex(-114.53102111816466, 95.4423828125, 669.2914428710938, "130");
		createVertex(55.11808013915955, 141.73193359375, 629.9212036132813, "131");
		createVertex(-102.36215209960997, 39.369873046875, 606.2991943359375, "132");
		createVertex(118.11029052734315, 551.180908203125, 236.22052001953125, "134");
		createVertex(-228.34645080566466, 86.6142578125, 984.2520141601563, "137");
		createVertex(101.40765380859315, 121.689208984375, 708.6614990234375, "138");
		createVertex(102.36212158203065, 39.369873046875, 606.2991943359375, "139");
		createVertex(39.370048522948615, 102.362060546875, 606.2991943359375, "140");
		createVertex(121.6892089843744, 101.40771484375, 708.6614990234375, "141");
		createVertex(348.1142883300775, 290.09521484375, 551.1812133789063, "142");
		createVertex(114.5310058593744, 95.4423828125, 669.2914428710938, "144");
		createVertex(141.7322998046869, -55.1181640625, 629.9212646484375, "146");
		createVertex(290.0952453613275, 348.1142578125, 551.1812133789063, "147");
		createVertex(86.61414337158143, 228.34619140625, 984.2520141601563, "148");
		createVertex(95.44248199462831, 114.531005859375, 669.2914428710938, "149");
		createVertex(-101.4077148437506, 121.689208984375, 708.6614990234375, "150");
		createVertex(-290.0952758789069, 348.1142578125, 551.1812133789063, "152");
		createVertex(-324.0025024414069, 388.802978515625, 393.7008972167969, "153");
		createVertex(236.22047424316347, 551.180908203125, 236.22048950195313, "154");
		createVertex(-118.1102294921881, 314.96044921875, 984.251953125, "155");
		createVertex(118.11019897460878, 314.96044921875, 984.251953125, "156");
		createVertex(-95.44254302978575, 114.531005859375, 669.2914428710938, "157");
		createVertex(-348.114349365235, 290.09521484375, 551.1812133789063, "158");
		createVertex(551.1810913085932, 236.220458984375, 236.2205810546875, "159");
		createVertex(314.9605712890619, 118.110107421875, 984.251953125, "160");
		createVertex(324.0024719238275, 388.802978515625, 393.7008972167969, "161");
		createVertex(-121.68922424316466, 101.40771484375, 708.6614990234375, "162");
		createVertex(388.8029785156244, 324.00244140625, 393.7008972167969, "163");
		createVertex(-388.80307006836, 324.00244140625, 393.700927734375, "164");
		createVertex(-118.1102294921881, -314.96044921875, 984.251953125, "166");
		createVertex(55.11807250976502, -141.732177734375, 629.9212036132813, "167");
		createVertex(118.11023712158143, -551.18115234375, 236.22061157226563, "168");
		createVertex(-101.40776824951232, -121.689453125, 708.6614990234375, "170");
		createVertex(-551.1810302734381, -118.110107421875, 236.2205810546875, "171");
		createVertex(-324.002532958985, -388.802978515625, 393.700927734375, "173");
		createVertex(-86.61417388916075, -228.34619140625, 984.2520141601563, "174");
		createVertex(-141.7322540283209, 55.117919921875, 629.9212036132813, "175");
		createVertex(-141.73236083984435, -55.1181640625, 629.9212646484375, "176");
		createVertex(-114.5311279296881, -95.442626953125, 669.2914428710938, "177");
		createVertex(-121.68931579589903, -101.407958984375, 708.6614990234375, "178");
		createVertex(-388.80300903320375, -324.002685546875, 393.70086669921875, "179");
		createVertex(-348.11428833007875, -290.0953369140625, 551.1812133789063, "181");
		createVertex(-55.11811828613342, -141.732177734375, 629.9212036132813, "183");
		createVertex(290.0952453613275, -348.1142578125, 551.1812744140625, "184");
		createVertex(-228.3465118408209, -86.6142578125, 984.2520751953125, "185");
		createVertex(-95.44261932373107, -114.53125, 669.2914428710938, "186");
		createVertex(-290.09524536132875, -348.1143798828125, 551.1812133789063, "188");
		createVertex(-39.37008666992248, -102.36181640625, 606.2991943359375, "189");
		createVertex(-102.36233520507872, -39.369873046875, 606.2992553710938, "190");
		createVertex(388.8030395507806, -324.0025634765625, 393.700927734375, "193");
		createVertex(-551.1810913085943, 236.220458984375, 236.2205810546875, "194");
		createVertex(95.44258880615175, -114.531005859375, 669.2914428710938, "195");
		createVertex(101.40773010253847, -121.689208984375, 708.6614379882813, "196");
		createVertex(118.11019897460878, -314.96044921875, 984.251953125, "197");
		createVertex(348.1143188476556, -290.0953369140625, 551.1812133789063, "198");
		createVertex(114.53109741210878, -95.442626953125, 669.2914428710938, "199");
		createVertex(86.61414337158143, -228.34619140625, 984.2520141601563, "200");
		createVertex(236.22047424316347, -551.18115234375, 236.22061157226563, "201");
		createVertex(324.00253295898375, -388.802978515625, 393.70086669921875, "203");
		createVertex(-314.9606323242194, 118.110107421875, 984.251953125, "204");
		createVertex(-236.22047424316466, -551.18115234375, 236.22061157226563, "205");
		createVertex(121.68927001953065, -101.40771484375, 708.6614379882813, "207");
		createVertex(-314.9608154296881, -118.1103515625, 984.2513427734375, "208");

		createFace(["21", "0", "4", "31", "46", "22"], "0");
		setUVsToFace(new Point(0.1057986170053482, 0.9990000128746033), new Point(0.0010000000474974513, 0.8485050797462463), new Point(0.1057983860373497, 0.8485049605369568), "0");
		createFace(["58", "19", "31", "25"], "1");
		setUVsToFace(new Point(0.8012272715568542, 0.848293662071228), new Point(0.8082138895988464, 0.8705500364303589), new Point(0.7523214221000671, 0.8705500364303589), "1");
		createFace(["57", "168", "19", "58"], "2");
		setUVsToFace(new Point(0.8012272679104193, 0.8334561183867422), new Point(0.8850659728050232, 0.766687273979187), new Point(0.8082138895988464, 0.8705500364303589), "2");
		createFace(["20", "53", "51", "59"], "3");
		setUVsToFace(new Point(0.33894798159599304, 0.31016823649406433), new Point(0.33894792199134827, 0.3598894476890564), new Point(0.24014298617839813, 0.35988932847976685), "3");
		createFace(["49", "201", "7", "2"], "4");
		setUVsToFace(new Point(0.6017906665802002, 0.269489807146431), new Point(0.6017906665802002, 0.1856509894132614), new Point(0.9970102310180664, 0.185651034116745), "4");
		createFace(["16", "49", "53", "20", "47", "19"], "5");
		setUVsToFace(new Point(0.6451092362403871, 0.6762381196022034), new Point(0.7053707030582699, 0.7619776099760058), new Point(0.5219836235046387, 0.7627761363983154), "5");
		createFace(["22", "46", "54", "43"], "6");
		setUVsToFace(new Point(0.8292204141616821, 0.4464160203933716), new Point(0.7938576340675354, 0.42948681116104126), new Point(0.8843499422073364, 0.42805203795433044), "6");
		createFace(["31", "14", "26", "25"], "7");
		setUVsToFace(new Point(0.7523214221000671, 0.8705500364303589), new Point(0.6754692196846008, 0.766687273979187), new Point(0.7593079159900307, 0.8334561183867323), "7");
		createFace(["1", "83", "33", "32"], "8");
		setUVsToFace(new Point(0.29395005106925964, 0.005997170694172382), new Point(0.4026353359222412, 0.005997130181640387), new Point(0.38781461119651794, 0.046434804797172546), "8");
		createFace(["14", "168", "57", "26"], "9");
		setUVsToFace(new Point(0.6754691959913219, 0.766687273979187), new Point(0.8850659728050232, 0.766687273979187), new Point(0.8012272715568542, 0.8334560990333557), "9");
		createFace(["50", "171", "29", "28"], "10");
		setUVsToFace(new Point(0.2974146604537964, 0.6349970698356628), new Point(0.29741457104678304, 0.8445938418612582), new Point(0.2697545289993286, 0.8096609115600586), "10");
		createFace(["53", "49", "2", "11"], "11");
		setUVsToFace(new Point(0.626491904258728, 0.1827176809310913), new Point(0.6017906665802002, 0.0010000203037634492), new Point(0.9970101028534095, 0.0010000254877553516), "11");
		createFace(["67", "40", "48", "62"], "12");
		setUVsToFace(new Point(0.1061873733997345, 0.41803911328315735), new Point(0.159205824136734, 0.27075397968292236), new Point(0.23808932622852463, 0.2991498124142553), "12");
		createFace(["51", "86", "91", "63", "24"], "13");
		setUVsToFace(new Point(0.10618268698453903, 0.2324017733335495), new Point(0.0009999441653840285, 0.008903379755239596), new Point(0.07653777960405922, 0.005337731645986388), "13");
		createFace(["14", "4", "0", "205"], "14");
		setUVsToFace(new Point(0.9021039605140686, 0.4503459632396698), new Point(0.9021039605140686, 0.5341848134994507), new Point(0.7973055243492126, 0.5341848134994507), "14");
		createFace(["63", "91", "83", "1"], "15");
		setUVsToFace(new Point(0.7909243702888489, 0.4449411928653717), new Point(0.6017906665802002, 0.4449411928653717), new Point(0.642014741897583, 0.2724231481552124), "15");
		createFace(["90", "84", "60", "12"], "16");
		setUVsToFace(new Point(0.5223416686058044, 0.004565839190036058), new Point(0.5978795289993286, 0.0010000000474974513), new Point(0.5268899603486934, 0.1982086063404476), "16");
		createFace(["60", "56", "21", "23"], "17");
		setUVsToFace(new Point(0.536557691758511, 0.3608673379766717), new Point(0.5859601497650146, 0.44643494486808777), new Point(0.24014292657375336, 0.4464348554611206), "17");
		createFace(["44", "13", "63", "1"], "18");
		setUVsToFace(new Point(0.47640857100486755, 0.9352135062217712), new Point(0.3013257086277008, 0.9621667265892029), new Point(0.3013257118601086, 0.8104484777556342), "18");
		createFace(["56", "10", "0", "21"], "19");
		setUVsToFace(new Point(0.025701033599476064, 0.6320636592566886), new Point(0.0010000000474974513, 0.4503459334373474), new Point(0.39621949195861816, 0.45034605264663696), "19");
		createFace(["64", "6", "35", "34"], "20");
		setUVsToFace(new Point(0.0010000000474974513, 0.3406587541103363), new Point(0.0010000541806221008, 0.2428470402956009), new Point(0.04173837602138519, 0.2568201720714569), "20");
		createFace(["56", "60", "84", "116", "27", "30"], "21");
		setUVsToFace(new Point(0.09980091863236168, 0.844593632224415), new Point(0.0010000000474974513, 0.8445935845375061), new Point(0.0010000000474974513, 0.6349972486495972), "21");
		createFace(["12", "13", "44", "6"], "22");
		setUVsToFace(new Point(0.4904594421386719, 0.8075151443481445), new Point(0.3013259053238575, 0.8075151972369463), new Point(0.34155014157295227, 0.6349970698356628), "22");
		createFace(["17", "5", "19", "47"], "23");
		setUVsToFace(new Point(0.29395005106925964, 0.04741256684064865), new Point(0.42939797043800354, 0.047412578016519547), new Point(0.42939808256873574, 0.14287428674465824), "23");
		createFace(["90", "12", "6", "64"], "24");
		setUVsToFace(new Point(0.7938576340675354, 0.42414093017578125), new Point(0.7938577232892363, 0.2724231524942334), new Point(0.9689403772354126, 0.2993764877319336), "24");
		createFace(["23", "21", "22", "43"], "25");
		setUVsToFace(new Point(0.13185271620750427, 0.756969153881073), new Point(0.2306573211952732, 0.756969033391498), new Point(0.2306576669216156, 0.8066904544830322), "25");
		createFace(["40", "17", "59", "24"], "26");
		setUVsToFace(new Point(0.16440449655056, 0.7510228753089905), new Point(0.1318526566028595, 0.7519410252571106), new Point(0.13876445743077848, 0.7281198969916395), "26");
		createFace(["43", "54", "48", "42"], "27");
		setUVsToFace(new Point(0.20076759159564972, 0.728052020072937), new Point(0.20837458968162537, 0.7516425251960754), new Point(0.17581118643283844, 0.7519410252571106), "27");
		createFace(["171", "56", "30", "29"], "28");
		setUVsToFace(new Point(0.297414630651474, 0.8445938229560852), new Point(0.09980511672070164, 0.8445937386625454), new Point(0.13002324104309082, 0.8096608519554138), "28");
		createFace(["168", "201", "49", "16"], "29");
		setUVsToFace(new Point(0.08483882993459702, 0.3416365385055542), new Point(0.08483882993459702, 0.44643494486808777), new Point(0.0010000000474974513, 0.44643494486808777), "29");
		createFace(["40", "67", "5", "17"], "30");
		setUVsToFace(new Point(0.2588609755039215, 0.17412321269512177), new Point(0.2588609755039215, 0.017586082220077515), new Point(0.28367477655410767, 0.01758613904353637), "30");
		createFace(["17", "47", "20", "59"], "31");
		setUVsToFace(new Point(0.5292893118275069, 0.35765323739778127), new Point(0.4387153089046478, 0.3598894476890564), new Point(0.4734209477901459, 0.341651052236557), "31");
		createFace(["31", "18", "54", "46"], "32");
		setUVsToFace(new Point(0.257883220911026, 0.17412321269512177), new Point(0.16242147982120514, 0.17412316799163818), new Point(0.16242140660073032, 0.03867527881966591), "32");
		createFace(["24", "63", "42", "48", "40"], "33");
		setUVsToFace(new Point(0.15075139701366425, 0.24844512343406677), new Point(0.15707477308297652, 0.1764669240308409), new Point(0.25882269876132474, 0.2873477396479499), "33");
		createFace(["116", "50", "28", "27"], "34");
		setUVsToFace(new Point(0.09980495274066925, 0.6349970698356628), new Point(0.2974146604537964, 0.6349970698356628), new Point(0.2697545886039734, 0.6699298024177551), "34");
		createFace(["44", "1", "32", "74"], "35");
		setUVsToFace(new Point(0.33992573618888855, 0.3191513419151306), new Point(0.4377375651429689, 0.3191513419151306), new Point(0.4237644374370575, 0.3598894476890564), "35");
		createFace(["63", "13", "23", "42"], "36");
		setUVsToFace(new Point(0.1570747196674347, 0.17646712064743042), new Point(0.2998257577419281, 0.227853462100029), new Point(0.3033914188251143, 0.3033913363178332), "36");
		createFace(["60", "23", "13", "12"], "37");
		setUVsToFace(new Point(0.5268900990486145, 0.19820836186408997), new Point(0.30339146357603064, 0.30339119545353904), new Point(0.2998257577419281, 0.227853462100029), "37");
		createFace(["8", "11", "2"], "38");
		setUVsToFace(new Point(0.49917784333229065, 0.766687273979187), new Point(0.6725358963012695, 0.8615376353263855), new Point(0.4933927357196808, 0.9007698893547058), "38");
		createFace(["2", "7", "8"], "39");
		setUVsToFace(new Point(0.18558397889137268, 0.9323437213897705), new Point(0.18558397889137268, 0.8485049605369568), new Point(0.2903822362422943, 0.8485049605369568), "39");
		createFace(["171", "9", "10"], "40");
		setUVsToFace(new Point(0.7479031682014465, 0.537118136882782), new Point(0.8527016043663025, 0.537118136882782), new Point(0.8527016043663025, 0.6209568977355957), "40");
		createFace(["10", "56", "171"], "41");
		setUVsToFace(new Point(0.768329381942749, 0.6349970698356628), new Point(0.9068910479545593, 0.7551308870315552), new Point(0.7092816829681396, 0.7555168271064758), "41");
		createFace(["35", "6", "44", "74"], "42");
		setUVsToFace(new Point(0.14667338351402864, 0.724566388112603), new Point(0.1318526566028595, 0.6841286420822144), new Point(0.24053794145584106, 0.6841287016868591), "42");
		createFace(["26", "57", "55", "52"], "43");
		setUVsToFace(new Point(0.242991641163826, 0.7647711038589478), new Point(0.242991641163826, 0.8066904544830322), new Point(0.2316354662179947, 0.8066904544830322), "43");
		createFace(["23", "43", "42"], "44");
		setUVsToFace(new Point(0.13185271620750427, 0.756969153881073), new Point(0.15911367535591125, 0.7912020683288574), new Point(0.1318526566028595, 0.8043376803398132), "44");
		createFace(["51", "24", "59"], "45");
		setUVsToFace(new Point(0.24014298617839813, 0.35988932847976685), new Point(0.24014292657375336, 0.3125210106372833), new Point(0.2674039304256439, 0.32565659284591675), "45");
		createFace(["31", "4", "14"], "46");
		setUVsToFace(new Point(0.8046560883522034, 0.8756008744239807), new Point(0.7380316853523254, 0.9292945265769958), new Point(0.6754692196846008, 0.8734833598136902), "46");
		createFace(["19", "168", "16"], "47");
		setUVsToFace(new Point(0.4933927357196808, 0.9037032127380371), new Point(0.6225633025169373, 0.9066518545150757), new Point(0.5578609108924866, 0.9599674344062805), "47");
		createFace(["205", "0", "10", "9"], "48");
		setUVsToFace(new Point(0.7943723201751708, 0.45034596596394905), new Point(0.7943723201751709, 0.5341848134994507), new Point(0.3991527557373047, 0.5341848134994507), "48");
		createFace(["53", "11", "86", "51"], "49");
		setUVsToFace(new Point(0.3991527557373047, 0.5371181964874268), new Point(0.7449699760999082, 0.5371182329674555), new Point(0.6955674886703491, 0.6226857304573059), "49");
		createFace(["25", "26", "52"], "50");
		setUVsToFace(new Point(0.7987303733825684, 0.8464366793632507), new Point(0.7838928699493408, 0.8463995456695557), new Point(0.7882649898529053, 0.835918664932251), "50");
		createFace(["57", "58", "55"], "51");
		setUVsToFace(new Point(0.2231190949678421, 0.7519410252571106), new Point(0.20935235917568207, 0.7464066743850708), new Point(0.22300030291080475, 0.740585446357727), "51");
		createFace(["62", "48", "54", "18"], "52");
		setUVsToFace(new Point(0.45786282420158386, 0.990891695022583), new Point(0.30132562805566765, 0.990891695022583), new Point(0.3224148750305176, 0.9660777449607849), "52");
		createFace(["87", "106", "111", "85"], "53");
		setUVsToFace(new Point(0.4448848846657363, 0.4755522340999924), new Point(0.39587336778640747, 0.39066070318222046), new Point(0.7389559149742126, 0.3906607925891876), "53");
		createFace(["106", "68", "71", "111"], "54");
		setUVsToFace(new Point(0.025505760684609413, 0.4849865138530731), new Point(0.0010000000474974513, 0.3047056794166565), new Point(0.39309415130194825, 0.30470573234042353), "54");
		createFace(["88", "89", "116", "84"], "55");
		setUVsToFace(new Point(0.5382055044174194, 0.7533815503120422), new Point(0.489193856716156, 0.6684905290603638), new Point(0.8322764980895603, 0.6684908449134375), "55");
		createFace(["70", "69", "116", "89"], "56");
		setUVsToFace(new Point(0.5968653559684753, 0.0010000403271988034), new Point(0.9889596104621887, 0.0010000000474974513), new Point(0.9644536375999451, 0.18128076195716858), "56");
		createFace(["88", "85", "111", "101", "104", "89"], "57");
		setUVsToFace(new Point(0.0009999375325158433, 0.9073500154729324), new Point(0.0010000269394367933, 0.6994107961654663), new Point(0.09901978109341239, 0.6994107323368198), "57");
		createFace(["72", "106", "113", "97"], "58");
		setUVsToFace(new Point(0.2950707674026489, 0.6957050561904907), new Point(0.0990236897306937, 0.6957049718968298), new Point(0.12900307774543762, 0.661048412322998), "58");
		createFace(["105", "81", "64", "34"], "59");
		setUVsToFace(new Point(0.1455024629831314, 0.8697542548179626), new Point(0.13079875707626343, 0.8296362161636353), new Point(0.2386244908793576, 0.8296361056505659), "59");
		createFace(["11", "8", "98", "100", "86"], "60");
		setUVsToFace(new Point(0.09902369230985641, 0.48776575922966003), new Point(0.2950707674026489, 0.48776575922966003), new Point(0.2676294445991516, 0.5224222540855408), "60");
		createFace(["102", "96", "81", "80"], "61");
		setUVsToFace(new Point(0.29877638816833496, 0.9861501455307007), new Point(0.29877638816833496, 0.8356316685676575), new Point(0.472474604845047, 0.8623717427253723), "61");
		createFace(["86", "87", "92", "91"], "62");
		setUVsToFace(new Point(0.0010000000474974513, 0.30100005865097046), new Point(0.07142805308103561, 0.10535117238759995), new Point(0.1269204020500183, 0.15584075450897217), "62");
		createFace(["8", "72", "97", "98"], "63");
		setUVsToFace(new Point(0.2950707674026489, 0.48776575922966003), new Point(0.29507070926051504, 0.6957051934488139), new Point(0.26762935519218445, 0.6610484719276428), "63");
		createFace(["134", "95", "103", "109"], "64");
		setUVsToFace(new Point(0.29507073760032654, 0.6994107365608215), new Point(0.29507073760032654, 0.9073501229286194), new Point(0.26762938499450684, 0.8726934790611267), "64");
		createFace(["99", "80", "77", "76"], "65");
		setUVsToFace(new Point(0.13079875707626343, 0.7481785416603088), new Point(0.23862457275390625, 0.7481786012649536), new Point(0.22392086684703827, 0.7882965803146362), "65");
		createFace(["83", "91", "92", "99"], "66");
		setUVsToFace(new Point(0.8436168659975056, 0.6115434541091007), new Point(0.6699186563491821, 0.6382838487625122), new Point(0.6699187159538269, 0.48776575922966003), "66");
		createFace(["68", "159", "154", "71"], "67");
		setUVsToFace(new Point(0.39587336778640747, 0.3878815085950469), new Point(0.39587336778640747, 0.3047056794166565), new Point(0.7879675030708313, 0.30470576882362366), "67");
		createFace(["87", "85", "102", "92"], "68");
		setUVsToFace(new Point(0.07142805308103561, 0.10535117238759995), new Point(0.2931595109744582, 0.0009998193728367813), new Point(0.29669690132141113, 0.07594063878059387), "68");
		createFace(["102", "85", "88", "96"], "69");
		setUVsToFace(new Point(0.29669684794400797, 0.07594066052265641), new Point(0.2931593954563141, 0.0010000000474974513), new Point(0.4888085126876831, 0.07142813503742218), "69");
		createFace(["81", "96", "90", "64"], "70");
		setUVsToFace(new Point(0.4465085338560285, 0.4877658862883764), new Point(0.4864146113395691, 0.6589195132255554), new Point(0.29877638816833496, 0.6589193940162659), "70");
		createFace(["111", "134", "109", "101"], "71");
		setUVsToFace(new Point(0.09902364015579224, 0.6994107365608215), new Point(0.29507073760032654, 0.6994107365608215), new Point(0.2676294445991516, 0.7340672612190247), "71");
		createFace(["33", "83", "99", "76"], "72");
		setUVsToFace(new Point(0.14466141164302826, 0.5766516327857971), new Point(0.13079875707626343, 0.5362354516983032), new Point(0.22783697486535262, 0.5362353266725026), "72");
		createFace(["35", "74", "32", "33", "76", "77", "105", "34"], "73");
		setUVsToFace(new Point(0.4891938567161561, 0.6142109632492064), new Point(0.49073123800737606, 0.5358071868000247), new Point(0.5406944788434574, 0.48776574926741983), "73");
		createFace(["87", "86", "100", "113", "106"], "74");
		setUVsToFace(new Point(0.0009999732720773757, 0.6957046742189235), new Point(0.0010000403271988034, 0.48776575922966003), new Point(0.1290031224489212, 0.5224222540855408), "74");
		createFace(["88", "84", "90", "96"], "75");
		setUVsToFace(new Point(0.4888085126876831, 0.07142813503742218), new Point(0.5931596159934998, 0.29315951466560364), new Point(0.518218994140625, 0.2966971695423126), "75");
		createFace(["95", "89", "104", "103"], "76");
		setUVsToFace(new Point(0.29507073760032654, 0.9073501229286194), new Point(0.09902367740869522, 0.9073501229286194), new Point(0.12900307774543762, 0.8726934194564819), "76");
		createFace(["194", "69", "70", "108"], "77");
		setUVsToFace(new Point(0.9889594912528991, 0.18406000124781127), new Point(0.9889594912528992, 0.2672358453273773), new Point(0.5968653559684753, 0.2672358453273773), "77");
		createFace(["77", "80", "81", "105"], "78");
		setUVsToFace(new Point(0.14466138184070587, 0.6581092476844788), new Point(0.13079875707626343, 0.6176928281784058), new Point(0.2278371203113015, 0.6176928281784058), "78");
		createFace(["72", "159", "68"], "79");
		setUVsToFace(new Point(0.414101779460907, 0.30100005865097046), new Point(0.3101319670677185, 0.30100005865097046), new Point(0.3101319670677185, 0.21782423555850983), "79");
		createFace(["68", "106", "72"], "80");
		setUVsToFace(new Point(0.7282803654670715, 0.7561607956886292), new Point(0.8657463788986206, 0.8753446936607361), new Point(0.6696996092796326, 0.875727653503418), "80");
		createFace(["95", "108", "70"], "81");
		setUVsToFace(new Point(0.0010000000474974513, 0.9110557436943054), new Point(0.10496975481510162, 0.9110557436943054), new Point(0.10496975481510162, 0.9942315220832825), "81");
		createFace(["95", "70", "89"], "82");
		setUVsToFace(new Point(0.6696996092796326, 0.9990000128746033), new Point(0.7282803654670715, 0.879433274269104), new Point(0.8657463192939758, 0.9986171722412109), "82");
		createFace(["134", "111", "71"], "83");
		setUVsToFace(new Point(0.49493321776390076, 0.7561607956886292), new Point(0.6669204235076904, 0.8502610921859741), new Point(0.48919379711151123, 0.8891831040382385), "83");
		createFace(["71", "154", "134"], "84");
		setUVsToFace(new Point(0.7907467484474182, 0.38788148760795593), new Point(0.7907467484474182, 0.30470573902130127), new Point(0.8947164416313171, 0.3047056794166565), "84");
		createFace(["50", "116", "69"], "85");
		setUVsToFace(new Point(0.3034661114215851, 0.30100005865097046), new Point(0.1314789354801178, 0.20689977705478668), new Point(0.309205561876297, 0.16797761619091034), "85");
		createFace(["69", "194", "50"], "86");
		setUVsToFace(new Point(0.7417351603507996, 0.4738365709781647), new Point(0.7417351603507996, 0.39066073298454285), new Point(0.8457048535346985, 0.39066070318222046), "86");
		createFace(["92", "102", "80", "99"], "87");
		setUVsToFace(new Point(0.4864146113395691, 0.8328523635864258), new Point(0.29877638816833496, 0.8328523635864258), new Point(0.3386823832988739, 0.6616986393928528), "87");
		createFace(["125", "160", "159", "72", "8"], "88");
		setUVsToFace(new Point(0.07458110898733139, 0.49254849553108215), new Point(0.22174331545829773, 0.4925481379032135), new Point(0.2953244351372941, 0.9812458363149446), "88");
		createFace(["160", "125", "118", "117"], "89");
		setUVsToFace(new Point(0.6464539170265198, 0.055981092154979706), new Point(0.7829596400260925, 0.0010000000474974513), new Point(0.7849186062812805, 0.05838293954730034), "89");
		createFace(["138", "148", "117", "141"], "90");
		setUVsToFace(new Point(0.6320177912712097, 0.5992406010627747), new Point(0.5785166621208191, 0.42284664511680603), new Point(0.7033881293754555, 0.42284664511680603), "90");
		createFace(["204", "194", "164", "158"], "91");
		setUVsToFace(new Point(0.5236366885711028, 0.4953098250743979), new Point(0.5756664276123047, 0.9867694973945618), new Point(0.46546635031700134, 0.8833043575286865), "91");
		createFace(["131", "148", "138", "149"], "92");
		setUVsToFace(new Point(0.6027972102165222, 0.6496390104293823), new Point(0.5785161574848844, 0.42284681740612184), new Point(0.6320177912712097, 0.5992406010627747), "92");
		createFace(["153", "108", "155", "152"], "93");
		setUVsToFace(new Point(0.40837470857945257, 0.8833043468675992), new Point(0.2981747090816498, 0.9867695569992065), new Point(0.3502044081687927, 0.4953099489212036), "93");
		createFace(["160", "156", "154", "147"], "94");
		setUVsToFace(new Point(0.35020450831662087, 0.0010000107971455119), new Point(0.5236367583274841, 0.0010000000474974513), new Point(0.5756664276123047, 0.4924596846103668), "94");
		createFace(["132", "123", "140", "139", "119", "120", "189", "190"], "95");
		setUVsToFace(new Point(0.8854075670242311, 0.3565777540206909), new Point(0.8299198150634767, 0.35548973083496094), new Point(0.7959201335906982, 0.320129930973053), "95");
		createFace(["7", "125", "8"], "96");
		setUVsToFace(new Point(0.0010000000474974513, 0.9812458157539368), new Point(0.07458110898733139, 0.49254849553108215), new Point(0.07458105683326721, 0.9812458157539368), "96");
		createFace(["127", "117", "118", "146"], "97");
		setUVsToFace(new Point(0.5981384515762329, 0.8797321319580078), new Point(0.5785166621208191, 0.6524893641471863), new Point(0.6864357596576043, 0.6524892928504684), "97");
		createFace(["147", "161", "149", "138"], "98");
		setUVsToFace(new Point(0.7062380909919739, 0.7363497614860535), new Point(0.7675302624702454, 0.6529396772384644), new Point(0.7549617290496826, 0.9336351156234741), "98");
		createFace(["156", "95", "134"], "99");
		setUVsToFace(new Point(0.07458114624023438, 0.0010000000474974513), new Point(0.22174330055713654, 0.48969778418540955), new Point(0.0745810866355896, 0.48969778418540955), "99");
		createFace(["154", "156", "134"], "100");
		setUVsToFace(new Point(0.0010000000474974513, 0.48969778418540955), new Point(0.07458114624023438, 0.0010000000474974513), new Point(0.0745810866355896, 0.48969778418540955), "100");
		createFace(["139", "127", "146", "119"], "101");
		setUVsToFace(new Point(0.7286592721939087, 0.17468520998954773), new Point(0.7572625875473022, 0.1648743897676468), new Point(0.7572627492001279, 0.2335500295852233), "101");
		createFace(["161", "154", "159", "163"], "102");
		setUVsToFace(new Point(0.4654664605483942, 0.3889944192913144), new Point(0.5756664276123047, 0.4924596846103668), new Point(0.29817473888397217, 0.49245965480804443), "102");
		createFace(["123", "121", "131", "140"], "103");
		setUVsToFace(new Point(0.6993173360824585, 0.25194532860976177), new Point(0.727920413017273, 0.24213455617427826), new Point(0.727920413017273, 0.31081026792526245), "103");
		createFace(["141", "117", "127", "144"], "104");
		setUVsToFace(new Point(0.6498866081237793, 0.5992406010627747), new Point(0.7033881977379215, 0.4228468174054329), new Point(0.6791073679924011, 0.6496390104293823), "104");
		createFace(["127", "131", "149", "144"], "105");
		setUVsToFace(new Point(0.6791073679924011, 0.6496390104293823), new Point(0.6027979153004308, 0.6496390104293823), new Point(0.6325433850288391, 0.6244397163391113), "105");
		createFace(["155", "204", "158", "152"], "106");
		setUVsToFace(new Point(0.3502044081687927, 0.4953099489212036), new Point(0.5236366702508114, 0.4953099489212036), new Point(0.46247896552085876, 0.7798391580581665), "106");
		createFace(["132", "175", "121", "123"], "107");
		setUVsToFace(new Point(0.7582125780454188, 0.2449059979614917), new Point(0.7866047620773315, 0.23450009524822235), new Point(0.7866047620773315, 0.31081026792526245), "107");
		createFace(["150", "126", "121", "157"], "108");
		setUVsToFace(new Point(0.8672900199890137, 0.17739394307136536), new Point(0.9207912087440491, 0.0010000000474974513), new Point(0.8965107202529907, 0.22779229283332825), "108");
		createFace(["162", "137", "126", "150"], "109");
		setUVsToFace(new Point(0.8494213223457336, 0.17739394307136536), new Point(0.7959202658255792, 0.0010000000474974513), new Point(0.9207912087440491, 0.0010000000474974513), "109");
		createFace(["157", "153", "152", "150"], "110");
		setUVsToFace(new Point(0.9366201162338257, 0.43311136960983276), new Point(0.9381747245788574, 0.714083731174469), new Point(0.8801997313143022, 0.6283348760376686), "110");
		createFace(["126", "155", "156", "148"], "111");
		setUVsToFace(new Point(0.6762190587471097, 0.31369848725719174), new Point(0.6334977149963379, 0.3520589768886566), new Point(0.5785167217254639, 0.21555331349372864), "111");
		createFace(["131", "127", "139", "140"], "112");
		setUVsToFace(new Point(0.7572625875473022, 0.23450009524822235), new Point(0.757262647151947, 0.31081026792526245), new Point(0.7288704514503479, 0.30040431022644043), "112");
		createFace(["144", "163", "142", "141"], "113");
		setUVsToFace(new Point(0.9974454504235367, 0.43311137652419246), new Point(0.9990000128746033, 0.714083731174469), new Point(0.941024899482727, 0.6283348798751831), "113");
		createFace(["164", "194", "108", "153"], "114");
		setUVsToFace(new Point(0.46546635031700134, 0.8833043575286865), new Point(0.5756664276123047, 0.9867694973945618), new Point(0.29817484271285005, 0.9867694600920515), "114");
		createFace(["150", "152", "158", "162"], "115");
		setUVsToFace(new Point(0.9581344127655029, 0.0010000000474974513), new Point(0.9747584462165833, 0.20852035284042358), new Point(0.9236418394403065, 0.20852034627502936), "115");
		createFace(["163", "159", "160", "142"], "116");
		setUVsToFace(new Point(0.4083748757839203, 0.388994425535202), new Point(0.29817473888397217, 0.49245965480804443), new Point(0.35020453720210254, 0.0010000320178189248), "116");
		createFace(["156", "155", "108", "95"], "117");
		setUVsToFace(new Point(0.07458111130093141, 0.0010000399224561196), new Point(0.22174334526062012, 0.0010000000474974513), new Point(0.2953244745731354, 0.48969778418540955), "117");
		createFace(["142", "147", "138", "141"], "118");
		setUVsToFace(new Point(0.992141842842102, 0.924454391002655), new Point(0.941024625155217, 0.9244544782887192), new Point(0.9576488733291626, 0.7169340252876282), "118");
		createFace(["147", "142", "160"], "119");
		setUVsToFace(new Point(0.4624790847301483, 0.285529226064682), new Point(0.4113622307777405, 0.285529226064682), new Point(0.3502045273780823, 0.0010000000474974513), "119");
		createFace(["130", "164", "153", "157"], "120");
		setUVsToFace(new Point(0.8539617657661438, 0.7147966623306274), new Point(0.8740989565849304, 0.9950509071350098), new Point(0.8170073754751593, 0.9950506158558885), "120");
		createFace(["175", "137", "162", "130"], "121");
		setUVsToFace(new Point(0.820200502872467, 0.22779230773448944), new Point(0.7959202519846498, 0.0009997791241825038), new Point(0.8494213223457336, 0.17739394307136536), "121");
		createFace(["204", "155", "126", "137"], "122");
		setUVsToFace(new Point(0.7930698990821838, 0.41999635100364685), new Point(0.6334977149963379, 0.3520589768886566), new Point(0.6762190461158752, 0.31369850039482117), "122");
		createFace(["154", "161", "147"], "123");
		setUVsToFace(new Point(0.5756664276123047, 0.4924596846103668), new Point(0.4654664397239685, 0.388994425535202), new Point(0.4624790847301483, 0.285529226064682), "123");
		createFace(["148", "156", "160", "117"], "124");
		setUVsToFace(new Point(0.6358996629714966, 0.21359433233737946), new Point(0.5785167217254639, 0.21555331349372864), new Point(0.6464540912969059, 0.055981088813391755), "124");
		createFace(["158", "164", "130", "162"], "125");
		setUVsToFace(new Point(0.817007303237915, 0.5062567591667175), new Point(0.8782994747161865, 0.4228467047214508), new Point(0.8657309412956238, 0.7035421133041382), "125");
		createFace(["157", "121", "175", "130"], "126");
		setUVsToFace(new Point(0.86676450146622, 0.20259308486602853), new Point(0.8965107202529907, 0.22779229283332825), new Point(0.820200502872467, 0.22779230773448944), "126");
		createFace(["126", "148", "131", "121"], "127");
		setUVsToFace(new Point(0.7062381397325996, 0.42284664511680603), new Point(0.8141570091247559, 0.42284664511680603), new Point(0.7945353388786316, 0.65008944272995), "127");
		createFace(["161", "163", "144", "149"], "128");
		setUVsToFace(new Point(0.9372912049293518, 0.9971882104873657), new Point(0.8801996111869812, 0.9971882104873657), new Point(0.9003366231918335, 0.7169340252876282), "128");
		createFace(["188", "173", "186", "170"], "129");
		setUVsToFace(new Point(0.7062633037567139, 0.736404299736023), new Point(0.7675642371177673, 0.6529824137687683), new Point(0.7549939155578613, 0.9337177276611328), "129");
		createFace(["181", "179", "9"], "130");
		setUVsToFace(new Point(0.4113956093788147, 0.28556984663009644), new Point(0.4084078073501587, 0.38904985785484314), new Point(0.29819193482398987, 0.4925297498703003), "130");
		createFace(["166", "188", "181"], "131");
		setUVsToFace(new Point(0.5236861109733582, 0.0010000000474974513), new Point(0.46251973509788513, 0.28556984663009644), new Point(0.4113956093788147, 0.28556984663009644), "131");
		createFace(["173", "205", "9", "179"], "132");
		setUVsToFace(new Point(0.46550750732421875, 0.38904982805252075), new Point(0.5757233500480652, 0.4925297498703003), new Point(0.29819193482398987, 0.4925297498703003), "132");
		createFace(["208", "9", "171"], "133");
		setUVsToFace(new Point(0.22177483141422272, 0.492593377828598), new Point(0.29536643624305725, 0.9813604354858398), new Point(0.22177481651306152, 0.9813604354858398), "133");
		createFace(["176", "183", "186", "177"], "134");
		setUVsToFace(new Point(0.6791537404060364, 0.6497063040733337), new Point(0.6028329196758088, 0.6497063431449753), new Point(0.6325831413269043, 0.624503493309021), "134");
		createFace(["194", "204", "50"], "135");
		setUVsToFace(new Point(0.0010000000474974513, 0.9813604354858398), new Point(0.07459162920713425, 0.492592990398407), new Point(0.07459160685539246, 0.9813604354858398), "135");
		createFace(["184", "203", "201"], "136");
		setUVsToFace(new Point(0.4113955795764923, 0.7799251079559326), new Point(0.4084077775478363, 0.8834050893783569), new Point(0.29819196462631226, 0.9868850111961365), "136");
		createFace(["193", "7", "201", "203"], "137");
		setUVsToFace(new Point(0.46550750732421875, 0.8834050297737122), new Point(0.5757231545180624, 0.9868849364769374), new Point(0.29819196462631226, 0.9868850111961365), "137");
		createFace(["167", "200", "174", "183"], "138");
		setUVsToFace(new Point(0.7258877931728056, 0.6501568555831909), new Point(0.7062633037567139, 0.4228816330432892), new Point(0.8141975998878479, 0.4228816330432892), "138");
		createFace(["125", "198", "184"], "139");
		setUVsToFace(new Point(0.5236862897872925, 0.4953556954860687), new Point(0.46251970529556274, 0.7799251675605774), new Point(0.4113955795764923, 0.7799251079559326), "139");
		createFace(["197", "166", "174", "200"], "140");
		setUVsToFace(new Point(0.7381438839369446, 0.06894714761252119), new Point(0.7931326627731323, 0.20547230541706085), new Point(0.7357414960861206, 0.20743153989315033), "140");
		createFace(["125", "7", "193", "198"], "141");
		setUVsToFace(new Point(0.5236861903040885, 0.49535602879883156), new Point(0.5757233500480652, 0.9868850111961365), new Point(0.46550750732421875, 0.8834050297737122), "141");
		createFace(["189", "183", "176", "190"], "142");
		setUVsToFace(new Point(0.6569735407829285, 0.2533430755138397), new Point(0.6853698492050171, 0.24293555319309235), new Point(0.6853698328972508, 0.31925653330116843), "142");
		createFace(["196", "200", "167", "195"], "143");
		setUVsToFace(new Point(0.8673384189605713, 0.17741917073726654), new Point(0.9208471179008484, 0.0010000381153076887), new Point(0.8965632915496826, 0.22782467305660248), "143");
		createFace(["146", "167", "120", "119"], "144");
		setUVsToFace(new Point(0.6832146048545837, 0.13373608887195587), new Point(0.683214545249939, 0.21005713939666748), new Point(0.6548182964324951, 0.1996496021747589), "144");
		createFace(["184", "198", "207", "196"], "145");
		setUVsToFace(new Point(0.9747967720031738, 0.2085498720407486), new Point(0.923672616481781, 0.20854991674423218), new Point(0.9402990937232971, 0.0010000381153076887), "145");
		createFace(["183", "174", "170", "186"], "146");
		setUVsToFace(new Point(0.6028327345848083, 0.6497063636779785), new Point(0.5785488486289978, 0.42288172245025635), new Point(0.6320575475692749, 0.599300742149353), "146");
		createFace(["174", "185", "176", "178"], "147");
		setUVsToFace(new Point(0.5785491470516017, 0.42288151071660907), new Point(0.7034378051757813, 0.4228816330432892), new Point(0.6791537404060364, 0.6497063040733337), "147");
		createFace(["176", "177", "178"], "148");
		setUVsToFace(new Point(0.6791537404060364, 0.6497063040733337), new Point(0.6494032740592957, 0.624503493309021), new Point(0.6499288082122803, 0.599300742149353), "148");
		createFace(["9", "208", "166", "181"], "149");
		setUVsToFace(new Point(0.29819193482398987, 0.4925297498703003), new Point(0.3502289950847626, 0.0010004183277487755), new Point(0.5236862198342792, 0.0010000553735592943), "149");
		createFace(["50", "204", "208", "171"], "150");
		setUVsToFace(new Point(0.07459160685539246, 0.9813604354858398), new Point(0.07459162175644168, 0.49259297902182086), new Point(0.22177483141422272, 0.492593377828598), "150");
		createFace(["146", "118", "207", "199"], "151");
		setUVsToFace(new Point(0.8202422261238098, 0.2278246432542801), new Point(0.7959580135083522, 0.0009998542968396584), new Point(0.8494670391082764, 0.17741917073726654), "151");
		createFace(["176", "175", "132", "190"], "152");
		setUVsToFace(new Point(0.6538764238357544, 0.1413717269897461), new Point(0.6538763046264648, 0.21005713939666748), new Point(0.6252691149711609, 0.20024491846561432), "152");
		createFace(["173", "179", "177", "186"], "153");
		setUVsToFace(new Point(0.9373074173927307, 0.9972798228263855), new Point(0.8802077770233154, 0.9972798824310303), new Point(0.9003475904464722, 0.716985821723938), "153");
		createFace(["205", "166", "197", "201", "168", "14"], "154");
		setUVsToFace(new Point(0.0010000039468282017, 0.48976749181747437), new Point(0.07459162175655365, 0.0010000000474974513), new Point(0.22177483141422272, 0.0010000000474974513), "154");
		createFace(["201", "197", "125", "184"], "155");
		setUVsToFace(new Point(0.29819196462631226, 0.9868850111961365), new Point(0.3502292037010193, 0.4953552782535553), new Point(0.523686059845832, 0.49535577183530055), "155");
		createFace(["198", "193", "199", "207"], "156");
		setUVsToFace(new Point(0.8170231580734253, 0.506303608417511), new Point(0.8783241904140765, 0.42288148319387764), new Point(0.865753710269928, 0.7036170363426208), "156");
		createFace(["207", "118", "200", "196"], "157");
		setUVsToFace(new Point(0.8494670391082764, 0.17741917073726654), new Point(0.7959581613540649, 0.0010000000474974513), new Point(0.9208476782283003, 0.0010000391191138103), "157");
		createFace(["120", "167", "183", "189"], "158");
		setUVsToFace(new Point(0.6274242401123047, 0.2603833079338074), new Point(0.6560317277908325, 0.2505711019039154), new Point(0.6560317277908325, 0.31925659344231505), "158");
		createFace(["195", "203", "184", "196"], "159");
		setUVsToFace(new Point(0.9366363883018494, 0.4331478476524353), new Point(0.9381911158561707, 0.7141603231430054), new Point(0.880207621074313, 0.6283991488205829), "159");
		createFace(["167", "146", "199", "195"], "160");
		setUVsToFace(new Point(0.8965632915496826, 0.22782467305660248), new Point(0.8202422261238098, 0.2278246432542801), new Point(0.8499926924705505, 0.20262186229228973), "160");
		createFace(["181", "188", "170", "178"], "161");
		setUVsToFace(new Point(0.9921408295631409, 0.9245356321334839), new Point(0.9410166144371033, 0.9245356917381287), new Point(0.9576429128646851, 0.7169857621192932), "161");
		createFace(["185", "208", "204", "137"], "162");
		setUVsToFace(new Point(0.6868199100085721, 0.32233988785222245), new Point(0.7251858115196228, 0.36506739258766174), new Point(0.5886605978012085, 0.4200561046600342), "162");
		createFace(["185", "137", "175", "176"], "163");
		setUVsToFace(new Point(0.5785488486289978, 0.6525318026542664), new Point(0.6864833071682558, 0.6525317802831428), new Point(0.6668587327003479, 0.8798069953918457), "163");
		createFace(["125", "197", "200", "118"], "164");
		setUVsToFace(new Point(0.5785488486289978, 0.0010000000474974513), new Point(0.7381437360270322, 0.06894718307239821), new Point(0.6954163908958435, 0.10731308907270432), "164");
		createFace(["177", "179", "181", "178"], "165");
		setUVsToFace(new Point(0.9974452203365773, 0.43314786878287614), new Point(0.9990000128746033, 0.7141603231430054), new Point(0.9410166144371033, 0.6283991932868958), "165");
		createFace(["174", "166", "208", "185"], "166");
		setUVsToFace(new Point(0.7357414960861206, 0.20743153989315033), new Point(0.7931326627731323, 0.20547230541706085), new Point(0.725186016995834, 0.3650673510066457), "166");
		createFace(["166", "205", "173", "188"], "167");
		setUVsToFace(new Point(0.5236856984435188, 0.0009998762551771678), new Point(0.5757233500480652, 0.4925297498703003), new Point(0.46550750732421875, 0.38904982805252075), "167");
		createFace(["193", "203", "195", "199"], "168");
		setUVsToFace(new Point(0.8741229176521301, 0.9951505064964294), new Point(0.8170231580734253, 0.995150625705719), new Point(0.8371626734733582, 0.7148564457893372), "168");
		createFace(["178", "170", "174"], "169");
		setUVsToFace(new Point(0.6499288082122803, 0.599300742149353), new Point(0.6320575475692749, 0.599300742149353), new Point(0.5785488486289978, 0.42288172245025635), "169");

		createSurface(["43", "15", "11", "27", "26", "44", "19", "29", "3", "21", "24", "20", "36", "52", "48", "37", "10", "4", "47", "34", "42", "12", "30", "46", "6", "13", "5", "31", "22", "45", "7", "23", "39", "32", "16", "28", "2", "14", "35", "8", "38", "50", "33", "40", "9", "41", "0", "18", "1", "17", "51", "49", "25"], "ReactorBottom1");
		createSurface(["54", "68", "59", "63", "85", "81", "56", "69", "64", "65", "72", "78", "61", "74", "57", "84", "53", "66", "73", "62", "86", "75", "58", "77", "82", "60", "71", "67", "80", "70", "87", "76", "79", "83", "55"], "ReactorBottom2");
		createSurface(["134", "166", "147", "137", "143", "159", "142", "130", "151", "135", "164", "167", "148", "131", "160", "140", "156", "169", "168", "144", "165", "132", "145", "161", "162", "158", "149", "155", "153", "136", "152", "154", "133", "146", "129", "139", "150", "141", "157", "138", "163"], "ReactorTop1");
		createSurface(["101", "125", "97", "117", "126", "122", "99", "89", "95", "110", "118", "106", "115", "98", "111", "88", "90", "103", "119", "102", "116", "123", "112", "91", "127", "108", "124", "104", "120", "114", "100", "94", "113", "96", "107", "128", "109", "92", "121", "105", "93"], "ReactorTop2");
		
		build ();
	}
}

class Screen extends Mesh5 {
	public function Screen () {
		coords = new Point3D(362.20477294921875, -1921.260009765625, 78.74015808105469);

		createVertex(64.90576171875, -149.6063232421875, -51.18110656738281, "0");
		createVertex(88.78988647460938, -108.3538818359375, -51.18110656738281, "1");
		createVertex(23.909713745117188, 3.9371337890625, -51.18110656738281, "2");
		createVertex(-64.90582275390625, -149.6063232421875, -51.18110656738281, "3");
		createVertex(-88.78994750976563, -108.3538818359375, -51.18110656738281, "4");
		createVertex(-23.909774780273438, 3.9371337890625, -51.18110656738281, "5");

		createFace(["1", "2", "5", "4", "3", "0"], "2");
		setUVsToFace(new Point(1 - 0.009999999776482582, 0.36833637952804565), new Point(1 - 0.36805060505867004, 0.9880308508872986), new Point(1 - 0.6319494157642815, 0.9880311936093502), "2");

		build ();
	}
}

class ScreenLight extends Mesh5 {
	public function ScreenLight () {
		x = 539.3701171875;
		y = -1921.2598876953125;

		createVertex(-169.2913818359375, -70.8662109375, 118.11026000976563, "0");
		createVertex(-185.03936767578125, -70.8662109375, 118.11026000976563, "1");
		createVertex(-185.03936767578125, 7.8740234375, 114.17323303222656, "2");
		createVertex(-169.2913818359375, 7.8740234375, 114.17323303222656, "3");
		createVertex(-169.20657348632813, -98.380859375, 118.11026000976563, "4");
		createVertex(-161.33258056640625, -84.74267578125, 118.11026000976563, "5");
		createVertex(-93.14154052734375, -124.11279296875, 114.17324829101563, "6");
		createVertex(-101.01553344726563, -137.7508544921875, 114.17324829101563, "7");
		createVertex(-253.31521606445313, -137.7508544921875, 114.17324829101563, "8");
		createVertex(-261.189208984375, -124.11279296875, 114.17324829101563, "9");
		createVertex(-192.9981689453125, -84.74267578125, 118.11026000976563, "10");
		createVertex(-185.12417602539063, -98.380859375, 118.11026000976563, "11");

		createFace(["0", "1", "2", "3"], "2");
		createFace(["4", "5", "6", "7"], "4");
		createFace(["9", "10", "11", "8"], "6");

		build ();
	}
}

class Ventilation extends Mesh5 {
	public function Ventilation () {
		coords = new Point3D(6.017908068568778e-13, 2322.834716796875, -629.9212646484375);

		createVertex(529.1339111328119, 78.739990234375, 214.181640625, "0");
		createVertex(529.1339111328119, -78.740234375, 214.18167114257813, "1");
		createVertex(417.77847290039, 78.739990234375, 102.826171875, "2");
		createVertex(417.7785034179681, -78.740234375, 102.826171875, "3");
		createVertex(-417.7784423828131, 78.740234375, 102.826171875, "4");
		createVertex(-529.1338500976568, 78.740234375, 214.18167114257813, "5");
		createVertex(-529.1338500976568, -78.739990234375, 214.181640625, "6");
		createVertex(-417.77835083007875, -78.739990234375, 102.826171875, "7");
		createVertex(78.74028778076112, 417.7783203125, 102.826171875, "8");
		createVertex(78.740257263183, 529.1337890625, 214.18167114257813, "9");
		createVertex(-78.73999786377013, 529.1337890625, 214.181640625, "10");
		createVertex(-78.73993682861388, 417.7783203125, 102.826171875, "11");

		createFace(["8", "9", "10", "11"], "0");
		setUVsToFace(new Point(0.49900170450910625, 0.501001579179785), new Point(0.49899822473526, 0.9990017414093018), new Point(0.0009982585906982422, 0.9989981651306152), "0");
		createFace(["3", "1", "0", "2"], "2");
		setUVsToFace(new Point(0.5009998506457531, 0.0010000000474974513), new Point(0.9990000128746033, 0.0010000000474974513), new Point(0.9990000128746033, 0.49900001287460327), "2");
		createFace(["6", "7", "4", "5"], "6");
		setUVsToFace(new Point(0.0009990896796807647, 0.0010008811950683594), new Point(0.49899911880493164, 0.0009990036487579346), new Point(0.4990005419761064, 0.49899896979486336), "6");

		build ();
	}
}

class ReactorLight extends Mesh5 {

	public function ReactorLight () {
		coords = new Point3D(6.017908068568778e-13, 2322.834716796875, -629.9212646484375);

		createVertex(-23.62204360961974, -520.2474365234375, 149.6064453125, "0");
		createVertex(23.622047424315806, -520.2474365234375, 149.6064453125, "1");
		createVertex(-23.62204360961974, -513.0888671875, 164.718994140625, "2");
		createVertex(23.622047424315806, -513.0888671875, 164.718994140625, "3");

		createFace(["0", "2", "3", "1"], "2");

		createSurface(["2"], "ReactorLight");

		build ();
	}
}

class Core extends Mesh5 {

	public function Core() {
		coords = new Point3D(4.137311695497081e-13, 2322.834716796875, -433.07086181640625);

		createVertex(78.74015808105428, 0, 0, "0");
		createVertex(68.19097900390584, 39.3701171875, 0, "1");
		createVertex(39.370075225829666, 68.19091796875, 0, "2");
		createVertex(-0.0000034418416861646908, 78.740234375, 0, "3");
		createVertex(-39.37008285522502, 68.19091796875, 0, "4");
		createVertex(-68.19097900390666, 39.3701171875, 0, "5");
		createVertex(-78.7401580810551, 0, 0, "6");
		createVertex(-68.1909866333012, -39.3701171875, 0, "7");
		createVertex(-39.37010192871135, -68.19091796875, 0, "8");
		createVertex(-0.00003660726766147694, -78.740234375, 0, "9");
		createVertex(39.370040893554275, -68.19091796875, 0, "10");
		createVertex(68.19094848632771, -39.3701171875, 0, "11");
		createVertex(78.74015808105428, 0, 409.4488220214844, "12");
		createVertex(68.19097900390584, 39.3701171875, 409.4488220214844, "13");
		createVertex(39.370075225829666, 68.19091796875, 409.4488220214844, "14");
		createVertex(-39.37008285522502, 68.19091796875, 409.4488220214844, "16");
		createVertex(-68.19097900390666, 39.3701171875, 409.4488220214844, "17");
		createVertex(-78.7401580810551, 0, 409.4488220214844, "18");
		createVertex(-68.1909866333012, -39.3701171875, 409.4488220214844, "19");
		createVertex(-39.37010192871135, -68.19091796875, 409.4488220214844, "20");
		createVertex(-0.00003660726766147694, -78.740234375, 409.4488220214844, "21");
		createVertex(39.370040893554275, -68.19091796875, 409.4488220214844, "22");
		createVertex(68.19094848632771, -39.3701171875, 409.4488220214844, "23");
		createVertex(-0.0000034418425956593925, 78.740234375, 409.4488220214844, "25");

		createFace(["7", "19", "18", "6"], "0");
		createFace(["23", "11", "0", "12"], "1");
		createFace(["12", "0", "1", "13"], "2");
		createFace(["17", "5", "6", "18"], "3");
		createFace(["2", "14", "13", "1"], "4");
		createFace(["11", "23", "22", "10"], "5");
		createFace(["3", "25", "14", "2"], "24");
		createFace(["20", "8", "9", "21"], "8");
		createFace(["10", "22", "21", "9"], "10");
		createFace(["19", "7", "8", "20"], "11");
		createFace(["16", "4", "5", "17"], "12");
		createFace(["25", "3", "4", "16"], "9");

		createSurface(["24", "9", "4", "2", "0", "1", "3", "5", "10", "11", "12", "8"], "Core");

		build ();
	}
}

// original bunker demo rotates ventilator textures
// we have to reimplement that, obviously

import flash.geom.*;
import flash.utils.setInterval;
class Ventilators extends Mesh5 {
	private var rotation:Matrix3D;
	private function rotate ():void {
		var m:Matrix3D = matrix;
		m.prepend (rotation);
		matrix = m;
	}
	private function rebase (vs:Vector.<Vector3D>):void {
		var v:Vector3D = new Vector3D;
		v.incrementBy (vs [0]);
		v.incrementBy (vs [1]);
		v.incrementBy (vs [2]);
		v.incrementBy (vs [3]);
		v.scaleBy (0.25);
		x += v.x; y += v.y; z += v.z;
		vs [0].decrementBy (v);
		vs [1].decrementBy (v);
		vs [2].decrementBy (v);
		vs [3].decrementBy (v);
	}
	
	public function Ventilators (n:int) {
		coords = new Point3D(6.017908068568778e-13, 2322.834716796875, -629.9212646484375);
		
		var vs:Vector.<Vector3D> = new Vector.<Vector3D>;
		switch (n) {
			case 0:
				vs.push(createVertex(548.6146850585932, -78.740234375, 194.70086669921875, "v0"));
				vs.push(createVertex(548.6146850585932, 78.739990234375, 194.70083618164063, "v1"));
				vs.push(createVertex(437.2592773437494, 78.739990234375, 83.34539794921875, "v2"));
				vs.push(createVertex(437.2593078613275, -78.740234375, 83.34539794921875, "v3"));
				rebase(vs);
				createFace(["v3", "v0", "v1", "v2"], "v6");
				setUVsToFace(new Point(0.9999999833754984, 0.9999995158196897), new Point(0, 0.9999992251396179), new Point(2.9067999207654793e-7, 0), "v6");
				break;
			case 1:
				vs.push(createVertex(-437.2592468261725, 78.740234375, 83.34539794921875, "v4"));
				vs.push(createVertex(-548.6146240234381, 78.740234375, 194.70086669921875, "v5"));
				vs.push(createVertex(-548.6146240234381, -78.739990234375, 194.70086669921875, "v6"));
				vs.push(createVertex(-437.2591552734381, -78.739990234375, 83.34539794921875, "v7"));
				rebase(vs);
				createFace(["v6", "v7", "v4", "v5"], "v1");
				setUVsToFace(new Point(0, -4.463188929548778e-8), new Point(1, 1.9378668980607472e-7), new Point(1, 1), "v1");
				break;
			case 2:
				vs.push(createVertex(78.74028778076112, 437.25927734375, 83.34539794921875, "v8"));
				vs.push(createVertex(78.740257263183, 548.614501953125, 194.70086669921875, "v9"));
				vs.push(createVertex(-78.73999786377013, 548.614501953125, 194.70086669921875, "v10"));
				vs.push(createVertex(-78.73993682861388, 437.259033203125, 83.34539794921875, "v11"));
				rebase(vs);
				createFace(["v9", "v10", "v11", "v8"], "v0");
				setUVsToFace(new Point(0, 0.9999998211860657), new Point(1.937866613843653e-7, 0), new Point(1, 3.875733227687306e-7), "v0");
				break;
		}
		
		var axis:Vector3D = vs[1].crossProduct (vs[0]);
		axis.normalize ();
		
		rotation = new Matrix3D;
		rotation.appendRotation (2, axis);
		
		build ();
		
		setInterval (rotate, 15);
	}
}