using BingoBrain.Core;
using System.Collections.Generic;

namespace BingoBrain
{
    public partial class PreferencesMgr
    {
        private void OnInitPreferences()
        {
            gameStartCount = preferences.gameStartCount;
            loginGameTodayTimes = preferences.loginGameTodayTimes;
            videoEffective_count = preferences.videoEffective_count;
            isLogEffective = preferences.isLogEffective;
            data_ver = preferences.data_ver;
            haveBeenGameStart = preferences.haveBeenGameStart;
            date = preferences.date;
            lastLoginDays = preferences.lastLoginDays;
            xpReachedRewardIndex = preferences.xpReachedRewardIndex;
            playerXP = preferences.playerXP;
            currency101 = preferences.currency101;
            max101 = preferences.max101;
            nextNewDayTime = preferences.nextNewDayTime;
            ballonCdTime = preferences.ballonCdTime;
            toDayMaxScore = preferences.toDayMaxScore;
            historyMaxScore = preferences.historyMaxScore;
            playerName = preferences.playerName;
            code = preferences.code;
            playerAvatarId = preferences.playerAvatarId;
            ticketGameNum = preferences.ticketGameNum;
            moneyGameNum = preferences.moneyGameNum;
            loginDay = preferences.loginDay;
            watchVideoBeginSum = preferences.watchVideoBeginSum;
            active = preferences.active;
            currency102 = preferences.currency102;
            max102 = preferences.max102;
            isResetGuide = preferences.isResetGuide;
            watchVideoSum = preferences.watchVideoSum;
            isOpenedInvite = preferences.isOpenedInvite;
            isGod = preferences.isGod;
            isGuideFinish = preferences.isGuideFinish;
            facebookId = preferences.facebookId;
            facebookName = preferences.facebookName;
            facebookAvatarUrl = preferences.facebookAvatarUrl;
            isFaceBookLogin = preferences.isFaceBookLogin;
            isShowRewardFly101 = preferences.isShowRewardFly101;
            isShowRewardFly102 = preferences.isShowRewardFly102;
            isShowRewardFly105 = preferences.isShowRewardFly105;
            isShowRewardFly106 = preferences.isShowRewardFly106;
            thisDayWatchSlyderVideoNum = preferences.thisDayWatchSlyderVideoNum;
            isPayBind = preferences.isPayBind;
            paypalAccount = preferences.paypalAccount;
            isSuccessRedeem = preferences.isSuccessRedeem;
            isOpenRedeem = preferences.isOpenRedeem;
            gameOfCount = preferences.gameOfCount;
            initPropFireCountUsed = preferences.initPropFireCountUsed;
            initPropBombCountUsed = preferences.initPropBombCountUsed;
            exchangeBindGuide = preferences.exchangeBindGuide;
            exchangeAccount = preferences.exchangeAccount;
            exchangeName = preferences.exchangeName;
            exchangeCoinAccount = preferences.exchangeCoinAccount;
            exchangeCoinFName = preferences.exchangeCoinFName;
            exchangeCoinLName = preferences.exchangeCoinLName;
            exchangeMailbox = preferences.exchangeMailbox;
            clearBubbleCount = preferences.clearBubbleCount;
            usePropCount = preferences.usePropCount;
            winLeftExtraBallCount = preferences.winLeftExtraBallCount;
            isRateUs = preferences.isRateUs;
            dailyTaskWinCount = preferences.dailyTaskWinCount;
            isOpenedRealGift = preferences.isOpenedRealGift;
            webViewOnlineTime = preferences.webViewOnlineTime;
            isClickH5Icon = preferences.isClickH5Icon;
            isShowOpenReward = preferences.isShowOpenReward;
            openRewardCount = preferences.openRewardCount;
            isRealProcessing = preferences.isRealProcessing;
            realWatchVideo = preferences.realWatchVideo;
            isEditInviteCode = preferences.isEditInviteCode;
            webViewMakeUpOnlineTime = preferences.webViewMakeUpOnlineTime;
            webViewADTaskOnlineTime = preferences.webViewADTaskOnlineTime;
            adCashFlyShowTime = preferences.adCashFlyShowTime;
            cardBoardIndex = preferences.cardBoardIndex;
            bingoSum = preferences.bingoSum;
            isFirstBingo = preferences.isFirstBingo;
            isFirstComboBingo = preferences.isFirstComboBingo;
            isCompleteFirstGame = preferences.isCompleteFirstGame;
            isFirstPropFull = preferences.isFirstPropFull;
            gameSum = preferences.gameSum;
            isOnceWheel = preferences.isOnceWheel;
            wheelVersion = preferences.wheelVersion;
            nextOpenWheelStampTime = preferences.nextOpenWheelStampTime;
            openDailyBonusStampTime = preferences.openDailyBonusStampTime;
            nextRecoveryTime = preferences.nextRecoveryTime;
            cardBoardSum = preferences.cardBoardSum;
            isFirstSlot = preferences.isFirstSlot;
            isFirstBox = preferences.isFirstBox;
            isSecondEndShow = preferences.isSecondEndShow;
            sum777 = preferences.sum777;
            makeupTaskH5Time = preferences.makeupTaskH5Time;
            coinMakeupTaskH5Time = preferences.coinMakeupTaskH5Time;
        }

        #region ValueType

        private int gameStartCount;


        public int GameStartCount
        {
            get { return gameStartCount; }
            set
            {
                if (gameStartCount == value) return;
                ExiteValue<int> exiteValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                exiteValue.oldValue = gameStartCount;
                exiteValue.newValue = value;

                gameStartCount = value;
                preferences.gameStartCount = gameStartCount;
                AddToAutoDelaySaveList(PreferencesField.gameStartCount, preferences.gameStartCount);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.gameStartCount, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.gameStartCount);
            }
        }

        private int loginGameTodayTimes;


