public static object LoadMem(LoadState S, Type t, int n)
 {
     ArrayList array = new ArrayList();
     for (int i=0; i<n; i++)
         array.Add(LoadMem(S, t));
     return array.ToArray(t);
 }

		public static void Init ()
		{
			curLoadState = LoadState.Loading;
			LoadTextureFolders ();
			LoadXMLPaths ();
			curLoadState = LoadState.Finished;
		}

 public void LoadNextScene()
 {
     int currLevelIndex = previousLevelIndex = Application.loadedLevel;
     loadState = LoadState.loading;
     currLevelIndex++;
     Application.LoadLevel(currLevelIndex);
 }

	void Awake ()
	{                
        /*
#if UNITY_STANDALONE_WIN || UNITY_EDITOR_WIN
        objPath = "file://" + Application.streamingAssetsPath + "/model2.obj";
#else
#if UNITY_ANDROID
        FileInfo fi = new FileInfo("/sdcard/model.obj");
        if (fi.Exists)
            objPath = "file://" +"/sdcard/model.obj";
        else
            objPath = Application.streamingAssetsPath + "/model2.obj";            
#endif
#endif
         */
#if STANDALONE_DEBUG
        IPAddress ip = IPAddress.Parse("127.0.0.1");
        serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        serverSocket.Bind(new IPEndPoint(ip, myPort));
        serverSocket.Listen(5);
        clientSocket = new List<Socket>();
#endif
        load_state = LoadState.IDLE;
        move_para = new MovePara();
        show_envelop = false;
        show_joint = false;
        show_body = true;

        gameObject.AddComponent<Animation>();
        animation.AddClip(move_para.create_move(Movement.RUN), "run");
        animation.AddClip(move_para.create_move(Movement.JUMP), "jump");
        animation.AddClip(move_para.create_move(Movement.SLIDE), "slide");
	}

		/// <summary>
		/// Create RenderWareFile from byte data<para/>
		/// Создание RenderWareFile из массива байт
		/// </summary>
		/// <param name="data">File content<para/>Содержимое файла</param>
		/// <param name="readNow">Read file immediately instead of threaded reading<para/>Прочитать файл сейчас же, не полагаясь на потоковый загрузчик</param>
		public RenderWareFile(byte[] data, bool readNow = false) {
			QueuedStream = new MemoryStream(data, false);
			State = LoadState.None;
			if (readNow) {
				ReadData();
			}
		}

 public void LoadMainMenu()
 {
     previousLevelIndex = Application.loadedLevel;
     loadState = LoadState.loading;
     DestroyPersistantObjects();
     Application.LoadLevel(0);
 }

        private void ChosenCode(Toon [] Character, Toon ChosenOne, Toon OpponentToon, Extras extra)
        {
            TransferAttributes(Character, ChosenOne, OnToon);
            int OpponentNum = rand.Next(0, extra.NumOfToons);
            if (OpponentNum != OnToon)
            {
                TransferAttributes(Character, OpponentToon, OpponentNum);
                extra.State = Extras.GameState.FIGHT;
                State = LoadState.Initialize;

            }
        }

        internal void EnsureLoaded() {
#if FALSE
            // If we're fully loaded, just return.
            if (_loadState == LoadState.Loaded) {
                return;
            }

            // If we're loading or not loaded, we need to take this lock.
            if (!_typeDb.BeginModuleLoad(this, 10000)) {
                Debug.Fail("Timeout loading {0}", _modName);
                //throw new InvalidOperationException("Cannot load module at this time");
                return;
            }

            try {
                // Ensure we haven't started/finished loading while waiting
                if (_loadState != LoadState.NotLoaded) {
                    return;
                }

                // Mark as loading now (before it completes), if we have circular
                // references we'll fix them up after loading
                // completes.
                _loadState = LoadState.Loading;

                using (var stream = new FileStream(_dbFile, FileMode.Open, FileAccess.Read, FileShare.Read)) {
                    Dictionary<string, object> contents = null;
                    try {
                        contents = (Dictionary<string, object>)Unpickle.Load(stream);
                    } catch (ArgumentException) {
                        _typeDb.OnDatabaseCorrupt();
                    } catch (InvalidOperationException) {
                        // Bug 511 - http://pytools.codeplex.com/workitem/511
                        // Ignore a corrupt database file.
                        _typeDb.OnDatabaseCorrupt();
                    }

                    if (contents != null) {
                        LoadModule(contents);
                    }
                }
            } catch (FileNotFoundException) {
                // if the file got deleted before we've loaded it don't crash...
            } catch (IOException) {
                // or if someone has locked the file for some reason, also don't crash...
            } finally {
                // Regardless of how we finish, mark us as loaded so we don't
                // try again.
                _loadState = LoadState.Loaded;
                _typeDb.EndModuleLoad(this);
            }
#endif
        }

 //#endif
 public static object LoadMem(LoadState S, Type t)
 {
     int size = Marshal.SizeOf(t);
     CharPtr str = new char[size];
     LoadBlock(S, str, size);
     byte[] bytes = new byte[str.chars.Length];
     for (int i = 0; i < str.chars.Length; i++)
         bytes[i] = (byte)str.chars[i];
     GCHandle pinnedPacket = GCHandle.Alloc(bytes, GCHandleType.Pinned);
     object b = Marshal.PtrToStructure(pinnedPacket.AddrOfPinnedObject(), t);
     pinnedPacket.Free();
     return b;
 }

 public static void Cancel()
 {
     if (activeSaveSlot != -1)
     {
         if (state == LoadState.Normal)
         {
             state = LoadState.ConfirmClear;
         }
         else
         {
             state = LoadState.Normal;
         }
     }
 }

        public MainToolbarViewModel(SongLoader songLoader, CurrentSongService currentSongService, PrintService printService, ExportImageService saveService)
        {
            LoadState = new LoadState();
            this.printService = printService;
            this.saveService = saveService;
            this.currentSongService = currentSongService;

            SelectedGuitarPath = currentSongService.GuitarPath.Name;

            OpenFileCommand = new RelayCommand(songLoader.OpenFile);
            LoadDiskTracksCommand = new RelayCommand(songLoader.LoadDiskTracks);
            LoadDLCTracksCommand = new RelayCommand(songLoader.LoadDLCTracks);
            PrintCommand = new RelayCommand<TabControl>(PrintTab);
            SaveCommand = new RelayCommand<TabControl>(SaveTabImage);

            Messenger.Default.Register<SongChange>(this, (SongChange c) => { if (c == SongChange.Score) RaisePropertyChanged("IsATrackLoaded"); });
        }

        internal async Task LoadDetail(string url)
        {
            base.SetProgressIndicator("LoadDetail", true, "Loading detail...");
            if (this.isLoadDetailAndChaper == LoadState.None)
            {
                this.isLoadDetailAndChaper = LoadState.Loading;
                var jsonDetail = await Config.GetDetail(url);
                if (jsonDetail.error_code == 0)
                {
                    bool isFavorite = App.dbHelper.Select<MangaCore.Sqlite.Models.SqlMangaFavorite>(t => t.Url == url) != null;
                    bool isRead = App.dbHelper.Select<MangaCore.Sqlite.Models.SqlHistoryRead>(t => t.UrlManga == url) != null;
                    ItemDetail.NameManga = jsonDetail.data._detailNameManga;
                    ItemDetail.UrlCover = jsonDetail.data._detailUrlCover;
                    ItemDetail.Description = jsonDetail.data._detailDescription;
                    //ItemDetail.Description = @"";
                    ItemDetail.Rating = jsonDetail.data._rating;
                    ItemDetail.IsFavorite = isFavorite;
                    ItemDetail.IsRead = isRead;
                    ItemDetail.UrlManga = url;


                    var listHistoryChaperRead = App.dbHelper.Select<MangaCore.Sqlite.Models.SqlHistoryRead>().Where(t => t.UrlManga == url);
                    var listHistoryDownload = App.dbHelper.Select<MangaCore.Sqlite.Models.SqlDownload>();
                    var listChaperBookmask = App.dbHelper.Select<MangaCore.Sqlite.Models.SqlChaperBookmask>().Where(t => t.Sever == App.NewSever);

                    foreach (var itemChaper in jsonDetail.data.listChap)
                    {
                        bool isRead2 = listHistoryChaperRead.FirstOrDefault(t => t.UrlChaper == itemChaper._urlChap) != null;
                        bool isDownload = listHistoryDownload.FirstOrDefault(t => t.Url == itemChaper._urlChap) != null;
                        bool isFavorite2 = listChaperBookmask.FirstOrDefault(t => t.Url == itemChaper._urlChap) != null;


                        this.Chapers.Add(new Chaper(itemChaper._chap, itemChaper._urlChap, DateTime.Now.ToString(MangaCore.Comon.FormatDateTime), isRead2, false, isDownload, isFavorite2, "", false));
                    }
                }
                else
                {
                    Utils.ShowMessage("Error: " + jsonDetail.msg, "Error", 0);
                }

            }
            base.SetProgressIndicator("LoadDetail", false, "Loading...");
        }

 private static TString LoadString(LoadState S)
 {
     uint size = (uint)LoadVar(S, typeof(uint));
      if (size==0)
       return null;
      else
      {
       CharPtr s=luaZ_openspace(S.L,S.b,size);
       LoadBlock(S, s, (int)size);
       return luaS_newlstr(S.L,s,size-1);		/* remove trailing '\0' */
      }
 }

 private static lua_Number LoadNumber(LoadState S)
 {
     return (lua_Number)LoadVar(S, typeof(lua_Number));
 }

 private static int LoadInt(LoadState S)
 {
     int x = (int)LoadVar(S, typeof(int));
      IF (x<0, "bad integer");
      return x;
 }

 private static void LoadHeader(LoadState S)
 {
     CharPtr h = new char[LUAC_HEADERSIZE];
      CharPtr s = new char[LUAC_HEADERSIZE];
      luaU_header(h);
      LoadBlock(S, s, LUAC_HEADERSIZE);
      IF (memcmp(h, s, LUAC_HEADERSIZE)!=0, "bad header");
 }

 private static Proto LoadFunction(LoadState S, TString p)
 {
     Proto f;
      if (++S.L.nCcalls > LUAI_MAXCCALLS) error(S,"code too deep");
      f=luaF_newproto(S.L);
      setptvalue2s(S.L,S.L.top,f); incr_top(S.L);
      f.source=LoadString(S); if (f.source==null) f.source=p;
      f.linedefined=LoadInt(S);
      f.lastlinedefined=LoadInt(S);
      f.nups=LoadByte(S);
      f.numparams=LoadByte(S);
      f.is_vararg=LoadByte(S);
      f.maxstacksize=LoadByte(S);
      LoadCode(S,f);
      LoadConstants(S,f);
      LoadDebug(S,f);
      IF (luaG_checkcode(f)==0 ? 1 : 0, "bad code");
      StkId.dec(ref S.L.top);
      S.L.nCcalls--;
      return f;
 }

 private static void LoadDebug(LoadState S, Proto f)
 {
     int i,n;
      n=LoadInt(S);
      f.lineinfo=luaM_newvector<int>(S.L,n);
      f.sizelineinfo=n;
      f.lineinfo = (int[])LoadVector(S, typeof(int), n);
      n=LoadInt(S);
      f.locvars=luaM_newvector<LocVar>(S.L,n);
      f.sizelocvars=n;
      for (i=0; i<n; i++) f.locvars[i].varname=null;
      for (i=0; i<n; i++)
      {
       f.locvars[i].varname=LoadString(S);
       f.locvars[i].startpc=LoadInt(S);
       f.locvars[i].endpc=LoadInt(S);
      }
      n=LoadInt(S);
      f.upvalues=luaM_newvector<TString>(S.L, n);
      f.sizeupvalues=n;
      for (i=0; i<n; i++) f.upvalues[i]=null;
      for (i=0; i<n; i++) f.upvalues[i]=LoadString(S);
 }

 private static void LoadCode(LoadState S, Proto f)
 {
     int n=LoadInt(S);
      f.code = luaM_newvector<Instruction>(S.L, n);
      f.sizecode=n;
      f.code = (Instruction[])LoadVector(S, typeof(Instruction), n);
 }

 private static int LoadChar(LoadState S)
 {
     return (char)LoadVar(S, typeof(char));
 }