public InfoService (Platform platform, VLogger logger)
        {
            this.platform = platform;
            this.logger = logger;

            string homeIdPart = string.Empty;

            //if (HomeOS.Shared.Globals.HomeId != null)
            //{
            //    homeIdPart = "/" + HomeOS.Shared.Globals.HomeId;
            //}

            host = new ServiceHost(this, new Uri(HomeOS.Hub.Common.Constants.InfoServiceAddress + homeIdPart));
            host.AddServiceEndpoint(typeof(IHomeOSInfo), new WebHttpBinding(), "").Behaviors.Add(new System.ServiceModel.Description.WebHttpBehavior());
            
            var smb = new System.ServiceModel.Description.ServiceMetadataBehavior();
            smb.HttpGetEnabled = true;
            host.Description.Behaviors.Add(smb);

            try
            {
                host.Open();
            }
            catch (Exception e)
            {
                logger.Log("Could not open the service host: " + e.Message + @"
Possible issues: 1) are you running the command prompt / Visual Studio in administrator mode?      
                 2) is another instance of Platform running?
                 3) is a local copy of Gatekeeper running?
                 4) is another process occupying the InfoServicePort (51430)?");

                throw e;
            }
        }

 public Program(LoadedImage image, ImageMap imageMap, IProcessorArchitecture arch, Platform platform) : this()
 {
     this.Image = image;
     this.ImageMap = imageMap;
     this.Architecture = arch;
     this.Platform = platform;
 }

        public ExePackLoader(IServiceProvider services, string filename, byte[] imgRaw)
            : base(services, filename, imgRaw)
        {
            arch = new IntelArchitecture(ProcessorMode.Real);
            platform = new MsdosPlatform(Services, arch);

            var exe = new ExeImageLoader(services, filename, imgRaw);
            this.exeHdrSize = (uint)(exe.e_cparHeader * 0x10U);
            this.hdrOffset = (uint)(exe.e_cparHeader + exe.e_cs) * 0x10U;
            ImageReader rdr = new LeImageReader(RawImage, hdrOffset);
            this.ip = rdr.ReadLeUInt16();
            this.cs = rdr.ReadLeUInt16();
            rdr.ReadLeUInt16();
            this.cbExepackHeader = rdr.ReadLeUInt16();
            this.sp = rdr.ReadLeUInt16();
            this.ss = rdr.ReadLeUInt16();
            this.cpUncompressed = rdr.ReadLeUInt16();

            int offset = ExePackHeaderOffset(exe);
            if (LoadedImage.CompareArrays(imgRaw, offset, signature, signature.Length))
            {
                relocationsOffset = 0x012D;
            }
            else if (LoadedImage.CompareArrays(imgRaw, offset, signature2, signature2.Length))
            {
                relocationsOffset = 0x0125;
            }
            else
                throw new ApplicationException("Not a recognized EXEPACK image.");
        }

    public static void Main(string[] args)
    {
        // setup test data
        var PlatformSet = new HashSet<Platform>();
        Platform Platform0;
        PlatformSet.Add(Platform0 = new Platform());
        var ManSet = new HashSet<Man>();
        Man Man0;
        ManSet.Add(Man0 = new Man());
        Man Man1;
        ManSet.Add(Man1 = new Man());
        Man0.ceiling = Platform0;
        Man1.ceiling = Platform0;
        Man0.floor = Platform0;
        Man1.floor = Platform0;
        var DateSet = new HashSet<Date>();
        var PersonSet = new HashSet<Person>();
        Eve Eve0;
        PersonSet.Add(Eve0 = Eve.Instance);
        var WomanSet = new HashSet<Woman>();
        WomanSet.Add(Eve0);
        var EveSet = new HashSet<Eve>();
        EveSet.Add(Eve0);

        // check test data
        Contract.Assert(Contract.ForAll(ManSet, m => ManSet.Where(n => FuncClass.Above(m, n)).Count() == 1), "BelowToo");
    }

 public SystemService Build(Platform platform)
 {
     SystemService svc = new SystemService();
     svc.Name = Name;
     svc.SyscallInfo = new SyscallInfo();
     svc.SyscallInfo.Vector = Convert.ToInt32(SyscallInfo.Vector, 16);
     if (SyscallInfo.RegisterValues != null)
     {
         svc.SyscallInfo.RegisterValues = new RegValue[SyscallInfo.RegisterValues.Length];
         for (int i = 0; i < SyscallInfo.RegisterValues.Length; ++i)
         {
             svc.SyscallInfo.RegisterValues[i] = new RegValue
             {
                 Register = platform.Architecture.GetRegister(SyscallInfo.RegisterValues[i].Register),
                 Value = Convert.ToInt32(SyscallInfo.RegisterValues[i].Value, 16),
             };
         }
     }
     else
     {
         svc.SyscallInfo.RegisterValues = new RegValue[0];
     }
     TypeLibraryLoader loader = new TypeLibraryLoader(platform, true);
     var sser = platform.CreateProcedureSerializer(loader, "stdapi");
     svc.Signature = sser.Deserialize(Signature, platform.Architecture.CreateFrame());
     svc.Characteristics = Characteristics != null ? Characteristics : DefaultProcedureCharacteristics.Instance;
     return svc;
 }

 void defineSourcePlatform()
 {
     if (platformSourceCombo.Items.Count > 0)
         SourcePlatform = new Platform(platformSourceCombo.SelectedItem.ToString(), GameVersion.RS2014.ToString());
     else
         SourcePlatform = new Platform(GamePlatform.None, GameVersion.None);
 }

		public LzExeUnpacker(IServiceProvider services, ExeImageLoader exe, string filename, byte [] rawImg) : base(services, filename, rawImg)
		{
            this.arch = new IntelArchitecture(ProcessorMode.Real);
            this.platform = new MsdosPlatform(services, arch);

            Validate(exe);
		}

 static void ChangeAniso(int newLevel, Platform somePlatform = Platform.Default)
 {
     Debug.Log(System.String.Format("{0} Set AnisoLevel '{2}' @ {1} platform", logTitle, somePlatform, newLevel));
     TextureImportParams tiParams = new TextureImportParams(Actions.SetAniso, somePlatform);
     tiParams.anisoLevel = newLevel;
     SelectedChangeAnyPlatformSettings(tiParams);
 }

        public void SetUp()
        {

            var appKey = "";
            var appSecret = "";
            var password = "";

            if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("APP_KEY")))
            {

                appKey = Environment.GetEnvironmentVariable("APP_KEY");
            }

            if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("APP_SECRET")))
            {
                appSecret = Environment.GetEnvironmentVariable("APP_SECRET");
            }

            if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("USER_NAME")))
            {
                UserName = Environment.GetEnvironmentVariable("USER_NAME");
                ToPhone = UserName;
            }

            if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("PASSWORD")))
            {
                password = Environment.GetEnvironmentVariable("PASSWORD");
            }
           
            RingCentralClient = new RingCentral.SDK.SDK(appKey, appSecret, ApiEndPoint,"C Sharp Test Suite", "1.0.0");
            Platform = RingCentralClient.GetPlatform();
            Platform._client = new HttpClient(MockResponseHandler) { BaseAddress = new Uri(ApiEndPoint) };
            AuthResult = Platform.Authorize(UserName, Extension, password, true);
        }

 public SceneManager(Platform platform, Engine engine, Scene startScene)
 {
     this.platform = platform;
     this.engine = engine;
     nextScene = startScene;
     sceneRenderer = new SceneRenderer(platform);
 }

    // move the inner level into the 'ring' of outer level
    // NOTE: called when the player enters the inner level
    public void changeRing()
    {
        if(camObject == null)
            camObject = GameObject.Find("Menu Camera").GetComponent<CameraScript>();
        else
            if(!plyr.rigidbody2D.isKinematic)
                camObject.jiggle = true;

        if (outer == null) {
            // there should be one and only one ring now
            outer = GameObject.Find("Platform");
            Platform plat = outer.GetComponent<Platform>();
            plat.ratio = platformRatio;

            outerPlatform = plat;
        } else {
            levelCount++;
            //if(levelCount%5==0)
                plyr.IncreaseJumps(levelCount);
            levelText.setValue (levelCount);

            Platform plat=outer.GetComponent<Platform>();
            plat.die();

            outer = inner;
            inner = null;

            outerPlatform = outer.GetComponent<Platform>();
        }
    }

        public HeartbeatService(Platform platform, VLogger log)
        {
            this.platform = platform;
            this.logger = log;
            this.tcb = SendHeartbeat;
            this.sequenceNumber = 0;
            try
            {
                this.uri = new Uri("https://" + GetHeartbeatServiceHostString() + ":" + Constants.HeartbeatServiceSecurePort + "/" +
                                   Constants.HeartbeatServiceWcfListenerEndPointUrlSuffix);
                this.heartbeatIntervalMins = Settings.HeartbeatIntervalMins;
                if (this.heartbeatIntervalMins < Constants.MinHeartbeatIntervalInMins)
                    this.heartbeatIntervalMins = Constants.MinHeartbeatIntervalInMins;
                if (this.heartbeatIntervalMins > Constants.MaxHeartbeatIntervalInMins)
                    this.heartbeatIntervalMins = Constants.MaxHeartbeatIntervalInMins;

                this.perfCountPercentProcTime = new PerformanceCounter("Process", "% Processor Time", Process.GetCurrentProcess().ProcessName, true);
                this.perfCountWorkingSet = new PerformanceCounter("Process", "Working Set", Process.GetCurrentProcess().ProcessName, true);
            }
            catch (Exception e)
            {
                logger.Log("Platform failed failed to construct heartbeat service , Exception={0}", e.Message);
            }

        }

 public Engine(Platform platform)
 {
     this.Assets = new Assets (platform);
     this.InputEventSystem = new InputEventSystem (platform);
     this.DebugRenderer = new DebugRenderer (platform);
     this.PrimitiveRenderer = new PrimitiveRenderer (platform);
 }

        public Mandelbrot( Platform platform, int width, int height )
        {
            openCLPlatform = platform;
            openCLDevices = openCLPlatform.QueryDevices(DeviceType.ALL);
            openCLContext = openCLPlatform.CreateDefaultContext();
            openCLCQ = openCLContext.CreateCommandQueue(openCLDevices[0], CommandQueueProperties.PROFILING_ENABLE);
            mandelBrotProgram = openCLContext.CreateProgramWithSource(File.ReadAllText("Mandelbrot.cl"));
            try
            {
                mandelBrotProgram.Build();
            }
            catch (OpenCLException)
            {
                string buildLog = mandelBrotProgram.GetBuildLog(openCLDevices[0]);
                MessageBox.Show(buildLog,"Build error(64 bit debug sessions in vs2008 always fail like this - debug in 32 bit or use vs2010)");
                Application.Exit();
            }
            mandelbrotKernel = mandelBrotProgram.CreateKernel("Mandelbrot");

            Left = -2.0f;
            Top = 2.0f;
            Right = 2.0f;
            Bottom = -2.0f;
            BitmapWidth = width;
            BitmapHeight = height;

            mandelbrotMemBuffer = openCLContext.CreateBuffer((MemFlags)((long)MemFlags.WRITE_ONLY), width*height*4, IntPtr.Zero);
        }

        public ItemCatalog(ItemData[] items_data)
        {
            _items = new Dictionary<ulong, Item>(items_data.GetLength(0) * 2);

            foreach (ItemData itemData in items_data)
            {
                Item item;
                FileStream textureStream = new FileStream(Environment.SpecialFolder.Resources + "\\Custom\\" + itemData.UniversalTexture, FileMode.Open);
                Texture2D universalTexture = Texture2D.FromStream(Game.GraphicsInstance.GraphicsDevice, textureStream);

                switch (itemData.ClassType)
                {
                    case "Teraform.Platform":
                        item = new Platform(new Point(0, 0), universalTexture, Item.ITEM_STATE.IN_INVENTORY);
                        break;
                    case "Teraform.Block":
                        item = new Block(new Point(0,0), universalTexture, Item.ITEM_STATE.IN_INVENTORY);
                        break;
                    default:
                        throw new NotSupportedException(string.Concat("Error, item type ", itemData.ClassType ," not recognized; check the world\'s .xml file"));
                }
                item._itemId = itemData.Id;
                item._itemName = itemData.Name;
                _items.Add(itemData.Id, item);
            }
        }

        public ConfigUpdater(Configuration config, VLogger log, int frequency, Delegate method, Platform platform)
        {
            this.config = config;
            this.logger = log;
            this.frequency = frequency;
            this.methodToInvoke = method;
            this.platform = platform;

            tcb = ConfigSync;
            timer = new Timer(tcb, null, 500, frequency);

            if (System.IO.Directory.Exists(temporaryZipLocation)) // creating temporary directory location for downloading and holding zips
                Utils.CleanDirectory(logger, temporaryZipLocation);
            Utils.CreateDirectory(logger, temporaryZipLocation);

            this.status = new UpdateStatus(this.frequency);

            ConfigUpdaterWebService webService = new ConfigUpdaterWebService(logger, this);

            string homeIdPart = "";
            if (!string.IsNullOrWhiteSpace(Settings.HomeId))
                homeIdPart = "/" + Settings.HomeId;

            string url = Constants.InfoServiceAddress + homeIdPart + "/config";
            serviceHost = ConfigUpdaterWebService.CreateServiceHost(webService, new Uri(url));
            serviceHost.Open();
            Utils.structuredLog(logger, "I", "ConfigUpdaterWebService initiated at " + url);

        }

 public DataTypeBuilder(TypeFactory factory, ITypeStore store, Platform platform)
 {
     this.store = store;
     this.factory = factory;
     this.unifier = new DataTypeBuilderUnifier(factory, store);
     this.platform = platform;
 }

		public static IApp StartApp(Platform platform)
		{
			// TODO: If the iOS or Android app being tested is included in the solution 
			// then open the Unit Tests window, right click Test Apps, select Add App Project
			// and select the app projects that should be tested.
			//
			// The iOS project should have the Xamarin.TestCloud.Agent NuGet package
			// installed. To start the Test Cloud Agent the following code should be
			// added to the FinishedLaunching method of the AppDelegate:
			//
			//    #if ENABLE_TEST_CLOUD
			//    Xamarin.Calabash.Start();
			//    #endif
			if(platform == Platform.Android)
			{
				return ConfigureApp
					.Android
					// TODO: Update this path to point to your Android app and uncomment the
					// code if the app is not included in the solution.
					//.ApkFile ("../../../Droid/bin/Debug/xamarinforms.apk")
					.StartApp();
			}

			return ConfigureApp
				.iOS
				// TODO: Update this path to point to your iOS app and uncomment the
				// code if the app is not included in the solution.
				//.AppBundle ("../../../iOS/bin/iPhoneSimulator/Debug/XamarinForms.iOS.app")
				//.DeviceIdentifier("F2CA162A-15A5-4023-B97A-427A2A9B59B7")
				//.CodesignIdentity("iPhone Developer: Rob DeRosa (VH66B6QF79)")
				.StartApp();
		}

 void defineTargetPlatform()
 {
     if (platformTargetCombo.Items.Count > 0)
         TargetPlatform = new Platform(platformTargetCombo.SelectedItem.ToString(), GameVersion.RS2014.ToString());
     else
         TargetPlatform = new Platform(GamePlatform.None, GameVersion.None);
 }

 public Level(Texture2D background, Platform[] platform, Door d, Player p)
 {
     Background = background;
     platforms = platform;
     door = d;
     player = p;
 }