        public int LoginGameTodayTimes
        {
            get { return loginGameTodayTimes; }
            set
            {
                if (loginGameTodayTimes == value) return;
                ExiteValue<int> exiteValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                exiteValue.oldValue = loginGameTodayTimes;
                exiteValue.newValue = value;

                loginGameTodayTimes = value;
                preferences.loginGameTodayTimes = loginGameTodayTimes;
                AddToAutoDelaySaveList(PreferencesField.loginGameTodayTimes, preferences.loginGameTodayTimes);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.loginGameTodayTimes, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.loginGameTodayTimes);
            }
        }

        private int videoEffective_count;


        public int VideoEffective_count
        {
            get { return videoEffective_count; }
            set
            {
                if (videoEffective_count == value) return;
                ExiteValue<int> exiteValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                exiteValue.oldValue = videoEffective_count;
                exiteValue.newValue = value;

                videoEffective_count = value;
                preferences.videoEffective_count = videoEffective_count;
                AddToAutoDelaySaveList(PreferencesField.videoEffective_count, preferences.videoEffective_count);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.videoEffective_count, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.videoEffective_count);
            }
        }

        private bool isLogEffective;


        public bool IsLogEffective
        {
            get { return isLogEffective; }
            set
            {
                if (isLogEffective == value) return;
                ExiteValue<bool> exiteValue = PreferencesDispatcher<bool>.Instance.ExiteValue;
                exiteValue.oldValue = isLogEffective;
                exiteValue.newValue = value;

                isLogEffective = value;
                preferences.isLogEffective = isLogEffective;
                AddToAutoDelaySaveList(PreferencesField.isLogEffective, preferences.isLogEffective);
                PreferencesDispatcher<bool>.Instance.Dispatch(PreferencesMsg.isLogEffective, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.isLogEffective);
            }
        }

        private long data_ver;


        public long Data_ver
        {
            get { return data_ver; }
            set
            {
                if (data_ver == value) return;
                ExiteValue<long> exiteValue = PreferencesDispatcher<long>.Instance.ExiteValue;
                exiteValue.oldValue = data_ver;
                exiteValue.newValue = value;

                data_ver = value;
                preferences.data_ver = data_ver;
                Save(PreferencesField.data_ver, preferences.data_ver);
                PreferencesDispatcher<long>.Instance.Dispatch(PreferencesMsg.data_ver, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.data_ver);
            }
        }

        private bool haveBeenGameStart;


        public bool HaveBeenGameStart
        {
            get { return haveBeenGameStart; }
            set
            {
                if (haveBeenGameStart == value) return;
                ExiteValue<bool> exiteValue = PreferencesDispatcher<bool>.Instance.ExiteValue;
                exiteValue.oldValue = haveBeenGameStart;
                exiteValue.newValue = value;

                haveBeenGameStart = value;
                preferences.haveBeenGameStart = haveBeenGameStart;
                AddToAutoDelaySaveList(PreferencesField.haveBeenGameStart, preferences.haveBeenGameStart);
                PreferencesDispatcher<bool>.Instance.Dispatch(PreferencesMsg.haveBeenGameStart, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.haveBeenGameStart);
            }
        }

        private string date;


        public string Date
        {
            get { return date; }
            set
            {
                if (date == value) return;
                ExiteValue<string> exiteValue = PreferencesDispatcher<string>.Instance.ExiteValue;
                exiteValue.oldValue = date;
                exiteValue.newValue = value;

                date = value;
                preferences.date = date;
                AddToAutoDelaySaveList(PreferencesField.date, preferences.date);
                PreferencesDispatcher<string>.Instance.Dispatch(PreferencesMsg.date, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.date);
            }
        }

        private int lastLoginDays;


        public int LastLoginDays
        {
            get { return lastLoginDays; }
            set
            {
                if (lastLoginDays == value) return;
                ExiteValue<int> exiteValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                exiteValue.oldValue = lastLoginDays;
                exiteValue.newValue = value;

                lastLoginDays = value;
                preferences.lastLoginDays = lastLoginDays;
                AddToAutoDelaySaveList(PreferencesField.lastLoginDays, preferences.lastLoginDays);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.lastLoginDays, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.lastLoginDays);
            }
        }

        private int xpReachedRewardIndex;


        public int XpReachedRewardIndex
        {
            get { return xpReachedRewardIndex; }
            set
            {
                if (xpReachedRewardIndex == value) return;
                ExiteValue<int> exiteValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                exiteValue.oldValue = xpReachedRewardIndex;
                exiteValue.newValue = value;

                xpReachedRewardIndex = value;
                preferences.xpReachedRewardIndex = xpReachedRewardIndex;
                AddToAutoDelaySaveList(PreferencesField.xpReachedRewardIndex, preferences.xpReachedRewardIndex);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.xpReachedRewardIndex, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.xpReachedRewardIndex);
            }
        }

        private int playerXP;


        public int PlayerXP
        {
            get { return playerXP; }
            set
            {
                if (playerXP == value) return;
                ExiteValue<int> exiteValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                exiteValue.oldValue = playerXP;
                exiteValue.newValue = value;

                playerXP = value;
                preferences.playerXP = playerXP;
                AddToAutoDelaySaveList(PreferencesField.playerXP, preferences.playerXP);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.playerXP, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.playerXP);
            }
        }

        private int currency101;


        public int Currency101
        {
            get { return currency101; }
            set
            {
                if (currency101 == value) return;
                ExiteValue<int> exiteValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                exiteValue.oldValue = currency101;
                exiteValue.newValue = value;

                currency101 = value;
                preferences.currency101 = currency101;
                AddToAutoDelaySaveList(PreferencesField.currency101, preferences.currency101);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.currency101, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.currency101);
            }
        }

        private int max101;


        public int Max101
        {
            get { return max101; }
            set
            {
                if (max101 == value) return;
                ExiteValue<int> exiteValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                exiteValue.oldValue = max101;
                exiteValue.newValue = value;

                max101 = value;
                preferences.max101 = max101;
                AddToAutoDelaySaveList(PreferencesField.max101, preferences.max101);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.max101, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.max101);
            }
        }

        private long nextNewDayTime;


        public long NextNewDayTime
        {
            get { return nextNewDayTime; }
            set
            {
                if (nextNewDayTime == value) return;
                ExiteValue<long> exiteValue = PreferencesDispatcher<long>.Instance.ExiteValue;
                exiteValue.oldValue = nextNewDayTime;
                exiteValue.newValue = value;

                nextNewDayTime = value;
                preferences.nextNewDayTime = nextNewDayTime;
                AddToAutoDelaySaveList(PreferencesField.nextNewDayTime, preferences.nextNewDayTime);
                PreferencesDispatcher<long>.Instance.Dispatch(PreferencesMsg.nextNewDayTime, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.nextNewDayTime);
            }
        }

        private long ballonCdTime;

        public long BallonCdTime
        {
            get { return ballonCdTime; }
            set
            {
                if (ballonCdTime == value) return;
                ExiteValue<long> exiteValue = PreferencesDispatcher<long>.Instance.ExiteValue;
                exiteValue.oldValue = ballonCdTime;
                exiteValue.newValue = value;

                ballonCdTime = value;
                preferences.ballonCdTime = ballonCdTime;
                AddToAutoDelaySaveList(PreferencesField.ballonCdTime, preferences.ballonCdTime);
                PreferencesDispatcher<long>.Instance.Dispatch(PreferencesMsg.ballonCdTime, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.ballonCdTime);
            }
        }

        private int toDayMaxScore;

        public int ToDayMaxScore
        {
            get { return toDayMaxScore; }
            set
            {
                if (toDayMaxScore == value) return;
                ExiteValue<int> exiteValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                exiteValue.oldValue = toDayMaxScore;
                exiteValue.newValue = value;

                toDayMaxScore = value;
                preferences.toDayMaxScore = toDayMaxScore;
                AddToAutoDelaySaveList(PreferencesField.toDayMaxScore, preferences.toDayMaxScore);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.toDayMaxScore, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.toDayMaxScore);
            }
        }

        private int historyMaxScore;


        public int HistoryMaxScore
        {
            get { return historyMaxScore; }
            set
            {
                if (historyMaxScore == value) return;
                ExiteValue<int> exiteValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                exiteValue.oldValue = historyMaxScore;
                exiteValue.newValue = value;

                historyMaxScore = value;
                preferences.historyMaxScore = historyMaxScore;
                AddToAutoDelaySaveList(PreferencesField.historyMaxScore, preferences.historyMaxScore);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.historyMaxScore, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.historyMaxScore);
            }
        }

        private string playerName="";


        public string PlayerName
        {
            get { return playerName; }
            set
            {
                if (playerName == value) return;
                ExiteValue<string> exiteValue = PreferencesDispatcher<string>.Instance.ExiteValue;
                exiteValue.oldValue = playerName;
                exiteValue.newValue = value;

                playerName = value;
                preferences.playerName = playerName;
                AddToAutoDelaySaveList(PreferencesField.playerName, preferences.playerName);
                PreferencesDispatcher<string>.Instance.Dispatch(PreferencesMsg.playerName, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.playerName);
            }
        }

        private string code;


        public string Code
        {
            get { return code; }
            set
            {
                if (code == value) return;
                ExiteValue<string> exiteValue = PreferencesDispatcher<string>.Instance.ExiteValue;
                exiteValue.oldValue = code;
                exiteValue.newValue = value;

                code = value;
                preferences.code = code;
                AddToAutoDelaySaveList(PreferencesField.code, preferences.code);
                PreferencesDispatcher<string>.Instance.Dispatch(PreferencesMsg.code, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.code);
            }
        }
        private int h5StayTime;
        public int H5StayTime
        {
            get { return h5StayTime; }
            set
            {
                if (h5StayTime == value) return;
                ExiteValue<int> changeValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                changeValue.oldValue = h5StayTime;
                changeValue.newValue = value;

                h5StayTime = value;
                preferences.h5StayTime = h5StayTime;
                AddToAutoDelaySaveList(PreferencesField.h5StayTime, preferences.h5StayTime);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.h5StayTime, changeValue);
                dataDispatcher.Dispatch(PreferencesMsg.h5StayTime);
            }
        }

        private decimal makeupTaskH5Time;

        public decimal MakeupTaskH5Time
        {
            get { return makeupTaskH5Time; }
            set
            {
                if (makeupTaskH5Time == value) return;
                ExiteValue<decimal> changeValue = PreferencesDispatcher<decimal>.Instance.ExiteValue;
                changeValue.oldValue = makeupTaskH5Time;
                changeValue.newValue = value;

                makeupTaskH5Time = value;
                preferences.makeupTaskH5Time = makeupTaskH5Time;
                AddToAutoDelaySaveList(PreferencesField.makeupTaskH5Time, preferences.makeupTaskH5Time);
                PreferencesDispatcher<decimal>.Instance.Dispatch(PreferencesMsg.makeupTaskH5Time, changeValue);
                dataDispatcher.Dispatch(PreferencesMsg.makeupTaskH5Time);
            }
        }

        public List<MakeupTaskData> MakeupTaskHistory
        {
            get
            {
                if (preferences.makeupTaskHistory == null) preferences.makeupTaskHistory = new List<MakeupTaskData>();
                return preferences.makeupTaskHistory;
            }
        }

        public void SaveMakeupTaskHistory()
        {
            AddToAutoDelaySaveList(PreferencesField.makeupTaskHistory, MakeupTaskHistory);
            PreferencesDispatcher<object>.Instance.Dispatch(PreferencesMsg.makeupTaskHistory);
            dataDispatcher.Dispatch(PreferencesMsg.makeupTaskHistory);
        }
        public List<MakeupTaskData> CoinMakeupTaskHistory
        {
            get
            {
                if (preferences.coinMakeupTaskHistory == null)
                    preferences.coinMakeupTaskHistory = new List<MakeupTaskData>();
                return preferences.coinMakeupTaskHistory;
            }

        }
        private decimal coinMakeupTaskH5Time;


        public decimal CoinMakeupTaskH5Time
        {
            get { return coinMakeupTaskH5Time; }
            set
            {
                if (coinMakeupTaskH5Time == value) return;
                ExiteValue<decimal> changeValue = PreferencesDispatcher<decimal>.Instance.ExiteValue;
                changeValue.oldValue = coinMakeupTaskH5Time;
                changeValue.newValue = value;

                coinMakeupTaskH5Time = value;
                preferences.coinMakeupTaskH5Time = coinMakeupTaskH5Time;
                AddToAutoDelaySaveList(PreferencesField.coinMakeupTaskH5Time, preferences.coinMakeupTaskH5Time);
                PreferencesDispatcher<decimal>.Instance.Dispatch(PreferencesMsg.coinMakeupTaskH5Time, changeValue);
                dataDispatcher.Dispatch(PreferencesMsg.coinMakeupTaskH5Time);
            }
        }
        public void SaveCoinMakeupTaskHistory()
        {
            AddToAutoDelaySaveList(PreferencesField.coinMakeupTaskHistory, CoinMakeupTaskHistory);
            PreferencesDispatcher<object>.Instance.Dispatch(PreferencesMsg.coinMakeupTaskHistory);
            dataDispatcher.Dispatch(PreferencesMsg.coinMakeupTaskHistory);
        }

        public string short_name;
        public string long_name;
        private int playerAvatarId;


        public int PlayerAvatarId
        {
            get { return playerAvatarId; }
            set
            {
                if (playerAvatarId == value) return;
                ExiteValue<int> exiteValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                exiteValue.oldValue = playerAvatarId;
                exiteValue.newValue = value;

                playerAvatarId = value;
                preferences.playerAvatarId = playerAvatarId;
                AddToAutoDelaySaveList(PreferencesField.playerAvatarId, preferences.playerAvatarId);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.playerAvatarId, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.playerAvatarId);
            }
        }

        private int ticketGameNum;


        public int TicketGameNum
        {
            get { return ticketGameNum; }
            set
            {
                if (ticketGameNum == value) return;
                ExiteValue<int> exiteValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                exiteValue.oldValue = ticketGameNum;
                exiteValue.newValue = value;

                ticketGameNum = value;
                preferences.ticketGameNum = ticketGameNum;
                AddToAutoDelaySaveList(PreferencesField.ticketGameNum, preferences.ticketGameNum);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.ticketGameNum, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.ticketGameNum);
            }
        }

        private int moneyGameNum;


        public int MoneyGameNum
        {
            get { return moneyGameNum; }
            set
            {
                if (moneyGameNum == value) return;
                ExiteValue<int> exiteValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                exiteValue.oldValue = moneyGameNum;
                exiteValue.newValue = value;

                moneyGameNum = value;
                preferences.moneyGameNum = moneyGameNum;
                AddToAutoDelaySaveList(PreferencesField.moneyGameNum, preferences.moneyGameNum);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.moneyGameNum, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.moneyGameNum);
            }
        }

        private int loginDay;


        public int LoginDay
        {
            get { return loginDay; }
            set
            {
                if (loginDay == value) return;
                ExiteValue<int> exiteValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                exiteValue.oldValue = loginDay;
                exiteValue.newValue = value;

                loginDay = value;
                preferences.loginDay = loginDay;
                AddToAutoDelaySaveList(PreferencesField.loginDay, preferences.loginDay);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.loginDay, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.loginDay);
            }
        }

        private int watchVideoBeginSum;


        public int WatchVideoBeginSum
        {
            get { return watchVideoBeginSum; }
            set
            {
                if (watchVideoBeginSum == value) return;
                ExiteValue<int> exiteValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                exiteValue.oldValue = watchVideoBeginSum;
                exiteValue.newValue = value;

                watchVideoBeginSum = value;
                preferences.watchVideoBeginSum = watchVideoBeginSum;
                AddToAutoDelaySaveList(PreferencesField.watchVideoBeginSum, preferences.watchVideoBeginSum);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.watchVideoBeginSum, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.watchVideoBeginSum);
            }
        }

        private int active;


        public int Active
        {
            get { return active; }
            set
            {
                if (active == value) return;
                ExiteValue<int> exiteValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                exiteValue.oldValue = active;
                exiteValue.newValue = value;

                active = value;
                preferences.active = active;
                AddToAutoDelaySaveList(PreferencesField.active, preferences.active);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.active, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.active);
            }
        }

        private decimal currency102;


        public decimal Currency102
        {
            get { return currency102; }
            set
            {
                if (currency102 == value) return;
                ExiteValue<decimal> exiteValue = PreferencesDispatcher<decimal>.Instance.ExiteValue;
                exiteValue.oldValue = currency102;
                exiteValue.newValue = value;

                currency102 = value;
                preferences.currency102 = currency102;
                AddToAutoDelaySaveList(PreferencesField.currency102, preferences.currency102);
                PreferencesDispatcher<decimal>.Instance.Dispatch(PreferencesMsg.currency102, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.currency102);
            }
        }

        private decimal max102;


        public decimal Max102
        {
            get { return max102; }
            set
            {
                if (max102 == value) return;
                ExiteValue<decimal> exiteValue = PreferencesDispatcher<decimal>.Instance.ExiteValue;
                exiteValue.oldValue = max102;
                exiteValue.newValue = value;

                max102 = value;
                preferences.max102 = max102;
                AddToAutoDelaySaveList(PreferencesField.max102, preferences.max102);
                PreferencesDispatcher<decimal>.Instance.Dispatch(PreferencesMsg.max102, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.max102);
            }
        }

        private bool isResetGuide;

        public bool IsResetGuide
        {
            get { return isResetGuide; }
            set
            {
                if (isResetGuide == value) return;
                ExiteValue<bool> exiteValue = PreferencesDispatcher<bool>.Instance.ExiteValue;
                exiteValue.oldValue = isResetGuide;
                exiteValue.newValue = value;

                isResetGuide = value;
                preferences.isResetGuide = isResetGuide;
                AddToAutoDelaySaveList(PreferencesField.isResetGuide, preferences.isResetGuide);
                PreferencesDispatcher<bool>.Instance.Dispatch(PreferencesMsg.isResetGuide, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.isResetGuide);
            }
        }

        private int watchVideoSum;


        public int WatchVideoSum
        {
            get { return watchVideoSum; }
            set
            {
                if (watchVideoSum == value) return;
                ExiteValue<int> exiteValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                exiteValue.oldValue = watchVideoSum;
                exiteValue.newValue = value;

                watchVideoSum = value;
                preferences.watchVideoSum = watchVideoSum;
                AddToAutoDelaySaveList(PreferencesField.watchVideoSum, preferences.watchVideoSum);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.watchVideoSum, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.watchVideoSum);
            }
        }

        private bool isOpenedInvite;


        public bool IsOpenedInvite
        {
            get { return isOpenedInvite; }
            set
            {
                if (isOpenedInvite == value) return;
                ExiteValue<bool> exiteValue = PreferencesDispatcher<bool>.Instance.ExiteValue;
                exiteValue.oldValue = isOpenedInvite;
                exiteValue.newValue = value;

                isOpenedInvite = value;
                preferences.isOpenedInvite = isOpenedInvite;
                AddToAutoDelaySaveList(PreferencesField.isOpenedInvite, preferences.isOpenedInvite);
                PreferencesDispatcher<bool>.Instance.Dispatch(PreferencesMsg.isOpenedInvite, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.isOpenedInvite);
            }
        }

        private bool isGod;

        public bool IsGod
        {
            get { return isGod; }
            set
            {
                if (isGod == value) return;
                ExiteValue<bool> exiteValue = PreferencesDispatcher<bool>.Instance.ExiteValue;
                exiteValue.oldValue = isGod;
                exiteValue.newValue = value;

                isGod = value;
                preferences.isGod = isGod;
                AddToAutoDelaySaveList(PreferencesField.isGod, preferences.isGod);
                PreferencesDispatcher<bool>.Instance.Dispatch(PreferencesMsg.isGod, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.isGod);
            }
        }

        private bool isGuideFinish;


        public bool IsGuideFinish
        {
            get { return isGuideFinish; }
            set
            {
                if (isGuideFinish == value) return;
                ExiteValue<bool> exiteValue = PreferencesDispatcher<bool>.Instance.ExiteValue;
                exiteValue.oldValue = isGuideFinish;
                exiteValue.newValue = value;

                isGuideFinish = value;
                preferences.isGuideFinish = isGuideFinish;
                AddToAutoDelaySaveList(PreferencesField.isGuideFinish, preferences.isGuideFinish);
                PreferencesDispatcher<bool>.Instance.Dispatch(PreferencesMsg.isGuideFinish, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.isGuideFinish);
            }
        }

        private string facebookId;


        public string FacebookId
        {
            get { return facebookId; }
            set
            {
                if (facebookId == value) return;
                ExiteValue<string> exiteValue = PreferencesDispatcher<string>.Instance.ExiteValue;
                exiteValue.oldValue = facebookId;
                exiteValue.newValue = value;

                facebookId = value;
                preferences.facebookId = facebookId;
                AddToAutoDelaySaveList(PreferencesField.facebookId, preferences.facebookId);
                PreferencesDispatcher<string>.Instance.Dispatch(PreferencesMsg.facebookId, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.facebookId);
            }
        }

        private string facebookName;


        public string FacebookName
        {
            get { return facebookName; }
            set
            {
                if (facebookName == value) return;
                ExiteValue<string> exiteValue = PreferencesDispatcher<string>.Instance.ExiteValue;
                exiteValue.oldValue = facebookName;
                exiteValue.newValue = value;

                facebookName = value;
                preferences.facebookName = facebookName;
                AddToAutoDelaySaveList(PreferencesField.facebookName, preferences.facebookName);
                PreferencesDispatcher<string>.Instance.Dispatch(PreferencesMsg.facebookName, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.facebookName);
            }
        }

        private string facebookAvatarUrl;


        public string FacebookAvatarUrl
        {
            get { return facebookAvatarUrl; }
            set
            {
                if (facebookAvatarUrl == value) return;
                ExiteValue<string> exiteValue = PreferencesDispatcher<string>.Instance.ExiteValue;
                exiteValue.oldValue = facebookAvatarUrl;
                exiteValue.newValue = value;

                facebookAvatarUrl = value;
                preferences.facebookAvatarUrl = facebookAvatarUrl;
                AddToAutoDelaySaveList(PreferencesField.facebookAvatarUrl, preferences.facebookAvatarUrl);
                PreferencesDispatcher<string>.Instance.Dispatch(PreferencesMsg.facebookAvatarUrl, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.facebookAvatarUrl);
            }
        }

        private bool isFaceBookLogin;


        public bool IsFaceBookLogin
        {
            get { return isFaceBookLogin; }
            set
            {
                if (isFaceBookLogin == value) return;
                ExiteValue<bool> exiteValue = PreferencesDispatcher<bool>.Instance.ExiteValue;
                exiteValue.oldValue = isFaceBookLogin;
                exiteValue.newValue = value;

                isFaceBookLogin = value;
                preferences.isFaceBookLogin = isFaceBookLogin;
                AddToAutoDelaySaveList(PreferencesField.isFaceBookLogin, preferences.isFaceBookLogin);
                PreferencesDispatcher<bool>.Instance.Dispatch(PreferencesMsg.isFaceBookLogin, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.isFaceBookLogin);
            }
        }

        private bool isShowRewardFly101;

        public bool IsShowRewardFly101
        {
            get { return isShowRewardFly101; }
            set
            {
                if (isShowRewardFly101 == value) return;
                ExiteValue<bool> exiteValue = PreferencesDispatcher<bool>.Instance.ExiteValue;
                exiteValue.oldValue = isShowRewardFly101;
                exiteValue.newValue = value;

                isShowRewardFly101 = value;
                preferences.isShowRewardFly101 = isShowRewardFly101;
                AddToAutoDelaySaveList(PreferencesField.isShowRewardFly101, preferences.isShowRewardFly101);
                PreferencesDispatcher<bool>.Instance.Dispatch(PreferencesMsg.isShowRewardFly101, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.isShowRewardFly101);
            }
        }

        private bool isShowRewardFly102;

        public bool IsShowRewardFly102
        {
            get { return isShowRewardFly102; }
            set
            {
                if (isShowRewardFly102 == value) return;
                ExiteValue<bool> exiteValue = PreferencesDispatcher<bool>.Instance.ExiteValue;
                exiteValue.oldValue = isShowRewardFly102;
                exiteValue.newValue = value;

                isShowRewardFly102 = value;
                preferences.isShowRewardFly102 = isShowRewardFly102;
                AddToAutoDelaySaveList(PreferencesField.isShowRewardFly102, preferences.isShowRewardFly102);
                PreferencesDispatcher<bool>.Instance.Dispatch(PreferencesMsg.isShowRewardFly102, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.isShowRewardFly102);
            }
        }

        private bool isShowRewardFly105;

        public bool IsShowRewardFly105
        {
            get { return isShowRewardFly105; }
            set
            {
                if (isShowRewardFly105 == value) return;
                ExiteValue<bool> exiteValue = PreferencesDispatcher<bool>.Instance.ExiteValue;
                exiteValue.oldValue = isShowRewardFly105;
                exiteValue.newValue = value;

                isShowRewardFly105 = value;
                preferences.isShowRewardFly105 = isShowRewardFly105;
                AddToAutoDelaySaveList(PreferencesField.isShowRewardFly105, preferences.isShowRewardFly105);
                PreferencesDispatcher<bool>.Instance.Dispatch(PreferencesMsg.isShowRewardFly105, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.isShowRewardFly105);
            }
        }

        private bool isShowRewardFly106;

        public bool IsShowRewardFly106
        {
            get { return isShowRewardFly106; }
            set
            {
                if (isShowRewardFly106 == value) return;
                ExiteValue<bool> exiteValue = PreferencesDispatcher<bool>.Instance.ExiteValue;
                exiteValue.oldValue = isShowRewardFly106;
                exiteValue.newValue = value;

                isShowRewardFly106 = value;
                preferences.isShowRewardFly106 = isShowRewardFly106;
                AddToAutoDelaySaveList(PreferencesField.isShowRewardFly106, preferences.isShowRewardFly106);
                PreferencesDispatcher<bool>.Instance.Dispatch(PreferencesMsg.isShowRewardFly106, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.isShowRewardFly106);
            }
        }

        private int thisDayWatchSlyderVideoNum;


        public int ThisDayWatchSlyderVideoNum
        {
            get { return thisDayWatchSlyderVideoNum; }
            set
            {
                if (thisDayWatchSlyderVideoNum == value) return;
                ExiteValue<int> exiteValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                exiteValue.oldValue = thisDayWatchSlyderVideoNum;
                exiteValue.newValue = value;

                thisDayWatchSlyderVideoNum = value;
                preferences.thisDayWatchSlyderVideoNum = thisDayWatchSlyderVideoNum;
                AddToAutoDelaySaveList(PreferencesField.thisDayWatchSlyderVideoNum,
                    preferences.thisDayWatchSlyderVideoNum);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.thisDayWatchSlyderVideoNum, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.thisDayWatchSlyderVideoNum);
            }
        }

        private bool isPayBind;


        public bool IsPayBind
        {
            get { return isPayBind; }
            set
            {
                if (isPayBind == value) return;
                ExiteValue<bool> exiteValue = PreferencesDispatcher<bool>.Instance.ExiteValue;
                exiteValue.oldValue = isPayBind;
                exiteValue.newValue = value;

                isPayBind = value;
                preferences.isPayBind = isPayBind;
                AddToAutoDelaySaveList(PreferencesField.isPayBind, preferences.isPayBind);
                PreferencesDispatcher<bool>.Instance.Dispatch(PreferencesMsg.isPayBind, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.isPayBind);
            }
        }

        private string paypalAccount;


        public string PaypalAccount
        {
            get { return paypalAccount; }
            set
            {
                if (paypalAccount == value) return;
                ExiteValue<string> exiteValue = PreferencesDispatcher<string>.Instance.ExiteValue;
                exiteValue.oldValue = paypalAccount;
                exiteValue.newValue = value;

                paypalAccount = value;
                preferences.paypalAccount = paypalAccount;
                AddToAutoDelaySaveList(PreferencesField.paypalAccount, preferences.paypalAccount);
                PreferencesDispatcher<string>.Instance.Dispatch(PreferencesMsg.paypalAccount, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.paypalAccount);
            }
        }

        private bool isSuccessRedeem;


        public bool IsSuccessRedeem
        {
            get { return isSuccessRedeem; }
            set
            {
                if (isSuccessRedeem == value) return;
                ExiteValue<bool> exiteValue = PreferencesDispatcher<bool>.Instance.ExiteValue;
                exiteValue.oldValue = isSuccessRedeem;
                exiteValue.newValue = value;

                isSuccessRedeem = value;
                preferences.isSuccessRedeem = isSuccessRedeem;
                AddToAutoDelaySaveList(PreferencesField.isSuccessRedeem, preferences.isSuccessRedeem);
                PreferencesDispatcher<bool>.Instance.Dispatch(PreferencesMsg.isSuccessRedeem, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.isSuccessRedeem);
            }
        }

        private bool isOpenRedeem;


        public bool IsOpenRedeem
        {
            get { return isOpenRedeem; }
            set
            {
                if (isOpenRedeem == value) return;
                ExiteValue<bool> exiteValue = PreferencesDispatcher<bool>.Instance.ExiteValue;
                exiteValue.oldValue = isOpenRedeem;
                exiteValue.newValue = value;

                isOpenRedeem = value;
                preferences.isOpenRedeem = isOpenRedeem;
                AddToAutoDelaySaveList(PreferencesField.isOpenRedeem, preferences.isOpenRedeem);
                PreferencesDispatcher<bool>.Instance.Dispatch(PreferencesMsg.isOpenRedeem, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.isOpenRedeem);
            }
        }

        private int gameOfCount;


        public int GameOfCount
        {
            get { return gameOfCount; }
            set
            {
                if (gameOfCount == value) return;
                ExiteValue<int> exiteValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                exiteValue.oldValue = gameOfCount;
                exiteValue.newValue = value;

                gameOfCount = value;
                preferences.gameOfCount = gameOfCount;
                AddToAutoDelaySaveList(PreferencesField.gameOfCount, preferences.gameOfCount);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.gameOfCount, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.gameOfCount);
            }
        }

        private int initPropFireCountUsed;


        public int InitPropFireCountUsed
        {
            get { return initPropFireCountUsed; }
            set
            {
                if (initPropFireCountUsed == value) return;
                ExiteValue<int> exiteValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                exiteValue.oldValue = initPropFireCountUsed;
                exiteValue.newValue = value;

                initPropFireCountUsed = value;
                preferences.initPropFireCountUsed = initPropFireCountUsed;
                AddToAutoDelaySaveList(PreferencesField.initPropFireCountUsed, preferences.initPropFireCountUsed);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.initPropFireCountUsed, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.initPropFireCountUsed);
            }
        }

        private int initPropBombCountUsed;


        public int InitPropBombCountUsed
        {
            get { return initPropBombCountUsed; }
            set
            {
                if (initPropBombCountUsed == value) return;
                ExiteValue<int> exiteValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                exiteValue.oldValue = initPropBombCountUsed;
                exiteValue.newValue = value;

                initPropBombCountUsed = value;
                preferences.initPropBombCountUsed = initPropBombCountUsed;
                AddToAutoDelaySaveList(PreferencesField.initPropBombCountUsed, preferences.initPropBombCountUsed);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.initPropBombCountUsed, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.initPropBombCountUsed);
            }
        }

        private bool exchangeBindGuide;


        public bool ExchangeBindGuide
        {
            get { return exchangeBindGuide; }
            set
            {
                if (exchangeBindGuide == value) return;
                ExiteValue<bool> exiteValue = PreferencesDispatcher<bool>.Instance.ExiteValue;
                exiteValue.oldValue = exchangeBindGuide;
                exiteValue.newValue = value;

                exchangeBindGuide = value;
                preferences.exchangeBindGuide = exchangeBindGuide;
                AddToAutoDelaySaveList(PreferencesField.exchangeBindGuide, preferences.exchangeBindGuide);
                PreferencesDispatcher<bool>.Instance.Dispatch(PreferencesMsg.exchangeBindGuide, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.exchangeBindGuide);
            }
        }

        private string exchangeAccount;


        public string ExchangeAccount
        {
            get { return exchangeAccount; }
            set
            {
                if (exchangeAccount == value) return;
                ExiteValue<string> exiteValue = PreferencesDispatcher<string>.Instance.ExiteValue;
                exiteValue.oldValue = exchangeAccount;
                exiteValue.newValue = value;

                exchangeAccount = value;
                preferences.exchangeAccount = exchangeAccount;
                AddToAutoDelaySaveList(PreferencesField.exchangeAccount, preferences.exchangeAccount);
                PreferencesDispatcher<string>.Instance.Dispatch(PreferencesMsg.exchangeAccount, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.exchangeAccount);
            }
        }

        private string exchangeName;


        public string ExchangeName
        {
            get { return exchangeName; }
            set
            {
                if (exchangeName == value) return;
                ExiteValue<string> exiteValue = PreferencesDispatcher<string>.Instance.ExiteValue;
                exiteValue.oldValue = exchangeName;
                exiteValue.newValue = value;

                exchangeName = value;
                preferences.exchangeName = exchangeName;
                AddToAutoDelaySaveList(PreferencesField.exchangeName, preferences.exchangeName);
                PreferencesDispatcher<string>.Instance.Dispatch(PreferencesMsg.exchangeName, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.exchangeName);
            }
        }

        private string exchangeCoinAccount;


        public string ExchangeCoinAccount
        {
            get { return exchangeCoinAccount; }
            set
            {
                if (exchangeCoinAccount == value) return;
                ExiteValue<string> exiteValue = PreferencesDispatcher<string>.Instance.ExiteValue;
                exiteValue.oldValue = exchangeCoinAccount;
                exiteValue.newValue = value;

                exchangeCoinAccount = value;
                preferences.exchangeCoinAccount = exchangeCoinAccount;
                AddToAutoDelaySaveList(PreferencesField.exchangeCoinAccount, preferences.exchangeCoinAccount);
                PreferencesDispatcher<string>.Instance.Dispatch(PreferencesMsg.exchangeCoinAccount, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.exchangeCoinAccount);
            }
        }

        private string exchangeCoinFName;


        public string ExchangeCoinFName
        {
            get { return exchangeCoinFName; }
            set
            {
                if (exchangeCoinFName == value) return;
                ExiteValue<string> exiteValue = PreferencesDispatcher<string>.Instance.ExiteValue;
                exiteValue.oldValue = exchangeCoinFName;
                exiteValue.newValue = value;

                exchangeCoinFName = value;
                preferences.exchangeCoinFName = exchangeCoinFName;
                AddToAutoDelaySaveList(PreferencesField.exchangeCoinFName, preferences.exchangeCoinFName);
                PreferencesDispatcher<string>.Instance.Dispatch(PreferencesMsg.exchangeCoinFName, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.exchangeCoinFName);
            }
        }

        private string exchangeCoinLName;


        public string ExchangeCoinLName
        {
            get { return exchangeCoinLName; }
            set
            {
                if (exchangeCoinLName == value) return;
                ExiteValue<string> exiteValue = PreferencesDispatcher<string>.Instance.ExiteValue;
                exiteValue.oldValue = exchangeCoinLName;
                exiteValue.newValue = value;

                exchangeCoinLName = value;
                preferences.exchangeCoinLName = exchangeCoinLName;
                AddToAutoDelaySaveList(PreferencesField.exchangeCoinLName, preferences.exchangeCoinLName);
                PreferencesDispatcher<string>.Instance.Dispatch(PreferencesMsg.exchangeCoinLName, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.exchangeCoinLName);
            }
        }

        private string exchangeMailbox;


        public string ExchangeMailbox
        {
            get { return exchangeMailbox; }
            set
            {
                if (exchangeMailbox == value) return;
                ExiteValue<string> exiteValue = PreferencesDispatcher<string>.Instance.ExiteValue;
                exiteValue.oldValue = exchangeMailbox;
                exiteValue.newValue = value;

                exchangeMailbox = value;
                preferences.exchangeMailbox = exchangeMailbox;
                AddToAutoDelaySaveList(PreferencesField.exchangeMailbox, preferences.exchangeMailbox);
                PreferencesDispatcher<string>.Instance.Dispatch(PreferencesMsg.exchangeMailbox, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.exchangeMailbox);
            }
        }

        private int clearBubbleCount;


        public int ClearBubbleCount
        {
            get { return clearBubbleCount; }
            set
            {
                if (clearBubbleCount == value) return;
                ExiteValue<int> exiteValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                exiteValue.oldValue = clearBubbleCount;
                exiteValue.newValue = value;

                clearBubbleCount = value;
                preferences.clearBubbleCount = clearBubbleCount;
                AddToAutoDelaySaveList(PreferencesField.clearBubbleCount, preferences.clearBubbleCount);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.clearBubbleCount, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.clearBubbleCount);
            }
        }

        private int usePropCount;


        public int UsePropCount
        {
            get { return usePropCount; }
            set
            {
                if (usePropCount == value) return;
                ExiteValue<int> exiteValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                exiteValue.oldValue = usePropCount;
                exiteValue.newValue = value;

                usePropCount = value;
                preferences.usePropCount = usePropCount;
                AddToAutoDelaySaveList(PreferencesField.usePropCount, preferences.usePropCount);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.usePropCount, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.usePropCount);
            }
        }

        private int winLeftExtraBallCount;


        public int WinLeftExtraBallCount
        {
            get { return winLeftExtraBallCount; }
            set
            {
                if (winLeftExtraBallCount == value) return;
                ExiteValue<int> exiteValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                exiteValue.oldValue = winLeftExtraBallCount;
                exiteValue.newValue = value;

                winLeftExtraBallCount = value;
                preferences.winLeftExtraBallCount = winLeftExtraBallCount;
                AddToAutoDelaySaveList(PreferencesField.winLeftExtraBallCount, preferences.winLeftExtraBallCount);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.winLeftExtraBallCount, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.winLeftExtraBallCount);
            }
        }

        private bool isRateUs;


        public bool IsRateUs
        {
            get { return isRateUs; }
            set
            {
                if (isRateUs == value) return;
                ExiteValue<bool> exiteValue = PreferencesDispatcher<bool>.Instance.ExiteValue;
                exiteValue.oldValue = isRateUs;
                exiteValue.newValue = value;

                isRateUs = value;
                preferences.isRateUs = isRateUs;
                AddToAutoDelaySaveList(PreferencesField.isRateUs, preferences.isRateUs);
                PreferencesDispatcher<bool>.Instance.Dispatch(PreferencesMsg.isRateUs, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.isRateUs);
            }
        }

        private int dailyTaskWinCount;


        public int DailyTaskWinCount
        {
            get { return dailyTaskWinCount; }
            set
            {
                if (dailyTaskWinCount == value) return;
                ExiteValue<int> exiteValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                exiteValue.oldValue = dailyTaskWinCount;
                exiteValue.newValue = value;

                dailyTaskWinCount = value;
                preferences.dailyTaskWinCount = dailyTaskWinCount;
                AddToAutoDelaySaveList(PreferencesField.dailyTaskWinCount, preferences.dailyTaskWinCount);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.dailyTaskWinCount, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.dailyTaskWinCount);
            }
        }

        private bool isOpenedRealGift;

        public bool IsOpenedRealGift
        {
            get { return isOpenedRealGift; }
            set
            {
                if (isOpenedRealGift == value) return;
                ExiteValue<bool> exiteValue = PreferencesDispatcher<bool>.Instance.ExiteValue;
                exiteValue.oldValue = isOpenedRealGift;
                exiteValue.newValue = value;

                isOpenedRealGift = value;
                preferences.isOpenedRealGift = isOpenedRealGift;
                AddToAutoDelaySaveList(PreferencesField.isOpenedRealGift, preferences.isOpenedRealGift);
                PreferencesDispatcher<bool>.Instance.Dispatch(PreferencesMsg.isOpenedRealGift, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.isOpenedRealGift);
            }
        }

        private decimal webViewOnlineTime;


        public decimal WebViewOnlineTime
        {
            get { return webViewOnlineTime; }
            set
            {
                if (webViewOnlineTime == value) return;
                ExiteValue<decimal> exiteValue = PreferencesDispatcher<decimal>.Instance.ExiteValue;
                exiteValue.oldValue = webViewOnlineTime;
                exiteValue.newValue = value;

                webViewOnlineTime = value;
                preferences.webViewOnlineTime = webViewOnlineTime;
                AddToAutoDelaySaveList(PreferencesField.webViewOnlineTime, preferences.webViewOnlineTime);
                PreferencesDispatcher<decimal>.Instance.Dispatch(PreferencesMsg.webViewOnlineTime, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.webViewOnlineTime);
            }
        }

        private bool isClickH5Icon;


        public bool IsClickH5Icon
        {
            get { return isClickH5Icon; }
            set
            {
                if (isClickH5Icon == value) return;
                ExiteValue<bool> exiteValue = PreferencesDispatcher<bool>.Instance.ExiteValue;
                exiteValue.oldValue = isClickH5Icon;
                exiteValue.newValue = value;

                isClickH5Icon = value;
                preferences.isClickH5Icon = isClickH5Icon;
                AddToAutoDelaySaveList(PreferencesField.isClickH5Icon, preferences.isClickH5Icon);
                PreferencesDispatcher<bool>.Instance.Dispatch(PreferencesMsg.isClickH5Icon, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.isClickH5Icon);
            }
        }

        private bool isShowOpenReward;

        public bool IsShowOpenReward
        {
            get { return isShowOpenReward; }
            set
            {
                if (isShowOpenReward == value) return;
                ExiteValue<bool> exiteValue = PreferencesDispatcher<bool>.Instance.ExiteValue;
                exiteValue.oldValue = isShowOpenReward;
                exiteValue.newValue = value;

                isShowOpenReward = value;
                preferences.isShowOpenReward = isShowOpenReward;
                AddToAutoDelaySaveList(PreferencesField.isShowOpenReward, preferences.isShowOpenReward);
                PreferencesDispatcher<bool>.Instance.Dispatch(PreferencesMsg.isShowOpenReward, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.isShowOpenReward);
            }
        }

        private int openRewardCount;


        public int OpenRewardCount
        {
            get { return openRewardCount; }
            set
            {
                if (openRewardCount == value) return;
                ExiteValue<int> exiteValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                exiteValue.oldValue = openRewardCount;
                exiteValue.newValue = value;

                openRewardCount = value;
                preferences.openRewardCount = openRewardCount;
                AddToAutoDelaySaveList(PreferencesField.openRewardCount, preferences.openRewardCount);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.openRewardCount, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.openRewardCount);
            }
        }

        private bool isRealProcessing;

        public bool IsRealProcessing
        {
            get { return isRealProcessing; }
            set
            {
                if (isRealProcessing == value) return;
                ExiteValue<bool> exiteValue = PreferencesDispatcher<bool>.Instance.ExiteValue;
                exiteValue.oldValue = isRealProcessing;
                exiteValue.newValue = value;

                isRealProcessing = value;
                preferences.isRealProcessing = isRealProcessing;
                AddToAutoDelaySaveList(PreferencesField.isRealProcessing, preferences.isRealProcessing);
                PreferencesDispatcher<bool>.Instance.Dispatch(PreferencesMsg.isRealProcessing, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.isRealProcessing);
            }
        }

        private int realWatchVideo;


        public int RealWatchVideo
        {
            get { return realWatchVideo; }
            set
            {
                if (realWatchVideo == value) return;
                ExiteValue<int> exiteValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                exiteValue.oldValue = realWatchVideo;
                exiteValue.newValue = value;

                realWatchVideo = value;
                preferences.realWatchVideo = realWatchVideo;
                AddToAutoDelaySaveList(PreferencesField.realWatchVideo, preferences.realWatchVideo);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.realWatchVideo, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.realWatchVideo);
            }
        }

        private bool isEditInviteCode;


        public bool IsEditInviteCode
        {
            get { return isEditInviteCode; }
            set
            {
                if (isEditInviteCode == value) return;
                ExiteValue<bool> exiteValue = PreferencesDispatcher<bool>.Instance.ExiteValue;
                exiteValue.oldValue = isEditInviteCode;
                exiteValue.newValue = value;

                isEditInviteCode = value;
                preferences.isEditInviteCode = isEditInviteCode;
                AddToAutoDelaySaveList(PreferencesField.isEditInviteCode, preferences.isEditInviteCode);
                PreferencesDispatcher<bool>.Instance.Dispatch(PreferencesMsg.isEditInviteCode, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.isEditInviteCode);
            }
        }

        private decimal webViewMakeUpOnlineTime;

        public decimal WebViewMakeUpOnlineTime
        {
            get { return webViewMakeUpOnlineTime; }
            set
            {
                if (webViewMakeUpOnlineTime == value) return;
                ExiteValue<decimal> exiteValue = PreferencesDispatcher<decimal>.Instance.ExiteValue;
                exiteValue.oldValue = webViewMakeUpOnlineTime;
                exiteValue.newValue = value;

                webViewMakeUpOnlineTime = value;
                preferences.webViewMakeUpOnlineTime = webViewMakeUpOnlineTime;
                AddToAutoDelaySaveList(PreferencesField.webViewMakeUpOnlineTime, preferences.webViewMakeUpOnlineTime);
                PreferencesDispatcher<decimal>.Instance.Dispatch(PreferencesMsg.webViewMakeUpOnlineTime, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.webViewMakeUpOnlineTime);
            }
        }

        private decimal webViewADTaskOnlineTime;

        public decimal WebViewADTaskOnlineTime
        {
            get { return webViewADTaskOnlineTime; }
            set
            {
                if (webViewADTaskOnlineTime == value) return;
                ExiteValue<decimal> exiteValue = PreferencesDispatcher<decimal>.Instance.ExiteValue;
                exiteValue.oldValue = webViewADTaskOnlineTime;
                exiteValue.newValue = value;

                webViewADTaskOnlineTime = value;
                preferences.webViewADTaskOnlineTime = webViewADTaskOnlineTime;
                AddToAutoDelaySaveList(PreferencesField.webViewADTaskOnlineTime, preferences.webViewADTaskOnlineTime);
                PreferencesDispatcher<decimal>.Instance.Dispatch(PreferencesMsg.webViewADTaskOnlineTime, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.webViewADTaskOnlineTime);
            }
        }

        private long adCashFlyShowTime;


        public long AdCashFlyShowTime
        {
            get { return adCashFlyShowTime; }
            set
            {
                if (adCashFlyShowTime == value) return;
                ExiteValue<long> exiteValue = PreferencesDispatcher<long>.Instance.ExiteValue;
                exiteValue.oldValue = adCashFlyShowTime;
                exiteValue.newValue = value;

                adCashFlyShowTime = value;
                preferences.adCashFlyShowTime = adCashFlyShowTime;
                AddToAutoDelaySaveList(PreferencesField.adCashFlyShowTime, preferences.adCashFlyShowTime);
                PreferencesDispatcher<long>.Instance.Dispatch(PreferencesMsg.adCashFlyShowTime, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.adCashFlyShowTime);
            }
        }

        private int cardBoardIndex;


        public int CardBoardIndex
        {
            get { return cardBoardIndex; }
            set
            {
                if (cardBoardIndex == value) return;
                ExiteValue<int> exiteValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                exiteValue.oldValue = cardBoardIndex;
                exiteValue.newValue = value;

                cardBoardIndex = value;
                preferences.cardBoardIndex = cardBoardIndex;
                AddToAutoDelaySaveList(PreferencesField.cardBoardIndex, preferences.cardBoardIndex);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.cardBoardIndex, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.cardBoardIndex);
            }
        }

        private int bingoSum;


        public int BingoSum
        {
            get { return bingoSum; }
            set
            {
                if (bingoSum == value) return;
                ExiteValue<int> exiteValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                exiteValue.oldValue = bingoSum;
                exiteValue.newValue = value;

                bingoSum = value;
                preferences.bingoSum = bingoSum;
                AddToAutoDelaySaveList(PreferencesField.bingoSum, preferences.bingoSum);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.bingoSum, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.bingoSum);
            }
        }

        private bool isFirstBingo;


        public bool IsFirstBingo
        {
            get { return isFirstBingo; }
            set
            {
                if (isFirstBingo == value) return;
                ExiteValue<bool> exiteValue = PreferencesDispatcher<bool>.Instance.ExiteValue;
                exiteValue.oldValue = isFirstBingo;
                exiteValue.newValue = value;

                isFirstBingo = value;
                preferences.isFirstBingo = isFirstBingo;
                AddToAutoDelaySaveList(PreferencesField.isFirstBingo, preferences.isFirstBingo);
                PreferencesDispatcher<bool>.Instance.Dispatch(PreferencesMsg.isFirstBingo, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.isFirstBingo);
            }
        }

        private bool isFirstComboBingo;


        public bool IsFirstComboBingo
        {
            get { return isFirstComboBingo; }
            set
            {
                if (isFirstComboBingo == value) return;
                ExiteValue<bool> exiteValue = PreferencesDispatcher<bool>.Instance.ExiteValue;
                exiteValue.oldValue = isFirstComboBingo;
                exiteValue.newValue = value;

                isFirstComboBingo = value;
                preferences.isFirstComboBingo = isFirstComboBingo;
                AddToAutoDelaySaveList(PreferencesField.isFirstComboBingo, preferences.isFirstComboBingo);
                PreferencesDispatcher<bool>.Instance.Dispatch(PreferencesMsg.isFirstComboBingo, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.isFirstComboBingo);
            }
        }

        private bool isCompleteFirstGame;


        public bool IsCompleteFirstGame
        {
            get { return isCompleteFirstGame; }
            set
            {
                if (isCompleteFirstGame == value) return;
                ExiteValue<bool> exiteValue = PreferencesDispatcher<bool>.Instance.ExiteValue;
                exiteValue.oldValue = isCompleteFirstGame;
                exiteValue.newValue = value;

                isCompleteFirstGame = value;
                preferences.isCompleteFirstGame = isCompleteFirstGame;
                AddToAutoDelaySaveList(PreferencesField.isCompleteFirstGame, preferences.isCompleteFirstGame);
                PreferencesDispatcher<bool>.Instance.Dispatch(PreferencesMsg.isCompleteFirstGame, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.isCompleteFirstGame);
            }
        }

        private bool isFirstPropFull;


        public bool IsFirstPropFull
        {
            get { return isFirstPropFull; }
            set
            {
                if (isFirstPropFull == value) return;
                ExiteValue<bool> exiteValue = PreferencesDispatcher<bool>.Instance.ExiteValue;
                exiteValue.oldValue = isFirstPropFull;
                exiteValue.newValue = value;

                isFirstPropFull = value;
                preferences.isFirstPropFull = isFirstPropFull;
                AddToAutoDelaySaveList(PreferencesField.isFirstPropFull, preferences.isFirstPropFull);
                PreferencesDispatcher<bool>.Instance.Dispatch(PreferencesMsg.isFirstPropFull, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.isFirstPropFull);
            }
        }

        private int gameSum;


        public int GameSum
        {
            get { return gameSum; }
            set
            {
                if (gameSum == value) return;
                ExiteValue<int> exiteValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                exiteValue.oldValue = gameSum;
                exiteValue.newValue = value;

                gameSum = value;
                preferences.gameSum = gameSum;
                AddToAutoDelaySaveList(PreferencesField.gameSum, preferences.gameSum);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.gameSum, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.gameSum);
            }
        }

        private bool isOnceWheel;


        public bool IsOnceWheel
        {
            get { return isOnceWheel; }
            set
            {
                if (isOnceWheel == value) return;
                ExiteValue<bool> exiteValue = PreferencesDispatcher<bool>.Instance.ExiteValue;
                exiteValue.oldValue = isOnceWheel;
                exiteValue.newValue = value;

                isOnceWheel = value;
                preferences.isOnceWheel = isOnceWheel;
                AddToAutoDelaySaveList(PreferencesField.isOnceWheel, preferences.isOnceWheel);
                PreferencesDispatcher<bool>.Instance.Dispatch(PreferencesMsg.isOnceWheel, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.isOnceWheel);
            }
        }

        private string wheelVersion;


        public string WheelVersion
        {
            get { return wheelVersion; }
            set
            {
                if (wheelVersion == value) return;
                ExiteValue<string> exiteValue = PreferencesDispatcher<string>.Instance.ExiteValue;
                exiteValue.oldValue = wheelVersion;
                exiteValue.newValue = value;

                wheelVersion = value;
                preferences.wheelVersion = wheelVersion;
                AddToAutoDelaySaveList(PreferencesField.wheelVersion, preferences.wheelVersion);
                PreferencesDispatcher<string>.Instance.Dispatch(PreferencesMsg.wheelVersion, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.wheelVersion);
            }
        }

        private long nextOpenWheelStampTime;


        public long NextOpenWheelStampTime
        {
            get { return nextOpenWheelStampTime; }
            set
            {
                if (nextOpenWheelStampTime == value) return;
                ExiteValue<long> exiteValue = PreferencesDispatcher<long>.Instance.ExiteValue;
                exiteValue.oldValue = nextOpenWheelStampTime;
                exiteValue.newValue = value;

                nextOpenWheelStampTime = value;
                preferences.nextOpenWheelStampTime = nextOpenWheelStampTime;
                AddToAutoDelaySaveList(PreferencesField.nextOpenWheelStampTime, preferences.nextOpenWheelStampTime);
                PreferencesDispatcher<long>.Instance.Dispatch(PreferencesMsg.nextOpenWheelStampTime, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.nextOpenWheelStampTime);
            }
        }

        private long openDailyBonusStampTime;


        public long OpenDailyBonusStampTime
        {
            get { return openDailyBonusStampTime; }
            set
            {
                if (openDailyBonusStampTime == value) return;
                ExiteValue<long> exiteValue = PreferencesDispatcher<long>.Instance.ExiteValue;
                exiteValue.oldValue = openDailyBonusStampTime;
                exiteValue.newValue = value;

                openDailyBonusStampTime = value;
                preferences.openDailyBonusStampTime = openDailyBonusStampTime;
                AddToAutoDelaySaveList(PreferencesField.openDailyBonusStampTime, preferences.openDailyBonusStampTime);
                PreferencesDispatcher<long>.Instance.Dispatch(PreferencesMsg.openDailyBonusStampTime, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.openDailyBonusStampTime);
            }
        }

        private long nextRecoveryTime;


        public long NextRecoveryTime
        {
            get { return nextRecoveryTime; }
            set
            {
                if (nextRecoveryTime == value) return;
                ExiteValue<long> exiteValue = PreferencesDispatcher<long>.Instance.ExiteValue;
                exiteValue.oldValue = nextRecoveryTime;
                exiteValue.newValue = value;

                nextRecoveryTime = value;
                preferences.nextRecoveryTime = nextRecoveryTime;
                AddToAutoDelaySaveList(PreferencesField.nextRecoveryTime, preferences.nextRecoveryTime);
                PreferencesDispatcher<long>.Instance.Dispatch(PreferencesMsg.nextRecoveryTime, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.nextRecoveryTime);
            }
        }

        private int cardBoardSum;


        public int CardBoardSum
        {
            get { return cardBoardSum; }
            set
            {
                if (cardBoardSum == value) return;
                ExiteValue<int> exiteValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                exiteValue.oldValue = cardBoardSum;
                exiteValue.newValue = value;

                cardBoardSum = value;
                preferences.cardBoardSum = cardBoardSum;
                AddToAutoDelaySaveList(PreferencesField.cardBoardSum, preferences.cardBoardSum);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.cardBoardSum, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.cardBoardSum);
            }
        }

        private bool isFirstSlot;


        public bool IsFirstSlot
        {
            get { return isFirstSlot; }
            set
            {
                if (isFirstSlot == value) return;
                ExiteValue<bool> exiteValue = PreferencesDispatcher<bool>.Instance.ExiteValue;
                exiteValue.oldValue = isFirstSlot;
                exiteValue.newValue = value;

                isFirstSlot = value;
                preferences.isFirstSlot = isFirstSlot;
                AddToAutoDelaySaveList(PreferencesField.isFirstSlot, preferences.isFirstSlot);
                PreferencesDispatcher<bool>.Instance.Dispatch(PreferencesMsg.isFirstSlot, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.isFirstSlot);
            }
        }

        private bool isFirstBox;


        public bool IsFirstBox
        {
            get { return isFirstBox; }
            set
            {
                if (isFirstBox == value) return;
                ExiteValue<bool> exiteValue = PreferencesDispatcher<bool>.Instance.ExiteValue;
                exiteValue.oldValue = isFirstBox;
                exiteValue.newValue = value;

                isFirstBox = value;
                preferences.isFirstBox = isFirstBox;
                AddToAutoDelaySaveList(PreferencesField.isFirstBox, preferences.isFirstBox);
                PreferencesDispatcher<bool>.Instance.Dispatch(PreferencesMsg.isFirstBox, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.isFirstBox);
            }
        }

        private bool isSecondEndShow;


        public bool IsSecondEndShow
        {
            get { return isSecondEndShow; }
            set
            {
                if (isSecondEndShow == value) return;
                ExiteValue<bool> exiteValue = PreferencesDispatcher<bool>.Instance.ExiteValue;
                exiteValue.oldValue = isSecondEndShow;
                exiteValue.newValue = value;

                isSecondEndShow = value;
                preferences.isSecondEndShow = isSecondEndShow;
                AddToAutoDelaySaveList(PreferencesField.isSecondEndShow, preferences.isSecondEndShow);
                PreferencesDispatcher<bool>.Instance.Dispatch(PreferencesMsg.isSecondEndShow, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.isSecondEndShow);
            }
        }

        private int sum777;


        public int Sum777
        {
            get { return sum777; }
            set
            {
                if (sum777 == value) return;
                ExiteValue<int> exiteValue = PreferencesDispatcher<int>.Instance.ExiteValue;
                exiteValue.oldValue = sum777;
                exiteValue.newValue = value;

                sum777 = value;
                preferences.sum777 = sum777;
                AddToAutoDelaySaveList(PreferencesField.sum777, preferences.sum777);
                PreferencesDispatcher<int>.Instance.Dispatch(PreferencesMsg.sum777, exiteValue);
                dataDispatcher.Dispatch(PreferencesMsg.sum777);
            }
        }

        #endregion

        #region RefType


        public List<bool> DailyTaskState
        {
            get
            {
                if (preferences.dailyTaskState == null) preferences.dailyTaskState = new List<bool>();
                return preferences.dailyTaskState;
            }
        }

        public void SaveDailyTaskState()
        {
            AddToAutoDelaySaveList(PreferencesField.dailyTaskState, DailyTaskState);
            PreferencesDispatcher<object>.Instance.Dispatch(PreferencesMsg.dailyTaskState);
            dataDispatcher.Dispatch(PreferencesMsg.dailyTaskState);
        }


        public List<bool> DailyTaskActiveState
        {
            get
            {
                if (preferences.dailyTaskActiveState == null) preferences.dailyTaskActiveState = new List<bool>();
                return preferences.dailyTaskActiveState;
            }
        }

        public void SaveDailyTaskActiveState()
        {
            AddToAutoDelaySaveList(PreferencesField.dailyTaskActiveState, DailyTaskActiveState);
            PreferencesDispatcher<object>.Instance.Dispatch(PreferencesMsg.dailyTaskActiveState);
            dataDispatcher.Dispatch(PreferencesMsg.dailyTaskActiveState);
        }


        public List<Task> ActiveMissions
        {
            get
            {
                if (preferences.activeMissions == null) preferences.activeMissions = new List<Task>();
                return preferences.activeMissions;
            }
        }

        public void SaveActiveMissions()
        {
            AddToAutoDelaySaveList(PreferencesField.activeMissions, ActiveMissions);
            PreferencesDispatcher<object>.Instance.Dispatch(PreferencesMsg.activeMissions);
            dataDispatcher.Dispatch(PreferencesMsg.activeMissions);
        }


        public List<int> FinishTaskList
        {
            get
            {
                if (preferences.finishTaskList == null) preferences.finishTaskList = new List<int>();
                return preferences.finishTaskList;
            }
        }

        public void SaveFinishTaskList()
        {
            AddToAutoDelaySaveList(PreferencesField.finishTaskList, FinishTaskList);
            PreferencesDispatcher<object>.Instance.Dispatch(PreferencesMsg.finishTaskList);
            dataDispatcher.Dispatch(PreferencesMsg.finishTaskList);
        }

        public List<int> CompleteGuideList
        {
            get
            {
                if (preferences.completeGuideList == null) preferences.completeGuideList = new List<int>();
                return preferences.completeGuideList;
            }
        }

        public void SaveCompleteGuideList()
        {
            AddToAutoDelaySaveList(PreferencesField.completeGuideList, CompleteGuideList);
            PreferencesDispatcher<object>.Instance.Dispatch(PreferencesMsg.completeGuideList);
            dataDispatcher.Dispatch(PreferencesMsg.completeGuideList);
        }

        public List<int> WithdrawGear
        {
            get
            {
                if (preferences.withdrawGear == null) preferences.withdrawGear = new List<int>();
                return preferences.withdrawGear;
            }
        }

        public void SaveWithdrawGear()
        {
            AddToAutoDelaySaveList(PreferencesField.withdrawGear, WithdrawGear);
            PreferencesDispatcher<object>.Instance.Dispatch(PreferencesMsg.withdrawGear);
            dataDispatcher.Dispatch(PreferencesMsg.withdrawGear);
        }


        public List<float> FerrWheelLst
        {
            get
            {
                if (preferences.ferrWheelLst == null) preferences.ferrWheelLst = new List<float>();
                return preferences.ferrWheelLst;
            }
        }

        public void SaveFerrWheelLst()
        {
            AddToAutoDelaySaveList(PreferencesField.ferrWheelLst, FerrWheelLst);
            PreferencesDispatcher<object>.Instance.Dispatch(PreferencesMsg.ferrWheelLst);
            dataDispatcher.Dispatch(PreferencesMsg.ferrWheelLst);
        }


        public List<float> VidelWheelLst
        {
            get
            {
                if (preferences.videlWheelLst == null) preferences.videlWheelLst = new List<float>();
                return preferences.videlWheelLst;
            }
        }

        public void SaveVidelWheelLst()
        {
            AddToAutoDelaySaveList(PreferencesField.videlWheelLst, VidelWheelLst);
            PreferencesDispatcher<object>.Instance.Dispatch(PreferencesMsg.videlWheelLst);
            dataDispatcher.Dispatch(PreferencesMsg.videlWheelLst);
        }

        public Dictionary<string, bool> StatisticDictionary
        {
            get
            {
                if (preferences.statisticDictionary == null)
                    preferences.statisticDictionary = new Dictionary<string, bool>();
                return preferences.statisticDictionary;
            }
        }

        public void SaveStatisticDictionary()
        {
            AddToAutoDelaySaveList(PreferencesField.statisticDictionary, StatisticDictionary);
            PreferencesDispatcher<object>.Instance.Dispatch(PreferencesMsg.statisticDictionary);
            dataDispatcher.Dispatch(PreferencesMsg.statisticDictionary);
        }

        public Dictionary<int, bool> StatisticMakeupDictionary
        {
            get
            {
                if (preferences.statisticMakeupDictionary == null)
                    preferences.statisticMakeupDictionary = new Dictionary<int, bool>();
                return preferences.statisticMakeupDictionary;
            }
        }

        public void SaveStatisticMakeupDictionary()
        {
            AddToAutoDelaySaveList(PreferencesField.statisticMakeupDictionary, StatisticMakeupDictionary);
            PreferencesDispatcher<object>.Instance.Dispatch(PreferencesMsg.statisticMakeupDictionary);
            dataDispatcher.Dispatch(PreferencesMsg.statisticMakeupDictionary);
        }

        public List<int> StatisticCashTarget
        {
            get
            {
                if (preferences.statisticCashTarget == null) preferences.statisticCashTarget = new List<int>();
                return preferences.statisticCashTarget;
            }
        }

        public void SaveStatisticCashTarget()
        {
            AddToAutoDelaySaveList(PreferencesField.statisticCashTarget, StatisticCashTarget);
            PreferencesDispatcher<object>.Instance.Dispatch(PreferencesMsg.statisticCashTarget);
            dataDispatcher.Dispatch(PreferencesMsg.statisticCashTarget);
        }


        public Dictionary<long, int> BankDic
        {
            get
            {
                if (preferences.bankDic == null) preferences.bankDic = new Dictionary<long, int>();
                return preferences.bankDic;
            }
        }

        public void SaveBankDic()
        {
            AddToAutoDelaySaveList(PreferencesField.bankDic, BankDic);
            PreferencesDispatcher<object>.Instance.Dispatch(PreferencesMsg.bankDic);
            dataDispatcher.Dispatch(PreferencesMsg.bankDic);
        }


        public List<DailyBonusItem> DailyBonusItemLst
        {
            get
            {
                if (preferences.dailyBonusItemLst == null) preferences.dailyBonusItemLst = new List<DailyBonusItem>();
                return preferences.dailyBonusItemLst;
            }
        }

        public void SaveDailyBonusItemLst()
        {
            AddToAutoDelaySaveList(PreferencesField.dailyBonusItemLst, DailyBonusItemLst);
            PreferencesDispatcher<object>.Instance.Dispatch(PreferencesMsg.dailyBonusItemLst);
            dataDispatcher.Dispatch(PreferencesMsg.dailyBonusItemLst);
        }

        #endregion
    }
}