modifiedMM/MultipleMaids/CM3D2/MultipleMaids/Plugin/MultipleMaids.Update.cs

using ExIni;
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using UnityEngine;
using UnityEngine.PostProcessing;
using UnityEngine.Rendering;
using Object = UnityEngine.Object;
using Util;

namespace CM3D2.MultipleMaids.Plugin
{
    public partial class MultipleMaids
    {
        public void Update()
        {
            if (!isInit)
            {
                return;
            }

            if (bGui)
            {
                if (Input.mouseScrollDelta.y != 0f)
                {
                    if (rectWin.Contains(Event.current.mousePosition))
                    {
                        GameMain.Instance.MainCamera.SetControl(false);
                        Input.ResetInputAxes();
                    }
                }

            }

            if (allowUpdate)
            {
                MaidUpdate();
                if (isFadeOut)
                {
                    bool flag = false;
                    for (int index = 0; index < maxMaidCnt; ++index)
                    {
                        if (maidArray[index] && maidArray[index].Visible && maidArray[index].IsAllProcPropBusy)
                        {
                            flag = true;
                        }
                    }

                    if (!flag)
                    {
                        if (!isBusyInit)
                        {
                            isBusyInit = true;
                        }
                        else
                        {
                            for (int index1 = 0; index1 < maxMaidCnt; ++index1)
                            {
                                if (!isLock[index1] && maidArray[index1] != null)
                                {
                                    maidArray[index1].CrossFade(poseArray[0] + ".anm", false, true, false, 0.0f, 1f);
                                    maidArray[index1].SetAutoTwistAll(true);
                                }

                                poseCount[index1] = 30;
                                if (maidArray[index1] && maidArray[index1].Visible)
                                {
                                    maidArray[index1].body0.BoneHitHeightY = -10f;
                                    if (selectList.Count > index1 && goSlot[(int)selectList[index1]] == null)
                                    {
                                        maidArray[index1].CrossFade(poseArray[0] + ".anm", false, true, false, 0.0f, 1f);
                                        maidArray[index1].SetAutoTwistAll(true);
                                        goSlot[(int)selectList[index1]] =
                                                new List<TBodySkin>(maidArray[index1].body0.goSlot);
                                        bodyHit[(int)selectList[index1]] = new List<TBodyHit>();
                                        for (int index2 = 0; index2 < goSlot[(int)selectList[index1]].Count; ++index2)
                                        {
                                            TBodyHit tbodyHit = new TBodyHit();
                                            TBodyHit bodyhit = maidArray[index1].body0.goSlot[index2].bonehair.bodyhit;
                                            if (bodyhit != null)
                                            {
                                                tbodyHit.spherelist = new List<THitSphere>(bodyhit.spherelist);
                                                tbodyHit.m_listHandHitL =
                                                        new List<THitSphere>(bodyhit.m_listHandHitL);
                                                tbodyHit.m_listHandHitR =
                                                        new List<THitSphere>(bodyhit.m_listHandHitR);
                                                tbodyHit.RotOffset = bodyhit.RotOffset;
                                                tbodyHit.tRoot = bodyhit.tRoot;
                                                tbodyHit.skrt_R1 = bodyhit.skrt_R1;
                                                tbodyHit.skrt_R2 = bodyhit.skrt_R2;
                                                tbodyHit.skrt_R3 = bodyhit.skrt_R3;
                                                tbodyHit.skrt_L1 = bodyhit.skrt_L1;
                                                tbodyHit.skrt_L2 = bodyhit.skrt_L2;
                                                tbodyHit.skrt_L3 = bodyhit.skrt_L3;
                                                tbodyHit.MOMO_FUTO = bodyhit.MOMO_FUTO;
                                                tbodyHit.HARA_FUTO = bodyhit.HARA_FUTO;
                                                tbodyHit.KOSHI_SCL = bodyhit.KOSHI_SCL;
                                                tbodyHit.KOSHI_SVAL = bodyhit.KOSHI_SVAL;
                                                tbodyHit.BodySkinTAG = bodyhit.BodySkinTAG;
                                                tbodyHit.SkirtFT = bodyhit.SkirtFT;
                                                tbodyHit.MST = bodyhit.MST;
                                                tbodyHit.MST_v = bodyhit.MST_v;
                                            }

                                            bodyHit[(int)selectList[index1]].Add(tbodyHit);
                                        }

                                        if (!isVR)
                                        {
                                            try
                                            {
                                                shodaiFlg[(int)selectList[index1]] = false;
                                                TMorph morph = maidArray[index1].body0.Face.morph;
                                                float num =
                                                        GetFieldValue<TMorph, float[]>(morph, "BlendValues")
                                                                [(int)morph.hash["tangopen"]];
                                            }
                                            catch
                                            {
                                                shodaiFlg[(int)selectList[index1]] = true;
                                            }

                                            if (!isVR)
                                            {
                                                eyeL[(int)selectList[index1]] = maidArray[index1].body0.quaDefEyeL.eulerAngles;
                                                eyeR[(int)selectList[index1]] = maidArray[index1].body0.quaDefEyeR.eulerAngles;
                                            }
                                        }

                                        if (isKamiyure)
                                        {
                                            for (int index2 = 0; index2 < maidArray[index1].body0.goSlot.Count; ++index2)
                                            {
                                                if (index2 >= 3 && index2 <= 6
                                                                && maidArray[index1].body0.goSlot[index2].obj != null)
                                                {
                                                    DynamicBone component = maidArray[index1]
                                                                            .body0.goSlot[index2].obj.GetComponent<DynamicBone>();
                                                    if (component != null)
                                                    {
                                                        component.m_Damping = kamiyure2;
                                                        component.m_Elasticity = kamiyure3;
                                                        if (index2 == 5)
                                                        {
                                                            component.m_Elasticity = kamiyure3 / 20f;
                                                        }

                                                        component.m_Radius = kamiyure4;
                                                        component.UpdateParameters();
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }

                            isBusyInit = false;
                            GameMain.Instance.MainCamera.FadeIn(1f, false, null, true, true, new Color());
                            isFadeOut = false;
                            bGui = true;
                        }
                    }
                }
            }

            if (isVR && isVRScroll && !getModKeyPressing(modKey.Ctrl) && !getModKeyPressing(modKey.Alt)
                                                                            && !Input.GetKey(KeyCode.Space) && !Input.GetKey(KeyCode.Z)
                                                                            && !Input.GetKey(KeyCode.X) && !Input.GetKey(KeyCode.W)
                                                                                                         && !Input.GetKey(KeyCode.Q)
                                                                                                             && !Input.GetKey(KeyCode.R)
                                                                            && !Input.GetKey(KeyCode.E) && !Input.GetKey(KeyCode.Y)
                                                                                                         && !Input.GetKey(KeyCode.V)
                                                                                                             && !Input.GetKey(KeyCode.C)
                                                                                                         && !Input.GetKey(KeyCode.D)
                                                                            && !Input.GetKey(KeyCode.S))
            {
                string VRCamera;
                GameMain.VRFamilyType VRFamily = GameMain.Instance.VRFamily;
                if (VRFamily == GameMain.VRFamilyType.Oculus) VRCamera = "TrackingSpace/CenterEyeAnchor";
                else if (VRFamily == GameMain.VRFamilyType.FOVE) VRCamera = "Fove Interface";
                else VRCamera = "Main Camera (eye)"; // implies VRFamilyType.HTC and VRFamilyType.NON

                Vector3 maid = GetFieldValue<OvrCamera, Vector3>(GameMain.Instance.OvrMgr.OvrCamera, "v")
                               + UTY.GetChildObject(mainCamera.gameObject, VRCamera, false).transform.rotation
                               * Vector3.forward
                               * (Input.GetAxis("Mouse ScrollWheel") * (float)(5.0 * Time.deltaTime * 2.0 * 5.0));
                SetFieldValue3<OvrCamera, Vector3>(GameMain.Instance.OvrMgr.OvrCamera, "v", maid);
                Transform fieldValue = GetFieldValue<OvrCamera, Transform>(GameMain.Instance.OvrMgr.OvrCamera, "m_trBaseHead");
                fieldValue.position = maid;
                SetFieldValue4<OvrCamera, Transform>(GameMain.Instance.OvrMgr.OvrCamera, "m_trBaseHead", fieldValue);
            }

            if (isMekure1a || isMekure2a || isZurasia)
            {
                mekureCount = 10;
                for (int index = 0; index < maidCnt; ++index)
                {
                    if (maidArray[index] && maidArray[index].Visible)
                    {
                        if (isMekure1a)
                        {
                            if (isMekure1)
                            {
                                maidArray[index].ItemChangeTemp("skirt", "めくれスカート");
                                maidArray[index].ItemChangeTemp("onepiece", "めくれスカート");
                            }
                            else
                            {
                                ResetProp(maidArray[index], MPN.skirt);
                                ResetProp(maidArray[index], MPN.onepiece);
                            }

                            maidArray[index].AllProcPropSeqStart();
                        }

                        if (isMekure2a)
                        {
                            if (isMekure2)
                            {
                                maidArray[index].ItemChangeTemp("skirt", "めくれスカート後ろ");
                                maidArray[index].ItemChangeTemp("onepiece", "めくれスカート後ろ");
                            }
                            else
                            {
                                ResetProp(maidArray[index], MPN.skirt);
                                ResetProp(maidArray[index], MPN.onepiece);
                            }

                            maidArray[index].AllProcPropSeqStart();
                        }

                        if (isZurasia)
                        {
                            if (isZurasi)
                            {
                                maidArray[index].ItemChangeTemp("panz", "パンツずらし");
                                maidArray[index].ItemChangeTemp("mizugi", "パンツずらし");
                            }
                            else
                            {
                                ResetProp(maidArray[index], MPN.panz);
                                ResetProp(maidArray[index], MPN.mizugi);
                            }

                            maidArray[index].AllProcPropSeqStart();
                        }
                    }
                }

                isMekure1a = false;
                isMekure2a = false;
                isZurasia = false;
            }

            if (mekureCount > 0)
            {
                --mekureCount;
                for (int index1 = 0; index1 < maidCnt; ++index1)
                {
                    if (maidArray[index1] && maidArray[index1].Visible && goSlot[(int)selectList[index1]] != null)
                    {
                        maidArray[index1].body0.goSlot = new List<TBodySkin>(goSlot[(int)selectList[index1]]);
                        for (int index2 = 0; index2 < bodyHit[(int)selectList[index1]].Count; ++index2)
                        {
                            maidArray[index1].body0.goSlot[index2].bonehair.bodyhit = bodyHit[(int)selectList[index1]][index2];
                        }
                    }
                }
            }

            if (isKamiyure)
            {
                int num = maidCnt;
                if (num == 0)
                {
                    num = 3;
                }

                for (int index1 = 0; index1 < num; ++index1)
                {
                    if (maidArray[index1] && maidArray[index1].Visible)
                    {
                        Maid maid = maidArray[index1];
                        for (int index2 = 0; index2 < maid.body0.goSlot.Count; ++index2)
                        {
                            if (index2 >= 3 && index2 <= 6 && maid.body0.goSlot[index2].obj != null)
                            {
                                DynamicBone component = maid.body0.goSlot[index2].obj.GetComponent<DynamicBone>();
                                if (component != null
                                    && (component.m_Damping != (double)kamiyure2
                                        || component.m_Elasticity != (double)kamiyure3
                                        || component.m_Radius != (double)kamiyure4)
                                    && (index2 != 5 || component.m_Damping != (double)kamiyure2
                                                        || component.m_Elasticity != kamiyure3 / 20.0
                                                        || component.m_Radius != (double)kamiyure4))
                                {
                                    component.m_Damping = kamiyure2;
                                    component.m_Elasticity = kamiyure3;
                                    if (index2 == 5)
                                    {
                                        component.m_Elasticity = kamiyure3 / 20f;
                                    }

                                    component.m_Radius = kamiyure4;
                                    component.UpdateParameters();
                                }
                            }
                        }
                    }
                }
            }

            if (isSkirtyure)
            {
                int num = maidCnt;
                if (num == 0)
                {
                    num = 3;
                }

                for (int index1 = 0; index1 < num; ++index1)
                {
                    if (maidArray[index1] && maidArray[index1].Visible)
                    {
                        for (int index2 = 0; index2 < maidArray[index1].body0.goSlot.Count; ++index2)
                        {
                            if (maidArray[index1].body0.goSlot[index2].obj != null)
                            {
                                DynamicSkirtBone fieldValue =
                                        GetFieldValue<BoneHair3, DynamicSkirtBone>(maidArray[index1].body0.goSlot[index2].bonehair3,
                                                                                   "m_SkirtBone");
                                if (fieldValue != null)
                                {
                                    fieldValue.m_vGravity = new Vector3(0.5f, 0.5f, 0.5f);
                                    if (fieldValue.m_fPanierForce != (double)skirtyure3
                                        || fieldValue.m_fPanierForceDistanceThreshold != (double)skirtyure2
                                        || fieldValue.m_fRegDefaultRadius != (double)skirtyure4)
                                    {
                                        fieldValue.m_fPanierForce = skirtyure3;
                                        fieldValue.m_fPanierForceDistanceThreshold = skirtyure2;
                                        fieldValue.m_fRegDefaultRadius = skirtyure4;
                                    }
                                }
                            }
                        }
                    }
                }
            }

            if ((!Input.GetKey(KeyCode.KeypadEnter) && Input.GetKeyDown(KeyCode.Keypad1)
                 || Input.GetKeyDown(KeyCode.Keypad2) || Input.GetKeyDown(KeyCode.Keypad3)
                 || Input.GetKeyDown(KeyCode.Keypad4) || Input.GetKeyDown(KeyCode.Keypad5)
                                                       || Input.GetKeyDown(KeyCode.Keypad6) || Input.GetKeyDown(KeyCode.Keypad7)
                 || Input.GetKeyDown(KeyCode.Keypad8) || Input.GetKeyDown(KeyCode.Keypad9)
                                                       || Input.GetKeyDown(KeyCode.Keypad0) || Input.GetKeyDown(KeyCode.KeypadDivide)
                                                       || Input.GetKeyDown(KeyCode.KeypadMultiply)
                 || Input.GetKeyDown(KeyCode.KeypadMinus)) && (Input.GetKey(KeyCode.H) || isVR))
            {
                if (Input.GetKeyDown(KeyCode.Keypad1))
                {
                    isWear = !isWear;
                }

                if (Input.GetKeyDown(KeyCode.Keypad2))
                {
                    isSkirt = !isSkirt;
                }

                if (Input.GetKeyDown(KeyCode.Keypad3))
                {
                    isBra = !isBra;
                }

                if (Input.GetKeyDown(KeyCode.Keypad4))
                {
                    isPanz = !isPanz;
                }

                if (Input.GetKeyDown(KeyCode.Keypad5))
                {
                    isHeadset = !isHeadset;
                }

                if (Input.GetKeyDown(KeyCode.Keypad6))
                {
                    isAccUde = !isAccUde;
                }

                if (Input.GetKeyDown(KeyCode.Keypad7))
                {
                    isGlove = !isGlove;
                }

                if (Input.GetKeyDown(KeyCode.Keypad8))
                {
                    isStkg = !isStkg;
                }

                if (Input.GetKeyDown(KeyCode.Keypad9))
                {
                    isShoes = !isShoes;
                }

                if (Input.GetKeyDown(KeyCode.Keypad0))
                {
                    isAccSenaka = !isAccSenaka;
                }

                if (Input.GetKeyDown(KeyCode.KeypadDivide))
                {
                    isMekure1 = !isMekure1;
                }

                if (Input.GetKeyDown(KeyCode.KeypadMultiply))
                {
                    isMekure2 = !isMekure2;
                }

                if (Input.GetKeyDown(KeyCode.KeypadMinus))
                {
                    isZurasi = !isZurasi;
                }

                h2Flg = true;
                if (sceneLevel != 3 && sceneLevel != 5)
                {
                    maidArray[0] = GameMain.Instance.CharacterMgr.GetMaid(0);
                    maidArray[1] = GameMain.Instance.CharacterMgr.GetMaid(1);
                    maidArray[2] = GameMain.Instance.CharacterMgr.GetMaid(2);
                    maidArray[3] = GameMain.Instance.CharacterMgr.GetMaid(3);
                    maidCnt = 4;
                }

                for (int index1 = 0; index1 < maidCnt; ++index1)
                {
                    if (maidArray[index1] && maidArray[index1].Visible)
                    {
                        if (Input.GetKeyDown(KeyCode.KeypadDivide) || Input.GetKeyDown(KeyCode.KeypadMultiply)
                                                                   || Input.GetKeyDown(KeyCode.KeypadMinus))
                        {
                            if (sceneLevel == 3 || sceneLevel == 5)
                            {
                                if (!isVR && goSlot[(int)selectList[index1]] != null)
                                {
                                    maidArray[index1].body0.goSlot =
                                            new List<TBodySkin>(goSlot[(int)selectList[index1]]);
                                    for (int index2 = 0; index2 < bodyHit[(int)selectList[index1]].Count; ++index2)
                                    {
                                        maidArray[index1].body0.goSlot[index2].bonehair.bodyhit = bodyHit[(int)selectList[index1]][index2];
                                    }
                                }

                                if (Input.GetKeyDown(KeyCode.KeypadDivide))
                                {
                                    isMekure1a = true;
                                }

                                if (Input.GetKeyDown(KeyCode.KeypadMultiply))
                                {
                                    isMekure2a = true;
                                }

                                if (Input.GetKeyDown(KeyCode.KeypadMinus))
                                {
                                    isZurasia = true;
                                }
                            }
                            else
                            {
                                if (Input.GetKeyDown(KeyCode.KeypadDivide))
                                {
                                    if (isMekure1)
                                    {
                                        maidArray[index1].ItemChangeTemp("skirt", "めくれスカート");
                                        maidArray[index1].ItemChangeTemp("onepiece", "めくれスカート");
                                    }
                                    else
                                    {
                                        ResetProp(maidArray[index1], MPN.skirt);
                                        ResetProp(maidArray[index1], MPN.onepiece);
                                    }

                                    maidArray[index1].AllProcPropSeqStart();
                                }

                                if (Input.GetKeyDown(KeyCode.KeypadMultiply))
                                {
                                    if (isMekure2)
                                    {
                                        maidArray[index1].ItemChangeTemp("skirt", "めくれスカート後ろ");
                                        maidArray[index1].ItemChangeTemp("onepiece", "めくれスカート後ろ");
                                    }
                                    else
                                    {
                                        ResetProp(maidArray[index1], MPN.skirt);
                                        ResetProp(maidArray[index1], MPN.onepiece);
                                    }

                                    maidArray[index1].AllProcPropSeqStart();
                                }

                                if (Input.GetKeyDown(KeyCode.KeypadMinus))
                                {
                                    if (isZurasi)
                                    {
                                        maidArray[index1].ItemChangeTemp("panz", "パンツずらし");
                                        maidArray[index1].ItemChangeTemp("mizugi", "パンツずらし");
                                    }
                                    else
                                    {
                                        ResetProp(maidArray[index1], MPN.panz);
                                        ResetProp(maidArray[index1], MPN.mizugi);
                                    }

                                    maidArray[index1].AllProcPropSeqStart();
                                }
                            }
                        }
                        else
                        {
                            Hashtable fieldValue = GetFieldValue<TBody, Hashtable>(maidArray[index1].body0, "m_hFoceHide");
                            if (Input.GetKeyDown(KeyCode.Keypad1))
                            {
                                fieldValue[TBody.SlotID.wear] = isWear;
                                fieldValue[TBody.SlotID.onepiece] = isWear;
                                fieldValue[TBody.SlotID.mizugi] = isWear;
                            }

                            if (Input.GetKeyDown(KeyCode.Keypad2))
                            {
                                fieldValue[TBody.SlotID.skirt] = isSkirt;
                            }

                            if (Input.GetKeyDown(KeyCode.Keypad3))
                            {
                                fieldValue[TBody.SlotID.bra] = isBra;
                            }

                            if (Input.GetKeyDown(KeyCode.Keypad4))
                            {
                                fieldValue[TBody.SlotID.panz] = isPanz;
                            }

                            if (Input.GetKeyDown(KeyCode.Keypad5))
                            {
                                fieldValue[TBody.SlotID.headset] = isHeadset;
                                fieldValue[TBody.SlotID.accHat] = isHeadset;
                            }

                            if (Input.GetKeyDown(KeyCode.Keypad6))
                            {
                                fieldValue[TBody.SlotID.accUde] = isAccUde;
                            }

                            if (Input.GetKeyDown(KeyCode.Keypad7))
                            {
                                fieldValue[TBody.SlotID.glove] = isGlove;
                            }

                            if (Input.GetKeyDown(KeyCode.Keypad8))
                            {
                                fieldValue[TBody.SlotID.stkg] = isStkg;
                            }

                            if (Input.GetKeyDown(KeyCode.Keypad9))
                            {
                                fieldValue[TBody.SlotID.shoes] = isShoes;
                            }

                            if (Input.GetKeyDown(KeyCode.Keypad0))
                            {
                                fieldValue[TBody.SlotID.accSenaka] = isAccSenaka;
                            }

                            SetFieldValue6<TBody, Hashtable>(maidArray[index1].body0, "m_hFoceHide", fieldValue);
                            maidArray[index1].body0.FixMaskFlag();
                            maidArray[index1].body0.FixVisibleFlag(false);
                        }
                    }
                }
            }

            Vector3 vector3_1;
            Quaternion rotation;
            if (!yotogiFlg && (sceneLevel == 14 || sceneLevel == 24))
            {
                Maid maid = maidArray[0];
                Vector3 vector3_2 = mainCameraTransform.TransformDirection(Vector3.forward);
                Vector3 vector3_3 = mainCameraTransform.TransformDirection(Vector3.right);
                vector3_1 = mainCameraTransform.TransformDirection(Vector3.up);
                if (Input.GetKeyDown(KeyCode.LeftBracket) || Input.GetKeyDown(KeyCode.BackQuote) && getModKeyPressing(modKey.Alt))
                {
                    for (int index = 0; index < 10; ++index)
                    {
                        Transform transform1 = maid.transform;
                        Vector3 position1 = maid.transform.position;
                        Vector3 right = Vector3.right;
                        rotation = maid.transform.rotation;
                        double num1 = -rotation.eulerAngles.x;
                        transform1.RotateAround(position1, right, (float)num1);
                        Transform transform2 = maid.transform;
                        Vector3 position2 = maid.transform.position;
                        Vector3 forward = Vector3.forward;
                        rotation = maid.transform.rotation;
                        double num2 = -rotation.eulerAngles.z;
                        transform2.RotateAround(position2, forward, (float)num2);
                    }
                }
                else if (Input.GetKey(KeyCode.Minus) && getModKeyPressing(modKey.Shift)
                         || Input.GetKey(KeyCode.I) && getModKeyPressing(modKey.Alt))
                {
                    maid.transform.RotateAround(maid.transform.position, new Vector3(vector3_3.x, 0.0f, vector3_3.z), 0.4f);
                }
                else if (Input.GetKey(KeyCode.Quote) && getModKeyPressing(modKey.Shift)
                         || Input.GetKey(KeyCode.K) && getModKeyPressing(modKey.Alt))
                {
                    maid.transform.RotateAround(maid.transform.position, new Vector3(vector3_3.x, 0.0f, vector3_3.z), -0.4f);
                }
                else if (Input.GetKey(KeyCode.Minus) || Input.GetKey(KeyCode.J) && getModKeyPressing(modKey.Alt))
                {
                    maid.transform.RotateAround(maid.transform.position, new Vector3(vector3_2.x, 0.0f, vector3_2.z), 0.4f);
                }
                else if (Input.GetKey(KeyCode.Quote) || Input.GetKey(KeyCode.L) && getModKeyPressing(modKey.Alt))
                {
                    maid.transform.RotateAround(maid.transform.position, new Vector3(vector3_2.x, 0.0f, vector3_2.z), -0.4f);
                }

                if (Input.GetKeyUp(KeyCode.H) && !hFlg)
                {
                    if (h2Flg)
                    {
                        h2Flg = false;
                    }
                    else
                    {
                        if (isVR)
                        {
                            isF6 = true;
                        }

                        if (!maidArray[0])
                        {
                            maidArray[0] = GameMain.Instance.CharacterMgr.GetMaid(0);
                        }

                        string str = "";
                        if (wearIndex == 0)
                        {
                            str = "Underwear";
                            wearIndex = 1;
                            isWear = false;
                            isSkirt = false;
                            isBra = true;
                            isPanz = true;
                            isHeadset = false;
                            isGlove = false;
                            isStkg = true;
                            isShoes = false;
                        }
                        else if (wearIndex == 1)
                        {
                            str = "Nude";
                            wearIndex = 2;
                            isWear = false;
                            isSkirt = false;
                            isBra = false;
                            isPanz = false;
                            isHeadset = false;
                            isGlove = false;
                            isStkg = false;
                            isShoes = false;
                        }
                        else if (wearIndex == 2)
                        {
                            str = "None";
                            wearIndex = 0;
                            isWear = true;
                            isSkirt = true;
                            isBra = true;
                            isPanz = true;
                            isHeadset = true;
                            isGlove = true;
                            isStkg = true;
                            isShoes = true;
                        }

                        TBody.MaskMode f_eMode = (TBody.MaskMode)Enum.Parse(typeof(TBody.MaskMode), str);
                        for (int index1 = 0; index1 < maidCnt; ++index1)
                        {
                            if (maidArray[index1] && maidArray[index1].Visible)
                            {
                                if (!isVR && goSlot[(int)selectList[index1]] != null)
                                {
                                    maidArray[index1].body0.goSlot =
                                            new List<TBodySkin>(goSlot[(int)selectList[index1]]);
                                    for (int index2 = 0; index2 < bodyHit[(int)selectList[index1]].Count; ++index2)
                                    {
                                        maidArray[index1].body0.goSlot[index2].bonehair.bodyhit = bodyHit[(int)selectList[index1]][index2];
                                    }
                                }

                                maidArray[index1].body0.SetMaskMode(f_eMode);
                            }
                        }
                    }
                }
            }

            if (isVR)
            {
                if (Input.GetKey(KeyCode.F7) && Input.GetKeyDown(KeyCode.Alpha1))
                {
                    string bgName = GameMain.Instance.BgMgr.GetBGName();
                    int num = 0;
                    foreach (string bg in bgArray)
                    {
                        if (bg == bgName)
                        {
                            bgIndex = num;
                            bgIndex6 = num;
                            break;
                        }

                        ++num;
                    }

                    lightX[0] = GameMain.Instance.MainLight.transform.eulerAngles.x;
                    lightY[0] = GameMain.Instance.MainLight.transform.eulerAngles.y;
                    lightX6 = lightX[0];
                    lightY6 = lightY[0];
                    loadScene = 10000;
                    kankyoLoadFlg = true;
                    GameMain.Instance.SoundMgr.PlaySe("se002.ogg", false);
                }

                if (Input.GetKey(KeyCode.F7) && Input.GetKeyDown(KeyCode.Alpha2))
                {
                    string bgName = GameMain.Instance.BgMgr.GetBGName();
                    int num = 0;
                    foreach (string bg in bgArray)
                    {
                        if (bg == bgName)
                        {
                            bgIndex = num;
                            bgIndex6 = num;
                            break;
                        }

                        ++num;
                    }

                    lightX[0] = GameMain.Instance.MainLight.transform.eulerAngles.x;
                    lightY[0] = GameMain.Instance.MainLight.transform.eulerAngles.y;
                    lightX6 = lightX[0];
                    lightY6 = lightY[0];
                    loadScene = 10001;
                    kankyoLoadFlg = true;
                    GameMain.Instance.SoundMgr.PlaySe("se002.ogg", false);
                }

                if (Input.GetKey(KeyCode.F7) && Input.GetKeyDown(KeyCode.Alpha3))
                {
                    string bgName = GameMain.Instance.BgMgr.GetBGName();
                    int num = 0;
                    foreach (string bg in bgArray)
                    {
                        if (bg == bgName)
                        {
                            bgIndex = num;
                            bgIndex6 = num;
                            break;
                        }

                        ++num;
                    }

                    lightX[0] = GameMain.Instance.MainLight.transform.eulerAngles.x;
                    lightY[0] = GameMain.Instance.MainLight.transform.eulerAngles.y;
                    lightX6 = lightX[0];
                    lightY6 = lightY[0];
                    loadScene = 10002;
                    kankyoLoadFlg = true;
                    GameMain.Instance.SoundMgr.PlaySe("se002.ogg", false);
                }

                if (Input.GetKey(KeyCode.F7) && Input.GetKeyDown(KeyCode.Alpha4))
                {
                    string bgName = GameMain.Instance.BgMgr.GetBGName();
                    int num = 0;
                    foreach (string bg in bgArray)
                    {
                        if (bg == bgName)
                        {
                            bgIndex = num;
                            bgIndex6 = num;
                            break;
                        }

                        ++num;
                    }

                    lightX[0] = GameMain.Instance.MainLight.transform.eulerAngles.x;
                    lightY[0] = GameMain.Instance.MainLight.transform.eulerAngles.y;
                    lightX6 = lightX[0];
                    lightY6 = lightY[0];
                    loadScene = 10003;
                    kankyoLoadFlg = true;
                    GameMain.Instance.SoundMgr.PlaySe("se002.ogg", false);
                }

                if (Input.GetKey(KeyCode.F7) && Input.GetKeyDown(KeyCode.Alpha5))
                {
                    string bgName = GameMain.Instance.BgMgr.GetBGName();
                    int num = 0;
                    foreach (string bg in bgArray)
                    {
                        if (bg == bgName)
                        {
                            bgIndex = num;
                            bgIndex6 = num;
                            break;
                        }

                        ++num;
                    }

                    lightX[0] = GameMain.Instance.MainLight.transform.eulerAngles.x;
                    lightY[0] = GameMain.Instance.MainLight.transform.eulerAngles.y;
                    lightX6 = lightX[0];
                    lightY6 = lightY[0];
                    loadScene = 10004;
                    kankyoLoadFlg = true;
                    GameMain.Instance.SoundMgr.PlaySe("se002.ogg", false);
                }

                if (Input.GetKey(KeyCode.F7) && Input.GetKeyDown(KeyCode.Alpha6))
                {
                    string bgName = GameMain.Instance.BgMgr.GetBGName();
                    int num = 0;
                    foreach (string bg in bgArray)
                    {
                        if (bg == bgName)
                        {
                            bgIndex = num;
                            bgIndex6 = num;
                            break;
                        }

                        ++num;
                    }

                    lightX[0] = GameMain.Instance.MainLight.transform.eulerAngles.x;
                    lightY[0] = GameMain.Instance.MainLight.transform.eulerAngles.y;
                    lightX6 = lightX[0];
                    lightY6 = lightY[0];
                    loadScene = 10005;
                    kankyoLoadFlg = true;
                    GameMain.Instance.SoundMgr.PlaySe("se002.ogg", false);
                }

                if (Input.GetKey(KeyCode.F7) && Input.GetKeyDown(KeyCode.Alpha7))
                {
                    string bgName = GameMain.Instance.BgMgr.GetBGName();
                    int num = 0;
                    foreach (string bg in bgArray)
                    {
                        if (bg == bgName)
                        {
                            bgIndex = num;
                            bgIndex6 = num;
                            break;
                        }

                        ++num;
                    }

                    lightX[0] = GameMain.Instance.MainLight.transform.eulerAngles.x;
                    lightY[0] = GameMain.Instance.MainLight.transform.eulerAngles.y;
                    lightX6 = lightX[0];
                    lightY6 = lightY[0];
                    loadScene = 10006;
                    kankyoLoadFlg = true;
                    GameMain.Instance.SoundMgr.PlaySe("se002.ogg", false);
                }

                if (Input.GetKey(KeyCode.F7) && Input.GetKeyDown(KeyCode.Alpha8))
                {
                    string bgName = GameMain.Instance.BgMgr.GetBGName();
                    int num = 0;
                    foreach (string bg in bgArray)
                    {
                        if (bg == bgName)
                        {
                            bgIndex = num;
                            bgIndex6 = num;
                            break;
                        }

                        ++num;
                    }

                    lightX[0] = GameMain.Instance.MainLight.transform.eulerAngles.x;
                    lightY[0] = GameMain.Instance.MainLight.transform.eulerAngles.y;
                    lightX6 = lightX[0];
                    lightY6 = lightY[0];
                    loadScene = 10007;
                    kankyoLoadFlg = true;
                    GameMain.Instance.SoundMgr.PlaySe("se002.ogg", false);
                }

                if (Input.GetKey(KeyCode.F7) && Input.GetKeyDown(KeyCode.Alpha9))
                {
                    string bgName = GameMain.Instance.BgMgr.GetBGName();
                    int num = 0;
                    foreach (string bg in bgArray)
                    {
                        if (bg == bgName)
                        {
                            bgIndex = num;
                            bgIndex6 = num;
                            break;
                        }

                        ++num;
                    }

                    lightX[0] = GameMain.Instance.MainLight.transform.eulerAngles.x;
                    lightY[0] = GameMain.Instance.MainLight.transform.eulerAngles.y;
                    lightX6 = lightX[0];
                    lightY6 = lightY[0];
                    loadScene = 10008;
                    kankyoLoadFlg = true;
                    GameMain.Instance.SoundMgr.PlaySe("se002.ogg", false);
                }

                if (Input.GetKey(KeyCode.F7) && Input.GetKeyDown(KeyCode.Alpha0))
                {
                    string bgName = GameMain.Instance.BgMgr.GetBGName();
                    int num = 0;
                    foreach (string bg in bgArray)
                    {
                        if (bg == bgName)
                        {
                            bgIndex = num;
                            bgIndex6 = num;
                            break;
                        }

                        ++num;
                    }

                    lightX[0] = GameMain.Instance.MainLight.transform.eulerAngles.x;
                    lightY[0] = GameMain.Instance.MainLight.transform.eulerAngles.y;
                    lightX6 = lightX[0];
                    lightY6 = lightY[0];
                    loadScene = 10009;
                    kankyoLoadFlg = true;
                    GameMain.Instance.SoundMgr.PlaySe("se002.ogg", false);
                }
            }

            if (isSavePose4)
            {
                isSavePose4 = false;
                Maid maid = maidArray[selectMaidIndex];
                Vector3 localEulerAngles = maid.transform.localEulerAngles;
                maid.transform.localEulerAngles = new Vector3(0.0f, 0.0f, 0.0f);
                Vector3 position = maid.transform.position;
                maid.transform.position = new Vector3(0.0f, 0.0f, 0.0f);
                Transform transform = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01", true);
                transform.eulerAngles = bipRotation;
                transform.position = bipPosition;
                maid.transform.localEulerAngles = localEulerAngles;
                maid.transform.position = position;
                CacheBoneDataArray cacheBoneDataArray = maid.gameObject.AddComponent<CacheBoneDataArray>();
                cacheBoneDataArray.CreateCache(maid.body0.GetBone("Bip01"));
                byte[] anmBinary = cacheBoneDataArray.GetAnmBinary(true, true);
                string path1 = Path.GetFullPath(".\\") + "Mod\\MultipleMaidsPose\\" + inName3 + ".anm";
                for (int index = 0; index < 100 && File.Exists(path1); ++index)
                {
                    inName3 += "_";
                    path1 = Path.GetFullPath(".\\") + "Mod\\MultipleMaidsPose\\" + inName3 + ".anm";
                }

                File.WriteAllBytes(path1, anmBinary);
                strList2 = new List<string>();
                strListE = new List<string>();
                strListE2 = new List<string>();
                strListS = new List<string>();
                strListD = new List<string>();
                strS = "";
                List<string> stringList1 = new List<string>(350 + poseArray2.Length);
                stringList1.AddRange(poseArray2);
                List<string> stringList2 = new List<string>();
                for (int index = 11; index < 200; ++index)
                {
                    if (index < 100)
                    {
                        using (AFileBase afileBase = GameUty.FileSystem.FileOpen("edit_pose_0" + index + "_f.anm"))
                        {
                            if (afileBase.IsValid())
                            {
                                stringList2.Add("edit_pose_0" + index + "_f");
                            }
                        }
                    }
                    else
                    {
                        using (AFileBase afileBase = GameUty.FileSystem.FileOpen("edit_pose_" + index + "_f.anm"))
                        {
                            if (afileBase.IsValid())
                            {
                                stringList2.Add("edit_pose_" + index + "_f");
                            }
                        }
                    }
                }

                for (int index1 = 15; index1 < 25; ++index1)
                {
                    for (int index2 = 0; index2 < 2; ++index2)
                    {
                        string str = "s";
                        if (index2 == 1)
                        {
                            str = "w";
                        }

                        for (int index3 = 1; index3 < 20; ++index3)
                        {
                            if (index3 < 10)
                            {
                                using (AFileBase afileBase =
                                        GameUty.FileSystem.FileOpen("edit_pose_dg" + index1 + str + "_00" + index3
                                                                    + "_f.anm"))
                                {
                                    if (afileBase.IsValid())
                                    {
                                        stringList2.Add("edit_pose_dg" + index1 + str + "_00" + index3 + "_f");
                                    }
                                }
                            }
                            else
                            {
                                using (AFileBase afileBase =
                                        GameUty.FileSystem.FileOpen("edit_pose_dg" + index1 + str + "_0" + index3
                                                                    + "_f.anm"))
                                {
                                    if (afileBase.IsValid())
                                    {
                                        stringList2.Add("edit_pose_dg" + index1 + str + "_0" + index3 + "_f");
                                    }
                                }
                            }
                        }
                    }
                }

                if (stringList2.Count > 0)
                {
                    stringList1.AddRange(stringList2.ToArray());
                }

                stringList1.AddRange(poseArrayVP2);
                stringList1.AddRange(poseArrayFB);
                stringList1.AddRange(poseArray4);
                stringList1.AddRange(poseArray5);
                stringList1.AddRange(poseArray6);
                poseArray = stringList1.ToArray();
                ((Action<string, List<string>>)((path, result_list) =>
                                                   {
                                                       string[] files = Directory.GetFiles(path);
                                                       countS = 0;
                                                       for (int index = 0; index < files.Length; ++index)
                                                       {
                                                           if (Path.GetExtension(files[index]) == ".anm")
                                                           {
                                                               strListS.Add(files[index].Split('\\')[files[index].Split('\\').Length - 1]
                                                                                        .Split('.')[0] + "　　　　　　　　　　　　　　　　　　　　/"
                                                                                                       + files[index]);
                                                               ++countS;
                                                           }
                                                       }
                                                   }))(Path.GetFullPath(".\\") + "Mod\\MultipleMaidsPose", new List<string>());
                string[] list = GameUty.FileSystem.GetList("motion", AFileSystemBase.ListType.AllFile);
                int num1 = 0;
                List<string> stringList3 = new List<string>();
                foreach (string path2 in list)
                {
                    string withoutExtension = Path.GetFileNameWithoutExtension(path2);
                    string directoryName = Path.GetDirectoryName(path2);
                    if (!withoutExtension.StartsWith("maid_motion_") && !withoutExtension.StartsWith("work_00")
                                                                     && !withoutExtension.EndsWith("_3_")
                                                                         && !withoutExtension.EndsWith("_5_")
                                                                     && !withoutExtension.StartsWith("ck_")
                                                                         && !withoutExtension.StartsWith("vr_")
                                                                         && !withoutExtension.StartsWith("dance_mc")
                                                                             && !withoutExtension.Contains("a01_")
                                                                     && !withoutExtension.StartsWith("j_")
                                                                         && !withoutExtension.StartsWith("k_")
                                                                         && !withoutExtension.StartsWith("t_")
                                                                             && !withoutExtension.StartsWith("cbl_")
                                                                         && !withoutExtension.Contains("b01_")
                                                                             && !withoutExtension.Contains("b02_")
                                                                             && !withoutExtension.Contains("_kubi_")
                                                                                 && !withoutExtension.EndsWith("_m2")
                                                                     && !withoutExtension.EndsWith("_m3")
                                                                         && !withoutExtension.Contains("_m2_once")
                                                                         && !withoutExtension.Contains("_m3_once")
                                                                             && !withoutExtension.StartsWith("h_")
                                                                         && !withoutExtension.StartsWith("event_")
                                                                             && !withoutExtension.StartsWith("man_")
                                                                             && !withoutExtension.EndsWith("_m")
                                                                                 && !withoutExtension.Contains("_m_")
                                                                     && !withoutExtension.Contains("_man")
                                                                     && !(withoutExtension == "dance_cm3d2_001_zoukin")
                                                                         && !(withoutExtension == "dance_cm3d2_001_mop")
                                                                         && !(withoutExtension == "maid_motion")
                                                                             && !(withoutExtension == "aruki_1_idougo_f")
                                                                         && !(withoutExtension == "sleep2")
                                                                             && !(withoutExtension == "stand_akire2")
                                                                             && !(withoutExtension == "ero_scene_001")
                                                                                 && !(withoutExtension == "ero_scenefm_001")
                                                                         && !(withoutExtension == "training_001")
                                                                             && !(withoutExtension == "workff_001")
                                                                             && !(withoutExtension == "workfm_001")
                                                                                 && !(withoutExtension == "dance_cm3d21_005_moe_mset")
                                                                         && !(withoutExtension == "hinpyoukai_001"))
                    {
                        if (!directoryName.Contains("\\sex\\"))
                        {
                            if (!withoutExtension.StartsWith("sex_"))
                            {
                                if (withoutExtension.StartsWith("dance_test"))
                                {
                                    strListD.Add(withoutExtension);
                                }
                                else
                                {
                                    bool flag = false;
                                    foreach (string str1 in strListS)
                                    {
                                        char[] chArray = new char[1] { '/' };
                                        string str2 = str1.Split(chArray)[0].Replace("　　　　　　　　　　　　　　　　　　　　", "");
                                        if (withoutExtension == str2)
                                        {
                                            flag = true;
                                            break;
                                        }
                                    }

                                    if (!flag)
                                    {
                                        stringList3.Add(withoutExtension);
                                    }
                                }
                            }
                        }
                        else if (!withoutExtension.StartsWith("pose_"))
                        {
                            strListE.Add(withoutExtension);
                        }
                    }
                }

                foreach (string str in stringList3)
                {
                    bool flag = false;
                    for (int index = 0; index < poseArray.Length; ++index)
                    {
                        if (str == poseArray[index])
                        {
                            flag = true;
                        }
                    }

                    if (!flag && str.StartsWith("edit_"))
                    {
                        strList2.Add(str);
                    }
                }

                foreach (string str in stringList3)
                {
                    bool flag = false;
                    for (int index = 0; index < poseArray.Length; ++index)
                    {
                        if (str == poseArray[index])
                        {
                            flag = true;
                        }
                    }

                    if (!flag && str.StartsWith("pose_"))
                    {
                        strList2.Add(str);
                    }
                }

                foreach (string str in stringList3)
                {
                    bool flag = false;
                    for (int index = 0; index < poseArray.Length; ++index)
                    {
                        if (str == poseArray[index])
                        {
                            flag = true;
                        }
                    }

                    if (!flag && !str.StartsWith("edit_") && !str.StartsWith("pose_"))
                    {
                        strList2.Add(str);
                    }
                }

                foreach (string str in strListE)
                {
                    bool flag = false;
                    for (int index = 0; index < poseArray.Length; ++index)
                    {
                        if (str == poseArray[index])
                        {
                            flag = true;
                        }
                    }

                    if (!flag)
                    {
                        strListE2.Add(str);
                        ++num1;
                    }
                }

                stringList1.AddRange(strList2.ToArray());
                stringList1.AddRange(strListE2.ToArray());
                existPose = false;
                poseIniStr = "";
                foreach (IniKey key in Preferences["pose"].Keys)
                {
                    IniKey iniKey = Preferences["pose"][key.Key];
                    if (iniKey.Value != null && iniKey.Value.ToString() != "" && iniKey.Value.ToString() != "del")
                    {
                        stringList1.AddRange(new string[1] { key.Key });
                        existPose = true;
                        if (poseIniStr == "")
                        {
                            poseIniStr = key.Key;
                        }
                    }
                }

                stringList1.AddRange(strListS.ToArray());
                poseArray = stringList1.ToArray();
                List<string> stringList4 = new List<string>(50 + poseGroupArray2.Length);
                stringList4.AddRange(poseGroupArray2);
                stringList4.AddRange(poseGroupArrayVP);
                stringList4.AddRange(poseGroupArrayFB);
                stringList4.AddRange(poseGroupArray3);
                stringList4.Add(poseArray5[0]);
                stringList4.Add(poseArray6[0]);
                stringList4.Add(strList2[0]);
                stringList4.Add(strListE2[0]);
                existPose = true;
                if (strListS.Count > 0 && poseIniStr == "")
                {
                    stringList4.Add(strListS[0]);
                }

                if (poseIniStr != "")
                {
                    stringList4.Add(poseIniStr);
                }

                poseGroupArray = stringList4.ToArray();
                groupList = new ArrayList();
                for (int index1 = 0; index1 < poseArray.Length; ++index1)
                {
                    for (int index2 = 0; index2 < poseGroupArray.Length; ++index2)
                    {
                        if (poseGroupArray[index2] == poseArray[index1])
                        {
                            groupList.Add(index1);
                            if (poseGroupArray[index2] == strList2[0])
                            {
                                sPoseCount = index1;
                            }
                        }
                    }
                }

                poseGroupComboList = new GUIContent[poseGroupArray.Length + 1];
                poseGroupComboList[0] = new GUIContent("1:通常");
                for (int index = 0; index < poseGroupArray.Length; ++index)
                {
                    if (poseGroupArray[index] == "maid_dressroom01")
                    {
                        poseGroupComboList[index + 1] = new GUIContent((index + 2).ToString() + ":立ち");
                    }

                    if (poseGroupArray[index] == "tennis_kamae_f")
                    {
                        poseGroupComboList[index + 1] = new GUIContent((index + 2).ToString() + ":中腰");
                    }

                    if (poseGroupArray[index] == "senakanagasi_f")
                    {
                        poseGroupComboList[index + 1] = new GUIContent((index + 2).ToString() + ":膝をつく");
                    }

                    if (poseGroupArray[index] == "work_hansei")
                    {
                        poseGroupComboList[index + 1] = new GUIContent((index + 2).ToString() + ":座り");
                    }

                    if (poseGroupArray[index] == "inu_taiki_f")
                    {
                        poseGroupComboList[index + 1] = new GUIContent((index + 2).ToString() + ":四つん這い");
                    }

                    if (poseGroupArray[index] == "syagami_pose_f")
                    {
                        poseGroupComboList[index + 1] = new GUIContent((index + 2).ToString() + ":床座り");
                    }

                    if (poseGroupArray[index] == "densyasuwari_taiki_f")
                    {
                        poseGroupComboList[index + 1] = new GUIContent((index + 2).ToString() + ":椅子座り");
                    }

                    if (poseGroupArray[index] == "work_kaiwa")
                    {
                        poseGroupComboList[index + 1] = new GUIContent((index + 2).ToString() + ":ソファー座り");
                    }

                    if (poseGroupArray[index] == "dance_cm3d2_001_f1,14.14")
                    {
                        poseGroupComboList[index + 1] = new GUIContent((index + 2).ToString() + ":ドキドキ☆Fallin' Love");
                    }

                    if (poseGroupArray[index] == "dance_cm3d_001_f1,39.25")
                    {
                        poseGroupComboList[index + 1] = new GUIContent((index + 2).ToString() + ":entrance to you");
                    }

                    if (poseGroupArray[index] == "dance_cm3d_002_end_f1,50.71")
                    {
                        poseGroupComboList[index + 1] = new GUIContent((index + 2).ToString() + ":scarlet leap");
                    }

                    if (poseGroupArray[index] == "dance_cm3d2_002_smt_f,7.76,")
                    {
                        poseGroupComboList[index + 1] = new GUIContent((index + 2).ToString() + ":stellar my tears");
                    }

                    if (poseGroupArray[index] == "dance_cm3d_003_sp2_f1,90.15")
                    {
                        poseGroupComboList[index + 1] = new GUIContent((index + 2).ToString() + ":rhythmix to you");
                    }

                    if (poseGroupArray[index] == "dance_cm3d2_003_hs_f1,0.01,")
                    {
                        poseGroupComboList[index + 1] = new GUIContent((index + 2).ToString() + ":happy!happy!スキャンダル!!");
                    }

                    if (poseGroupArray[index] == "dance_cm3d_004_kano_f1,124.93")
                    {
                        poseGroupComboList[index + 1] = new GUIContent((index + 2).ToString() + ":Can Know Two Close");
                    }

                    if (poseGroupArray[index] == "dance_cm3d2_004_sse_f1,0.01")
                    {
                        poseGroupComboList[index + 1] = new GUIContent((index + 2).ToString() + ":sweet sweet everyday");
                    }

                    if (poseGroupArray[index] == "turusi_sex_in_taiki_f")
                    {
                        poseGroupComboList[index + 1] = new GUIContent((index + 2).ToString() + ":拘束");
                    }

                    if (poseGroupArray[index] == "rosyutu_pose01_f")
                    {
                        poseGroupComboList[index + 1] = new GUIContent((index + 2).ToString() + ":エロ");
                    }

                    if (poseGroupArray[index] == "rosyutu_aruki_f_once_,1.37")
                    {
                        poseGroupComboList[index + 1] = new GUIContent((index + 2).ToString() + ":歩き");
                    }

                    if (poseGroupArray[index] == "stand_desk1")
                    {
                        poseGroupComboList[index + 1] = new GUIContent((index + 2).ToString() + ":その他");
                    }

                    if (poseGroupArray[index] == poseArray5[0])
                    {
                        poseGroupComboList[index + 1] = new GUIContent((index + 2).ToString() + ":ダンスMC");
                    }

                    if (poseGroupArray[index] == poseArray6[0])
                    {
                        poseGroupComboList[index + 1] = new GUIContent((index + 2).ToString() + ":ダンス");
                    }

                    if (index == poseGroupArray.Length - 3)
                    {
                        poseGroupComboList[index + 1] = new GUIContent((index + 2).ToString() + ":通常2");
                    }

                    if (index == poseGroupArray.Length - 2)
                    {
                        poseGroupComboList[index + 1] = new GUIContent((index + 2).ToString() + ":エロ2");
                    }

                    if (index == poseGroupArray.Length - 1)
                    {
                        poseGroupComboList[index + 1] = new GUIContent("99:登録ポーズ");
                    }
                }

                int index4 = -1;
                for (int index1 = 0; index1 < groupList.Count; ++index1)
                {
                    if (poseIndex[selectMaidIndex] < (int)groupList[index1])
                    {
                        index4 = index1;
                        break;
                    }
                }

                int length = (int)groupList[0];
                int num2 = 0;
                if (index4 > 0)
                {
                    length = (int)groupList[index4] - (int)groupList[index4 - 1];
                    num2 = (int)groupList[index4 - 1];
                }

                if (index4 < 0)
                {
                    index4 = groupList.Count;
                    length = poseArray.Length - (int)groupList[index4 - 1];
                    num2 = (int)groupList[index4 - 1];
                }

                poseComboList = new GUIContent[length];
                int index5 = 0;
                for (int index1 = num2; index1 < num2 + length; ++index1)
                {
                    bool flag = false;
                    foreach (IniKey key in Preferences["pose"].Keys)
                    {
                        if (poseArray[index1] == key.Key)
                        {
                            IniKey iniKey = Preferences["pose"][key.Key];
                            if (iniKey.Value != null && iniKey.Value.ToString() != "" && iniKey.Value.ToString() != "del")
                            {
                                poseComboList[index5] =
                                        new GUIContent((index5 + 1).ToString() + ":" + iniKey.Value.Split('_')[0] + "　　　　　　　　　　　　　　　　　　　　"
                                                       + key.Key);
                                flag = true;
                            }
                        }
                    }

                    if (!flag)
                    {
                        poseComboList[index5] = new GUIContent((index5 + 1).ToString() + ":" + poseArray[index1]);
                    }

                    ++index5;
                }

                poseGroupCombo.selectedItemIndex = index4;
                poseGroupIndex = index4;
                poseCombo.selectedItemIndex = 0;
                for (int group = (int)groupList[groupList.Count - 1]; group < poseArray.Length; ++group)
                {
                    if (poseArray[group].Split('/')[0].Replace("　　　　　　　　　　　　　　　　　　　　", "") == inName3)
                    {
                        poseIndex[selectMaidIndex] = group;
                        string path2 = poseArray[group].Split('/')[1];
                        byte[] numArray = new byte[0];
                        try
                        {
                            using (FileStream fileStream = new FileStream(path2, FileMode.Open, FileAccess.Read))
                            {
                                numArray = new byte[fileStream.Length];
                                fileStream.Read(numArray, 0, numArray.Length);
                            }
                        }
                        catch { }

                        if (0 < numArray.Length)
                        {
                            long hashCode = Path.GetFileName(path2).GetHashCode();
                            maid.body0.CrossFade(hashCode.ToString(), numArray, false, false, false, 0.0f, 1f);
                            Maid.AutoTwist[] autoTwistArray = new Maid.AutoTwist[6]
                            {
                                    Maid.AutoTwist.ShoulderL, Maid.AutoTwist.ShoulderR, Maid.AutoTwist.WristL, Maid.AutoTwist.WristR,
                                    Maid.AutoTwist.ThighL, Maid.AutoTwist.ThighR
                            };
                            foreach (Maid.AutoTwist f_eType in autoTwistArray)
                            {
                                maid.SetAutoTwist(f_eType, true);
                            }

                            break;
                        }

                        break;
                    }
                }

                isLock[selectMaidIndex] = false;
                inName3 = "";
                isSavePose = false;
            }

            if (isSavePose3)
            {
                Maid maid = maidArray[selectMaidIndex];
                isSavePose3 = false;
                isSavePose4 = true;
                Transform transform = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01", true);
                transform.eulerAngles = bipRotation;
                transform.position = bipPosition;
            }

            if (isSavePose2)
            {
                Maid maid = maidArray[selectMaidIndex];
                isSavePose2 = false;
                isSavePose3 = true;
                Transform transform = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01", true);
                transform.eulerAngles = bipRotation;
                transform.position = bipPosition;
            }

            if (isSavePose)
            {
                Maid maid = maidArray[selectMaidIndex];
                Transform transform = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01", true);
                bipPosition = new Vector3(transform.position.x - maid.transform.position.x,
                                          transform.position.y,
                                          transform.position.z - maid.transform.position.z);
                bipRotation = transform.eulerAngles;
                maid.transform.localEulerAngles = new Vector3(0.0f, 0.0f, 0.0f);
                maid.transform.position = new Vector3(maid.transform.position.x, 0.0f, maid.transform.position.z);
                isSavePose = false;
                isSavePose2 = true;
                isStop[selectMaidIndex] = true;
            }

            if (saveScene > 0)
            {
                string str1 = "";
                string str2 = "";
                DateTime now = DateTime.Now;
                string str3 = now.Year.ToString() + "/" + now.Month.ToString("00") + "/" + now.Day.ToString("00") + " "
                              + now.Hour.ToString("00") + ":" + now.Minute.ToString("00");
                if (saveScene < 9999)
                {
                    date[saveScene - 1 - page * 10] = str3;
                    ninzu[saveScene - 1 - page * 10] = maidCnt.ToString() + "人";
                }

                string[] strArray1 = new string[7]
                {
                        str2 + str3 + "," +  maidCnt + "," + bgArray[bgIndex].Replace("_", " ") + ",",
                        bg.localEulerAngles.x.ToString("0.###"), ",", null, null, null, null
                };
                string[] strArray2 = strArray1;
                int index1 = 3;
                float num = bg.localEulerAngles.y;
                string str4 = num.ToString("0.###");
                strArray2[index1] = str4;
                strArray1[4] = ",";
                string[] strArray3 = strArray1;
                int index2 = 5;
                num = bg.localEulerAngles.z;
                string str5 = num.ToString("0.###");
                strArray3[index2] = str5;
                strArray1[6] = ",";
                string str6 = string.Concat(strArray1);
                string[] strArray4 = new string[7];
                strArray4[0] = str6;
                string[] strArray5 = strArray4;
                int index3 = 1;
                num = bg.position.x;
                string str7 = num.ToString("0.###");
                strArray5[index3] = str7;
                strArray4[2] = ",";
                string[] strArray6 = strArray4;
                int index4 = 3;
                num = bg.position.y;
                string str8 = num.ToString("0.###");
                strArray6[index4] = str8;
                strArray4[4] = ",";
                string[] strArray7 = strArray4;
                int index5 = 5;
                num = bg.position.z;
                string str9 = num.ToString("0.###");
                strArray7[index5] = str9;
                strArray4[6] = ",";
                string str10 = string.Concat(strArray4);
                string[] strArray8 = new string[7];
                strArray8[0] = str10;
                string[] strArray9 = strArray8;
                int index6 = 1;
                num = bg.localScale.x;
                string str11 = num.ToString("0.###");
                strArray9[index6] = str11;
                strArray8[2] = ",";
                string[] strArray10 = strArray8;
                int index7 = 3;
                num = bg.localScale.y;
                string str12 = num.ToString("0.###");
                strArray10[index7] = str12;
                strArray8[4] = ",";
                string[] strArray11 = strArray8;
                int index8 = 5;
                num = bg.localScale.z;
                string str13 = num.ToString("0.###");
                strArray11[index8] = str13;
                strArray8[6] = ",";
                string str14 = string.Concat(strArray8) + softG.x.ToString("0.###") + "," + softG.y.ToString("0.###") + ","
                               + softG.z.ToString("0.###") + "," + bgmIndex + "," + effectIndex + ","
                               + lightIndex[0] + "," + lightColorR[0] + "," + lightColorG[0] + ","
                               + lightColorB[0] + ",";
                string[] strArray12 = new string[7];
                strArray12[0] = str14;
                string[] strArray13 = strArray12;
                int index9 = 1;
                num = GameMain.Instance.MainLight.transform.eulerAngles.x;
                string str15 = num.ToString("0.###");
                strArray13[index9] = str15;
                strArray12[2] = ",";
                string[] strArray14 = strArray12;
                int index10 = 3;
                num = GameMain.Instance.MainLight.transform.eulerAngles.y;
                string str16 = num.ToString("0.###");
                strArray14[index10] = str16;
                strArray12[4] = ",";
                string[] strArray15 = strArray12;
                int index11 = 5;
                num = GameMain.Instance.MainLight.transform.eulerAngles.z;
                string str17 = num.ToString("0.###");
                strArray15[index11] = str17;
                strArray12[6] = ",";
                string str18 = string.Concat(strArray12) + GameMain.Instance.MainLight.GetComponent<Light>().intensity + ","
                               + GameMain.Instance.MainLight.GetComponent<Light>().spotAngle + ","
                               + GameMain.Instance.MainLight.GetComponent<Light>().range + ","
                               + mainCamera.GetTargetPos().x + "," + mainCamera.GetTargetPos().y + ","
                               + mainCamera.GetTargetPos().z + "," + mainCamera.GetDistance() + ",";
                string[] strArray16 = new string[7];
                strArray16[0] = str18;
                string[] strArray17 = strArray16;
                int index12 = 1;
                num = mainCamera.transform.eulerAngles.x;
                string str19 = num.ToString("0.###");
                strArray17[index12] = str19;
                strArray16[2] = ",";
                string[] strArray18 = strArray16;
                int index13 = 3;
                num = mainCamera.transform.eulerAngles.y;
                string str20 = num.ToString("0.###");
                strArray18[index13] = str20;
                strArray16[4] = ",";
                string[] strArray19 = strArray16;
                int index14 = 5;
                num = mainCamera.transform.eulerAngles.z;
                string str21 = num.ToString("0.###");
                strArray19[index14] = str21;
                strArray16[6] = ",";
                string str22 = string.Concat(strArray16);
                inName = inName.Replace("_", " ").Replace(",", " ");
                inText = inText.Replace("_", " ").Replace(",", " ");
                string str23;
                if (isMessage)
                {
                    str23 = str22 + "1," + inName + "," + inText.Replace("\n", "&kaigyo");
                }
                else
                {
                    str23 = str22 + "0,,";
                }

                if (doguObject.Count > 0)
                {
                    string str24 = str23 + "," + doguArray[doguIndex[doguSelectIndex]].Replace("_", " ") + ",";
                    string[] strArray20 = new string[7];
                    strArray20[0] = str24;
                    string[] strArray21 = strArray20;
                    int index15 = 1;
                    num = doguObject[doguSelectIndex].transform.localEulerAngles.x;
                    string str25 = num.ToString("0.###");
                    strArray21[index15] = str25;
                    strArray20[2] = ",";
                    string[] strArray22 = strArray20;
                    int index16 = 3;
                    num = doguObject[doguSelectIndex].transform.localEulerAngles.y;
                    string str26 = num.ToString("0.###");
                    strArray22[index16] = str26;
                    strArray20[4] = ",";
                    string[] strArray23 = strArray20;
                    int index17 = 5;
                    num = doguObject[doguSelectIndex].transform.localEulerAngles.z;
                    string str27 = num.ToString("0.###");
                    strArray23[index17] = str27;
                    strArray20[6] = ",";
                    string str28 = string.Concat(strArray20);
                    string[] strArray24 = new string[7];
                    strArray24[0] = str28;
                    string[] strArray25 = strArray24;
                    int index18 = 1;
                    num = doguObject[doguSelectIndex].transform.position.x;
                    string str29 = num.ToString("0.###");
                    strArray25[index18] = str29;
                    strArray24[2] = ",";
                    string[] strArray26 = strArray24;
                    int index19 = 3;
                    num = doguObject[doguSelectIndex].transform.position.y;
                    string str30 = num.ToString("0.###");
                    strArray26[index19] = str30;
                    strArray24[4] = ",";
                    string[] strArray27 = strArray24;
                    int index20 = 5;
                    num = doguObject[doguSelectIndex].transform.position.z;
                    string str31 = num.ToString("0.###");
                    strArray27[index20] = str31;
                    strArray24[6] = ",";
                    string str32 = string.Concat(strArray24);
                    string[] strArray28 = new string[6];
                    strArray28[0] = str32;
                    string[] strArray29 = strArray28;
                    int index21 = 1;
                    num = doguObject[doguSelectIndex].transform.localScale.x;
                    string str33 = num.ToString("0.###");
                    strArray29[index21] = str33;
                    strArray28[2] = ",";
                    string[] strArray30 = strArray28;
                    int index22 = 3;
                    num = doguObject[doguSelectIndex].transform.localScale.y;
                    string str34 = num.ToString("0.###");
                    strArray30[index22] = str34;
                    strArray28[4] = ",";
                    string[] strArray31 = strArray28;
                    int index23 = 5;
                    num = doguObject[doguSelectIndex].transform.localScale.z;
                    string str35 = num.ToString("0.###");
                    strArray31[index23] = str35;
                    str23 = string.Concat(strArray28);
                }

                string str36 = str23 + "_";
                for (int i = 0; i < maidCnt; ++i)
                {
                    Maid maid = maidArray[i];
                    string str24 = "";
                    string str25 = "";
                    SetIK(maid, i);
                    for (int index15 = 0; index15 < 20; ++index15)
                    {
                        string str26 = str24;
                        string[] strArray20 = new string[7];
                        strArray20[0] = str26;
                        string[] strArray21 = strArray20;
                        int index16 = 1;
                        num = Finger[i, index15].localEulerAngles.x;
                        string str27 = num.ToString("0.###");
                        strArray21[index16] = str27;
                        strArray20[2] = ",";
                        string[] strArray22 = strArray20;
                        int index17 = 3;
                        num = Finger[i, index15].localEulerAngles.y;
                        string str28 = num.ToString("0.###");
                        strArray22[index17] = str28;
                        strArray20[4] = ",";
                        string[] strArray23 = strArray20;
                        int index18 = 5;
                        num = Finger[i, index15].localEulerAngles.z;
                        string str29 = num.ToString("0.###");
                        strArray23[index18] = str29;
                        strArray20[6] = ":";
                        str24 = string.Concat(strArray20);
                    }

                    for (int index15 = 20; index15 < 40; ++index15)
                    {
                        string str26 = str25;
                        string[] strArray20 = new string[7];
                        strArray20[0] = str26;
                        string[] strArray21 = strArray20;
                        int index16 = 1;
                        num = Finger[i, index15].localEulerAngles.x;
                        string str27 = num.ToString("0.###");
                        strArray21[index16] = str27;
                        strArray20[2] = ",";
                        string[] strArray22 = strArray20;
                        int index17 = 3;
                        num = Finger[i, index15].localEulerAngles.y;
                        string str28 = num.ToString("0.###");
                        strArray22[index17] = str28;
                        strArray20[4] = ",";
                        string[] strArray23 = strArray20;
                        int index18 = 5;
                        num = Finger[i, index15].localEulerAngles.z;
                        string str29 = num.ToString("0.###");
                        strArray23[index18] = str29;
                        strArray20[6] = ":";
                        str25 = string.Concat(strArray20);
                    }

                    string str30 = "";
                    string[] strArray24 = new string[7];
                    strArray24[0] = str30;
                    string[] strArray25 = strArray24;
                    int index19 = 1;
                    num = Spine.eulerAngles.x;
                    string str31 = num.ToString("0.###");
                    strArray25[index19] = str31;
                    strArray24[2] = ",";
                    string[] strArray26 = strArray24;
                    int index20 = 3;
                    num = Spine.eulerAngles.y;
                    string str32 = num.ToString("0.###");
                    strArray26[index20] = str32;
                    strArray24[4] = ",";
                    string[] strArray27 = strArray24;
                    int index21 = 5;
                    num = Spine.eulerAngles.z;
                    string str33 = num.ToString("0.###");
                    strArray27[index21] = str33;
                    strArray24[6] = ":";
                    string str34 = string.Concat(strArray24);
                    string[] strArray28 = new string[7];
                    strArray28[0] = str34;
                    string[] strArray29 = strArray28;
                    int index22 = 1;
                    num = Spine0a.eulerAngles.x;
                    string str35 = num.ToString("0.###");
                    strArray29[index22] = str35;
                    strArray28[2] = ",";
                    string[] strArray30 = strArray28;
                    int index23 = 3;
                    num = Spine0a.eulerAngles.y;
                    string str37 = num.ToString("0.###");
                    strArray30[index23] = str37;
                    strArray28[4] = ",";
                    string[] strArray31 = strArray28;
                    int index24 = 5;
                    num = Spine0a.eulerAngles.z;
                    string str38 = num.ToString("0.###");
                    strArray31[index24] = str38;
                    strArray28[6] = ":";
                    string str39 = string.Concat(strArray28);
                    string[] strArray32 = new string[7];
                    strArray32[0] = str39;
                    string[] strArray33 = strArray32;
                    int index25 = 1;
                    num = Spine1.eulerAngles.x;
                    string str40 = num.ToString("0.###");
                    strArray33[index25] = str40;
                    strArray32[2] = ",";
                    string[] strArray34 = strArray32;
                    int index26 = 3;
                    num = Spine1.eulerAngles.y;
                    string str41 = num.ToString("0.###");
                    strArray34[index26] = str41;
                    strArray32[4] = ",";
                    string[] strArray35 = strArray32;
                    int index27 = 5;
                    num = Spine1.eulerAngles.z;
                    string str42 = num.ToString("0.###");
                    strArray35[index27] = str42;
                    strArray32[6] = ":";
                    string str43 = string.Concat(strArray32);
                    string[] strArray36 = new string[7];
                    strArray36[0] = str43;
                    string[] strArray37 = strArray36;
                    int index28 = 1;
                    num = Spine1a.eulerAngles.x;
                    string str44 = num.ToString("0.###");
                    strArray37[index28] = str44;
                    strArray36[2] = ",";
                    string[] strArray38 = strArray36;
                    int index29 = 3;
                    num = Spine1a.eulerAngles.y;
                    string str45 = num.ToString("0.###");
                    strArray38[index29] = str45;
                    strArray36[4] = ",";
                    string[] strArray39 = strArray36;
                    int index30 = 5;
                    num = Spine1a.eulerAngles.z;
                    string str46 = num.ToString("0.###");
                    strArray39[index30] = str46;
                    strArray36[6] = ":";
                    string str47 = string.Concat(strArray36);
                    string[] strArray40 = new string[7];
                    strArray40[0] = str47;
                    string[] strArray41 = strArray40;
                    int index31 = 1;
                    num = Pelvis.eulerAngles.x;
                    string str48 = num.ToString("0.###");
                    strArray41[index31] = str48;
                    strArray40[2] = ",";
                    string[] strArray42 = strArray40;
                    int index32 = 3;
                    num = Pelvis.eulerAngles.y;
                    string str49 = num.ToString("0.###");
                    strArray42[index32] = str49;
                    strArray40[4] = ",";
                    string[] strArray43 = strArray40;
                    int index33 = 5;
                    num = Pelvis.eulerAngles.z;
                    string str50 = num.ToString("0.###");
                    strArray43[index33] = str50;
                    strArray40[6] = ":";
                    string str51 = string.Concat(strArray40);
                    string[] strArray44 = new string[7];
                    strArray44[0] = str51;
                    string[] strArray45 = strArray44;
                    int index34 = 1;
                    num = HandL1[i].localEulerAngles.x;
                    string str52 = num.ToString("0.###");
                    strArray45[index34] = str52;
                    strArray44[2] = ",";
                    string[] strArray46 = strArray44;
                    int index35 = 3;
                    num = HandL1[i].localEulerAngles.y;
                    string str53 = num.ToString("0.###");
                    strArray46[index35] = str53;
                    strArray44[4] = ",";
                    string[] strArray47 = strArray44;
                    int index36 = 5;
                    num = HandL1[i].localEulerAngles.z;
                    string str54 = num.ToString("0.###");
                    strArray47[index36] = str54;
                    strArray44[6] = ":";
                    string str55 = string.Concat(strArray44);
                    string[] strArray48 = new string[7];
                    strArray48[0] = str55;
                    string[] strArray49 = strArray48;
                    int index37 = 1;
                    num = UpperArmL1[i].eulerAngles.x;
                    string str56 = num.ToString("0.###");
                    strArray49[index37] = str56;
                    strArray48[2] = ",";
                    string[] strArray50 = strArray48;
                    int index38 = 3;
                    num = UpperArmL1[i].eulerAngles.y;
                    string str57 = num.ToString("0.###");
                    strArray50[index38] = str57;
                    strArray48[4] = ",";
                    string[] strArray51 = strArray48;
                    int index39 = 5;
                    num = UpperArmL1[i].eulerAngles.z;
                    string str58 = num.ToString("0.###");
                    strArray51[index39] = str58;
                    strArray48[6] = ":";
                    string str59 = string.Concat(strArray48);
                    string[] strArray52 = new string[7];
                    strArray52[0] = str59;
                    string[] strArray53 = strArray52;
                    int index40 = 1;
                    num = ForearmL1[i].eulerAngles.x;
                    string str60 = num.ToString("0.###");
                    strArray53[index40] = str60;
                    strArray52[2] = ",";
                    string[] strArray54 = strArray52;
                    int index41 = 3;
                    num = ForearmL1[i].eulerAngles.y;
                    string str61 = num.ToString("0.###");
                    strArray54[index41] = str61;
                    strArray52[4] = ",";
                    string[] strArray55 = strArray52;
                    int index42 = 5;
                    num = ForearmL1[i].eulerAngles.z;
                    string str62 = num.ToString("0.###");
                    strArray55[index42] = str62;
                    strArray52[6] = ":";
                    string str63 = string.Concat(strArray52);
                    string[] strArray56 = new string[7];
                    strArray56[0] = str63;
                    string[] strArray57 = strArray56;
                    int index43 = 1;
                    num = HandR1[i].localEulerAngles.x;
                    string str64 = num.ToString("0.###");
                    strArray57[index43] = str64;
                    strArray56[2] = ",";
                    string[] strArray58 = strArray56;
                    int index44 = 3;
                    num = HandR1[i].localEulerAngles.y;
                    string str65 = num.ToString("0.###");
                    strArray58[index44] = str65;
                    strArray56[4] = ",";
                    string[] strArray59 = strArray56;
                    int index45 = 5;
                    num = HandR1[i].localEulerAngles.z;
                    string str66 = num.ToString("0.###");
                    strArray59[index45] = str66;
                    strArray56[6] = ":";
                    string str67 = string.Concat(strArray56);
                    string[] strArray60 = new string[7];
                    strArray60[0] = str67;
                    string[] strArray61 = strArray60;
                    int index46 = 1;
                    num = UpperArmR1[i].eulerAngles.x;
                    string str68 = num.ToString("0.###");
                    strArray61[index46] = str68;
                    strArray60[2] = ",";
                    string[] strArray62 = strArray60;
                    int index47 = 3;
                    num = UpperArmR1[i].eulerAngles.y;
                    string str69 = num.ToString("0.###");
                    strArray62[index47] = str69;
                    strArray60[4] = ",";
                    string[] strArray63 = strArray60;
                    int index48 = 5;
                    num = UpperArmR1[i].eulerAngles.z;
                    string str70 = num.ToString("0.###");
                    strArray63[index48] = str70;
                    strArray60[6] = ":";
                    string str71 = string.Concat(strArray60);
                    string[] strArray64 = new string[7];
                    strArray64[0] = str71;
                    string[] strArray65 = strArray64;
                    int index49 = 1;
                    num = ForearmR1[i].eulerAngles.x;
                    string str72 = num.ToString("0.###");
                    strArray65[index49] = str72;
                    strArray64[2] = ",";
                    string[] strArray66 = strArray64;
                    int index50 = 3;
                    num = ForearmR1[i].eulerAngles.y;
                    string str73 = num.ToString("0.###");
                    strArray66[index50] = str73;
                    strArray64[4] = ",";
                    string[] strArray67 = strArray64;
                    int index51 = 5;
                    num = ForearmR1[i].eulerAngles.z;
                    string str74 = num.ToString("0.###");
                    strArray67[index51] = str74;
                    strArray64[6] = ":";
                    string str75 = string.Concat(strArray64);
                    string[] strArray68 = new string[7];
                    strArray68[0] = str75;
                    string[] strArray69 = strArray68;
                    int index52 = 1;
                    num = HandL2[i].localEulerAngles.x;
                    string str76 = num.ToString("0.###");
                    strArray69[index52] = str76;
                    strArray68[2] = ",";
                    string[] strArray70 = strArray68;
                    int index53 = 3;
                    num = HandL2[i].localEulerAngles.y;
                    string str77 = num.ToString("0.###");
                    strArray70[index53] = str77;
                    strArray68[4] = ",";
                    string[] strArray71 = strArray68;
                    int index54 = 5;
                    num = HandL2[i].localEulerAngles.z;
                    string str78 = num.ToString("0.###");
                    strArray71[index54] = str78;
                    strArray68[6] = ":";
                    string str79 = string.Concat(strArray68);
                    string[] strArray72 = new string[7];
                    strArray72[0] = str79;
                    string[] strArray73 = strArray72;
                    int index55 = 1;
                    num = UpperArmL2[i].eulerAngles.x;
                    string str80 = num.ToString("0.###");
                    strArray73[index55] = str80;
                    strArray72[2] = ",";
                    string[] strArray74 = strArray72;
                    int index56 = 3;
                    num = UpperArmL2[i].eulerAngles.y;
                    string str81 = num.ToString("0.###");
                    strArray74[index56] = str81;
                    strArray72[4] = ",";
                    string[] strArray75 = strArray72;
                    int index57 = 5;
                    num = UpperArmL2[i].eulerAngles.z;
                    string str82 = num.ToString("0.###");
                    strArray75[index57] = str82;
                    strArray72[6] = ":";
                    string str83 = string.Concat(strArray72);
                    string[] strArray76 = new string[7];
                    strArray76[0] = str83;
                    string[] strArray77 = strArray76;
                    int index58 = 1;
                    num = ForearmL2[i].eulerAngles.x;
                    string str84 = num.ToString("0.###");
                    strArray77[index58] = str84;
                    strArray76[2] = ",";
                    string[] strArray78 = strArray76;
                    int index59 = 3;
                    num = ForearmL2[i].eulerAngles.y;
                    string str85 = num.ToString("0.###");
                    strArray78[index59] = str85;
                    strArray76[4] = ",";
                    string[] strArray79 = strArray76;
                    int index60 = 5;
                    num = ForearmL2[i].eulerAngles.z;
                    string str86 = num.ToString("0.###");
                    strArray79[index60] = str86;
                    strArray76[6] = ":";
                    string str87 = string.Concat(strArray76);
                    string[] strArray80 = new string[7];
                    strArray80[0] = str87;
                    string[] strArray81 = strArray80;
                    int index61 = 1;
                    num = HandR2[i].localEulerAngles.x;
                    string str88 = num.ToString("0.###");
                    strArray81[index61] = str88;
                    strArray80[2] = ",";
                    string[] strArray82 = strArray80;
                    int index62 = 3;
                    num = HandR2[i].localEulerAngles.y;
                    string str89 = num.ToString("0.###");
                    strArray82[index62] = str89;
                    strArray80[4] = ",";
                    string[] strArray83 = strArray80;
                    int index63 = 5;
                    num = HandR2[i].localEulerAngles.z;
                    string str90 = num.ToString("0.###");
                    strArray83[index63] = str90;
                    strArray80[6] = ":";
                    string str91 = string.Concat(strArray80);
                    string[] strArray84 = new string[7];
                    strArray84[0] = str91;
                    string[] strArray85 = strArray84;
                    int index64 = 1;
                    num = UpperArmR2[i].eulerAngles.x;
                    string str92 = num.ToString("0.###");
                    strArray85[index64] = str92;
                    strArray84[2] = ",";
                    string[] strArray86 = strArray84;
                    int index65 = 3;
                    num = UpperArmR2[i].eulerAngles.y;
                    string str93 = num.ToString("0.###");
                    strArray86[index65] = str93;
                    strArray84[4] = ",";
                    string[] strArray87 = strArray84;
                    int index66 = 5;
                    num = UpperArmR2[i].eulerAngles.z;
                    string str94 = num.ToString("0.###");
                    strArray87[index66] = str94;
                    strArray84[6] = ":";
                    string str95 = string.Concat(strArray84);
                    string[] strArray88 = new string[7];
                    strArray88[0] = str95;
                    string[] strArray89 = strArray88;
                    int index67 = 1;
                    num = ForearmR2[i].eulerAngles.x;
                    string str96 = num.ToString("0.###");
                    strArray89[index67] = str96;
                    strArray88[2] = ",";
                    string[] strArray90 = strArray88;
                    int index68 = 3;
                    num = ForearmR2[i].eulerAngles.y;
                    string str97 = num.ToString("0.###");
                    strArray90[index68] = str97;
                    strArray88[4] = ",";
                    string[] strArray91 = strArray88;
                    int index69 = 5;
                    num = ForearmR2[i].eulerAngles.z;
                    string str98 = num.ToString("0.###");
                    strArray91[index69] = str98;
                    strArray88[6] = ":";
                    string str99 = string.Concat(strArray88);
                    string[] strArray92 = new string[7];
                    strArray92[0] = str99;
                    string[] strArray93 = strArray92;
                    int index70 = 1;
                    num = Head.eulerAngles.x;
                    string str100 = num.ToString("0.###");
                    strArray93[index70] = str100;
                    strArray92[2] = ",";
                    string[] strArray94 = strArray92;
                    int index71 = 3;
                    num = Head.eulerAngles.y;
                    string str101 = num.ToString("0.###");
                    strArray94[index71] = str101;
                    strArray92[4] = ",";
                    string[] strArray95 = strArray92;
                    int index72 = 5;
                    num = Head.eulerAngles.z;
                    string str102 = num.ToString("0.###");
                    strArray95[index72] = str102;
                    strArray92[6] = ":";
                    string str103 = string.Concat(strArray92);
                    string[] strArray96 = new string[7];
                    strArray96[0] = str103;
                    string[] strArray97 = strArray96;
                    int index73 = 1;
                    num = maid.transform.localEulerAngles.x;
                    string str104 = num.ToString("0.###");
                    strArray97[index73] = str104;
                    strArray96[2] = ",";
                    string[] strArray98 = strArray96;
                    int index74 = 3;
                    num = maid.transform.localEulerAngles.y;
                    string str105 = num.ToString("0.###");
                    strArray98[index74] = str105;
                    strArray96[4] = ",";
                    string[] strArray99 = strArray96;
                    int index75 = 5;
                    num = maid.transform.localEulerAngles.z;
                    string str106 = num.ToString("0.###");
                    strArray99[index75] = str106;
                    strArray96[6] = ":";
                    string str107 = string.Concat(strArray96);
                    string[] strArray100 = new string[7];
                    strArray100[0] = str107;
                    string[] strArray101 = strArray100;
                    int index76 = 1;
                    num = maid.transform.position.x;
                    string str108 = num.ToString("0.###");
                    strArray101[index76] = str108;
                    strArray100[2] = ",";
                    string[] strArray102 = strArray100;
                    int index77 = 3;
                    num = maid.transform.position.y;
                    string str109 = num.ToString("0.###");
                    strArray102[index77] = str109;
                    strArray100[4] = ",";
                    string[] strArray103 = strArray100;
                    int index78 = 5;
                    num = maid.transform.position.z;
                    string str110 = num.ToString("0.###");
                    strArray103[index78] = str110;
                    strArray100[6] = ":";
                    string str111 = string.Concat(strArray100);
                    string[] strArray104 = new string[7];
                    strArray104[0] = str111;
                    string[] strArray105 = strArray104;
                    int index79 = 1;
                    num = maid.transform.localScale.x;
                    string str112 = num.ToString("0.###");
                    strArray105[index79] = str112;
                    strArray104[2] = ",";
                    string[] strArray106 = strArray104;
                    int index80 = 3;
                    num = maid.transform.localScale.y;
                    string str113 = num.ToString("0.###");
                    strArray106[index80] = str113;
                    strArray104[4] = ",";
                    string[] strArray107 = strArray104;
                    int index81 = 5;
                    num = maid.transform.localScale.z;
                    string str114 = num.ToString("0.###");
                    strArray107[index81] = str114;
                    strArray104[6] = ":";
                    string str115 = string.Concat(strArray104);
                    string str116;
                    if (poseArray[poseIndex[i]].Contains("MultipleMaidsPose"))
                    {
                        string str26 = poseArray[poseIndex[i]].Replace("　", "").Split('/')[0];
                        str116 = str115 + "MultipleMaidsPose" + str26.Replace("_", " ").Replace(",", "|") + ":";
                    }
                    else
                    {
                        str116 = str115 + poseArray[poseIndex[i]].Replace("_", " ").Replace(",", "|") + ":";
                    }

                    string str117 = str116 + faceIndex[i] + ":";
                    TMorph morph = maid.body0.Face.morph;
                    float[] fieldValue1 = GetFieldValue<TMorph, float[]>(morph, "BlendValues");
                    float[] fieldValue2 = GetFieldValue<TMorph, float[]>(morph, "BlendValuesBackup");
                    string str118 = str117 + fieldValue2[(int)morph.hash["eyeclose"]] + ","
                                    + fieldValue2[(int)morph.hash["eyeclose2"]] + ","
                                    + fieldValue2[(int)morph.hash["eyeclose3"]] + ","
                                    + fieldValue2[(int)morph.hash["eyeclose6"]] + ","
                                    + fieldValue1[(int)morph.hash["hitomih"]] + ","
                                    + fieldValue1[(int)morph.hash["hitomis"]] + ","
                                    + fieldValue1[(int)morph.hash["mayuha"]] + ","
                                    + fieldValue1[(int)morph.hash["mayuup"]] + ","
                                    + fieldValue1[(int)morph.hash["mayuv"]] + ","
                                    + fieldValue1[(int)morph.hash["mayuvhalf"]] + ","
                                    + fieldValue1[(int)morph.hash["moutha"]] + ","
                                    + fieldValue1[(int)morph.hash["mouths"]] + ","
                                    + fieldValue1[(int)morph.hash["mouthdw"]] + ","
                                    + fieldValue1[(int)morph.hash["mouthup"]] + ","
                                    + fieldValue1[(int)morph.hash["tangout"]] + ","
                                    + fieldValue1[(int)morph.hash["tangup"]] + ","
                                    + fieldValue1[(int)morph.hash["eyebig"]] + ","
                                    + fieldValue2[(int)morph.hash["eyeclose5"]] + ","
                                    + fieldValue1[(int)morph.hash["mayuw"]] + ","
                                    + fieldValue1[(int)morph.hash["mouthhe"]] + ","
                                    + fieldValue1[(int)morph.hash["mouthc"]] + ","
                                    + fieldValue1[(int)morph.hash["mouthi"]] + ","
                                    + fieldValue1[(int)morph.hash["mouthuphalf"]] + ",";
                    string str119;
                    try
                    {
                        str119 = str118 + fieldValue1[(int)morph.hash["tangopen"]] + ",";
                    }
                    catch
                    {
                        str119 = str118 + "0,";
                    }

                    string str120 = fieldValue1[(int)morph.hash["namida"]] <= 0.0
                                            ? str119 + 0 + ","
                                            : str119 + 1 + ",";
                    string str121 = fieldValue1[(int)morph.hash["tear1"]] <= 0.0
                                            ? str120 + 0 + ","
                                            : str120 + 1 + ",";
                    string str122 = fieldValue1[(int)morph.hash["tear2"]] <= 0.0
                                            ? str121 + 0 + ","
                                            : str121 + 1 + ",";
                    string str123 = fieldValue1[(int)morph.hash["tear3"]] <= 0.0
                                            ? str122 + 0 + ","
                                            : str122 + 1 + ",";
                    string str124 = fieldValue1[(int)morph.hash["shock"]] <= 0.0
                                            ? str123 + 0 + ","
                                            : str123 + 1 + ",";
                    string str125 = fieldValue1[(int)morph.hash["yodare"]] <= 0.0
                                            ? str124 + 0 + ","
                                            : str124 + 1 + ",";
                    string str126 = fieldValue1[(int)morph.hash["hoho"]] <= 0.0
                                            ? str125 + 0 + ","
                                            : str125 + 1 + ",";
                    string str127 = fieldValue1[(int)morph.hash["hoho2"]] <= 0.0
                                            ? str126 + 0 + ","
                                            : str126 + 1 + ",";
                    string str128 = fieldValue1[(int)morph.hash["hohos"]] <= 0.0
                                            ? str127 + 0 + ","
                                            : str127 + 1 + ",";
                    string str129 = fieldValue1[(int)morph.hash["hohol"]] <= 0.0
                                            ? str128 + 0 + ","
                                            : str128 + 1 + ",";
                    string str130 = fieldValue1[(int)morph.hash["toothoff"]] <= 0.0
                                            ? str129 + 0 + ","
                                            : str129 + 1 + ",";
                    string str131 = fieldValue1[(int)morph.hash["nosefook"]] <= 0.0
                                            ? str130 + 0 + ":"
                                            : str130 + 1 + ":";
                    string str132 = "";
                    string str133 =
                            (!isLook[i]
                                     ? str132 + 0 + ",0,0:"
                                     : str132 + 1 + "," + lookX[i].ToString("0.###") + "," + lookY[i].ToString("0.###")
                                                 + ":").ToString() + itemIndex[i] + ":";
                    Transform transform1 = CMT.SearchObjName(maid.body0.m_Bones.transform, "_IK_handL", true);
                    Transform transform2 = CMT.SearchObjName(maid.body0.m_Bones.transform, "_IK_handR", true);
                    string str134 = str133 + transform1.localEulerAngles.x.ToString("0.###") + ","
                                    + transform1.localEulerAngles.y.ToString("0.###") + ","
                                    + transform1.localEulerAngles.z.ToString("0.###") + ":"
                                    + transform2.localEulerAngles.x.ToString("0.###") + ","
                                    + transform2.localEulerAngles.y.ToString("0.###") + ","
                                    + transform2.localEulerAngles.z.ToString("0.###") + ":";
                    string[] strArray108 = new string[7];
                    strArray108[0] = str134;
                    string[] strArray109 = strArray108;
                    int index82 = 1;
                    num = ClavicleL1[i].eulerAngles.x;
                    string str135 = num.ToString("0.###");
                    strArray109[index82] = str135;
                    strArray108[2] = ",";
                    string[] strArray110 = strArray108;
                    int index83 = 3;
                    num = ClavicleL1[i].eulerAngles.y;
                    string str136 = num.ToString("0.###");
                    strArray110[index83] = str136;
                    strArray108[4] = ",";
                    string[] strArray111 = strArray108;
                    int index84 = 5;
                    num = ClavicleL1[i].eulerAngles.z;
                    string str137 = num.ToString("0.###");
                    strArray111[index84] = str137;
                    strArray108[6] = ":";
                    string str138 = string.Concat(strArray108);
                    string[] strArray112 = new string[7];
                    strArray112[0] = str138;
                    string[] strArray113 = strArray112;
                    int index85 = 1;
                    num = ClavicleR1[i].eulerAngles.x;
                    string str139 = num.ToString("0.###");
                    strArray113[index85] = str139;
                    strArray112[2] = ",";
                    string[] strArray114 = strArray112;
                    int index86 = 3;
                    num = ClavicleR1[i].eulerAngles.y;
                    string str140 = num.ToString("0.###");
                    strArray114[index86] = str140;
                    strArray112[4] = ",";
                    string[] strArray115 = strArray112;
                    int index87 = 5;
                    num = ClavicleR1[i].eulerAngles.z;
                    string str141 = num.ToString("0.###");
                    strArray115[index87] = str141;
                    strArray112[6] = ":";
                    string str142 = string.Concat(strArray112);
                    string str143 = !hanten[i] ? str142 + "0:" : str142 + "1:";
                    Transform transform3 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01", true);
                    Transform transform4 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L Toe0", true);
                    Transform transform5 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R Toe0", true);
                    Transform transform6 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L Toe01", true);
                    Transform transform7 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R Toe01", true);
                    Transform transform8 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L Toe0Nub", true);
                    Transform transform9 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R Toe0Nub", true);
                    Transform transform10 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L Toe1", true);
                    Transform transform11 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R Toe1", true);
                    Transform transform12 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L Toe11", true);
                    Transform transform13 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R Toe11", true);
                    Transform transform14 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L Toe1Nub", true);
                    Transform transform15 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R Toe1Nub", true);
                    Transform transform16 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L Toe2", true);
                    Transform transform17 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R Toe2", true);
                    Transform transform18 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L Toe21", true);
                    Transform transform19 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R Toe21", true);
                    Transform transform20 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L Toe2Nub", true);
                    Transform transform21 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R Toe2Nub", true);
                    string str144 = str143;
                    string[] strArray116 = new string[7];
                    strArray116[0] = str144;
                    string[] strArray117 = strArray116;
                    int index88 = 1;
                    num = transform3.eulerAngles.x;
                    string str145 = num.ToString("0.###");
                    strArray117[index88] = str145;
                    strArray116[2] = ",";
                    string[] strArray118 = strArray116;
                    int index89 = 3;
                    num = transform3.eulerAngles.y;
                    string str146 = num.ToString("0.###");
                    strArray118[index89] = str146;
                    strArray116[4] = ",";
                    string[] strArray119 = strArray116;
                    int index90 = 5;
                    num = transform3.eulerAngles.z;
                    string str147 = num.ToString("0.###");
                    strArray119[index90] = str147;
                    strArray116[6] = ":";
                    string str148 = string.Concat(strArray116);
                    string[] strArray120 = new string[7];
                    strArray120[0] = str148;
                    string[] strArray121 = strArray120;
                    int index91 = 1;
                    num = transform4.localEulerAngles.x;
                    string str149 = num.ToString("0.###");
                    strArray121[index91] = str149;
                    strArray120[2] = ",";
                    string[] strArray122 = strArray120;
                    int index92 = 3;
                    num = transform4.localEulerAngles.y;
                    string str150 = num.ToString("0.###");
                    strArray122[index92] = str150;
                    strArray120[4] = ",";
                    string[] strArray123 = strArray120;
                    int index93 = 5;
                    num = transform4.localEulerAngles.z;
                    string str151 = num.ToString("0.###");
                    strArray123[index93] = str151;
                    strArray120[6] = ":";
                    string str152 = string.Concat(strArray120);
                    string[] strArray124 = new string[7];
                    strArray124[0] = str152;
                    string[] strArray125 = strArray124;
                    int index94 = 1;
                    num = transform5.localEulerAngles.x;
                    string str153 = num.ToString("0.###");
                    strArray125[index94] = str153;
                    strArray124[2] = ",";
                    string[] strArray126 = strArray124;
                    int index95 = 3;
                    num = transform5.localEulerAngles.y;
                    string str154 = num.ToString("0.###");
                    strArray126[index95] = str154;
                    strArray124[4] = ",";
                    string[] strArray127 = strArray124;
                    int index96 = 5;
                    num = transform5.localEulerAngles.z;
                    string str155 = num.ToString("0.###");
                    strArray127[index96] = str155;
                    strArray124[6] = ":";
                    string str156 = string.Concat(strArray124);
                    string[] strArray128 = new string[7];
                    strArray128[0] = str156;
                    string[] strArray129 = strArray128;
                    int index97 = 1;
                    num = transform6.localEulerAngles.x;
                    string str157 = num.ToString("0.###");
                    strArray129[index97] = str157;
                    strArray128[2] = ",";
                    string[] strArray130 = strArray128;
                    int index98 = 3;
                    num = transform6.localEulerAngles.y;
                    string str158 = num.ToString("0.###");
                    strArray130[index98] = str158;
                    strArray128[4] = ",";
                    string[] strArray131 = strArray128;
                    int index99 = 5;
                    num = transform6.localEulerAngles.z;
                    string str159 = num.ToString("0.###");
                    strArray131[index99] = str159;
                    strArray128[6] = ":";
                    string str160 = string.Concat(strArray128);
                    string[] strArray132 = new string[7];
                    strArray132[0] = str160;
                    string[] strArray133 = strArray132;
                    int index100 = 1;
                    num = transform7.localEulerAngles.x;
                    string str161 = num.ToString("0.###");
                    strArray133[index100] = str161;
                    strArray132[2] = ",";
                    string[] strArray134 = strArray132;
                    int index101 = 3;
                    num = transform7.localEulerAngles.y;
                    string str162 = num.ToString("0.###");
                    strArray134[index101] = str162;
                    strArray132[4] = ",";
                    string[] strArray135 = strArray132;
                    int index102 = 5;
                    num = transform7.localEulerAngles.z;
                    string str163 = num.ToString("0.###");
                    strArray135[index102] = str163;
                    strArray132[6] = ":";
                    string str164 = string.Concat(strArray132);
                    string[] strArray136 = new string[7];
                    strArray136[0] = str164;
                    string[] strArray137 = strArray136;
                    int index103 = 1;
                    num = transform8.localEulerAngles.x;
                    string str165 = num.ToString("0.###");
                    strArray137[index103] = str165;
                    strArray136[2] = ",";
                    string[] strArray138 = strArray136;
                    int index104 = 3;
                    num = transform8.localEulerAngles.y;
                    string str166 = num.ToString("0.###");
                    strArray138[index104] = str166;
                    strArray136[4] = ",";
                    string[] strArray139 = strArray136;
                    int index105 = 5;
                    num = transform8.localEulerAngles.z;
                    string str167 = num.ToString("0.###");
                    strArray139[index105] = str167;
                    strArray136[6] = ":";
                    string str168 = string.Concat(strArray136);
                    string[] strArray140 = new string[7];
                    strArray140[0] = str168;
                    string[] strArray141 = strArray140;
                    int index106 = 1;
                    num = transform9.localEulerAngles.x;
                    string str169 = num.ToString("0.###");
                    strArray141[index106] = str169;
                    strArray140[2] = ",";
                    string[] strArray142 = strArray140;
                    int index107 = 3;
                    num = transform9.localEulerAngles.y;
                    string str170 = num.ToString("0.###");
                    strArray142[index107] = str170;
                    strArray140[4] = ",";
                    string[] strArray143 = strArray140;
                    int index108 = 5;
                    num = transform9.localEulerAngles.z;
                    string str171 = num.ToString("0.###");
                    strArray143[index108] = str171;
                    strArray140[6] = ":";
                    string str172 = string.Concat(strArray140);
                    string[] strArray144 = new string[7];
                    strArray144[0] = str172;
                    string[] strArray145 = strArray144;
                    int index109 = 1;
                    num = transform10.localEulerAngles.x;
                    string str173 = num.ToString("0.###");
                    strArray145[index109] = str173;
                    strArray144[2] = ",";
                    string[] strArray146 = strArray144;
                    int index110 = 3;
                    num = transform10.localEulerAngles.y;
                    string str174 = num.ToString("0.###");
                    strArray146[index110] = str174;
                    strArray144[4] = ",";
                    string[] strArray147 = strArray144;
                    int index111 = 5;
                    num = transform10.localEulerAngles.z;
                    string str175 = num.ToString("0.###");
                    strArray147[index111] = str175;
                    strArray144[6] = ":";
                    string str176 = string.Concat(strArray144);
                    string[] strArray148 = new string[7];
                    strArray148[0] = str176;
                    string[] strArray149 = strArray148;
                    int index112 = 1;
                    num = transform11.localEulerAngles.x;
                    string str177 = num.ToString("0.###");
                    strArray149[index112] = str177;
                    strArray148[2] = ",";
                    string[] strArray150 = strArray148;
                    int index113 = 3;
                    num = transform11.localEulerAngles.y;
                    string str178 = num.ToString("0.###");
                    strArray150[index113] = str178;
                    strArray148[4] = ",";
                    string[] strArray151 = strArray148;
                    int index114 = 5;
                    num = transform11.localEulerAngles.z;
                    string str179 = num.ToString("0.###");
                    strArray151[index114] = str179;
                    strArray148[6] = ":";
                    string str180 = string.Concat(strArray148);
                    string[] strArray152 = new string[7];
                    strArray152[0] = str180;
                    string[] strArray153 = strArray152;
                    int index115 = 1;
                    num = transform12.localEulerAngles.x;
                    string str181 = num.ToString("0.###");
                    strArray153[index115] = str181;
                    strArray152[2] = ",";
                    string[] strArray154 = strArray152;
                    int index116 = 3;
                    num = transform12.localEulerAngles.y;
                    string str182 = num.ToString("0.###");
                    strArray154[index116] = str182;
                    strArray152[4] = ",";
                    string[] strArray155 = strArray152;
                    int index117 = 5;
                    num = transform12.localEulerAngles.z;
                    string str183 = num.ToString("0.###");
                    strArray155[index117] = str183;
                    strArray152[6] = ":";
                    string str184 = string.Concat(strArray152);
                    string[] strArray156 = new string[7];
                    strArray156[0] = str184;
                    string[] strArray157 = strArray156;
                    int index118 = 1;
                    num = transform13.localEulerAngles.x;
                    string str185 = num.ToString("0.###");
                    strArray157[index118] = str185;
                    strArray156[2] = ",";
                    string[] strArray158 = strArray156;
                    int index119 = 3;
                    num = transform13.localEulerAngles.y;
                    string str186 = num.ToString("0.###");
                    strArray158[index119] = str186;
                    strArray156[4] = ",";
                    string[] strArray159 = strArray156;
                    int index120 = 5;
                    num = transform13.localEulerAngles.z;
                    string str187 = num.ToString("0.###");
                    strArray159[index120] = str187;
                    strArray156[6] = ":";
                    string str188 = string.Concat(strArray156);
                    string[] strArray160 = new string[7];
                    strArray160[0] = str188;
                    string[] strArray161 = strArray160;
                    int index121 = 1;
                    num = transform14.localEulerAngles.x;
                    string str189 = num.ToString("0.###");
                    strArray161[index121] = str189;
                    strArray160[2] = ",";
                    string[] strArray162 = strArray160;
                    int index122 = 3;
                    num = transform14.localEulerAngles.y;
                    string str190 = num.ToString("0.###");
                    strArray162[index122] = str190;
                    strArray160[4] = ",";
                    string[] strArray163 = strArray160;
                    int index123 = 5;
                    num = transform14.localEulerAngles.z;
                    string str191 = num.ToString("0.###");
                    strArray163[index123] = str191;
                    strArray160[6] = ":";
                    string str192 = string.Concat(strArray160);
                    string[] strArray164 = new string[7];
                    strArray164[0] = str192;
                    string[] strArray165 = strArray164;
                    int index124 = 1;
                    num = transform15.localEulerAngles.x;
                    string str193 = num.ToString("0.###");
                    strArray165[index124] = str193;
                    strArray164[2] = ",";
                    string[] strArray166 = strArray164;
                    int index125 = 3;
                    num = transform15.localEulerAngles.y;
                    string str194 = num.ToString("0.###");
                    strArray166[index125] = str194;
                    strArray164[4] = ",";
                    string[] strArray167 = strArray164;
                    int index126 = 5;
                    num = transform15.localEulerAngles.z;
                    string str195 = num.ToString("0.###");
                    strArray167[index126] = str195;
                    strArray164[6] = ":";
                    string str196 = string.Concat(strArray164);
                    string[] strArray168 = new string[7];
                    strArray168[0] = str196;
                    string[] strArray169 = strArray168;
                    int index127 = 1;
                    num = transform16.localEulerAngles.x;
                    string str197 = num.ToString("0.###");
                    strArray169[index127] = str197;
                    strArray168[2] = ",";
                    string[] strArray170 = strArray168;
                    int index128 = 3;
                    num = transform16.localEulerAngles.y;
                    string str198 = num.ToString("0.###");
                    strArray170[index128] = str198;
                    strArray168[4] = ",";
                    string[] strArray171 = strArray168;
                    int index129 = 5;
                    num = transform16.localEulerAngles.z;
                    string str199 = num.ToString("0.###");
                    strArray171[index129] = str199;
                    strArray168[6] = ":";
                    string str200 = string.Concat(strArray168);
                    string[] strArray172 = new string[7];
                    strArray172[0] = str200;
                    string[] strArray173 = strArray172;
                    int index130 = 1;
                    num = transform17.localEulerAngles.x;
                    string str201 = num.ToString("0.###");
                    strArray173[index130] = str201;
                    strArray172[2] = ",";
                    string[] strArray174 = strArray172;
                    int index131 = 3;
                    num = transform17.localEulerAngles.y;
                    string str202 = num.ToString("0.###");
                    strArray174[index131] = str202;
                    strArray172[4] = ",";
                    string[] strArray175 = strArray172;
                    int index132 = 5;
                    num = transform17.localEulerAngles.z;
                    string str203 = num.ToString("0.###");
                    strArray175[index132] = str203;
                    strArray172[6] = ":";
                    string str204 = string.Concat(strArray172);
                    string[] strArray176 = new string[7];
                    strArray176[0] = str204;
                    string[] strArray177 = strArray176;
                    int index133 = 1;
                    num = transform18.localEulerAngles.x;
                    string str205 = num.ToString("0.###");
                    strArray177[index133] = str205;
                    strArray176[2] = ",";
                    string[] strArray178 = strArray176;
                    int index134 = 3;
                    num = transform18.localEulerAngles.y;
                    string str206 = num.ToString("0.###");
                    strArray178[index134] = str206;
                    strArray176[4] = ",";
                    string[] strArray179 = strArray176;
                    int index135 = 5;
                    num = transform18.localEulerAngles.z;
                    string str207 = num.ToString("0.###");
                    strArray179[index135] = str207;
                    strArray176[6] = ":";
                    string str208 = string.Concat(strArray176);
                    string[] strArray180 = new string[7];
                    strArray180[0] = str208;
                    string[] strArray181 = strArray180;
                    int index136 = 1;
                    num = transform19.localEulerAngles.x;
                    string str209 = num.ToString("0.###");
                    strArray181[index136] = str209;
                    strArray180[2] = ",";
                    string[] strArray182 = strArray180;
                    int index137 = 3;
                    num = transform19.localEulerAngles.y;
                    string str210 = num.ToString("0.###");
                    strArray182[index137] = str210;
                    strArray180[4] = ",";
                    string[] strArray183 = strArray180;
                    int index138 = 5;
                    num = transform19.localEulerAngles.z;
                    string str211 = num.ToString("0.###");
                    strArray183[index138] = str211;
                    strArray180[6] = ":";
                    string str212 = string.Concat(strArray180);
                    string[] strArray184 = new string[7];
                    strArray184[0] = str212;
                    string[] strArray185 = strArray184;
                    int index139 = 1;
                    num = transform20.localEulerAngles.x;
                    string str213 = num.ToString("0.###");
                    strArray185[index139] = str213;
                    strArray184[2] = ",";
                    string[] strArray186 = strArray184;
                    int index140 = 3;
                    num = transform20.localEulerAngles.y;
                    string str214 = num.ToString("0.###");
                    strArray186[index140] = str214;
                    strArray184[4] = ",";
                    string[] strArray187 = strArray184;
                    int index141 = 5;
                    num = transform20.localEulerAngles.z;
                    string str215 = num.ToString("0.###");
                    strArray187[index141] = str215;
                    strArray184[6] = ":";
                    string str216 = string.Concat(strArray184);
                    string[] strArray188 = new string[7];
                    strArray188[0] = str216;
                    string[] strArray189 = strArray188;
                    int index142 = 1;
                    num = transform21.localEulerAngles.x;
                    string str217 = num.ToString("0.###");
                    strArray189[index142] = str217;
                    strArray188[2] = ",";
                    string[] strArray190 = strArray188;
                    int index143 = 3;
                    num = transform21.localEulerAngles.y;
                    string str218 = num.ToString("0.###");
                    strArray190[index143] = str218;
                    strArray188[4] = ",";
                    string[] strArray191 = strArray188;
                    int index144 = 5;
                    num = transform21.localEulerAngles.z;
                    string str219 = num.ToString("0.###");
                    strArray191[index144] = str219;
                    strArray188[6] = ":";
                    string str220 = string.Concat(strArray188);
                    string[] strArray192 = new string[7];
                    strArray192[0] = str220;
                    string[] strArray193 = strArray192;
                    int index145 = 1;
                    num = maid.body0.quaDefEyeL.eulerAngles.x;
                    string str221 = num.ToString("0.###");
                    strArray193[index145] = str221;
                    strArray192[2] = ",";
                    string[] strArray194 = strArray192;
                    int index146 = 3;
                    num = maid.body0.quaDefEyeL.eulerAngles.y;
                    string str222 = num.ToString("0.###");
                    strArray194[index146] = str222;
                    strArray192[4] = ",";
                    string[] strArray195 = strArray192;
                    int index147 = 5;
                    num = maid.body0.quaDefEyeL.eulerAngles.z;
                    string str223 = num.ToString("0.###");
                    strArray195[index147] = str223;
                    strArray192[6] = ":";
                    string str224 = string.Concat(strArray192);
                    string[] strArray196 = new string[7];
                    strArray196[0] = str224;
                    string[] strArray197 = strArray196;
                    int index148 = 1;
                    num = maid.body0.quaDefEyeR.eulerAngles.x;
                    string str225 = num.ToString("0.###");
                    strArray197[index148] = str225;
                    strArray196[2] = ",";
                    string[] strArray198 = strArray196;
                    int index149 = 3;
                    num = maid.body0.quaDefEyeR.eulerAngles.y;
                    string str226 = num.ToString("0.###");
                    strArray198[index149] = str226;
                    strArray196[4] = ",";
                    string[] strArray199 = strArray196;
                    int index150 = 5;
                    num = maid.body0.quaDefEyeR.eulerAngles.z;
                    string str227 = num.ToString("0.###");
                    strArray199[index150] = str227;
                    strArray196[6] = ":";
                    string str228 = string.Concat(strArray196);
                    Transform transform22 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Mune_L", true);
                    Transform transform23 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Mune_L_sub", true);
                    Transform transform24 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Mune_R", true);
                    Transform transform25 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Mune_R_sub", true);
                    string str229 = str228;
                    string[] strArray200 = new string[7];
                    strArray200[0] = str229;
                    string[] strArray201 = strArray200;
                    int index151 = 1;
                    num = transform22.localEulerAngles.x;
                    string str230 = num.ToString("0.###");
                    strArray201[index151] = str230;
                    strArray200[2] = ",";
                    string[] strArray202 = strArray200;
                    int index152 = 3;
                    num = transform22.localEulerAngles.y;
                    string str231 = num.ToString("0.###");
                    strArray202[index152] = str231;
                    strArray200[4] = ",";
                    string[] strArray203 = strArray200;
                    int index153 = 5;
                    num = transform22.localEulerAngles.z;
                    string str232 = num.ToString("0.###");
                    strArray203[index153] = str232;
                    strArray200[6] = ":";
                    string str233 = string.Concat(strArray200);
                    string[] strArray204 = new string[7];
                    strArray204[0] = str233;
                    string[] strArray205 = strArray204;
                    int index154 = 1;
                    num = transform23.localEulerAngles.x;
                    string str234 = num.ToString("0.###");
                    strArray205[index154] = str234;
                    strArray204[2] = ",";
                    string[] strArray206 = strArray204;
                    int index155 = 3;
                    num = transform23.localEulerAngles.y;
                    string str235 = num.ToString("0.###");
                    strArray206[index155] = str235;
                    strArray204[4] = ",";
                    string[] strArray207 = strArray204;
                    int index156 = 5;
                    num = transform23.localEulerAngles.z;
                    string str236 = num.ToString("0.###");
                    strArray207[index156] = str236;
                    strArray204[6] = ":";
                    string str237 = string.Concat(strArray204);
                    string[] strArray208 = new string[7];
                    strArray208[0] = str237;
                    string[] strArray209 = strArray208;
                    int index157 = 1;
                    num = transform24.localEulerAngles.x;
                    string str238 = num.ToString("0.###");
                    strArray209[index157] = str238;
                    strArray208[2] = ",";
                    string[] strArray210 = strArray208;
                    int index158 = 3;
                    num = transform24.localEulerAngles.y;
                    string str239 = num.ToString("0.###");
                    strArray210[index158] = str239;
                    strArray208[4] = ",";
                    string[] strArray211 = strArray208;
                    int index159 = 5;
                    num = transform24.localEulerAngles.z;
                    string str240 = num.ToString("0.###");
                    strArray211[index159] = str240;
                    strArray208[6] = ":";
                    string str241 = string.Concat(strArray208);
                    string[] strArray212 = new string[7];
                    strArray212[0] = str241;
                    string[] strArray213 = strArray212;
                    int index160 = 1;
                    num = transform25.localEulerAngles.x;
                    string str242 = num.ToString("0.###");
                    strArray213[index160] = str242;
                    strArray212[2] = ",";
                    string[] strArray214 = strArray212;
                    int index161 = 3;
                    num = transform25.localEulerAngles.y;
                    string str243 = num.ToString("0.###");
                    strArray214[index161] = str243;
                    strArray212[4] = ",";
                    string[] strArray215 = strArray212;
                    int index162 = 5;
                    num = transform25.localEulerAngles.z;
                    string str244 = num.ToString("0.###");
                    strArray215[index162] = str244;
                    strArray212[6] = ":";
                    string str245 = string.Concat(strArray212);
                    string[] strArray216 = new string[6];
                    strArray216[0] = str245;
                    string[] strArray217 = strArray216;
                    int index163 = 1;
                    num = transform3.position.x;
                    string str246 = num.ToString("0.###");
                    strArray217[index163] = str246;
                    strArray216[2] = ",";
                    string[] strArray218 = strArray216;
                    int index164 = 3;
                    num = transform3.position.y;
                    string str247 = num.ToString("0.###");
                    strArray218[index164] = str247;
                    strArray216[4] = ",";
                    string[] strArray219 = strArray216;
                    int index165 = 5;
                    num = transform3.position.z;
                    string str248 = num.ToString("0.###");
                    strArray219[index165] = str248;
                    string str249 = string.Concat(strArray216);
                    str1 = str1 + str24 + str25 + str131 + str249;
                    if (i + 1 != maidCnt)
                    {
                        str1 += ";";
                    }
                }

                string str250 = "_" + lightKage[0] + ",";
                string str251;
                if (isBloom)
                {
                    string str24 = str250 + "1," + bloom1 + "," + bloom2 + "," + bloom3 + "," + bloom4
                                   + "," + bloom5 + ",";
                    str251 = !isBloomA ? str24 + "0," : str24 + "1,";
                }
                else
                {
                    str251 = str250 + "0,0,0,0,0,0,0,";
                }

                string str252 =
                        (!isBlur
                                 ? str251 + "0,0,0,0,0,"
                                 : str251 + "1," + blur1 + "," + blur2 + "," + blur3 + ","
                                             + blur4 + ",").ToString() + bokashi + "," + kamiyure + ",";
                string str253;
                if (isDepth)
                {
                    string str24 = str252 + "1," + depth1 + "," + depth2 + "," + depth3 + "," + depth4
                                   + ",";
                    str253 = !isDepthA ? str24 + "0," : str24 + "1,";
                }
                else
                {
                    str253 = str252 + "0,0,0,0,0,0,";
                }

                string str254 = !isFog
                                        ? str253 + "0,0,0,0,0,0,0,0,"
                                        : str253 + "1," + fog1 + "," + fog2 + "," + fog3 + "," + fog4
                                          + "," + fog5 + "," + fog6 + "," + fog7 + ",";
                string str255 = !isSepia ? str254 + "0" : str254 + "1";
                string str256 = "_";
                for (int index15 = 1; index15 < lightList.Count; ++index15)
                {
                    str256 = str256 + lightIndex[index15] + "," + lightColorR[index15] + ","
                             + lightColorG[index15] + "," + lightColorB[index15] + "," + lightX[index15] + ","
                             + lightY[index15] + "," + lightAkarusa[index15] + "," + lightRange[index15] + ";";
                }

                string str257 = "_";
                for (int index15 = 0; index15 < doguBObject.Count; ++index15)
                {
                    string str24 = str257 + doguBObject[index15].name.Replace("_", " ") + ",";
                    string[] strArray20 = new string[7];
                    strArray20[0] = str24;
                    string[] strArray21 = strArray20;
                    int index16 = 1;
                    num = doguBObject[index15].transform.localEulerAngles.x;
                    string str25 = num.ToString("0.###");
                    strArray21[index16] = str25;
                    strArray20[2] = ",";
                    string[] strArray22 = strArray20;
                    int index17 = 3;
                    num = doguBObject[index15].transform.localEulerAngles.y;
                    string str26 = num.ToString("0.###");
                    strArray22[index17] = str26;
                    strArray20[4] = ",";
                    string[] strArray23 = strArray20;
                    int index18 = 5;
                    num = doguBObject[index15].transform.localEulerAngles.z;
                    string str27 = num.ToString("0.###");
                    strArray23[index18] = str27;
                    strArray20[6] = ",";
                    string str28 = string.Concat(strArray20);
                    string[] strArray24 = new string[7];
                    strArray24[0] = str28;
                    string[] strArray25 = strArray24;
                    int index19 = 1;
                    num = doguBObject[index15].transform.position.x;
                    string str29 = num.ToString("0.###");
                    strArray25[index19] = str29;
                    strArray24[2] = ",";
                    string[] strArray26 = strArray24;
                    int index20 = 3;
                    num = doguBObject[index15].transform.position.y;
                    string str30 = num.ToString("0.###");
                    strArray26[index20] = str30;
                    strArray24[4] = ",";
                    string[] strArray27 = strArray24;
                    int index21 = 5;
                    num = doguBObject[index15].transform.position.z;
                    string str31 = num.ToString("0.###");
                    strArray27[index21] = str31;
                    strArray24[6] = ",";
                    string str32 = string.Concat(strArray24);
                    string[] strArray28 = new string[6];
                    strArray28[0] = str32;
                    string[] strArray29 = strArray28;
                    int index22 = 1;
                    num = doguBObject[index15].transform.localScale.x;
                    string str33 = num.ToString("0.###");
                    strArray29[index22] = str33;
                    strArray28[2] = ",";
                    string[] strArray30 = strArray28;
                    int index23 = 3;
                    num = doguBObject[index15].transform.localScale.y;
                    string str34 = num.ToString("0.###");
                    strArray30[index23] = str34;
                    strArray28[4] = ",";
                    string[] strArray31 = strArray28;
                    int index24 = 5;
                    num = doguBObject[index15].transform.localScale.z;
                    string str35 = num.ToString("0.###");
                    strArray31[index24] = str35;
                    str257 = string.Concat(strArray28) + ";";
                }

                string str258 = "_";
                for (int index15 = 0; index15 < lightList.Count; ++index15)
                {
                    str258 = str258 + lightList[index15].transform.position.x + ","
                             + lightList[index15].transform.position.y + "," + lightList[index15].transform.position.z
                             + ";";
                }

                Preferences["scene"]["s" + saveScene].Value = str36 + str1 + str255 + str256 + str257 + str258;
                SaveConfig();
                saveScene = 0;
            }

            for (int index = 0; index < maidCnt; ++index)
            {
                if (haraCount[index] > 0)
                {
                    --haraCount[index];
                    CMT.SearchObjName(maidArray[index].body0.m_Bones.transform, "Bip01", true).position = haraPosition[index];
                }

                if (isLoadFace[index])
                {
                    isLoadFace[index] = false;
                    TMorph morph = maidArray[index].body0.Face.morph;
                    float[] fieldValue = GetFieldValue<TMorph, float[]>(morph, "BlendValues");
                    fieldValue[(int)morph.hash["mouthuphalf"]] = fieldValue[(int)morph.hash["mouthuphalf"]] - 0.01f;
                    maidArray[index].body0.Face.morph.FixBlendValues_Face();
                }
            }

            if (isScene)
            {
                isScene = false;
                string[] strArray1 = Preferences["scene"]["s" + loadScene].Value.Split('_');
                string[] strArray2 = strArray1[1].Split(';');
                string[] strArray3 = strArray1[0].Split(',');
                string[] strArray4 = null;
                string[] strArray5 = null;
                string[] strArray6 = null;
                string[] strArray7 = null;
                if (strArray1.Length >= 5)
                {
                    strArray4 = strArray1[2].Split(',');
                    strArray5 = strArray1[3].Split(';');
                    strArray6 = strArray1[4].Split(';');
                }

                if (strArray1.Length >= 6)
                {
                    strArray7 = strArray1[5].Split(';');
                }

                if (!int.TryParse(strArray3[2], out bgIndex))
                {
                    string str = strArray3[2].Replace(" ", "_");
                    for (int index = 0; index < bgArray.Length; ++index)
                    {
                        if (str == bgArray[index])
                        {
                            bgIndex = index;
                            break;
                        }
                    }
                }

                if (bgArray[bgIndex].Length == 36)
                {
                    GameMain.Instance.BgMgr.ChangeBgMyRoom(bgArray[bgIndex]);
                }
                else
                {
                    GameMain.Instance.BgMgr.ChangeBg(bgArray[bgIndex]);
                }

                bgCombo.selectedItemIndex = bgIndex;
                bg.localEulerAngles = new Vector3(float.Parse(strArray3[3]), float.Parse(strArray3[4]), float.Parse(strArray3[5]));
                bg.position = new Vector3(float.Parse(strArray3[6]), float.Parse(strArray3[7]), float.Parse(strArray3[8]));
                bg.localScale = new Vector3(float.Parse(strArray3[9]), float.Parse(strArray3[10]), float.Parse(strArray3[11]));
                softG = new Vector3(float.Parse(strArray3[12]), float.Parse(strArray3[13]), float.Parse(strArray3[14]));
                for (int index1 = 0; index1 < maidCnt; ++index1)
                {
                    Maid maid = maidArray[index1];
                    delCount[index1] = 20;
                    if (!isVR && goSlot[(int)selectList[index1]] != null)
                    {
                        maidArray[index1].body0.goSlot = new List<TBodySkin>(goSlot[(int)selectList[index1]]);
                        for (int index2 = 0; index2 < bodyHit[(int)selectList[index1]].Count; ++index2)
                        {
                            maidArray[index1].body0.goSlot[index2].bonehair.bodyhit = bodyHit[(int)selectList[index1]][index2];
                        }
                    }

                    for (int index2 = 0; index2 < maid.body0.goSlot.Count; ++index2)
                    {
                        if (maid.body0.goSlot[index2].obj != null)
                        {
                            DynamicBone component = maid.body0.goSlot[index2].obj.GetComponent<DynamicBone>();
                            if (component != null && component.enabled)
                            {
                                component.m_Gravity = new Vector3(softG.x * 5f, softG.y * 5f + kamiyure, softG.z * 5f);
                            }
                        }

                        List<THair1> fieldValue = GetFieldValue<TBoneHair_, List<THair1>>(maid.body0.goSlot[index2].bonehair, "hair1list");
                        for (int index3 = 0; index3 < fieldValue.Count; ++index3)
                        {
                            fieldValue[index3].SoftG = new Vector3(softG.x, softG.y + kamiyure, softG.z);
                        }
                    }
                }

                if (!kankyoLoadFlg)
                {
                    int bgmIndex = this.bgmIndex;
                    this.bgmIndex = int.Parse(strArray3[15]);
                    if (bgmIndex != this.bgmIndex)
                    {
                        GameMain.Instance.SoundMgr.PlayBGM(bgmArray[this.bgmIndex] + ".ogg", 0.0f, true);
                        bgmCombo.selectedItemIndex = this.bgmIndex;
                    }
                }

                if (doguObject.Count > 0 && doguObject[doguSelectIndex] != null)
                {
                    GraphicsUtils.Destroy(doguObject[doguSelectIndex]);
                    doguObject.RemoveAt(doguSelectIndex);
                    doguIndex.RemoveAt(doguSelectIndex);
                }

                doguSelectIndex = 0;
                if (strArray3.Length > 16)
                {
                    effectIndex = int.Parse(strArray3[16]);
                    if (!isVR)
                    {
                        Vignetting component = GameMain.Instance.MainCamera.gameObject.GetComponent<Vignetting>();
                        component.mode = Vignetting.AberrationMode.Simple;
                        component.intensity = -3.98f;
                        component.chromaticAberration = -0.75f;
                        component.axialAberration = 1.18f;
                        component.blurSpread = 4.19f;
                        component.luminanceDependency = 0.494f;
                        component.blurDistance = 1.71f;
                        component.enabled = false;
                        if (kami)
                        {
                            kami.SetActive(false);
                        }

                        if (effectIndex == 0)
                        {
                            component.enabled = false;
                        }

                        if (effectIndex == 1)
                        {
                            component.mode = Vignetting.AberrationMode.Simple;
                            component.intensity = -1f;
                            component.chromaticAberration = 0.0f;
                            component.axialAberration = 0.0f;
                            component.blurSpread = 5f;
                            component.luminanceDependency = 0.0f;
                            component.blurDistance = 0.0f;
                            component.enabled = true;
                        }

                        if (effectIndex == 2)
                        {
                            component.enabled = true;
                        }

                        if (effectIndex == 3)
                        {
                            component.mode = Vignetting.AberrationMode.Simple;
                            component.intensity = 9f;
                            component.chromaticAberration = 0.0f;
                            component.axialAberration = 0.0f;
                            component.blurSpread = 5f;
                            component.luminanceDependency = 0.0f;
                            component.blurDistance = 0.0f;
                            component.enabled = true;
                        }

                        if (effectIndex == 4)
                        {
                            kami = (GameObject)Instantiate(Resources.Load("Prefab/p_kamihubuki_photo_ver"));
                            Vector3 localPosition = kami.transform.localPosition;
                            localPosition.y = 3.5f;
                            kami.transform.localPosition = localPosition;
                        }

                        if (effectIndex == 5)
                        {
                            kami = (GameObject)Instantiate(Resources.Load("Prefab/p_kamihubuki_photo_ver"));
                            Vector3 localPosition = kami.transform.localPosition;
                            localPosition.y = 3.5f;
                            kami.transform.localPosition = localPosition;
                            component.enabled = true;
                            component.mode = Vignetting.AberrationMode.Simple;
                            component.intensity = -2.5f;
                            component.chromaticAberration = -0.3f;
                            component.axialAberration = 0.5f;
                            component.blurSpread = 4.5f;
                            component.luminanceDependency = 0.2f;
                            component.blurDistance = 0.8f;
                            component.enabled = true;
                        }

                        Vector3 localPosition1;
                        if (effectIndex == 6)
                        {
                            kami.SetActive(false);
                            kami = (GameObject)Instantiate(Resources.Load("Prefab/p_powder_snow_photo_ver"));
                            localPosition1 = kami.transform.localPosition;
                            localPosition1.y = 3.5f;
                            kami.transform.localPosition = localPosition1;
                        }

                        if (effectIndex == 7)
                        {
                            kami.SetActive(false);
                            kami = (GameObject)Instantiate(Resources.Load("Prefab/p_powder_snow_photo_ver"));
                            localPosition1 = kami.transform.localPosition;
                            localPosition1.y = 3.5f;
                            kami.transform.localPosition = localPosition1;
                            component.enabled = true;
                            component.mode = Vignetting.AberrationMode.Simple;
                            component.intensity = -2.5f;
                            component.chromaticAberration = -0.3f;
                            component.axialAberration = 0.5f;
                            component.blurSpread = 4.5f;
                            component.luminanceDependency = 0.2f;
                            component.blurDistance = 0.8f;
                            component.enabled = true;
                        }

                        if (effectIndex == 8)
                        {
                            kami.SetActive(false);
                            kami = (GameObject)Instantiate(Resources.Load("Prefab/p_powder_snow_photo_ver"));
                            localPosition1 = kami.transform.localPosition;
                            localPosition1.y = 3.5f;
                            kami.transform.localPosition = localPosition1;
                            component.mode = Vignetting.AberrationMode.Simple;
                            component.intensity = 8f;
                            component.chromaticAberration = 0.0f;
                            component.axialAberration = 0.0f;
                            component.blurSpread = 5f;
                            component.luminanceDependency = 0.0f;
                            component.blurDistance = 0.0f;
                            component.enabled = true;
                        }
                    }

                    for (int index = 1; index < lightList.Count; ++index)
                    {
                        GraphicsUtils.Destroy(lightList[index]);
                    }

                    lightIndex = new List<int>
                    {
                        0
                    };
                    lightColorR = new List<float>
                    {
                        1f
                    };
                    lightColorG = new List<float>
                    {
                        1f
                    };
                    lightColorB = new List<float>
                    {
                        1f
                    };
                    lightX = new List<float>
                    {
                        40f
                    };
                    lightY = new List<float>
                    {
                        180f
                    };
                    lightAkarusa = new List<float>
                    {
                        0.95f
                    };
                    lightKage = new List<float>
                    {
                        0.098f
                    };
                    lightRange = new List<float>
                    {
                        50f
                    };
                    lightCombo.selectedItemIndex = 0;
                    lightList = new List<GameObject>
                    {
                        GameMain.Instance.MainLight.gameObject
                    };
                    lightComboList = new GUIContent[lightList.Count];
                    for (int index = 0; index < lightList.Count; ++index)
                    {
                        lightComboList[index] = index != 0 ? new GUIContent("追加" + index) : new GUIContent("メイン");
                    }

                    selectLightIndex = 0;
                    GameMain.Instance.MainLight.Reset();
                    GameMain.Instance.MainLight.SetIntensity(0.95f);
                    GameMain.Instance.MainLight.GetComponent<Light>().spotAngle = 50f;
                    GameMain.Instance.MainLight.GetComponent<Light>().range = 10f;
                    GameMain.Instance.MainLight.gameObject.transform.position = new Vector3(0.0f, 2f, 0.0f);
                    GameMain.Instance.MainLight.GetComponent<Light>().type = LightType.Directional;
                    bgObject.SetActive(true);
                    mainCamera.GetComponent<Camera>().backgroundColor = new Color(0.0f, 0.0f, 0.0f);
                    isIdx1 = false;
                    isIdx2 = false;
                    isIdx3 = false;
                    isIdx4 = false;
                    lightIndex[0] = int.Parse(strArray3[17]);
                    lightColorR[0] = float.Parse(strArray3[18]);
                    lightColorG[0] = float.Parse(strArray3[19]);
                    lightColorB[0] = float.Parse(strArray3[20]);
                    GameMain.Instance.MainLight.Reset();
                    GameMain.Instance.MainLight.SetIntensity(0.95f);
                    GameMain.Instance.MainLight.GetComponent<Light>().spotAngle = 50f;
                    GameMain.Instance.MainLight.GetComponent<Light>().range = 10f;
                    GameMain.Instance.MainLight.gameObject.transform.position = new Vector3(0.0f, 2f, 0.0f);
                    if (lightIndex[0] == 0)
                    {
                        GameMain.Instance.MainLight.GetComponent<Light>().type = LightType.Directional;
                    }
                    else if (lightIndex[0] == 1)
                    {
                        GameMain.Instance.MainLight.transform.eulerAngles += Vector3.right * 40f;
                        GameMain.Instance.MainLight.GetComponent<Light>().type = LightType.Spot;
                    }
                    else if (lightIndex[0] == 2)
                    {
                        GameMain.Instance.MainLight.GetComponent<Light>().type = LightType.Point;
                    }
                    else if (lightIndex[0] == 3)
                    {
                        GameMain.Instance.MainLight.GetComponent<Light>().type = LightType.Directional;
                        bgObject.SetActive(false);
                    }

                    if (lightIndex[0] != 3)
                    {
                        GameMain.Instance.MainLight.GetComponent<Light>().color = new Color(lightColorR[0], lightColorG[0], lightColorB[0]);
                        bgObject.SetActive(true);
                        mainCamera.GetComponent<Camera>().backgroundColor = new Color(0.0f, 0.0f, 0.0f);
                    }
                    else
                    {
                        mainCamera.GetComponent<Camera>().backgroundColor = new Color(lightColorR[0], lightColorG[0], lightColorB[0]);
                    }

                    GameMain.Instance.MainLight.transform.eulerAngles =
                            new Vector3(float.Parse(strArray3[21]), float.Parse(strArray3[22]), float.Parse(strArray3[23]));
                    GameMain.Instance.MainLight.GetComponent<Light>().intensity = float.Parse(strArray3[24]);
                    GameMain.Instance.MainLight.GetComponent<Light>().spotAngle = float.Parse(strArray3[25]);
                    GameMain.Instance.MainLight.GetComponent<Light>().range = float.Parse(strArray3[26]);
                    lightX = new List<float>
                    {
                        float.Parse(strArray3[21])
                    };
                    lightY = new List<float>
                    {
                        float.Parse(strArray3[22])
                    };
                    lightAkarusa = new List<float>
                    {
                        float.Parse(strArray3[24])
                    };
                    lightKage = new List<float>
                    {
                        0.098f
                    };
                    lightRange = new List<float>
                    {
                        float.Parse(strArray3[25])
                    };
                    selectLightIndex = 0;
                    isIdx1 = false;
                    isIdx2 = false;
                    isIdx3 = false;
                    isIdx4 = false;
                    if (!kankyoLoadFlg && !isVR)
                    {
                        mainCamera.SetTargetPos(new Vector3(float.Parse(strArray3[27]),
                                                            float.Parse(strArray3[28]),
                                                            float.Parse(strArray3[29])),
                                                true);
                        mainCamera.SetDistance(float.Parse(strArray3[30]), true);
                        mainCamera.transform.eulerAngles = new Vector3(float.Parse(strArray3[31]), float.Parse(strArray3[32]), float.Parse(strArray3[33]));
                        if (int.Parse(strArray3[34]) == 1)
                        {
                            inName = strArray3[35];
                            inText = strArray3[36];
                            inText = inText.Replace("&kaigyo", "\n");
                            isMessage = true;
                            bGuiMessage = false;
                            GameObject gameObject =
                                    GameObject.Find("__GameMain__/SystemUI Root").transform.Find("MessageWindowPanel").gameObject;
                            MessageWindowMgr messageWindowMgr = GameMain.Instance.ScriptMgr.adv_kag.MessageWindowMgr;
                            messageWindowMgr.OpenMessageWindowPanel();
                            MessageClass messageClass = new MessageClass(gameObject, messageWindowMgr);
                            messageClass.SetText(inName, inText, "", 0, AudioSourceMgr.Type.System);
                            messageClass.FinishChAnime();
                        }
                        else if (isMessage)
                        {
                            isMessage = false;
                            GameObject gameObject =
                                    GameObject.Find("__GameMain__/SystemUI Root").transform.Find("MessageWindowPanel").gameObject;
                            GameMain.Instance.ScriptMgr.adv_kag.MessageWindowMgr.CloseMessageWindowPanel();
                        }
                    }
                }

                if (strArray3.Length > 37 && strArray3[37] != "")
                {
                    if (doguSelectIndex == doguObject.Count)
                    {
                        doguIndex.Add(0);
                    }
                    else if (doguObject.Count > 0 && doguObject[doguSelectIndex] != null)
                    {
                        GraphicsUtils.Destroy(doguObject[doguSelectIndex]);
                        doguObject.RemoveAt(doguSelectIndex);
                    }
                    else
                    {
                        doguIndex.Add(0);
                        doguSelectIndex = doguIndex.Count - 1;
                    }

                    string str = strArray3[37].Replace(" ", "_");
                    for (int index = 0; index < doguArray.Length; ++index)
                    {
                        if (str == doguArray[index])
                        {
                            doguIndex[doguSelectIndex] = index;
                            break;
                        }
                    }

                    if (!doguArray[doguIndex[doguSelectIndex]].StartsWith("mirror"))
                    {
                        Object original = null;
                        for (int index = 0; index < 5; ++index)
                        {
                            original = Resources.Load("Prefab/" + doguArray[doguIndex[doguSelectIndex]]);
                            if (original == null)
                            {
                                List<int> doguIndex;
                                int doguSelectIndex;
                                (doguIndex = this.doguIndex)[doguSelectIndex = this.doguSelectIndex] = doguIndex[doguSelectIndex] + 1;
                            }
                            else
                            {
                                break;
                            }
                        }

                        doguObject.Add(Instantiate(original) as GameObject);
                    }
                    else
                    {
                        Material material = new Material(Shader.Find("Mirror"));
                        GameObject primitive = GameObject.CreatePrimitive(PrimitiveType.Plane);
                        primitive.transform.localScale = new Vector3(0.3f, 1f, 0.3f);
                        primitive.GetComponent<Renderer>().material = material;
                        primitive.AddComponent<MirrorReflection2>();
                        MirrorReflection2 component = primitive.GetComponent<MirrorReflection2>();
                        component.m_TextureSize = 2048;
                        component.m_ClipPlaneOffset = 0.0f;
                        primitive.GetComponent<Renderer>().enabled = true;
                        doguObject.Add(primitive);
                    }

                    Vector3 zero1 = Vector3.zero;
                    Vector3 zero2 = Vector3.zero;
                    zero2.x = -90f;
                    switch (doguIndex[doguSelectIndex])
                    {
                        case 1:
                            zero1.z = -0.5f;
                            break;
                        case 2:
                            zero1.z = -0.5f;
                            break;
                        case 3:
                            zero1.z = 0.5f;
                            zero2.z = 90f;
                            break;
                        case 4:
                            zero1.z = 0.9f;
                            break;
                        case 5:
                            zero1.z = 0.9f;
                            break;
                        case 6:
                            zero1.z = 0.6f;
                            zero2.x = 0.0f;
                            doguObject[doguSelectIndex].transform.localScale = new Vector3(4.5f, 4.5f, 4.5f);
                            break;
                        case 7:
                            zero1.z = 0.6f;
                            doguObject[doguSelectIndex].transform.localScale = new Vector3(3.5f, 3.5f, 3.5f);
                            break;
                        case 8:
                            zero1.z = 0.5f;
                            zero2.x = 0.0f;
                            break;
                        case 9:
                            zero1.z = 0.32f;
                            zero2.z = 180f;
                            break;
                        case 10:
                            zero1.z = 0.6f;
                            break;
                        case 11:
                            zero1.z = 0.6f;
                            break;
                        case 12:
                            zero1.z = 0.5f;
                            zero2.z = 180f;
                            break;
                        case 13:
                            zero1.z = 0.7f;
                            zero2.z = 180f;
                            break;
                        case 14:
                            zero1.z = -0.4f;
                            break;
                        case 15:
                            zero1.z = -0.4f;
                            break;
                        case 16:
                            zero1.z = -0.4f;
                            zero2.z = 180f;
                            break;
                        case 17:
                            zero1.z = -0.4f;
                            break;
                        case 18:
                            zero1.z = -0.2f;
                            break;
                        case 19:
                            zero1.z = 0.0f;
                            break;
                        case 20:
                            zero1.z = 3.4f;
                            zero1.x = -1f;
                            break;
                        case 21:
                            zero1.z = 3.4f;
                            zero1.x = -1f;
                            break;
                        case 22:
                            zero1.z = 3.4f;
                            zero1.y = 0.3f;
                            zero1.x = -1f;
                            break;
                        case 23:
                            zero1.z = 2.7f;
                            zero1.x = 0.77f;
                            zero2.z = 90f;
                            break;
                        case 25:
                            zero1.z = 0.5f;
                            zero1.y = 0.9f;
                            zero2.z = 180f;
                            break;
                        case 26:
                            zero1.z = 0.5f;
                            zero1.y = 0.9f;
                            zero2.z = 180f;
                            break;
                        case 29:
                            zero1.z = 0.5f;
                            zero1.x = -1.05f;
                            break;
                        case 30:
                            zero1.z = 0.0f;
                            zero2.z = 0.0f;
                            doguObject[doguSelectIndex].transform.localScale = new Vector3(0.75f, 0.75f, 0.75f);
                            break;
                        case 31:
                            zero1.z = -0.6f;
                            zero1.y = 0.96f;
                            zero2.z = 180f;
                            doguObject[doguSelectIndex].transform.localScale = new Vector3(0.2f, 0.4f, 0.2f);
                            break;
                        case 32:
                            zero1.z = -0.6f;
                            zero1.y = 0.96f;
                            zero2.z = 180f;
                            doguObject[doguSelectIndex].transform.localScale = new Vector3(0.1f, 0.4f, 0.2f);
                            break;
                        case 33:
                            zero1.z = -0.6f;
                            zero1.y = 0.85f;
                            zero2.z = 180f;
                            doguObject[doguSelectIndex].transform.localScale = new Vector3(0.03f, 0.18f, 0.124f);
                            break;
                        default:
                            zero1.z = 0.5f;
                            break;
                    }

                    doguObject[doguSelectIndex].transform.localPosition = zero1;
                    doguObject[doguSelectIndex].transform.localRotation = Quaternion.Euler(zero2);
                    doguObject[doguSelectIndex].transform.localEulerAngles =
                            new Vector3(float.Parse(strArray3[38]), float.Parse(strArray3[39]), float.Parse(strArray3[40]));
                    doguObject[doguSelectIndex].transform.position =
                            new Vector3(float.Parse(strArray3[41]), float.Parse(strArray3[42]), float.Parse(strArray3[43]));
                    doguObject[doguSelectIndex].transform.localScale =
                            new Vector3(float.Parse(strArray3[44]), float.Parse(strArray3[45]), float.Parse(strArray3[46]));
                }

                if (!kankyoLoadFlg)
                {
                    for (int i = 0; i < strArray2.Length && maidCnt > i; ++i)
                    {
                        Maid maid = maidArray[i];
                        if (maid && maid.Visible)
                        {
                            SetIK(maid, i);
                            Transform transform1 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01", true);
                            Transform transform2 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L Toe0", true);
                            Transform transform3 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R Toe0", true);
                            Transform transform4 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L Toe01", true);
                            Transform transform5 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R Toe01", true);
                            Transform transform6 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L Toe0Nub", true);
                            Transform transform7 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R Toe0Nub", true);
                            Transform transform8 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L Toe1", true);
                            Transform transform9 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R Toe1", true);
                            Transform transform10 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L Toe11", true);
                            Transform transform11 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R Toe11", true);
                            Transform transform12 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L Toe1Nub", true);
                            Transform transform13 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R Toe1Nub", true);
                            Transform transform14 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L Toe2", true);
                            Transform transform15 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R Toe2", true);
                            Transform transform16 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L Toe21", true);
                            Transform transform17 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R Toe21", true);
                            Transform transform18 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L Toe2Nub", true);
                            Transform transform19 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R Toe2Nub", true);
                            string[] strArray8 = strArray2[i].Split(':');
                            for (int index = 0; index < 40; ++index)
                            {
                                string[] strArray9 = strArray8[index].Split(',');
                                Finger[i, index].localEulerAngles =
                                        new Vector3(float.Parse(strArray9[0]), float.Parse(strArray9[1]), float.Parse(strArray9[2]));
                            }

                            bool flag1 = false;
                            if (strArray8.Length == 64)
                            {
                                flag1 = true;
                            }

                            if (!isVR)
                            {
                                maid.body0.quaDefEyeL.eulerAngles = eyeL[(int)selectList[i]];
                                maid.body0.quaDefEyeR.eulerAngles = eyeR[(int)selectList[i]];
                            }

                            for (int index1 = 0; index1 < 3; ++index1)
                            {
                                for (int index2 = 40; index2 < strArray8.Length; ++index2)
                                {
                                    string[] strArray9 = strArray8[index2].Split(',');
                                    switch (index2)
                                    {
                                        case 40:
                                            if (flag1)
                                            {
                                                Spine.localEulerAngles =
                                                        new Vector3(float.Parse(strArray9[0]),
                                                                    float.Parse(strArray9[1]),
                                                                    float.Parse(strArray9[2]));
                                            }

                                            if (!flag1)
                                            {
                                                Spine.eulerAngles = new Vector3(float.Parse(strArray9[0]),
                                                                                float.Parse(strArray9[1]),
                                                                                float.Parse(strArray9[2]));
                                                break;
                                            }

                                            break;
                                        case 41:
                                            if (flag1)
                                            {
                                                Spine0a.localEulerAngles =
                                                        new Vector3(float.Parse(strArray9[0]),
                                                                    float.Parse(strArray9[1]),
                                                                    float.Parse(strArray9[2]));
                                            }

                                            if (!flag1)
                                            {
                                                Spine0a.eulerAngles =
                                                        new Vector3(float.Parse(strArray9[0]),
                                                                    float.Parse(strArray9[1]),
                                                                    float.Parse(strArray9[2]));
                                                break;
                                            }

                                            break;
                                        case 42:
                                            if (flag1)
                                            {
                                                Spine1.localEulerAngles =
                                                        new Vector3(float.Parse(strArray9[0]),
                                                                    float.Parse(strArray9[1]),
                                                                    float.Parse(strArray9[2]));
                                            }

                                            if (!flag1)
                                            {
                                                Spine1.eulerAngles = new Vector3(float.Parse(strArray9[0]),
                                                                                 float.Parse(strArray9[1]),
                                                                                 float.Parse(strArray9[2]));
                                                break;
                                            }

                                            break;
                                        case 43:
                                            if (flag1)
                                            {
                                                Spine1a.localEulerAngles =
                                                        new Vector3(float.Parse(strArray9[0]),
                                                                    float.Parse(strArray9[1]),
                                                                    float.Parse(strArray9[2]));
                                            }

                                            if (!flag1)
                                            {
                                                Spine1a.eulerAngles =
                                                        new Vector3(float.Parse(strArray9[0]),
                                                                    float.Parse(strArray9[1]),
                                                                    float.Parse(strArray9[2]));
                                                break;
                                            }

                                            break;
                                        case 44:
                                            if (flag1)
                                            {
                                                Pelvis.localEulerAngles =
                                                        new Vector3(float.Parse(strArray9[0]),
                                                                    float.Parse(strArray9[1]),
                                                                    float.Parse(strArray9[2]));
                                            }

                                            if (!flag1)
                                            {
                                                Pelvis.eulerAngles = new Vector3(float.Parse(strArray9[0]),
                                                                                 float.Parse(strArray9[1]),
                                                                                 float.Parse(strArray9[2]));
                                                break;
                                            }

                                            break;
                                        case 45:
                                            HandL1[i].localEulerAngles =
                                                    new Vector3(float.Parse(strArray9[0]),
                                                                float.Parse(strArray9[1]),
                                                                float.Parse(strArray9[2]));
                                            break;
                                        case 46:
                                            if (flag1)
                                            {
                                                UpperArmL1[i].localEulerAngles =
                                                        new Vector3(float.Parse(strArray9[0]),
                                                                    float.Parse(strArray9[1]),
                                                                    float.Parse(strArray9[2]));
                                            }

                                            if (!flag1)
                                            {
                                                UpperArmL1[i].eulerAngles =
                                                        new Vector3(float.Parse(strArray9[0]),
                                                                    float.Parse(strArray9[1]),
                                                                    float.Parse(strArray9[2]));
                                                break;
                                            }

                                            break;
                                        case 47:
                                            if (flag1)
                                            {
                                                ForearmL1[i].localEulerAngles =
                                                        new Vector3(float.Parse(strArray9[0]),
                                                                    float.Parse(strArray9[1]),
                                                                    float.Parse(strArray9[2]));
                                            }

                                            if (!flag1)
                                            {
                                                ForearmL1[i].eulerAngles =
                                                        new Vector3(float.Parse(strArray9[0]),
                                                                    float.Parse(strArray9[1]),
                                                                    float.Parse(strArray9[2]));
                                                break;
                                            }

                                            break;
                                        case 48:
                                            HandR1[i].localEulerAngles =
                                                    new Vector3(float.Parse(strArray9[0]),
                                                                float.Parse(strArray9[1]),
                                                                float.Parse(strArray9[2]));
                                            break;
                                        case 49:
                                            if (flag1)
                                            {
                                                UpperArmR1[i].localEulerAngles =
                                                        new Vector3(float.Parse(strArray9[0]),
                                                                    float.Parse(strArray9[1]),
                                                                    float.Parse(strArray9[2]));
                                            }

                                            if (!flag1)
                                            {
                                                UpperArmR1[i].eulerAngles =
                                                        new Vector3(float.Parse(strArray9[0]),
                                                                    float.Parse(strArray9[1]),
                                                                    float.Parse(strArray9[2]));
                                                break;
                                            }

                                            break;
                                        case 50:
                                            if (flag1)
                                            {
                                                ForearmR1[i].localEulerAngles =
                                                        new Vector3(float.Parse(strArray9[0]),
                                                                    float.Parse(strArray9[1]),
                                                                    float.Parse(strArray9[2]));
                                            }

                                            if (!flag1)
                                            {
                                                ForearmR1[i].eulerAngles =
                                                        new Vector3(float.Parse(strArray9[0]),
                                                                    float.Parse(strArray9[1]),
                                                                    float.Parse(strArray9[2]));
                                                break;
                                            }

                                            break;
                                        case 51:
                                            HandL2[i].localEulerAngles =
                                                    new Vector3(float.Parse(strArray9[0]),
                                                                float.Parse(strArray9[1]),
                                                                float.Parse(strArray9[2]));
                                            break;
                                        case 52:
                                            if (flag1)
                                            {
                                                UpperArmL2[i].localEulerAngles =
                                                        new Vector3(float.Parse(strArray9[0]),
                                                                    float.Parse(strArray9[1]),
                                                                    float.Parse(strArray9[2]));
                                            }

                                            if (!flag1)
                                            {
                                                UpperArmL2[i].eulerAngles =
                                                        new Vector3(float.Parse(strArray9[0]),
                                                                    float.Parse(strArray9[1]),
                                                                    float.Parse(strArray9[2]));
                                                break;
                                            }

                                            break;
                                        case 53:
                                            if (flag1)
                                            {
                                                ForearmL2[i].localEulerAngles =
                                                        new Vector3(float.Parse(strArray9[0]),
                                                                    float.Parse(strArray9[1]),
                                                                    float.Parse(strArray9[2]));
                                            }

                                            if (!flag1)
                                            {
                                                ForearmL2[i].eulerAngles =
                                                        new Vector3(float.Parse(strArray9[0]),
                                                                    float.Parse(strArray9[1]),
                                                                    float.Parse(strArray9[2]));
                                                break;
                                            }

                                            break;
                                        case 54:
                                            HandR2[i].localEulerAngles =
                                                    new Vector3(float.Parse(strArray9[0]),
                                                                float.Parse(strArray9[1]),
                                                                float.Parse(strArray9[2]));
                                            break;
                                        case 55:
                                            if (flag1)
                                            {
                                                UpperArmR2[i].localEulerAngles =
                                                        new Vector3(float.Parse(strArray9[0]),
                                                                    float.Parse(strArray9[1]),
                                                                    float.Parse(strArray9[2]));
                                            }

                                            if (!flag1)
                                            {
                                                UpperArmR2[i].eulerAngles =
                                                        new Vector3(float.Parse(strArray9[0]),
                                                                    float.Parse(strArray9[1]),
                                                                    float.Parse(strArray9[2]));
                                                break;
                                            }

                                            break;
                                        case 56:
                                            if (flag1)
                                            {
                                                ForearmR2[i].localEulerAngles =
                                                        new Vector3(float.Parse(strArray9[0]),
                                                                    float.Parse(strArray9[1]),
                                                                    float.Parse(strArray9[2]));
                                            }

                                            if (!flag1)
                                            {
                                                ForearmR2[i].eulerAngles =
                                                        new Vector3(float.Parse(strArray9[0]),
                                                                    float.Parse(strArray9[1]),
                                                                    float.Parse(strArray9[2]));
                                                break;
                                            }

                                            break;
                                        case 57:
                                            if (flag1)
                                            {
                                                Head.localEulerAngles =
                                                        new Vector3(float.Parse(strArray9[0]),
                                                                    float.Parse(strArray9[1]),
                                                                    float.Parse(strArray9[2]));
                                            }

                                            if (!flag1)
                                            {
                                                Head.eulerAngles = new Vector3(float.Parse(strArray9[0]),
                                                                               float.Parse(strArray9[1]),
                                                                               float.Parse(strArray9[2]));
                                                break;
                                            }

                                            break;
                                        case 58:
                                            maid.transform.localEulerAngles =
                                                    new Vector3(float.Parse(strArray9[0]),
                                                                float.Parse(strArray9[1]),
                                                                float.Parse(strArray9[2]));
                                            break;
                                        case 59:
                                            maid.transform.position =
                                                    new Vector3(float.Parse(strArray9[0]),
                                                                float.Parse(strArray9[1]),
                                                                float.Parse(strArray9[2]));
                                            break;
                                        case 60:
                                            maid.transform.localScale =
                                                    new Vector3(float.Parse(strArray9[0]),
                                                                float.Parse(strArray9[1]),
                                                                float.Parse(strArray9[2]));
                                            break;
                                        case 63:
                                            if (index1 <= 0)
                                            {
                                                hanten[i] = false;
                                                hantenn[i] = false;
                                                TMorph morph = maid.body0.Face.morph;
                                                float[] fieldValue1 = GetFieldValue<TMorph, float[]>(morph, "BlendValues");
                                                float[] fieldValue2 = GetFieldValue<TMorph, float[]>(morph, "BlendValuesBackup");
                                                if (!isVR)
                                                {
                                                    maid.boMabataki = false;
                                                }

                                                fieldValue2[(int)morph.hash["eyeclose"]] = float.Parse(strArray9[0]);
                                                fieldValue2[(int)morph.hash["eyeclose2"]] = float.Parse(strArray9[1]);
                                                fieldValue2[(int)morph.hash["eyeclose3"]] = float.Parse(strArray9[2]);
                                                fieldValue2[(int)morph.hash["eyeclose6"]] = float.Parse(strArray9[3]);
                                                fieldValue1[(int)morph.hash["hitomih"]] = float.Parse(strArray9[4]);
                                                fieldValue1[(int)morph.hash["hitomis"]] = float.Parse(strArray9[5]);
                                                fieldValue1[(int)morph.hash["mayuha"]] = float.Parse(strArray9[6]);
                                                fieldValue1[(int)morph.hash["mayuup"]] = float.Parse(strArray9[7]);
                                                fieldValue1[(int)morph.hash["mayuv"]] = float.Parse(strArray9[8]);
                                                fieldValue1[(int)morph.hash["mayuvhalf"]] = float.Parse(strArray9[9]);
                                                fieldValue1[(int)morph.hash["moutha"]] = float.Parse(strArray9[10]);
                                                fieldValue1[(int)morph.hash["mouths"]] = float.Parse(strArray9[11]);
                                                fieldValue1[(int)morph.hash["mouthdw"]] = float.Parse(strArray9[12]);
                                                fieldValue1[(int)morph.hash["mouthup"]] = float.Parse(strArray9[13]);
                                                fieldValue1[(int)morph.hash["tangout"]] = float.Parse(strArray9[14]);
                                                fieldValue1[(int)morph.hash["tangup"]] = float.Parse(strArray9[15]);
                                                fieldValue1[(int)morph.hash["eyebig"]] = float.Parse(strArray9[16]);
                                                fieldValue2[(int)morph.hash["eyeclose5"]] = float.Parse(strArray9[17]);
                                                fieldValue1[(int)morph.hash["mayuw"]] = float.Parse(strArray9[18]);
                                                fieldValue1[(int)morph.hash["mouthhe"]] = float.Parse(strArray9[19]);
                                                fieldValue1[(int)morph.hash["mouthc"]] = float.Parse(strArray9[20]);
                                                fieldValue1[(int)morph.hash["mouthi"]] = float.Parse(strArray9[21]);
                                                fieldValue1[(int)morph.hash["mouthuphalf"]] = float.Parse(strArray9[22]) + 0.01f;
                                                isLoadFace[i] = true;
                                                try
                                                {
                                                    fieldValue1[(int)morph.hash["tangopen"]] = float.Parse(strArray9[23]);
                                                }
                                                catch { }

                                                if (float.Parse(strArray9[24]) == 1.0)
                                                {
                                                    fieldValue1[(int)morph.hash["namida"]] = 1f;
                                                }
                                                else
                                                {
                                                    fieldValue1[(int)morph.hash["namida"]] = 0.0f;
                                                }

                                                if (float.Parse(strArray9[25]) == 1.0)
                                                {
                                                    fieldValue1[(int)morph.hash["tear1"]] = 1f;
                                                }
                                                else
                                                {
                                                    fieldValue1[(int)morph.hash["tear1"]] = 0.0f;
                                                }

                                                if (float.Parse(strArray9[26]) == 1.0)
                                                {
                                                    fieldValue1[(int)morph.hash["tear2"]] = 1f;
                                                }
                                                else
                                                {
                                                    fieldValue1[(int)morph.hash["tear2"]] = 0.0f;
                                                }

                                                if (float.Parse(strArray9[27]) == 1.0)
                                                {
                                                    fieldValue1[(int)morph.hash["tear3"]] = 1f;
                                                }
                                                else
                                                {
                                                    fieldValue1[(int)morph.hash["tear3"]] = 0.0f;
                                                }

                                                if (float.Parse(strArray9[28]) == 1.0)
                                                {
                                                    fieldValue1[(int)morph.hash["shock"]] = 1f;
                                                }
                                                else
                                                {
                                                    fieldValue1[(int)morph.hash["shock"]] = 0.0f;
                                                }

                                                if (float.Parse(strArray9[29]) == 1.0)
                                                {
                                                    fieldValue1[(int)morph.hash["yodare"]] = 1f;
                                                }
                                                else
                                                {
                                                    fieldValue1[(int)morph.hash["yodare"]] = 0.0f;
                                                }

                                                if (float.Parse(strArray9[30]) == 1.0)
                                                {
                                                    fieldValue1[(int)morph.hash["hoho"]] = 0.5f;
                                                }
                                                else
                                                {
                                                    fieldValue1[(int)morph.hash["hoho"]] = 0.0f;
                                                }

                                                if (float.Parse(strArray9[31]) == 1.0)
                                                {
                                                    fieldValue1[(int)morph.hash["hoho2"]] = 0.5f;
                                                }
                                                else
                                                {
                                                    fieldValue1[(int)morph.hash["hoho2"]] = 0.0f;
                                                }

                                                if (float.Parse(strArray9[32]) == 1.0)
                                                {
                                                    fieldValue1[(int)morph.hash["hohos"]] = 1f;
                                                }
                                                else
                                                {
                                                    fieldValue1[(int)morph.hash["hohos"]] = 0.0f;
                                                }

                                                if (float.Parse(strArray9[33]) == 1.0)
                                                {
                                                    fieldValue1[(int)morph.hash["hohol"]] = 1f;
                                                }
                                                else
                                                {
                                                    fieldValue1[(int)morph.hash["hohol"]] = 0.0f;
                                                }

                                                if (float.Parse(strArray9[34]) == 1.0)
                                                {
                                                    fieldValue1[(int)morph.hash["toothoff"]] = 1f;
                                                }
                                                else
                                                {
                                                    fieldValue1[(int)morph.hash["toothoff"]] = 0.0f;
                                                }

                                                if (strArray9.Length > 35)
                                                {
                                                    morph.boNoseFook = float.Parse(strArray9[35]) == 1.0;
                                                }

                                                isFace[i] = true;
                                                isFaceInit = true;
                                                break;
                                            }

                                            break;
                                        case 64:
                                            if (index1 <= 0 && !isVR)
                                            {
                                                if (int.Parse(strArray9[0]) == 1)
                                                {
                                                    isLook[i] = true;
                                                    lookX[i] = float.Parse(strArray9[1]);
                                                    lookY[i] = float.Parse(strArray9[2]);
                                                    if (maid.body0.offsetLookTarget.x != (double)lookY[i])
                                                    {
                                                        int num = !isLock[i] ? 1 : (lookY[i] >= 0.0 ? 1 : 0);
                                                        maid.body0.offsetLookTarget =
                                                                num != 0
                                                                        ? new Vector3(lookY[i], 1f, lookX[i])
                                                                        : new Vector3(lookY[i] * 0.6f, 1f, lookX[i]);
                                                    }

                                                    if (lookX[i] != (double)lookXn[i])
                                                    {
                                                        lookXn[i] = lookX[i];
                                                        maid.body0.offsetLookTarget = new Vector3(lookY[i], 1f, lookX[i]);
                                                    }

                                                    if (lookY[i] != (double)lookYn[i])
                                                    {
                                                        lookYn[i] = lookY[i];
                                                        int num = !isLock[i] ? 1 : (lookY[i] >= 0.0 ? 1 : 0);
                                                        maid.body0.offsetLookTarget =
                                                                num != 0
                                                                        ? new Vector3(lookY[i], 1f, lookX[i])
                                                                        : new Vector3(lookY[i] * 0.6f, 1f, lookX[i]);
                                                    }
                                                }
                                                else
                                                {
                                                    isLook[i] = false;
                                                }

                                                if (isLook[i])
                                                {
                                                    maid.body0.trsLookTarget = GameMain.Instance.MainCamera.transform;
                                                    maid.body0.boHeadToCam = true;
                                                    maid.body0.boEyeToCam = true;
                                                    maid.body0.trsLookTarget = null;
                                                }
                                                else
                                                {
                                                    maid.body0.trsLookTarget = GameMain.Instance.MainCamera.transform;
                                                    maid.body0.boHeadToCam = true;
                                                    maid.body0.boEyeToCam = true;
                                                }

                                                break;
                                            }

                                            break;
                                        case 65:
                                            if (index1 <= 0)
                                            {
                                                if (itemIndex[i] != int.Parse(strArray9[0]))
                                                {
                                                    itemIndex[i] = int.Parse(strArray9[0]);
                                                    if (itemIndex[i] == itemArray.Length - 1)
                                                    {
                                                        itemIndex[i] = 0;
                                                    }

                                                    string[] strArray10 = new string[2];
                                                    string[] strArray11 = itemArray[itemIndex[i]].Split(',');
                                                    if (itemIndex[i] > 13)
                                                    {
                                                        strArray11 = itemArray[itemIndex[i] + 1].Split(',');
                                                    }

                                                    maid.DelProp(MPN.handitem, true);
                                                    maid.DelProp(MPN.accvag, true);
                                                    maid.DelProp(MPN.accanl, true);
                                                    bool flag2 = false;
                                                    if (itemIndex[i] == 12 || itemIndex[i] == 13)
                                                    {
                                                        flag2 = true;
                                                    }

                                                    if (!flag2)
                                                    {
                                                        maid.DelProp(MPN.kousoku_upper, true);
                                                        maid.DelProp(MPN.kousoku_lower, true);
                                                    }

                                                    if (strArray11[0] != "")
                                                    {
                                                        maid.SetProp(strArray11[0], strArray11[1], 0, true, false);
                                                    }

                                                    if (itemIndex[i] == 12)
                                                    {
                                                        string[] strArray12 = itemArray[itemIndex[i] - 1].Split(',');
                                                        maid.SetProp(strArray12[0], strArray12[1], 0, true, false);
                                                    }

                                                    if (itemIndex[i] == 13)
                                                    {
                                                        string[] strArray12 = itemArray[itemIndex[i] + 1].Split(',');
                                                        maid.SetProp(strArray12[0], strArray12[1], 0, true, false);
                                                    }

                                                    if (itemIndex[i] == 23)
                                                    {
                                                        string[] strArray12 = itemArray[itemIndex[i]].Split(',');
                                                        maid.SetProp(strArray12[0], strArray12[1], 0, true, false);
                                                        cafeFlg[i] = true;
                                                    }

                                                    maid.AllProcPropSeqStart();
                                                }

                                                IK_hand = CMT.SearchObjName(maid.body0.m_Bones.transform, "_IK_handL", true);
                                                break;
                                            }

                                            break;
                                        case 66:
                                            CMT.SearchObjName(maid.body0.m_Bones.transform, "_IK_handL", true).localEulerAngles =
                                                    new Vector3(float.Parse(strArray9[0]),
                                                                float.Parse(strArray9[1]),
                                                                float.Parse(strArray9[2]));
                                            break;
                                        case 67:
                                            CMT.SearchObjName(maid.body0.m_Bones.transform, "_IK_handR", true).localEulerAngles =
                                                    new Vector3(float.Parse(strArray9[0]),
                                                                float.Parse(strArray9[1]),
                                                                float.Parse(strArray9[2]));
                                            break;
                                        case 68:
                                            if (strArray9.Length >= 2)
                                            {
                                                ClavicleL1[i].eulerAngles =
                                                        new Vector3(float.Parse(strArray9[0]),
                                                                    float.Parse(strArray9[1]),
                                                                    float.Parse(strArray9[2]));
                                                break;
                                            }

                                            break;
                                        case 69:
                                            ClavicleR1[i].eulerAngles =
                                                    new Vector3(float.Parse(strArray9[0]),
                                                                float.Parse(strArray9[1]),
                                                                float.Parse(strArray9[2]));
                                            break;
                                        case 70:
                                            if (int.Parse(strArray9[0]) == 1)
                                            {
                                                hanten[i] = true;
                                                hantenn[i] = true;
                                                break;
                                            }

                                            break;
                                        case 71:
                                            transform1.eulerAngles =
                                                    new Vector3(float.Parse(strArray9[0]),
                                                                float.Parse(strArray9[1]),
                                                                float.Parse(strArray9[2]));
                                            break;
                                        case 72:
                                            transform2.localEulerAngles =
                                                    new Vector3(float.Parse(strArray9[0]),
                                                                float.Parse(strArray9[1]),
                                                                float.Parse(strArray9[2]));
                                            break;
                                        case 73:
                                            transform3.localEulerAngles =
                                                    new Vector3(float.Parse(strArray9[0]),
                                                                float.Parse(strArray9[1]),
                                                                float.Parse(strArray9[2]));
                                            break;
                                        case 74:
                                            transform4.localEulerAngles =
                                                    new Vector3(float.Parse(strArray9[0]),
                                                                float.Parse(strArray9[1]),
                                                                float.Parse(strArray9[2]));
                                            break;
                                        case 75:
                                            transform5.localEulerAngles =
                                                    new Vector3(float.Parse(strArray9[0]),
                                                                float.Parse(strArray9[1]),
                                                                float.Parse(strArray9[2]));
                                            break;
                                        case 76:
                                            transform6.localEulerAngles =
                                                    new Vector3(float.Parse(strArray9[0]),
                                                                float.Parse(strArray9[1]),
                                                                float.Parse(strArray9[2]));
                                            break;
                                        case 77:
                                            transform7.localEulerAngles =
                                                    new Vector3(float.Parse(strArray9[0]),
                                                                float.Parse(strArray9[1]),
                                                                float.Parse(strArray9[2]));
                                            break;
                                        case 78:
                                            transform8.localEulerAngles =
                                                    new Vector3(float.Parse(strArray9[0]),
                                                                float.Parse(strArray9[1]),
                                                                float.Parse(strArray9[2]));
                                            break;
                                        case 79:
                                            transform9.localEulerAngles =
                                                    new Vector3(float.Parse(strArray9[0]),
                                                                float.Parse(strArray9[1]),
                                                                float.Parse(strArray9[2]));
                                            break;
                                        case 80:
                                            transform10.localEulerAngles =
                                                    new Vector3(float.Parse(strArray9[0]),
                                                                float.Parse(strArray9[1]),
                                                                float.Parse(strArray9[2]));
                                            break;
                                        case 81:
                                            transform11.localEulerAngles =
                                                    new Vector3(float.Parse(strArray9[0]),
                                                                float.Parse(strArray9[1]),
                                                                float.Parse(strArray9[2]));
                                            break;
                                        case 82:
                                            transform12.localEulerAngles =
                                                    new Vector3(float.Parse(strArray9[0]),
                                                                float.Parse(strArray9[1]),
                                                                float.Parse(strArray9[2]));
                                            break;
                                        case 83:
                                            transform13.localEulerAngles =
                                                    new Vector3(float.Parse(strArray9[0]),
                                                                float.Parse(strArray9[1]),
                                                                float.Parse(strArray9[2]));
                                            break;
                                        case 84:
                                            transform14.localEulerAngles =
                                                    new Vector3(float.Parse(strArray9[0]),
                                                                float.Parse(strArray9[1]),
                                                                float.Parse(strArray9[2]));
                                            break;
                                        case 85:
                                            transform15.localEulerAngles =
                                                    new Vector3(float.Parse(strArray9[0]),
                                                                float.Parse(strArray9[1]),
                                                                float.Parse(strArray9[2]));
                                            break;
                                        case 86:
                                            transform16.localEulerAngles =
                                                    new Vector3(float.Parse(strArray9[0]),
                                                                float.Parse(strArray9[1]),
                                                                float.Parse(strArray9[2]));
                                            break;
                                        case 87:
                                            transform17.localEulerAngles =
                                                    new Vector3(float.Parse(strArray9[0]),
                                                                float.Parse(strArray9[1]),
                                                                float.Parse(strArray9[2]));
                                            break;
                                        case 88:
                                            transform18.localEulerAngles =
                                                    new Vector3(float.Parse(strArray9[0]),
                                                                float.Parse(strArray9[1]),
                                                                float.Parse(strArray9[2]));
                                            break;
                                        case 89:
                                            transform19.localEulerAngles =
                                                    new Vector3(float.Parse(strArray9[0]),
                                                                float.Parse(strArray9[1]),
                                                                float.Parse(strArray9[2]));
                                            break;
                                        case 90:
                                            if (!isVR)
                                            {
                                                maid.body0.quaDefEyeL.eulerAngles =
                                                        new Vector3(float.Parse(strArray9[0]),
                                                                    float.Parse(strArray9[1]),
                                                                    float.Parse(strArray9[2]));
                                                break;
                                            }

                                            break;
                                        case 91:
                                            if (!isVR)
                                            {
                                                maid.body0.quaDefEyeR.eulerAngles =
                                                        new Vector3(float.Parse(strArray9[0]),
                                                                    float.Parse(strArray9[1]),
                                                                    float.Parse(strArray9[2]));
                                                break;
                                            }

                                            break;
                                        case 92:
                                            vIKMuneL[i] = new Vector3(float.Parse(strArray9[0]),
                                                                      float.Parse(strArray9[1]),
                                                                      float.Parse(strArray9[2]));
                                            muneIKL[i] = true;
                                            break;
                                        case 93:
                                            vIKMuneLSub[i] = new Vector3(float.Parse(strArray9[0]),
                                                                         float.Parse(strArray9[1]),
                                                                         float.Parse(strArray9[2]));
                                            break;
                                        case 94:
                                            vIKMuneR[i] = new Vector3(float.Parse(strArray9[0]),
                                                                      float.Parse(strArray9[1]),
                                                                      float.Parse(strArray9[2]));
                                            muneIKR[i] = true;
                                            break;
                                        case 95:
                                            vIKMuneRSub[i] = new Vector3(float.Parse(strArray9[0]),
                                                                         float.Parse(strArray9[1]),
                                                                         float.Parse(strArray9[2]));
                                            break;
                                        case 96:
                                            haraCount[i] = 2;
                                            haraPosition[i] = new Vector3(float.Parse(strArray9[0]),
                                                                          float.Parse(strArray9[1]),
                                                                          float.Parse(strArray9[2]));
                                            transform1.position = new Vector3(float.Parse(strArray9[0]),
                                                                              float.Parse(strArray9[1]),
                                                                              float.Parse(strArray9[2]));
                                            break;
                                    }
                                }
                            }

                            isStop[i] = true;
                            isLock[i] = true;
                        }
                    }
                }

                isBloom = false;
                bloom1 = 2.85f;
                bloom2 = 3f;
                bloom3 = 0.0f;
                bloom4 = 0.0f;
                bloom5 = 0.0f;
                isBloomA = false;
                isBlur = false;
                blur1 = -3.98f;
                blur4 = -0.75f;
                blur2 = 0.9f;
                blur3 = 4.19f;
                bokashi = 0.0f;
                kamiyure = 0.0f;
                isDepth = false;
                isDepthA = false;
                depth1 = 3f;
                depth2 = 0.1f;
                depth3 = 15f;
                depth4 = 3f;
                isFog = false;
                fog1 = 4f;
                fog2 = 1f;
                fog3 = 1f;
                fog4 = 0.0f;
                fog5 = 1f;
                fog6 = 1f;
                fog7 = 1f;
                isSepia = false;
                if (strArray4 != null)
                {
                    lightKage[0] = float.Parse(strArray4[0]);
                    if (int.Parse(strArray4[1]) == 1)
                    {
                        isBloom = true;
                        bloom1 = float.Parse(strArray4[2]);
                        bloom2 = float.Parse(strArray4[3]);
                        bloom3 = float.Parse(strArray4[4]);
                        bloom4 = float.Parse(strArray4[5]);
                        bloom5 = float.Parse(strArray4[6]);
                        if (int.Parse(strArray4[7]) == 1)
                        {
                            isBloomA = true;
                        }
                    }

                    if (int.Parse(strArray4[8]) == 1)
                    {
                        isBlur = true;
                        blur1 = float.Parse(strArray4[9]);
                        blur2 = float.Parse(strArray4[10]);
                        blur3 = float.Parse(strArray4[11]);
                        blur4 = float.Parse(strArray4[12]);
                    }

                    bokashi = float.Parse(strArray4[13]);
                    kamiyure = float.Parse(strArray4[14]);
                    if (strArray4.Length > 15)
                    {
                        if (int.Parse(strArray4[15]) == 1)
                        {
                            isDepth = true;
                            depth1 = float.Parse(strArray4[16]);
                            depth2 = float.Parse(strArray4[17]);
                            depth3 = float.Parse(strArray4[18]);
                            depth4 = float.Parse(strArray4[19]);
                            if (int.Parse(strArray4[20]) == 1)
                            {
                                isDepthA = true;
                            }
                        }

                        if (int.Parse(strArray4[21]) == 1)
                        {
                            isFog = true;
                            fog1 = float.Parse(strArray4[22]);
                            fog2 = float.Parse(strArray4[23]);
                            fog3 = float.Parse(strArray4[24]);
                            fog4 = float.Parse(strArray4[25]);
                            fog5 = float.Parse(strArray4[26]);
                            fog6 = float.Parse(strArray4[27]);
                            fog7 = float.Parse(strArray4[28]);
                        }

                        if (int.Parse(strArray4[29]) == 1)
                        {
                            isSepia = true;
                        }
                    }
                }

                if (strArray5 != null)
                {
                    for (int index1 = 0; index1 < strArray5.Length - 1; ++index1)
                    {
                        string[] strArray8 = strArray5[index1].Split(',');
                        GameObject gameObject = new GameObject("Light");
                        gameObject.AddComponent<Light>();
                        lightList.Add(gameObject);
                        lightIndex.Add(int.Parse(strArray8[0]));
                        lightColorR.Add(float.Parse(strArray8[1]));
                        lightColorG.Add(float.Parse(strArray8[2]));
                        lightColorB.Add(float.Parse(strArray8[3]));
                        lightX.Add(float.Parse(strArray8[4]));
                        lightY.Add(float.Parse(strArray8[5]));
                        lightAkarusa.Add(float.Parse(strArray8[6]));
                        lightRange.Add(float.Parse(strArray8[7]));
                        lightKage.Add(0.098f);
                        gameObject.transform.position = GameMain.Instance.MainLight.transform.position;
                        selectLightIndex = lightList.Count - 1;
                        lightComboList = new GUIContent[lightList.Count];
                        for (int index2 = 0; index2 < lightList.Count; ++index2)
                        {
                            lightComboList[index2] = index2 != 0 ? new GUIContent("追加" + index2) : new GUIContent("メイン");
                        }

                        lightCombo.selectedItemIndex = selectLightIndex;
                        gameObject.GetComponent<Light>().intensity = lightAkarusa[index1];
                        gameObject.GetComponent<Light>().spotAngle = lightRange[index1];
                        gameObject.GetComponent<Light>().range = lightRange[index1] / 5f;
                        if (lightIndex[selectLightIndex] == 0)
                        {
                            lightList[selectLightIndex].GetComponent<Light>().type = LightType.Directional;
                        }
                        else if (lightIndex[selectLightIndex] == 1)
                        {
                            lightList[selectLightIndex].GetComponent<Light>().type = LightType.Spot;
                        }
                        else if (lightIndex[selectLightIndex] == 2)
                        {
                            lightList[selectLightIndex].GetComponent<Light>().type = LightType.Point;
                        }
                        else if (lightIndex[selectLightIndex] == 3)
                        {
                            lightList[selectLightIndex].GetComponent<Light>().type = LightType.Directional;
                            lightList[selectLightIndex].SetActive(false);
                        }
                    }
                }

                if (strArray7 != null)
                {
                    for (int index = 0; index < lightList.Count; ++index)
                    {
                        string[] strArray8 = strArray7[index].Split(',');
                        lightList[index].transform.position =
                                new Vector3(float.Parse(strArray8[0]), float.Parse(strArray8[1]), float.Parse(strArray8[2]));
                        if (gLight[index] == null)
                        {
                            gLight[index] = GameObject.CreatePrimitive(PrimitiveType.Cube);
                            gLight[index].GetComponent<Renderer>().material =
                                    new Material(Shader.Find("Transparent/Diffuse")) { color = new Color(0.5f, 0.5f, 1f, 0.8f) };
                            gLight[index].layer = 8;
                            gLight[index].GetComponent<Renderer>().enabled = false;
                            gLight[index].SetActive(false);
                            gLight[index].transform.position = lightList[index].transform.position;
                            mLight[index] = gLight[index].AddComponent<MouseDrag6>();
                            mLight[index].obj = gLight[index];
                            mLight[index].maid = lightList[index].gameObject;
                            mLight[index].angles = lightList[index].transform.eulerAngles;
                            gLight[index].transform.localScale = new Vector3(0.12f, 0.12f, 0.12f);
                            mLight[index].ido = 1;
                            mLight[index].isScale = false;
                        }
                    }
                }

                if (strArray6 != null)
                {
                    for (int index = 0; index < doguBObject.Count; ++index)
                    {
                        GraphicsUtils.Destroy(doguBObject[index]);
                    }

                    doguBObject = new List<GameObject>();
                    for (int index1 = 0; index1 < strArray6.Length - 1; ++index1)
                    {
                        string[] strArray8 = strArray6[index1].Split(',');
                        string str1 = strArray8[0].Replace(" ", "_");
                        GameObject original1 = null;
                        bool flag1 = true;
                        if (str1.Contains(".menu"))
                        {
                            string str2 = str1;
                            byte[] f_byBuf = null;
                            using (AFileBase afileBase = GameUty.FileOpen(str2, null))
                            {
                                if (flag1 = afileBase.IsValid())
                                {
                                    f_byBuf = new byte[afileBase.GetSize()];
                                    afileBase.Read(ref f_byBuf, afileBase.GetSize());
                                }
                            }
                            if (flag1)
                            {
                                string[] filename2 = ProcScriptBin(maidArray[0], f_byBuf, str2, false);
                                original1 = ImportCM2.LoadSkinMesh_R(filename2[0], filename2, "", maidArray[0].body0.goSlot[8], 1);
                                doguBObject.Add(original1);
                                original1.name = str2;
                                Vector3 zero1 = Vector3.zero;
                                Vector3 zero2 = Vector3.zero;
                                zero1.z = 0.4f;

                                if (str1.Contains("HandItem"))
                                {
                                    switch (str1)
                                    {
                                        case "HandItemR_WineGlass_I_.menu":
                                            zero2.z = 90f;
                                            zero1.y = 0.04f;
                                            goto case "HandItemL_Dance_Hataki_I_.menu";
                                        case "HandItemR_WineBottle_I_.menu":
                                            zero2.z = 90f;
                                            goto case "HandItemL_Dance_Hataki_I_.menu";
                                        case "HandItemR_Mop_I_.menu":
                                            zero2.x = 90f;
                                            goto case "HandItemL_Dance_Hataki_I_.menu";
                                        case "HandItemL_Dance_Hataki_I_.menu":
                                        case "HandItemL_Dance_Mop_I_.menu": break;
                                        default:
                                            zero2.x = -90f;
                                            goto case "HandItemL_Dance_Hataki_I_.menu";
                                    }
                                }

                                original1.transform.localPosition = zero1;
                                original1.transform.localRotation = Quaternion.Euler(zero2);
                            }
                        }
                        else
                        {
                            try
                            {
                                bool flag2 = false;
                                bool flag3 = false;
                                if (str1.StartsWith("BG_"))
                                {
                                    Object original2 = GameMain.Instance.BgMgr.CreateAssetBundle(str1.Replace("BG_", ""));
                                    if (original2 == null)
                                    {
                                        original2 = Resources.Load(str1.Replace("BG_", "BG/"));
                                    }

                                    original1 = Instantiate(original2) as GameObject;
                                    doguBObject.Add(original1);
                                }
                                else if (str1.Contains("#"))
                                {
                                    original1 = GameMain.Instance.BgMgr.CreateAssetBundle(str1.Split('#')[1]);
                                    if (original1 != null)
                                    {
                                        original1 = Instantiate(original1);
                                        MeshRenderer[] componentsInChildren = original1.GetComponentsInChildren<MeshRenderer>();
                                        for (int index2 = 0; index2 < componentsInChildren.Length; ++index2)
                                        {
                                            if (componentsInChildren[index2] != null)
                                            {
                                                componentsInChildren[index2].shadowCastingMode = ShadowCastingMode.Off;
                                            }
                                        }
                                    }

                                    flag2 = true;
                                    if (!parArray[parIndex].Contains("Odogu_"))
                                    {
                                        flag3 = true;
                                    }

                                    doguBObject.Add(original1);
                                }
                                else if (!str1.StartsWith("mirror") && str1.IndexOf(":") < 0)
                                {
                                    Object original2;
                                    bool isBG = str1.StartsWith("BG");
                                    string name = isBG ? str1.Replace("BG", "") : str1;

                                    original2 = GameMain.Instance.BgMgr.CreateAssetBundle(name);
                                    if (original2 == null)
                                    {
                                        original2 = Resources.Load((isBG ? "BG/" : "Prefab/") + name);
                                    }

                                    original1 = Instantiate(original2) as GameObject;
                                    doguBObject.Add(original1);
                                }
                                else if (str1.StartsWith("mirror"))
                                {
                                    Material material = new Material(Shader.Find("Mirror"));
                                    GameObject primitive = GameObject.CreatePrimitive(PrimitiveType.Plane);
                                    primitive.transform.localScale = new Vector3(0.3f, 1f, 0.3f);
                                    primitive.GetComponent<Renderer>().material = material;
                                    primitive.AddComponent<MirrorReflection2>();
                                    MirrorReflection2 component = primitive.GetComponent<MirrorReflection2>();
                                    component.m_TextureSize = 2048;
                                    component.m_ClipPlaneOffset = 0.0f;
                                    primitive.GetComponent<Renderer>().enabled = true;
                                    original1 = primitive;
                                    doguBObject.Add(original1);
                                }
                                else
                                {
                                    string[] strArray9 = str1.Split(':');
                                    Object original2 = GameMain.Instance.BgMgr.CreateAssetBundle(strArray9[0]);
                                    if (original2 == null)
                                    {
                                        original2 = Resources.Load("BG/" + strArray9[0]);
                                    }

                                    GameObject gameObject = Instantiate(original2) as GameObject;
                                    int num = 0;
                                    int.TryParse(strArray9[1], out int result);
                                    foreach (Transform transform in gameObject.transform)
                                    {
                                        if (result == num)
                                        {
                                            original1 = transform.gameObject;
                                            break;
                                        }

                                        ++num;
                                    }

                                    doguBObject.Add(original1);
                                    original1.transform.parent = null;
                                    GraphicsUtils.Destroy(gameObject);
                                    gameObject.SetActive(false);
                                }

                                original1.name = str1;
                                Vector3 zero1 = Vector3.zero;
                                Vector3 zero2 = Vector3.zero;
                                if (str1.StartsWith("BG_"))
                                {
                                    original1.transform.localScale = new Vector3(0.1f, 0.1f, 0.1f);
                                }

                                switch (str1)
                                {
                                    case "Odogu_XmasTreeMini_photo_ver":
                                        zero1.z = 0.6f;
                                        original1.transform.localScale = new Vector3(4.5f, 4.5f, 4.5f);
                                        IEnumerator enumerator1 = original1.transform.GetEnumerator();
                                        try
                                        {
                                            while (enumerator1.MoveNext())
                                            {
                                                Transform current = (Transform)enumerator1.Current;
                                                if (current.GetComponent<Collider>() != null)
                                                {
                                                    current.GetComponent<Collider>().enabled = false;
                                                }
                                            }

                                            break;
                                        }
                                        finally
                                        {
                                            (enumerator1 as IDisposable)?.Dispose();
                                        }
                                    case "Odogu_KadomatsuMini_photo_ver":
                                        zero1.z = 0.6f;
                                        original1.transform.localScale = new Vector3(3.5f, 3.5f, 3.5f);
                                        IEnumerator enumerator2 = original1.transform.GetEnumerator();
                                        try
                                        {
                                            while (enumerator2.MoveNext())
                                            {
                                                Transform current = (Transform)enumerator2.Current;
                                                if (current.GetComponent<Collider>() != null)
                                                {
                                                    current.GetComponent<Collider>().enabled = false;
                                                }
                                            }

                                            break;
                                        }
                                        finally
                                        {
                                            (enumerator2 as IDisposable)?.Dispose();
                                        }
                                    case "Odogu_ClassRoomDesk":
                                        zero1.z = 0.5f;
                                        zero2.x = -90f;
                                        break;
                                    case "mirror1":
                                        zero1.z = -0.6f;
                                        zero1.y = 0.96f;
                                        zero2.z = 180f;
                                        zero2.x = -90f;
                                        original1.transform.localScale = new Vector3(0.2f, 0.4f, 0.2f);
                                        break;
                                    case "mirror2":
                                        zero1.z = -0.6f;
                                        zero1.y = 0.96f;
                                        zero2.z = 180f;
                                        zero2.x = -90f;
                                        original1.transform.localScale = new Vector3(0.1f, 0.4f, 0.2f);
                                        break;
                                    case "mirror3":
                                        zero1.z = -0.6f;
                                        zero1.y = 0.85f;
                                        zero2.z = 180f;
                                        zero2.x = -90f;
                                        original1.transform.localScale = new Vector3(0.03f, 0.18f, 0.124f);
                                        break;
                                    case "Particle/pLineY":
                                    case "Particle/pLineP02":
                                    case "Particle/pLine_act2":
                                        original1.transform.localScale = new Vector3(3f, 3f, 3f);
                                        break;
                                    case "Mob_Man_Stand001":
                                    case "Mob_Man_Stand002":
                                    case "Mob_Man_Stand003":
                                    case "Mob_Man_Sit001":
                                    case "Mob_Man_Sit002":
                                    case "Mob_Man_Sit003":
                                    case "Mob_Girl_Stand001":
                                    case "Mob_Girl_Stand002":
                                    case "Mob_Girl_Stand003":
                                    case "Mob_Girl_Sit001":
                                    case "Mob_Girl_Sit002":
                                    case "Mob_Girl_Sit003":
                                    case "Salon:63":
                                    case "Salon:65":
                                    case "Salon:69":
                                    case "Salon_Entrance:0":
                                    case "Salon_Entrance:1":
                                    case "Salon_Entrance:2":
                                    case "Salon_Entrance:3":
                                    case "Salon_Entrance:4":
                                    case "Pool:26":
                                    case "Shitsumu:23":
                                    case "Shitsumu_Night:23":
                                        zero1.z = 0.5f;
                                        zero2.x = -90f;
                                        break;
                                    case "Odogu_Dresser_photo_ver":
                                        GameObject.Find("Prim.00000000").GetComponent<Collider>().enabled = false;
                                        GameObject.Find("Prim.00000001").GetComponent<Collider>().enabled = false;
                                        GameObject.Find("Prim.00000002").GetComponent<Collider>().enabled = false;
                                        GameObject.Find("Prim.00000004").GetComponent<Collider>().enabled = false;
                                        break;
                                    default:
                                        zero1.z = 0.5f;
                                        if (str1.StartsWith("Odogu_"))
                                        {
                                            IEnumerator enumerator3 = original1.transform.GetEnumerator();
                                            try
                                            {
                                                while (enumerator3.MoveNext())
                                                {
                                                    Transform current = (Transform)enumerator3.Current;
                                                    if (current.GetComponent<Collider>() != null)
                                                    {
                                                        current.GetComponent<Collider>().enabled = false;
                                                    }
                                                }

                                                break;
                                            }
                                            finally
                                            {
                                                (enumerator3 as IDisposable)?.Dispose();
                                            }
                                        }
                                        else
                                        {
                                            if (original1.GetComponent<Collider>() != null)
                                            {
                                                original1.GetComponent<Collider>().enabled = false;
                                            }

                                            break;
                                        }
                                }

                                if (flag2)
                                {
                                    zero1.z = 0.4f;
                                    if (flag3)
                                    {
                                        zero2.x = -90f;
                                    }
                                }

                                original1.transform.localPosition = zero1;
                                original1.transform.localRotation = Quaternion.Euler(zero2);
                            }
                            catch
                            {
                                flag1 = false;
                            }
                        }

                        if (flag1)
                        {
                            doguCnt = doguBObject.Count - 1;
                            gDogu[doguCnt] = GameObject.CreatePrimitive(PrimitiveType.Cube);
                            Vector3 localEulerAngles = original1.transform.localEulerAngles;
                            original1.transform.localEulerAngles =
                                    new Vector3(float.Parse(strArray8[1]), float.Parse(strArray8[2]), float.Parse(strArray8[3]));
                            original1.transform.position =
                                    new Vector3(float.Parse(strArray8[4]), float.Parse(strArray8[5]), float.Parse(strArray8[6]));
                            gDogu[doguCnt].transform.localEulerAngles =
                                    new Vector3(float.Parse(strArray8[1]), float.Parse(strArray8[2]), float.Parse(strArray8[3]));
                            gDogu[doguCnt].transform.position =
                                    new Vector3(float.Parse(strArray8[4]), float.Parse(strArray8[5]), float.Parse(strArray8[6]));
                            gDogu[doguCnt].GetComponent<Renderer>().material = m_material;
                            gDogu[doguCnt].layer = 8;
                            gDogu[doguCnt].GetComponent<Renderer>().enabled = false;
                            gDogu[doguCnt].SetActive(false);
                            gDogu[doguCnt].transform.position = original1.transform.position;
                            mDogu[doguCnt] = gDogu[doguCnt].AddComponent<MouseDrag6>();
                            mDogu[doguCnt].obj = gDogu[doguCnt];
                            mDogu[doguCnt].maid = original1;
                            mDogu[doguCnt].angles = localEulerAngles;
                            gDogu[doguCnt].transform.localScale = new Vector3(cubeSize, cubeSize, cubeSize);
                            mDogu[doguCnt].ido = 1;
                            mDogu[doguCnt].isScale = false;
                            if (str1 == "Particle/pLineY")
                            {
                                mDogu[doguCnt].count = 180;
                            }

                            if (str1 == "Particle/pLineP02")
                            {
                                mDogu[doguCnt].count = 115;
                            }

                            if (original1.name == "Particle/pLine_act2")
                            {
                                mDogu[doguCnt].count = 80;
                                original1.transform.localScale = new Vector3(3f, 3f, 3f);
                            }

                            if (original1.name == "Particle/pHeart01")
                            {
                                mDogu[doguCnt].count = 80;
                            }

                            if (str1 == "mirror1" || str1 == "mirror2" || str1 == "mirror3")
                            {
                                mDogu[doguCnt].isScale = true;
                                mDogu[doguCnt].isScale2 = true;
                                mDogu[doguCnt].scale2 = original1.transform.localScale;
                                if (str1 == "mirror1")
                                {
                                    mDogu[doguCnt].scale = new Vector3(original1.transform.localScale.x * 5f,
                                                                       original1.transform.localScale.y * 5f,
                                                                       original1.transform.localScale.z * 5f);
                                }

                                if (str1 == "mirror2")
                                {
                                    mDogu[doguCnt].scale = new Vector3(original1.transform.localScale.x * 10f,
                                                                       original1.transform.localScale.y * 10f,
                                                                       original1.transform.localScale.z * 10f);
                                }

                                if (str1 == "mirror3")
                                {
                                    mDogu[doguCnt].scale = new Vector3(original1.transform.localScale.x * 33f,
                                                                       original1.transform.localScale.y * 33f,
                                                                       original1.transform.localScale.z * 33f);
                                }
                            }

                            if (str1 == "Odogu_XmasTreeMini_photo_ver" || str1 == "Odogu_KadomatsuMini_photo_ver")
                            {
                                mDogu[doguCnt].isScale2 = true;
                                mDogu[doguCnt].scale2 = original1.transform.localScale;
                            }

                            original1.transform.localScale =
                                    new Vector3(float.Parse(strArray8[7]), float.Parse(strArray8[8]), float.Parse(strArray8[9]));
                        }
                    }
                }

                loadScene = 0;
                kankyoLoadFlg = false;
            }

            for (int i = 0; i < maidCnt; ++i)
            {
                if (loadPose[i] != "" && isLoadPose[i])
                {
                    IniKey iniKey = Preferences["pose"][loadPose[i]];
                    if (iniKey.Value == null || iniKey.Value.ToString() == "" || iniKey.Value.ToString() == "del")
                    {
                        loadPose[i] = "";
                        isLoadPose[i] = false;
                    }
                    else
                    {
                        if (loadCount[i] > 4)
                        {
                            isLoadPose[i] = false;
                            loadPose[i] = "";
                            loadCount[i] = 0;
                        }

                        int num = 0;
                        while (num < 10)
                        {
                            ++num;
                        }

                        ++loadCount[i];
                        Maid maid = maidArray[i];
                        isStop[i] = true;
                        if (maid && maid.Visible)
                        {
                            SetIK(maid, i);
                            Transform transform1 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01", true);
                            Transform transform2 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L Toe0", true);
                            Transform transform3 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R Toe0", true);
                            Transform transform4 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L Toe01", true);
                            Transform transform5 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R Toe01", true);
                            Transform transform6 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L Toe0Nub", true);
                            Transform transform7 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R Toe0Nub", true);
                            Transform transform8 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L Toe1", true);
                            Transform transform9 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R Toe1", true);
                            Transform transform10 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L Toe11", true);
                            Transform transform11 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R Toe11", true);
                            Transform transform12 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L Toe1Nub", true);
                            Transform transform13 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R Toe1Nub", true);
                            Transform transform14 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L Toe2", true);
                            Transform transform15 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R Toe2", true);
                            Transform transform16 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L Toe21", true);
                            Transform transform17 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R Toe21", true);
                            Transform transform18 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L Toe2Nub", true);
                            Transform transform19 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R Toe2Nub", true);
                            string[] strArray1 = iniKey.Value.Split('_')[1].Split(':');
                            for (int index = 0; index < 40; ++index)
                            {
                                string[] strArray2 = strArray1[index].Split(',');
                                Finger[i, index].localEulerAngles =
                                        new Vector3(float.Parse(strArray2[0]), float.Parse(strArray2[1]), float.Parse(strArray2[2]));
                            }

                            bool flag = false;
                            if (strArray1.Length == 64)
                            {
                                flag = true;
                            }

                            Vector3 localEulerAngles = maid.transform.localEulerAngles;
                            maid.transform.localEulerAngles = new Vector3(0.0f, 0.0f, 0.0f);
                            Vector3 position = maid.transform.position;
                            maid.transform.position = new Vector3(0.0f, 0.0f, 0.0f);
                            for (int index1 = 0; index1 < 3; ++index1)
                            {
                                for (int index2 = 40; index2 < strArray1.Length; ++index2)
                                {
                                    string[] strArray2 = strArray1[index2].Split(',');
                                    switch (index2)
                                    {
                                        case 40:
                                            if (flag)
                                            {
                                                Spine.localEulerAngles =
                                                        new Vector3(float.Parse(strArray2[0]),
                                                                    float.Parse(strArray2[1]),
                                                                    float.Parse(strArray2[2]));
                                            }

                                            if (!flag)
                                            {
                                                Spine.eulerAngles = new Vector3(float.Parse(strArray2[0]),
                                                                                float.Parse(strArray2[1]),
                                                                                float.Parse(strArray2[2]));
                                                break;
                                            }

                                            break;
                                        case 41:
                                            if (flag)
                                            {
                                                Spine0a.localEulerAngles =
                                                        new Vector3(float.Parse(strArray2[0]),
                                                                    float.Parse(strArray2[1]),
                                                                    float.Parse(strArray2[2]));
                                            }

                                            if (!flag)
                                            {
                                                Spine0a.eulerAngles =
                                                        new Vector3(float.Parse(strArray2[0]),
                                                                    float.Parse(strArray2[1]),
                                                                    float.Parse(strArray2[2]));
                                                break;
                                            }

                                            break;
                                        case 42:
                                            if (flag)
                                            {
                                                Spine1.localEulerAngles =
                                                        new Vector3(float.Parse(strArray2[0]),
                                                                    float.Parse(strArray2[1]),
                                                                    float.Parse(strArray2[2]));
                                            }

                                            if (!flag)
                                            {
                                                Spine1.eulerAngles = new Vector3(float.Parse(strArray2[0]),
                                                                                 float.Parse(strArray2[1]),
                                                                                 float.Parse(strArray2[2]));
                                                break;
                                            }

                                            break;
                                        case 43:
                                            if (flag)
                                            {
                                                Spine1a.localEulerAngles =
                                                        new Vector3(float.Parse(strArray2[0]),
                                                                    float.Parse(strArray2[1]),
                                                                    float.Parse(strArray2[2]));
                                            }

                                            if (!flag)
                                            {
                                                Spine1a.eulerAngles =
                                                        new Vector3(float.Parse(strArray2[0]),
                                                                    float.Parse(strArray2[1]),
                                                                    float.Parse(strArray2[2]));
                                                break;
                                            }

                                            break;
                                        case 44:
                                            if (flag)
                                            {
                                                Pelvis.localEulerAngles =
                                                        new Vector3(float.Parse(strArray2[0]),
                                                                    float.Parse(strArray2[1]),
                                                                    float.Parse(strArray2[2]));
                                            }

                                            if (!flag)
                                            {
                                                Pelvis.eulerAngles = new Vector3(float.Parse(strArray2[0]),
                                                                                 float.Parse(strArray2[1]),
                                                                                 float.Parse(strArray2[2]));
                                                break;
                                            }

                                            break;
                                        case 45:
                                            HandL1[i].localEulerAngles =
                                                    new Vector3(float.Parse(strArray2[0]),
                                                                float.Parse(strArray2[1]),
                                                                float.Parse(strArray2[2]));
                                            break;
                                        case 46:
                                            if (flag)
                                            {
                                                UpperArmL1[i].localEulerAngles =
                                                        new Vector3(float.Parse(strArray2[0]),
                                                                    float.Parse(strArray2[1]),
                                                                    float.Parse(strArray2[2]));
                                            }

                                            if (!flag)
                                            {
                                                UpperArmL1[i].eulerAngles =
                                                        new Vector3(float.Parse(strArray2[0]),
                                                                    float.Parse(strArray2[1]),
                                                                    float.Parse(strArray2[2]));
                                                break;
                                            }

                                            break;
                                        case 47:
                                            if (flag)
                                            {
                                                ForearmL1[i].localEulerAngles =
                                                        new Vector3(float.Parse(strArray2[0]),
                                                                    float.Parse(strArray2[1]),
                                                                    float.Parse(strArray2[2]));
                                            }

                                            if (!flag)
                                            {
                                                ForearmL1[i].eulerAngles =
                                                        new Vector3(float.Parse(strArray2[0]),
                                                                    float.Parse(strArray2[1]),
                                                                    float.Parse(strArray2[2]));
                                                break;
                                            }

                                            break;
                                        case 48:
                                            HandR1[i].localEulerAngles =
                                                    new Vector3(float.Parse(strArray2[0]),
                                                                float.Parse(strArray2[1]),
                                                                float.Parse(strArray2[2]));
                                            break;
                                        case 49:
                                            if (flag)
                                            {
                                                UpperArmR1[i].localEulerAngles =
                                                        new Vector3(float.Parse(strArray2[0]),
                                                                    float.Parse(strArray2[1]),
                                                                    float.Parse(strArray2[2]));
                                            }

                                            if (!flag)
                                            {
                                                UpperArmR1[i].eulerAngles =
                                                        new Vector3(float.Parse(strArray2[0]),
                                                                    float.Parse(strArray2[1]),
                                                                    float.Parse(strArray2[2]));
                                                break;
                                            }

                                            break;
                                        case 50:
                                            if (flag)
                                            {
                                                ForearmR1[i].localEulerAngles =
                                                        new Vector3(float.Parse(strArray2[0]),
                                                                    float.Parse(strArray2[1]),
                                                                    float.Parse(strArray2[2]));
                                            }

                                            if (!flag)
                                            {
                                                ForearmR1[i].eulerAngles =
                                                        new Vector3(float.Parse(strArray2[0]),
                                                                    float.Parse(strArray2[1]),
                                                                    float.Parse(strArray2[2]));
                                                break;
                                            }

                                            break;
                                        case 51:
                                            HandL2[i].localEulerAngles =
                                                    new Vector3(float.Parse(strArray2[0]),
                                                                float.Parse(strArray2[1]),
                                                                float.Parse(strArray2[2]));
                                            break;
                                        case 52:
                                            if (flag)
                                            {
                                                UpperArmL2[i].localEulerAngles =
                                                        new Vector3(float.Parse(strArray2[0]),
                                                                    float.Parse(strArray2[1]),
                                                                    float.Parse(strArray2[2]));
                                            }

                                            if (!flag)
                                            {
                                                UpperArmL2[i].eulerAngles =
                                                        new Vector3(float.Parse(strArray2[0]),
                                                                    float.Parse(strArray2[1]),
                                                                    float.Parse(strArray2[2]));
                                                break;
                                            }

                                            break;
                                        case 53:
                                            if (flag)
                                            {
                                                ForearmL2[i].localEulerAngles =
                                                        new Vector3(float.Parse(strArray2[0]),
                                                                    float.Parse(strArray2[1]),
                                                                    float.Parse(strArray2[2]));
                                            }

                                            if (!flag)
                                            {
                                                ForearmL2[i].eulerAngles =
                                                        new Vector3(float.Parse(strArray2[0]),
                                                                    float.Parse(strArray2[1]),
                                                                    float.Parse(strArray2[2]));
                                                break;
                                            }

                                            break;
                                        case 54:
                                            HandR2[i].localEulerAngles =
                                                    new Vector3(float.Parse(strArray2[0]),
                                                                float.Parse(strArray2[1]),
                                                                float.Parse(strArray2[2]));
                                            break;
                                        case 55:
                                            if (flag)
                                            {
                                                UpperArmR2[i].localEulerAngles =
                                                        new Vector3(float.Parse(strArray2[0]),
                                                                    float.Parse(strArray2[1]),
                                                                    float.Parse(strArray2[2]));
                                            }

                                            if (!flag)
                                            {
                                                UpperArmR2[i].eulerAngles =
                                                        new Vector3(float.Parse(strArray2[0]),
                                                                    float.Parse(strArray2[1]),
                                                                    float.Parse(strArray2[2]));
                                                break;
                                            }

                                            break;
                                        case 56:
                                            if (flag)
                                            {
                                                ForearmR2[i].localEulerAngles =
                                                        new Vector3(float.Parse(strArray2[0]),
                                                                    float.Parse(strArray2[1]),
                                                                    float.Parse(strArray2[2]));
                                            }

                                            if (!flag)
                                            {
                                                ForearmR2[i].eulerAngles =
                                                        new Vector3(float.Parse(strArray2[0]),
                                                                    float.Parse(strArray2[1]),
                                                                    float.Parse(strArray2[2]));
                                                break;
                                            }

                                            break;
                                        case 57:
                                            if (flag)
                                            {
                                                Head.localEulerAngles =
                                                        new Vector3(float.Parse(strArray2[0]),
                                                                    float.Parse(strArray2[1]),
                                                                    float.Parse(strArray2[2]));
                                            }

                                            if (!flag)
                                            {
                                                Head.eulerAngles = new Vector3(float.Parse(strArray2[0]),
                                                                               float.Parse(strArray2[1]),
                                                                               float.Parse(strArray2[2]));
                                                break;
                                            }

                                            break;
                                        case 66:
                                            CMT.SearchObjName(maid.body0.m_Bones.transform, "_IK_handL", true).localEulerAngles =
                                                    new Vector3(float.Parse(strArray2[0]),
                                                                float.Parse(strArray2[1]),
                                                                float.Parse(strArray2[2]));
                                            break;
                                        case 67:
                                            CMT.SearchObjName(maid.body0.m_Bones.transform, "_IK_handR", true).localEulerAngles =
                                                    new Vector3(float.Parse(strArray2[0]),
                                                                float.Parse(strArray2[1]),
                                                                float.Parse(strArray2[2]));
                                            break;
                                        case 68:
                                            if (strArray2.Length >= 2)
                                            {
                                                ClavicleL1[i].eulerAngles =
                                                        new Vector3(float.Parse(strArray2[0]),
                                                                    float.Parse(strArray2[1]),
                                                                    float.Parse(strArray2[2]));
                                                break;
                                            }

                                            break;
                                        case 69:
                                            ClavicleR1[i].eulerAngles =
                                                    new Vector3(float.Parse(strArray2[0]),
                                                                float.Parse(strArray2[1]),
                                                                float.Parse(strArray2[2]));
                                            break;
                                        case 71:
                                            transform1.eulerAngles =
                                                    new Vector3(float.Parse(strArray2[0]),
                                                                float.Parse(strArray2[1]),
                                                                float.Parse(strArray2[2]));
                                            break;
                                        case 72:
                                            transform2.localEulerAngles =
                                                    new Vector3(float.Parse(strArray2[0]),
                                                                float.Parse(strArray2[1]),
                                                                float.Parse(strArray2[2]));
                                            break;
                                        case 73:
                                            transform3.localEulerAngles =
                                                    new Vector3(float.Parse(strArray2[0]),
                                                                float.Parse(strArray2[1]),
                                                                float.Parse(strArray2[2]));
                                            break;
                                        case 74:
                                            transform4.localEulerAngles =
                                                    new Vector3(float.Parse(strArray2[0]),
                                                                float.Parse(strArray2[1]),
                                                                float.Parse(strArray2[2]));
                                            break;
                                        case 75:
                                            transform5.localEulerAngles =
                                                    new Vector3(float.Parse(strArray2[0]),
                                                                float.Parse(strArray2[1]),
                                                                float.Parse(strArray2[2]));
                                            break;
                                        case 76:
                                            transform6.localEulerAngles =
                                                    new Vector3(float.Parse(strArray2[0]),
                                                                float.Parse(strArray2[1]),
                                                                float.Parse(strArray2[2]));
                                            break;
                                        case 77:
                                            transform7.localEulerAngles =
                                                    new Vector3(float.Parse(strArray2[0]),
                                                                float.Parse(strArray2[1]),
                                                                float.Parse(strArray2[2]));
                                            break;
                                        case 78:
                                            transform8.localEulerAngles =
                                                    new Vector3(float.Parse(strArray2[0]),
                                                                float.Parse(strArray2[1]),
                                                                float.Parse(strArray2[2]));
                                            break;
                                        case 79:
                                            transform9.localEulerAngles =
                                                    new Vector3(float.Parse(strArray2[0]),
                                                                float.Parse(strArray2[1]),
                                                                float.Parse(strArray2[2]));
                                            break;
                                        case 80:
                                            transform10.localEulerAngles =
                                                    new Vector3(float.Parse(strArray2[0]),
                                                                float.Parse(strArray2[1]),
                                                                float.Parse(strArray2[2]));
                                            break;
                                        case 81:
                                            transform11.localEulerAngles =
                                                    new Vector3(float.Parse(strArray2[0]),
                                                                float.Parse(strArray2[1]),
                                                                float.Parse(strArray2[2]));
                                            break;
                                        case 82:
                                            transform12.localEulerAngles =
                                                    new Vector3(float.Parse(strArray2[0]),
                                                                float.Parse(strArray2[1]),
                                                                float.Parse(strArray2[2]));
                                            break;
                                        case 83:
                                            transform13.localEulerAngles =
                                                    new Vector3(float.Parse(strArray2[0]),
                                                                float.Parse(strArray2[1]),
                                                                float.Parse(strArray2[2]));
                                            break;
                                        case 84:
                                            transform14.localEulerAngles =
                                                    new Vector3(float.Parse(strArray2[0]),
                                                                float.Parse(strArray2[1]),
                                                                float.Parse(strArray2[2]));
                                            break;
                                        case 85:
                                            transform15.localEulerAngles =
                                                    new Vector3(float.Parse(strArray2[0]),
                                                                float.Parse(strArray2[1]),
                                                                float.Parse(strArray2[2]));
                                            break;
                                        case 86:
                                            transform16.localEulerAngles =
                                                    new Vector3(float.Parse(strArray2[0]),
                                                                float.Parse(strArray2[1]),
                                                                float.Parse(strArray2[2]));
                                            break;
                                        case 87:
                                            transform17.localEulerAngles =
                                                    new Vector3(float.Parse(strArray2[0]),
                                                                float.Parse(strArray2[1]),
                                                                float.Parse(strArray2[2]));
                                            break;
                                        case 88:
                                            transform18.localEulerAngles =
                                                    new Vector3(float.Parse(strArray2[0]),
                                                                float.Parse(strArray2[1]),
                                                                float.Parse(strArray2[2]));
                                            break;
                                        case 89:
                                            transform19.localEulerAngles =
                                                    new Vector3(float.Parse(strArray2[0]),
                                                                float.Parse(strArray2[1]),
                                                                float.Parse(strArray2[2]));
                                            break;
                                        case 92:
                                            vIKMuneL[i] = new Vector3(float.Parse(strArray2[0]),
                                                                      float.Parse(strArray2[1]),
                                                                      float.Parse(strArray2[2]));
                                            muneIKL[i] = true;
                                            break;
                                        case 93:
                                            vIKMuneLSub[i] = new Vector3(float.Parse(strArray2[0]),
                                                                         float.Parse(strArray2[1]),
                                                                         float.Parse(strArray2[2]));
                                            break;
                                        case 94:
                                            vIKMuneR[i] = new Vector3(float.Parse(strArray2[0]),
                                                                      float.Parse(strArray2[1]),
                                                                      float.Parse(strArray2[2]));
                                            muneIKR[i] = true;
                                            break;
                                        case 95:
                                            vIKMuneRSub[i] = new Vector3(float.Parse(strArray2[0]),
                                                                         float.Parse(strArray2[1]),
                                                                         float.Parse(strArray2[2]));
                                            break;
                                        case 96:
                                            transform1.position = new Vector3(float.Parse(strArray2[0]),
                                                                              float.Parse(strArray2[1]),
                                                                              float.Parse(strArray2[2]));
                                            break;
                                    }
                                }
                            }

                            maid.transform.localEulerAngles = localEulerAngles;
                            maid.transform.position = position;
                        }
                    }
                }

                if (loadPose[i] != "" && !isLoadPose[i])
                {
                    IniKey iniKey = Preferences["pose"][loadPose[i]];
                    if (iniKey.Value != null && iniKey.Value.ToString() != "" && iniKey.Value.ToString() != "del")
                    {
                        isStop[i] = true;
                    }

                    isLoadPose[i] = true;
                }
            }

            if (loadScene > 0)
            {
                IniKey iniKey = Preferences["scene"]["s" + loadScene];
                if (iniKey.Value == null || iniKey.Value.ToString() == "")
                {
                    loadScene = 0;
                }
                else
                {
                    isScene = true;
                    if (!kankyoLoadFlg)
                    {
                        string[] strArray1 = iniKey.Value.Split('_')[1].Split(';');
                        for (int i = 0; i < strArray1.Length; ++i)
                        {
                            if (maidCnt > i)
                            {
                                Maid maid = maidArray[i];
                                for (int index = 0; index < 10; ++index)
                                {
                                    Transform transform1 = maid.transform;
                                    Vector3 position1 = maid.transform.position;
                                    Vector3 right = Vector3.right;
                                    rotation = maid.transform.rotation;
                                    double num1 = -rotation.eulerAngles.x;
                                    transform1.RotateAround(position1, right, (float)num1);
                                    Transform transform2 = maid.transform;
                                    Vector3 position2 = maid.transform.position;
                                    Vector3 forward = Vector3.forward;
                                    rotation = maid.transform.rotation;
                                    double num2 = -rotation.eulerAngles.z;
                                    transform2.RotateAround(position2, forward, (float)num2);
                                }

                                string[] array2 = strArray1[i].Split(':');
                                if (!int.TryParse(array2[61], out poseIndex[i]))
                                {
                                    string str = array2[61].Replace(" ", "_").Replace("|", ",");
                                    for (int index = 0; index < poseArray.Length; ++index)
                                    {
                                        if (str == poseArray[index])
                                        {
                                            poseIndex[i] = index;
                                            break;
                                        }
                                    }
                                }

                                string[] strArray2 = poseArray[poseIndex[i]].Split(',');
                                isStop[i] = true;
                                poseCount[i] = 20;
                                if (array2[61].Contains("MultipleMaidsPose"))
                                {
                                    string url = "";
                                    ((Action<string, List<string>>)((path, result_list) =>
                                                                       {
                                                                           string[] files = Directory.GetFiles(path);
                                                                           for (int index1 = 0; index1 < files.Length; ++index1)
                                                                           {
                                                                               if (Path.GetExtension(files[index1]) == ".anm")
                                                                               {
                                                                                   string str1 =
                                                                                           files[index1].Split('\\')[files[index1]
                                                                                                                     .Split('\\').Length
                                                                                                                     - 1].Split('.')[0];
                                                                                   if (str1 == array2[61].Replace("MultipleMaidsPose", ""))
                                                                                   {
                                                                                       url = files[index1];
                                                                                       for (int index2 = 0;
                                                                                            index2 < poseArray.Length;
                                                                                            ++index2)
                                                                                       {
                                                                                           string str2 = poseArray[index2]
                                                                                                         .Replace("　", "").Split('/')[0];
                                                                                           if (str1 == str2)
                                                                                           {
                                                                                               poseIndex[i] = index2;
                                                                                           }
                                                                                       }

                                                                                       break;
                                                                                   }
                                                                               }
                                                                           }
                                                                       }))(Path.GetFullPath(".\\") + "Mod\\MultipleMaidsPose",
                                                                            new List<string>());
                                    if (url != "")
                                    {
                                        string path = url;
                                        byte[] numArray = new byte[0];
                                        try
                                        {
                                            using (FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read))
                                            {
                                                numArray = new byte[fileStream.Length];
                                                fileStream.Read(numArray, 0, numArray.Length);
                                            }
                                        }
                                        catch { }

                                        if (0 < numArray.Length)
                                        {
                                            long hashCode = Path.GetFileName(path).GetHashCode();
                                            maid.body0.CrossFade(hashCode.ToString(), numArray, false, false, false, 0.0f, 1f);
                                            Maid.AutoTwist[] autoTwistArray = new Maid.AutoTwist[6]
                                            {
                                                    Maid.AutoTwist.ShoulderL, Maid.AutoTwist.ShoulderR, Maid.AutoTwist.WristL,
                                                    Maid.AutoTwist.WristR, Maid.AutoTwist.ThighL, Maid.AutoTwist.ThighR
                                            };
                                            foreach (Maid.AutoTwist f_eType in autoTwistArray)
                                            {
                                                maid.SetAutoTwist(f_eType, true);
                                            }
                                        }
                                    }
                                }
                                else
                                {
                                    if (strArray2[0].StartsWith("p") && int.TryParse(strArray2[0].Substring(1), out int result))
                                    {
                                        loadPose[i] = strArray2[0];
                                    }
                                    else if (!strArray2[0].StartsWith("dance_"))
                                    {
                                        maidArray[i].CrossFade(strArray2[0] + ".anm", false, true, false, 0.0f, 1f);
                                    }
                                    else
                                    {
                                        if (!maidArray[i]
                                                              .body0.m_Bones.GetComponent<Animation>().GetClip(strArray2[0] + ".anm"))
                                        {
                                            maidArray[i].body0.LoadAnime(strArray2[0] + ".anm",
                                                                         GameUty.FileSystem,
                                                                         strArray2[0] + ".anm",
                                                                         false,
                                                                         false);
                                        }

                                        maidArray[i].body0.m_Bones.GetComponent<Animation>().Play(strArray2[0] + ".anm");
                                    }
                                }

                                if (strArray2.Length > 1)
                                {
                                    maidArray[i].body0.m_Bones.GetComponent<Animation>()[strArray2[0] + ".anm"].time =
                                            float.Parse(strArray2[1]);
                                    isStop[i] = true;
                                    if (strArray2.Length > 2)
                                    {
                                        CMT.SearchObjName(maidArray[i].body0.m_Bones.transform, "Bip01", true);
                                        isPoseIti[i] = true;
                                        poseIti[i] = maidArray[i].transform.position;
                                        maidArray[i].transform.position = new Vector3(100f, 100f, 100f);
                                    }
                                }

                                faceIndex[i] = int.Parse(array2[62]);
                                if (faceIndex[i] < faceArray.Length)
                                {
                                    maid.FaceAnime(faceArray[faceIndex[i]], 0.01f, 0);
                                }
                                else
                                {
                                    faceIndex[i] = 0;
                                }

                                TMorph morph = maid.body0.Face.morph;
                                if (!isVR)
                                {
                                    maid.boMabataki = false;
                                    morph.EyeMabataki = 0.0f;
                                    maid.body0.Face.morph.FixBlendValues_Face();
                                }
                            }
                            else
                            {
                                break;
                            }
                        }
                    }
                }
            }

            if (allowUpdate || sceneLevel == 14 || sceneLevel == 24)
            {
                if (isF6 && !cameraObj && !isVR)
                {
                    cameraObj = new GameObject("subCamera");
                    subcamera = cameraObj.AddComponent<Camera>();
                    subcamera.CopyFrom(Camera.main);
                    cameraObj.SetActive(true);
                    subcamera.clearFlags = CameraClearFlags.Depth;
                    subcamera.cullingMask = 256;
                    subcamera.depth = 1f;
                    subcamera.transform.parent = mainCamera.transform;

                    if (lightList.Count == 0)
                    {
                        float num = 2f;
                        if (Application.unityVersion.StartsWith("4"))
                        {
                            num = 1f;
                        }

                        GameObject gameObject = new GameObject("Light");
                        gameObject.AddComponent<Light>();
                        lightList.Add(gameObject);
                        lightColorR.Add(1f);
                        lightColorG.Add(1f);
                        lightColorB.Add(1f);
                        lightIndex.Add(0);
                        lightX.Add(40f);
                        lightY.Add(180f);
                        lightAkarusa.Add(num);
                        lightKage.Add(0.098f);
                        lightRange.Add(50f);
                        gameObject.transform.position = GameMain.Instance.MainLight.transform.position;
                        gameObject.GetComponent<Light>().intensity = 2f;
                        gameObject.GetComponent<Light>().spotAngle = 50f;
                        gameObject.GetComponent<Light>().range = 10f;
                        gameObject.GetComponent<Light>().type = LightType.Directional;
                        gameObject.GetComponent<Light>().color = new Color(0.5f, 1f, 0.0f);
                        gameObject.GetComponent<Light>().cullingMask = 256;

                        // lightComboList = new GUIContent[lightList.Count];
                        // lightComboList[0] = new GUIContent("メイン");
                        // lightCombo.selectedItemIndex = 0;
                        // selectLightIndex = 0;
                    }
                }

                if ((!isF6S || !getModKeyPressing(modKey.Shift) || !Input.GetKeyDown(KeyCode.F6))
                    && (isF6S || !getModKeyPressing(modKey.Shift) || !Input.GetKeyDown(KeyCode.F6)))
                {
                    if (!isF6 && Input.GetKeyDown(KeyCode.F6) && sceneLevel != 5 && sceneLevel != 3
                        && !isVR && maidArray[0] && maidArray[0].Visible)
                    {
                        isF6 = true;
                        bGui = true;
                        isFaceInit = true;
                        isGuiInit = true;
                        maidArray[0].boMabataki = false;
                        selectMaidIndex = 0;
                        maidCnt = 1;
                        isFace[0] = true;
                        faceFlg = true;
                        kankyoFlg = false;
                        string bgName = GameMain.Instance.BgMgr.GetBGName();
                        int num = 0;
                        foreach (string bg in bgArray)
                        {
                            if (bg == bgName)
                            {
                                bgIndex = num;
                                bgIndex6 = num;
                                break;
                            }

                            ++num;
                        }

                        bgCombo.selectedItemIndex = bgIndex6;
                        lightX[0] = GameMain.Instance.MainLight.transform.eulerAngles.x;
                        lightY[0] = GameMain.Instance.MainLight.transform.eulerAngles.y;
                    }
                    else if (!isF6 && Input.GetKeyDown(KeyCode.F7) && sceneLevel != 5 && sceneLevel != 3
                             && !isVR && maidArray[0] && maidArray[0].Visible)
                    {
                        isF6 = true;
                        bGui = true;
                        isGuiInit = true;
                        selectMaidIndex = 0;
                        maidCnt = 1;
                        isFace[0] = false;
                        faceFlg = false;
                        kankyoFlg = true;
                        string bgName = GameMain.Instance.BgMgr.GetBGName();
                        int num = 0;
                        foreach (string bg in bgArray)
                        {
                            if (bg == bgName)
                            {
                                bgIndex = num;
                                bgIndex6 = num;
                                break;
                            }

                            ++num;
                        }

                        bgmCombo.selectedItemIndex = bgmIndex;
                        bgCombo.selectedItemIndex = bgIndex6;
                        lightX[0] = GameMain.Instance.MainLight.transform.eulerAngles.x;
                        lightY[0] = GameMain.Instance.MainLight.transform.eulerAngles.y;
                        lightX6 = lightX[0];
                        lightY6 = lightY[0];
                    }
                    else if (isVR && Input.GetKey(KeyCode.F7) && Input.GetKeyDown(KeyCode.BackQuote)
                             || isF6 && (Input.GetKeyDown(KeyCode.F6) || Input.GetKeyDown(KeyCode.F7)))
                    {
                        isF6 = false;
                        bGui = false;
                        maidArray[0].boMabataki = true;
                        bgIndex = bgIndex6;
                        bg.localScale = new Vector3(1f, 1f, 1f);
                        if (!isVR)
                        {
                            Bloom fieldValue = GetFieldValue<CameraMain, Bloom>(mainCamera, "m_gcBloom");
                            fieldValue.enabled = true;
                            fieldValue.bloomIntensity = 2.85f;
                            fieldValue.hdr = Bloom.HDRBloomMode.Auto;
                            fieldValue.bloomThreshholdColor = new Color(1f, 1f, 1f);
                            fieldValue.bloomBlurIterations = 3;
                        }
                        else if (bgArray[bgIndex].Length == 36)
                        {
                            GameMain.Instance.BgMgr.ChangeBgMyRoom(bgArray[bgIndex]);
                        }
                        else
                        {
                            GameMain.Instance.BgMgr.ChangeBg(bgArray[bgIndex]);
                        }

                        mainCamera.GetComponent<Camera>().backgroundColor = new Color(0.0f, 0.0f, 0.0f);
                        maidCnt = 0;
                        wearIndex = 0;
                        faceFlg = false;
                        faceFlg2 = false;
                        sceneFlg = false;
                        poseFlg = false;
                        kankyoFlg = false;
                        kankyo2Flg = false;
                        unLockFlg = false;
                        ikMaid = 0;
                        ikBui = 0;
                        isNamida = false;
                        isTear1 = false;
                        isTear2 = false;
                        isTear3 = false;
                        isShock = false;
                        isYodare = false;
                        isHoho = false;
                        isHoho2 = false;
                        isHohos = false;
                        isHohol = false;
                        isToothoff = false;
                        isNosefook = false;
                        isFaceInit = false;
                        isPoseInit = false;
                        isWear = true;
                        isSkirt = true;
                        isBra = true;
                        isPanz = true;
                        isHeadset = true;
                        isAccUde = true;
                        isStkg = true;
                        isShoes = true;
                        isGlove = true;
                        isMegane = true;
                        isAccSenaka = true;
                        isPanel = true;
                        isBloom = false;
                        isBloomA = false;
                        isBlur = false;
                        isBlur2 = false;
                        bloom1 = 2.85f;
                        bloom2 = 3f;
                        bloom3 = 0.0f;
                        bloom4 = 0.0f;
                        bloom5 = 0.0f;
                        blur1 = -3.98f;
                        blur4 = -0.75f;
                        blur2 = 0.9f;
                        blur3 = 4.19f;
                        bokashi = 0.0f;
                        kamiyure = 0.0f;
                        isDepth = false;
                        isDepthA = false;
                        depth1 = 3f;
                        depth2 = 0.1f;
                        depth3 = 15f;
                        depth4 = 2.5f;
                        isFog = false;
                        fog1 = 4f;
                        fog2 = 1f;
                        fog3 = 1f;
                        fog4 = 0.0f;
                        fog5 = 1f;
                        fog6 = 1f;
                        fog7 = 1f;
                        isSepia = false;
                        isBloomS = true;
                        isDepthS = false;
                        isBlurS = false;
                        isFogS = false;
                        if (depth_field_ != null)
                        {
                            depth_field_.enabled = false;
                        }

                        if (fog_ != null)
                        {
                            fog_.enabled = false;
                        }

                        if (sepia_tone_ != null)
                        {
                            sepia_tone_.enabled = false;
                        }

                        isCube = false;
                        isCube2 = true;
                        isCube3 = false;
                        isCube4 = true;
                        effectIndex = 0;
                        selectMaidIndex = 0;
                        copyIndex = 0;
                        selectLightIndex = 0;
                        doguBIndex = 0;
                        parIndex = 0;
                        isEditNo = 0;
                        editSelectMaid = null;
                        for (int index = 0; index < 10; ++index)
                        {
                            date[index] = "";
                            ninzu[index] = "";
                        }

                        if (kami)
                        {
                            kami.SetActive(false);
                        }

                        lightIndex = new List<int>
                        {
                            0
                        };
                        lightColorR = new List<float>
                        {
                            1f
                        };
                        lightColorG = new List<float>
                        {
                            1f
                        };
                        lightColorB = new List<float>
                        {
                            1f
                        };
                        lightX = new List<float>
                        {
                            lightX6
                        };
                        lightY = new List<float>
                        {
                            lightY6
                        };
                        lightAkarusa = new List<float>
                        {
                            0.95f
                        };
                        lightKage = new List<float>
                        {
                            0.098f
                        };
                        lightRange = new List<float>
                        {
                            50f
                        };
                        isIdx1 = false;
                        isIdx2 = false;
                        isIdx3 = false;
                        isIdx4 = false;
                        bgObject.SetActive(true);
                        GameMain.Instance.MainLight.Reset();
                        GameMain.Instance.MainLight.SetIntensity(0.95f);
                        GameMain.Instance.MainLight.GetComponent<Light>().spotAngle = 30f;
                        GameMain.Instance.MainLight.GetComponent<Light>().range = 10f;
                        GameMain.Instance.MainLight.gameObject.transform.position = new Vector3(0.0f, 2f, 0.0f);
                        GameMain.Instance.MainLight.GetComponent<Light>().type = LightType.Directional;
                        GameMain.Instance.MainLight.transform.eulerAngles =
                                new Vector3(lightX6, lightY6, GameMain.Instance.MainLight.transform.eulerAngles.z);
                        for (int index = 0; index < doguBObject.Count; ++index)
                        {
                            GraphicsUtils.Destroy(doguBObject[index]);
                        }

                        doguBObject.Clear();
                        doguBIndex = 0;
                        parIndex = 0;
                        doguCombo.selectedItemIndex = 0;
                        parCombo.selectedItemIndex = 0;
                        for (int index = 1; index < lightList.Count; ++index)
                        {
                            GraphicsUtils.Destroy(lightList[index]);
                        }

                        lightList = new List<GameObject>
                        {
                            GameMain.Instance.MainLight.gameObject
                        };
                        lightComboList = new GUIContent[lightList.Count];
                        lightComboList[0] = new GUIContent("メイン");
                        lightCombo.selectedItemIndex = 0;
                        selectLightIndex = 0;
                        GameMain.Instance.BgMgr.ChangeBg(bgArray[bgIndex6]);
                        bgCombo.selectedItemIndex = bgIndex6;
                        bgCombo2.selectedItemIndex = 0;
                        itemCombo2.selectedItemIndex = 0;
                        slotCombo.selectedItemIndex = 0;
                        sortList.Clear();
                        maidCallScrollPos = new Vector2(0.0f, 0.0f);
                        poseScrollPos = new Vector2(0.0f, 0.0f);
                        faceScrollPos = new Vector2(0.0f, 0.0f);
                        bgScrollPos = new Vector2(0.0f, 0.0f);
                        saveSceneScrollPos = new Vector2(0.0f, 0.0f);
                        bg2ScrollPos = new Vector2(0.0f, 0.0f);

                        if (!isVR)
                        {
                            Vignetting component = GameMain.Instance.MainCamera.gameObject.GetComponent<Vignetting>();
                            component.mode = Vignetting.AberrationMode.Simple;
                            component.intensity = -3.98f;
                            component.chromaticAberration = -0.75f;
                            component.axialAberration = 1.18f;
                            component.blurSpread = 4.19f;
                            component.luminanceDependency = 0.494f;
                            component.blurDistance = 1.71f;
                            component.enabled = false;
                        }

                        doguIndex.Clear();
                        doguSelectIndex = 0;
                        for (int index = 0; index < doguObject.Count; ++index)
                        {
                            if (doguObject[index] != null)
                            {
                                GraphicsUtils.Destroy(doguObject[index]);
                                doguObject[index] = null;
                            }
                        }

                        doguObject.Clear();
                    }
                }

                for (int index = 0; index < maidCnt; ++index)
                {
                    if (maidArray[index] && maidArray[index].Visible)
                    {
                        Maid maid = maidArray[index];
                        if (isLook[index] != isLookn[index])
                        {
                            isLookn[index] = isLook[index];
                            if (isLook[index])
                            {
                                maid.body0.trsLookTarget = GameMain.Instance.MainCamera.transform;
                                maid.body0.boHeadToCam = true;
                                maid.body0.boEyeToCam = true;
                                maid.body0.trsLookTarget = null;
                            }
                            else
                            {
                                maid.body0.trsLookTarget = GameMain.Instance.MainCamera.transform;
                                maid.body0.boHeadToCam = true;
                                maid.body0.boEyeToCam = true;
                            }
                        }
                    }
                }

                if (maidArray[selectMaidIndex] && maidArray[selectMaidIndex].Visible
                                                                 && (!faceFlg && !poseFlg && !sceneFlg && !kankyoFlg && !kankyo2Flg
                                                                     || sceneFlg || kankyoFlg || kankyo2Flg))
                {
                    for (int index = 0; index < maidCnt; ++index)
                    {
                        if (maidArray[index] && !maidArray[index].boMabataki)
                        {
                            maidArray[index].body0.Face.morph.FixBlendValues_Face();
                        }
                    }
                }

                if (maidArray[selectMaidIndex] && maidArray[selectMaidIndex].Visible && poseFlg)
                {
                    if (isPoseInit)
                    {
                        if (!isDanceChu)
                        {
                            Maid maid = maidArray[selectMaidIndex];
                            isPoseInit = false;
                            isWear = maid.body0.GetMask(TBody.SlotID.wear) || maid.body0.GetMask(TBody.SlotID.mizugi)
                                                                           || maid.body0.GetMask(TBody.SlotID.onepiece);
                            isSkirt = maid.body0.GetMask(TBody.SlotID.skirt);
                            isBra = maid.body0.GetMask(TBody.SlotID.bra);
                            isPanz = maid.body0.GetMask(TBody.SlotID.panz);
                            isMaid = maid.body0.GetMask(TBody.SlotID.body);
                            isHeadset = maid.body0.GetMask(TBody.SlotID.headset) || maid.body0.GetMask(TBody.SlotID.accHat)
                                                                                 || maid.body0.GetMask(TBody.SlotID.accHead)
                                                                                     || maid.body0.GetMask(TBody.SlotID.accKamiSubL)
                                                                                 || maid.body0.GetMask(TBody.SlotID.accKamiSubR)
                                                                                     || maid.body0.GetMask(TBody.SlotID.accKami_1_)
                                                                                     || maid.body0.GetMask(TBody.SlotID.accKami_2_)
                                                                                 || maid.body0.GetMask(TBody.SlotID.accKami_3_);
                            isAccUde = maid.body0.GetMask(TBody.SlotID.accUde);
                            isStkg = maid.body0.GetMask(TBody.SlotID.stkg);
                            isShoes = maid.body0.GetMask(TBody.SlotID.shoes);
                            isGlove = maid.body0.GetMask(TBody.SlotID.glove);
                            isMegane = maid.body0.GetMask(TBody.SlotID.megane);
                            isAccSenaka = maid.body0.GetMask(TBody.SlotID.accSenaka);
                            TMorph morph = maidArray[selectMaidIndex].body0.Face.morph;
                            float[] fieldValue1 = GetFieldValue<TMorph, float[]>(morph, "BlendValues");
                            float[] fieldValue2 = GetFieldValue<TMorph, float[]>(morph, "BlendValuesBackup");
                            eyeclose = fieldValue2[(int)morph.hash["eyeclose"]];
                            eyeclose2 = fieldValue2[(int)morph.hash["eyeclose2"]];
                            eyeclose3 = fieldValue2[(int)morph.hash["eyeclose3"]];
                            eyeclose6 = fieldValue2[(int)morph.hash["eyeclose6"]];
                            hitomih = fieldValue1[(int)morph.hash["hitomih"]];
                            hitomis = fieldValue1[(int)morph.hash["hitomis"]];
                            mayuha = fieldValue1[(int)morph.hash["mayuha"]];
                            mayuup = fieldValue1[(int)morph.hash["mayuup"]];
                            mayuv = fieldValue1[(int)morph.hash["mayuv"]];
                            mayuvhalf = fieldValue1[(int)morph.hash["mayuvhalf"]];
                            moutha = fieldValue1[(int)morph.hash["moutha"]];
                            mouths = fieldValue1[(int)morph.hash["mouths"]];
                            mouthdw = fieldValue1[(int)morph.hash["mouthdw"]];
                            mouthup = fieldValue1[(int)morph.hash["mouthup"]];
                            tangout = fieldValue1[(int)morph.hash["tangout"]];
                            tangup = fieldValue1[(int)morph.hash["tangup"]];
                            eyebig = fieldValue1[(int)morph.hash["eyebig"]];
                            eyeclose5 = fieldValue2[(int)morph.hash["eyeclose5"]];
                            mayuw = fieldValue1[(int)morph.hash["mayuw"]];
                            mouthhe = fieldValue1[(int)morph.hash["mouthhe"]];
                            mouthc = fieldValue1[(int)morph.hash["mouthc"]];
                            mouthi = fieldValue1[(int)morph.hash["mouthi"]];
                            mouthuphalf = fieldValue1[(int)morph.hash["mouthuphalf"]];
                            try
                            {
                                tangopen = fieldValue1[(int)morph.hash["tangopen"]];
                            }
                            catch { }

                            isNamida = fieldValue1[(int)morph.hash["namida"]] > 0.0;
                            isTear1 = fieldValue1[(int)morph.hash["tear1"]] > 0.0;
                            isTear2 = fieldValue1[(int)morph.hash["tear2"]] > 0.0;
                            isTear3 = fieldValue1[(int)morph.hash["tear3"]] > 0.0;
                            isShock = fieldValue1[(int)morph.hash["shock"]] > 0.0;
                            isYodare = fieldValue1[(int)morph.hash["yodare"]] > 0.0;
                            isHoho = fieldValue1[(int)morph.hash["hoho"]] > 0.0;
                            isHoho2 = fieldValue1[(int)morph.hash["hoho2"]] > 0.0;
                            isHohos = fieldValue1[(int)morph.hash["hohos"]] > 0.0;
                            isHohol = fieldValue1[(int)morph.hash["hohol"]] > 0.0;
                            isToothoff = fieldValue1[(int)morph.hash["toothoff"]] > 0.0;
                            isNosefook = fieldValue1[(int)morph.hash["nosefook"]] > 0.0;
                        }
                    }
                    else
                    {
                        Maid maid = maidArray[selectMaidIndex];
                        if (goSlot[(int)selectList[selectMaidIndex]] != null)
                        {
                            maidArray[selectMaidIndex].body0.goSlot =
                                    new List<TBodySkin>(goSlot[(int)selectList[selectMaidIndex]]);
                            for (int index = 0; index < bodyHit[(int)selectList[selectMaidIndex]].Count; ++index)
                            {
                                maidArray[selectMaidIndex].body0.goSlot[index].bonehair.bodyhit =
                                        bodyHit[(int)selectList[selectMaidIndex]][index];
                            }
                        }

                        if (maid.body0.GetMask(TBody.SlotID.wear) != isWear)
                        {
                            maid.body0.SetMask(TBody.SlotID.wear, isWear);
                        }

                        if (maid.body0.GetMask(TBody.SlotID.mizugi) != isWear)
                        {
                            maid.body0.SetMask(TBody.SlotID.mizugi, isWear);
                        }

                        if (maid.body0.GetMask(TBody.SlotID.onepiece) != isWear)
                        {
                            maid.body0.SetMask(TBody.SlotID.onepiece, isWear);
                        }

                        if (maid.body0.GetMask(TBody.SlotID.skirt) != isSkirt)
                        {
                            maid.body0.SetMask(TBody.SlotID.skirt, isSkirt);
                        }

                        if (maid.body0.GetMask(TBody.SlotID.bra) != isBra)
                        {
                            maid.body0.SetMask(TBody.SlotID.bra, isBra);
                        }

                        if (maid.body0.GetMask(TBody.SlotID.panz) != isPanz)
                        {
                            maid.body0.SetMask(TBody.SlotID.panz, isPanz);
                        }

                        if (maid.body0.GetMask(TBody.SlotID.headset) != isHeadset)
                        {
                            maid.body0.SetMask(TBody.SlotID.headset, isHeadset);
                        }

                        if (maid.body0.GetMask(TBody.SlotID.accHat) != isHeadset)
                        {
                            maid.body0.SetMask(TBody.SlotID.accHat, isHeadset);
                        }

                        if (maid.body0.GetMask(TBody.SlotID.accHead) != isHeadset)
                        {
                            maid.body0.SetMask(TBody.SlotID.accHead, isHeadset);
                        }

                        if (maid.body0.GetMask(TBody.SlotID.accKamiSubL) != isHeadset)
                        {
                            maid.body0.SetMask(TBody.SlotID.accKamiSubL, isHeadset);
                        }

                        if (maid.body0.GetMask(TBody.SlotID.accKamiSubR) != isHeadset)
                        {
                            maid.body0.SetMask(TBody.SlotID.accKamiSubR, isHeadset);
                        }

                        if (maid.body0.GetMask(TBody.SlotID.accKami_1_) != isHeadset)
                        {
                            maid.body0.SetMask(TBody.SlotID.accKami_1_, isHeadset);
                        }

                        if (maid.body0.GetMask(TBody.SlotID.accKami_2_) != isHeadset)
                        {
                            maid.body0.SetMask(TBody.SlotID.accKami_2_, isHeadset);
                        }

                        if (maid.body0.GetMask(TBody.SlotID.accKami_3_) != isHeadset)
                        {
                            maid.body0.SetMask(TBody.SlotID.accKami_3_, isHeadset);
                        }

                        if (maid.body0.GetMask(TBody.SlotID.accUde) != isAccUde)
                        {
                            maid.body0.SetMask(TBody.SlotID.accUde, isAccUde);
                        }

                        if (maid.body0.GetMask(TBody.SlotID.stkg) != isStkg)
                        {
                            maid.body0.SetMask(TBody.SlotID.stkg, isStkg);
                        }

                        if (maid.body0.GetMask(TBody.SlotID.shoes) != isShoes)
                        {
                            maid.body0.SetMask(TBody.SlotID.shoes, isShoes);
                        }

                        if (maid.body0.GetMask(TBody.SlotID.glove) != isGlove)
                        {
                            maid.body0.SetMask(TBody.SlotID.glove, isGlove);
                        }

                        if (maid.body0.GetMask(TBody.SlotID.megane) != isMegane)
                        {
                            maid.body0.SetMask(TBody.SlotID.megane, isMegane);
                        }

                        if (maid.body0.GetMask(TBody.SlotID.accSenaka) != isAccSenaka)
                        {
                            maid.body0.SetMask(TBody.SlotID.accSenaka, isAccSenaka);
                        }

                        if (mekure1[selectMaidIndex] != mekure1n[selectMaidIndex])
                        {
                            mekure1n[selectMaidIndex] = mekure1[selectMaidIndex];
                            if (mekure1[selectMaidIndex])
                            {
                                maid.ItemChangeTemp("skirt", "めくれスカート");
                                maid.ItemChangeTemp("onepiece", "めくれスカート");
                                mekure2[selectMaidIndex] = false;
                                mekure2n[selectMaidIndex] = false;
                            }
                            else
                            {
                                ResetProp(maid, MPN.skirt);
                                ResetProp(maid, MPN.onepiece);
                            }

                            maid.AllProcPropSeqStart();
                        }

                        if (mekure2[selectMaidIndex] != mekure2n[selectMaidIndex])
                        {
                            mekure2n[selectMaidIndex] = mekure2[selectMaidIndex];
                            if (mekure2[selectMaidIndex])
                            {
                                maid.ItemChangeTemp("skirt", "めくれスカート後ろ");
                                maid.ItemChangeTemp("onepiece", "めくれスカート後ろ");
                                mekure1[selectMaidIndex] = false;
                                mekure1n[selectMaidIndex] = false;
                            }
                            else
                            {
                                ResetProp(maid, MPN.skirt);
                                ResetProp(maid, MPN.onepiece);
                            }

                            maid.AllProcPropSeqStart();
                        }

                        if (zurasi[selectMaidIndex] != zurasin[selectMaidIndex])
                        {
                            zurasin[selectMaidIndex] = zurasi[selectMaidIndex];
                            if (zurasi[selectMaidIndex])
                            {
                                maid.ItemChangeTemp("panz", "パンツずらし");
                                maid.ItemChangeTemp("mizugi", "パンツずらし");
                            }
                            else
                            {
                                ResetProp(maid, MPN.panz);
                                ResetProp(maid, MPN.mizugi);
                            }

                            maid.AllProcPropSeqStart();
                        }

                        if (!isDanceChu)
                        {
                            if (maid.body0.GetMask(TBody.SlotID.body) != isMaid)
                            {
                                Hashtable fieldValue = GetFieldValue<TBody, Hashtable>(maid.body0, "m_hFoceHide");
                                fieldValue[TBody.SlotID.body] = isMaid;
                                fieldValue[TBody.SlotID.head] = isMaid;
                                fieldValue[TBody.SlotID.eye] = isMaid;
                                fieldValue[TBody.SlotID.hairF] = isMaid;
                                fieldValue[TBody.SlotID.hairR] = isMaid;
                                fieldValue[TBody.SlotID.hairS] = isMaid;
                                fieldValue[TBody.SlotID.hairT] = isMaid;
                                fieldValue[TBody.SlotID.hairAho] = isMaid;
                                fieldValue[TBody.SlotID.chikubi] = isMaid;
                                fieldValue[TBody.SlotID.underhair] = isMaid;
                                fieldValue[TBody.SlotID.moza] = isMaid;
                                if (maid.body0.goSlot[19].m_strModelFileName.Contains("melala_body"))
                                {
                                    fieldValue[TBody.SlotID.accHana] = isMaid;
                                }

                                maid.body0.FixMaskFlag();
                                maid.body0.FixVisibleFlag(false);
                            }

                            if (isLook[selectMaidIndex] != isLookn[selectMaidIndex])
                            {
                                isLookn[selectMaidIndex] = isLook[selectMaidIndex];
                                if (isLook[selectMaidIndex])
                                {
                                    maid.body0.trsLookTarget = GameMain.Instance.MainCamera.transform;
                                    maid.body0.boHeadToCam = true;
                                    maid.body0.boEyeToCam = true;
                                    maid.body0.trsLookTarget = null;
                                }
                                else
                                {
                                    maid.body0.trsLookTarget = GameMain.Instance.MainCamera.transform;
                                    maid.body0.boHeadToCam = true;
                                    maid.body0.boEyeToCam = true;
                                }
                            }

                            if (isLook[selectMaidIndex])
                            {
                                if (maid.body0.offsetLookTarget.x != (double)lookY[selectMaidIndex])
                                {
                                    int num = !isLock[selectMaidIndex] ? 1 : (lookY[selectMaidIndex] >= 0.0 ? 1 : 0);
                                    maid.body0.offsetLookTarget =
                                            num != 0
                                                    ? new Vector3(lookY[selectMaidIndex], 1f, lookX[selectMaidIndex])
                                                    : new Vector3(lookY[selectMaidIndex] * 0.6f, 1f, lookX[selectMaidIndex]);
                                }

                                if (lookX[selectMaidIndex] != (double)lookXn[selectMaidIndex])
                                {
                                    lookXn[selectMaidIndex] = lookX[selectMaidIndex];
                                    maid.body0.offsetLookTarget = new Vector3(lookY[selectMaidIndex], 1f, lookX[selectMaidIndex]);
                                }

                                if (lookY[selectMaidIndex] != (double)lookYn[selectMaidIndex])
                                {
                                    lookYn[selectMaidIndex] = lookY[selectMaidIndex];
                                    int num = !isLock[selectMaidIndex] ? 1 : (lookY[selectMaidIndex] >= 0.0 ? 1 : 0);
                                    maid.body0.offsetLookTarget =
                                            num != 0
                                                    ? new Vector3(lookY[selectMaidIndex], 1f, lookX[selectMaidIndex])
                                                    : new Vector3(lookY[selectMaidIndex] * 0.6f, 1f, lookX[selectMaidIndex]);
                                }
                            }

                            if (isHanten)
                            {
                                isHanten = false;
                                SetHanten(maid, selectMaidIndex);
                            }

                            if (hanten[selectMaidIndex] != hantenn[selectMaidIndex])
                            {
                                hantenn[selectMaidIndex] = hanten[selectMaidIndex];
                                isStop[selectMaidIndex] = true;
                                isLock[selectMaidIndex] = true;
                                isHanten = true;
                            }

                            if (voice1[selectMaidIndex] != voice1n[selectMaidIndex])
                            {
                                voice1n[selectMaidIndex] = voice1[selectMaidIndex];
                                if (voice1[selectMaidIndex])
                                {
                                    zFlg[selectMaidIndex] = true;
                                    xFlg[selectMaidIndex] = false;
                                    voice2[selectMaidIndex] = false;
                                    voice2n[selectMaidIndex] = false;
                                }
                                else
                                {
                                    zFlg[selectMaidIndex] = false;
                                }
                            }

                            if (voice2[selectMaidIndex] != voice2n[selectMaidIndex])
                            {
                                voice2n[selectMaidIndex] = voice2[selectMaidIndex];
                                if (voice2[selectMaidIndex])
                                {
                                    xFlg[selectMaidIndex] = true;
                                    zFlg[selectMaidIndex] = false;
                                    voice1[selectMaidIndex] = false;
                                    voice1n[selectMaidIndex] = false;
                                }
                                else
                                {
                                    xFlg[selectMaidIndex] = false;
                                }
                            }

                            for (int index = 0; index < maidCnt; ++index)
                            {
                                if (!maidArray[index].boMabataki)
                                {
                                    maidArray[index].body0.Face.morph.FixBlendValues_Face();
                                }
                            }
                        }
                    }
                }

                if (maidArray[selectMaidIndex] && maidArray[selectMaidIndex].Visible && (isF6 || okFlg && faceFlg))
                {
                    if (isFaceInit)
                    {
                        if (!isDanceChu)
                        {
                            TMorph morph = maidArray[selectMaidIndex].body0.Face.morph;
                            float[] fieldValue1 = GetFieldValue<TMorph, float[]>(morph, "BlendValues");
                            float[] fieldValue2 = GetFieldValue<TMorph, float[]>(morph, "BlendValuesBackup");
                            Maid maid = maidArray[selectMaidIndex];
                            maidArray[selectMaidIndex].boMabataki = false;
                            morph.EyeMabataki = 0.0f;
                            isFaceInit = false;
                            maidArray[selectMaidIndex].body0.Face.morph.FixBlendValues_Face();
                            eyeclose = fieldValue2[(int)morph.hash["eyeclose"]];
                            eyeclose2 = fieldValue2[(int)morph.hash["eyeclose2"]];
                            eyeclose3 = fieldValue2[(int)morph.hash["eyeclose3"]];
                            eyeclose6 = fieldValue2[(int)morph.hash["eyeclose6"]];
                            hitomih = fieldValue1[(int)morph.hash["hitomih"]];
                            hitomis = fieldValue1[(int)morph.hash["hitomis"]];
                            mayuha = fieldValue1[(int)morph.hash["mayuha"]];
                            mayuup = fieldValue1[(int)morph.hash["mayuup"]];
                            mayuv = fieldValue1[(int)morph.hash["mayuv"]];
                            mayuvhalf = fieldValue1[(int)morph.hash["mayuvhalf"]];
                            moutha = fieldValue1[(int)morph.hash["moutha"]];
                            mouths = fieldValue1[(int)morph.hash["mouths"]];
                            mouthdw = fieldValue1[(int)morph.hash["mouthdw"]];
                            mouthup = fieldValue1[(int)morph.hash["mouthup"]];
                            tangout = fieldValue1[(int)morph.hash["tangout"]];
                            tangup = fieldValue1[(int)morph.hash["tangup"]];
                            eyebig = fieldValue1[(int)morph.hash["eyebig"]];
                            eyeclose5 = fieldValue2[(int)morph.hash["eyeclose5"]];
                            mayuw = fieldValue1[(int)morph.hash["mayuw"]];
                            mouthhe = fieldValue1[(int)morph.hash["mouthhe"]];
                            mouthc = fieldValue1[(int)morph.hash["mouthc"]];
                            mouthi = fieldValue1[(int)morph.hash["mouthi"]];
                            mouthuphalf = fieldValue1[(int)morph.hash["mouthuphalf"]];
                            try
                            {
                                tangopen = fieldValue1[(int)morph.hash["tangopen"]];
                            }
                            catch { }

                            isWear = maid.body0.GetMask(TBody.SlotID.wear) || maid.body0.GetMask(TBody.SlotID.mizugi)
                                                                           || maid.body0.GetMask(TBody.SlotID.onepiece);
                            isSkirt = maid.body0.GetMask(TBody.SlotID.skirt);
                            isBra = maid.body0.GetMask(TBody.SlotID.bra);
                            isPanz = maid.body0.GetMask(TBody.SlotID.panz);
                            isHeadset = maid.body0.GetMask(TBody.SlotID.headset) || maid.body0.GetMask(TBody.SlotID.accHat)
                                                                                 || maid.body0.GetMask(TBody.SlotID.accHead)
                                                                                     || maid.body0.GetMask(TBody.SlotID.accKamiSubL)
                                                                                 || maid.body0.GetMask(TBody.SlotID.accKamiSubR)
                                                                                     || maid.body0.GetMask(TBody.SlotID.accKami_1_)
                                                                                     || maid.body0.GetMask(TBody.SlotID.accKami_2_)
                                                                                 || maid.body0.GetMask(TBody.SlotID.accKami_3_);
                            isAccUde = maid.body0.GetMask(TBody.SlotID.accUde);
                            isStkg = maid.body0.GetMask(TBody.SlotID.stkg);
                            isShoes = maid.body0.GetMask(TBody.SlotID.shoes);
                            isGlove = maid.body0.GetMask(TBody.SlotID.glove);
                            isMegane = maid.body0.GetMask(TBody.SlotID.megane);
                            isAccSenaka = maid.body0.GetMask(TBody.SlotID.accSenaka);
                            isNamida = fieldValue1[(int)morph.hash["namida"]] > 0.0;
                            isTear1 = fieldValue1[(int)morph.hash["tear1"]] > 0.0;
                            isTear2 = fieldValue1[(int)morph.hash["tear2"]] > 0.0;
                            isTear3 = fieldValue1[(int)morph.hash["tear3"]] > 0.0;
                            isShock = fieldValue1[(int)morph.hash["shock"]] > 0.0;
                            isYodare = fieldValue1[(int)morph.hash["yodare"]] > 0.0;
                            isHoho = fieldValue1[(int)morph.hash["hoho"]] > 0.0;
                            isHoho2 = fieldValue1[(int)morph.hash["hoho2"]] > 0.0;
                            isHohos = fieldValue1[(int)morph.hash["hohos"]] > 0.0;
                            isHohol = fieldValue1[(int)morph.hash["hohol"]] > 0.0;
                            isToothoff = fieldValue1[(int)morph.hash["toothoff"]] > 0.0;
                            isNosefook = fieldValue1[(int)morph.hash["nosefook"]] > 0.0;
                        }
                    }
                    else
                    {
                        Maid maid = maidArray[selectMaidIndex];
                        if (!yotogiFlg && sceneLevel != 5 && sceneLevel != 3)
                        {
                            if (maid.body0.GetMask(TBody.SlotID.wear) != isWear)
                            {
                                maid.body0.SetMask(TBody.SlotID.wear, isWear);
                            }

                            if (maid.body0.GetMask(TBody.SlotID.mizugi) != isWear)
                            {
                                maid.body0.SetMask(TBody.SlotID.mizugi, isWear);
                            }

                            if (maid.body0.GetMask(TBody.SlotID.onepiece) != isWear)
                            {
                                maid.body0.SetMask(TBody.SlotID.onepiece, isWear);
                            }

                            if (maid.body0.GetMask(TBody.SlotID.skirt) != isSkirt)
                            {
                                maid.body0.SetMask(TBody.SlotID.skirt, isSkirt);
                            }

                            if (maid.body0.GetMask(TBody.SlotID.bra) != isBra)
                            {
                                maid.body0.SetMask(TBody.SlotID.bra, isBra);
                            }

                            if (maid.body0.GetMask(TBody.SlotID.panz) != isPanz)
                            {
                                maid.body0.SetMask(TBody.SlotID.panz, isPanz);
                            }

                            if (maid.body0.GetMask(TBody.SlotID.headset) != isHeadset)
                            {
                                maid.body0.SetMask(TBody.SlotID.headset, isHeadset);
                            }

                            if (maid.body0.GetMask(TBody.SlotID.accHat) != isHeadset)
                            {
                                maid.body0.SetMask(TBody.SlotID.accHat, isHeadset);
                            }

                            if (maid.body0.GetMask(TBody.SlotID.accHead) != isHeadset)
                            {
                                maid.body0.SetMask(TBody.SlotID.accHead, isHeadset);
                            }

                            if (maid.body0.GetMask(TBody.SlotID.accKamiSubL) != isHeadset)
                            {
                                maid.body0.SetMask(TBody.SlotID.accKamiSubL, isHeadset);
                            }

                            if (maid.body0.GetMask(TBody.SlotID.accKamiSubR) != isHeadset)
                            {
                                maid.body0.SetMask(TBody.SlotID.accKamiSubR, isHeadset);
                            }

                            if (maid.body0.GetMask(TBody.SlotID.accKami_1_) != isHeadset)
                            {
                                maid.body0.SetMask(TBody.SlotID.accKami_1_, isHeadset);
                            }

                            if (maid.body0.GetMask(TBody.SlotID.accKami_2_) != isHeadset)
                            {
                                maid.body0.SetMask(TBody.SlotID.accKami_2_, isHeadset);
                            }

                            if (maid.body0.GetMask(TBody.SlotID.accKami_3_) != isHeadset)
                            {
                                maid.body0.SetMask(TBody.SlotID.accKami_3_, isHeadset);
                            }

                            if (maid.body0.GetMask(TBody.SlotID.accUde) != isAccUde)
                            {
                                maid.body0.SetMask(TBody.SlotID.accUde, isAccUde);
                            }

                            if (maid.body0.GetMask(TBody.SlotID.stkg) != isStkg)
                            {
                                maid.body0.SetMask(TBody.SlotID.stkg, isStkg);
                            }

                            if (maid.body0.GetMask(TBody.SlotID.shoes) != isShoes)
                            {
                                maid.body0.SetMask(TBody.SlotID.shoes, isShoes);
                            }

                            if (maid.body0.GetMask(TBody.SlotID.glove) != isGlove)
                            {
                                maid.body0.SetMask(TBody.SlotID.glove, isGlove);
                            }

                            if (maid.body0.GetMask(TBody.SlotID.megane) != isMegane)
                            {
                                maid.body0.SetMask(TBody.SlotID.megane, isMegane);
                            }

                            if (maid.body0.GetMask(TBody.SlotID.accSenaka) != isAccSenaka)
                            {
                                maid.body0.SetMask(TBody.SlotID.accSenaka, isAccSenaka);
                            }

                            if (mekure1[selectMaidIndex] != mekure1n[selectMaidIndex])
                            {
                                mekure1n[selectMaidIndex] = mekure1[selectMaidIndex];
                                if (mekure1[selectMaidIndex])
                                {
                                    maid.ItemChangeTemp("skirt", "めくれスカート");
                                    maid.ItemChangeTemp("onepiece", "めくれスカート");
                                    mekure2[selectMaidIndex] = false;
                                    mekure2n[selectMaidIndex] = false;
                                }
                                else
                                {
                                    ResetProp(maid, MPN.skirt);
                                    ResetProp(maid, MPN.onepiece);
                                }

                                maid.AllProcPropSeqStart();
                            }

                            if (mekure2[selectMaidIndex] != mekure2n[selectMaidIndex])
                            {
                                mekure2n[selectMaidIndex] = mekure2[selectMaidIndex];
                                if (mekure2[selectMaidIndex])
                                {
                                    maid.ItemChangeTemp("skirt", "めくれスカート後ろ");
                                    maid.ItemChangeTemp("onepiece", "めくれスカート後ろ");
                                    mekure1[selectMaidIndex] = false;
                                    mekure1n[selectMaidIndex] = false;
                                }
                                else
                                {
                                    ResetProp(maid, MPN.skirt);
                                    ResetProp(maid, MPN.onepiece);
                                }

                                maid.AllProcPropSeqStart();
                            }

                            if (zurasi[selectMaidIndex] != zurasin[selectMaidIndex])
                            {
                                zurasin[selectMaidIndex] = zurasi[selectMaidIndex];
                                if (zurasi[selectMaidIndex])
                                {
                                    maid.ItemChangeTemp("panz", "パンツずらし");
                                    maid.ItemChangeTemp("mizugi", "パンツずらし");
                                }
                                else
                                {
                                    ResetProp(maid, MPN.panz);
                                    ResetProp(maid, MPN.mizugi);
                                }

                                maid.AllProcPropSeqStart();
                            }
                        }

                        if (!isDanceChu)
                        {
                            TMorph morph = maidArray[selectMaidIndex].body0.Face.morph;
                            float[] fieldValue1 = GetFieldValue<TMorph, float[]>(morph, "BlendValues");
                            float[] fieldValue2 = GetFieldValue<TMorph, float[]>(morph, "BlendValuesBackup");
                            fieldValue2[(int)morph.hash["eyeclose"]] = eyeclose;
                            fieldValue2[(int)morph.hash["eyeclose2"]] = eyeclose2;
                            fieldValue2[(int)morph.hash["eyeclose3"]] = eyeclose3;
                            fieldValue2[(int)morph.hash["eyeclose6"]] = eyeclose6;
                            fieldValue1[(int)morph.hash["hitomih"]] = hitomih;
                            fieldValue1[(int)morph.hash["hitomis"]] = hitomis;
                            fieldValue1[(int)morph.hash["mayuha"]] = mayuha;
                            fieldValue1[(int)morph.hash["mayuup"]] = mayuup;
                            fieldValue1[(int)morph.hash["mayuv"]] = mayuv;
                            fieldValue1[(int)morph.hash["mayuvhalf"]] = mayuvhalf;
                            fieldValue1[(int)morph.hash["tangout"]] = tangout;
                            fieldValue1[(int)morph.hash["tangup"]] = tangup;
                            fieldValue1[(int)morph.hash["eyebig"]] = eyebig;
                            fieldValue2[(int)morph.hash["eyeclose5"]] = eyeclose5;
                            fieldValue1[(int)morph.hash["mayuw"]] = mayuw;
                            try
                            {
                                fieldValue1[(int)morph.hash["tangopen"]] = tangopen;
                            }
                            catch { }

                            if (!isDanceChu)
                            {
                                fieldValue1[(int)morph.hash["moutha"]] = moutha;
                                fieldValue1[(int)morph.hash["mouths"]] = mouths;
                                fieldValue1[(int)morph.hash["mouthdw"]] = mouthdw;
                                fieldValue1[(int)morph.hash["mouthup"]] = mouthup;
                                fieldValue1[(int)morph.hash["mouthhe"]] = mouthhe;
                                fieldValue1[(int)morph.hash["mouthc"]] = mouthc;
                                fieldValue1[(int)morph.hash["mouthi"]] = mouthi;
                                fieldValue1[(int)morph.hash["mouthuphalf"]] = mouthuphalf;
                            }

                            if (isNamida)
                            {
                                fieldValue1[(int)morph.hash["namida"]] = 1f;
                            }
                            else
                            {
                                fieldValue1[(int)morph.hash["namida"]] = 0.0f;
                            }

                            if (isTear1)
                            {
                                fieldValue1[(int)morph.hash["tear1"]] = 1f;
                            }
                            else
                            {
                                fieldValue1[(int)morph.hash["tear1"]] = 0.0f;
                            }

                            if (isTear2)
                            {
                                fieldValue1[(int)morph.hash["tear2"]] = 1f;
                            }
                            else
                            {
                                fieldValue1[(int)morph.hash["tear2"]] = 0.0f;
                            }

                            if (isTear3)
                            {
                                fieldValue1[(int)morph.hash["tear3"]] = 1f;
                            }
                            else
                            {
                                fieldValue1[(int)morph.hash["tear3"]] = 0.0f;
                            }

                            if (isShock)
                            {
                                fieldValue1[(int)morph.hash["shock"]] = 1f;
                            }
                            else
                            {
                                fieldValue1[(int)morph.hash["shock"]] = 0.0f;
                            }

                            if (isYodare)
                            {
                                fieldValue1[(int)morph.hash["yodare"]] = 1f;
                            }
                            else
                            {
                                fieldValue1[(int)morph.hash["yodare"]] = 0.0f;
                            }

                            if (isHoho)
                            {
                                fieldValue1[(int)morph.hash["hoho"]] = 0.5f;
                            }
                            else
                            {
                                fieldValue1[(int)morph.hash["hoho"]] = 0.0f;
                            }

                            if (isHoho2)
                            {
                                fieldValue1[(int)morph.hash["hoho2"]] = 0.5f;
                            }
                            else
                            {
                                fieldValue1[(int)morph.hash["hoho2"]] = 0.0f;
                            }

                            if (isHohos)
                            {
                                fieldValue1[(int)morph.hash["hohos"]] = 1f;
                            }
                            else
                            {
                                fieldValue1[(int)morph.hash["hohos"]] = 0.0f;
                            }

                            if (isHohol)
                            {
                                fieldValue1[(int)morph.hash["hohol"]] = 1f;
                            }
                            else
                            {
                                fieldValue1[(int)morph.hash["hohol"]] = 0.0f;
                            }

                            if (isToothoff)
                            {
                                fieldValue1[(int)morph.hash["toothoff"]] = 1f;
                            }
                            else
                            {
                                fieldValue1[(int)morph.hash["toothoff"]] = 0.0f;
                            }

                            morph.boNoseFook = isNosefook;
                            for (int index = 0; index < maidCnt; ++index)
                            {
                                maidArray[index].body0.Face.morph.FixBlendValues_Face();
                            }
                        }
                    }
                }

                if (isF6 && !okFlg && (!escFlg && Input.GetKeyDown(KeyCode.Escape) || Input.GetKeyDown(KeyCode.Tab)))
                {
                    bGui = !bGui;
                }

                if (isF6 && maidArray[0] != null && maidArray[0].Visible)
                {
                    for (int index = 0; index < 999; ++index)
                    {
                        if (gDogu[index] != null)
                        {
                            gDogu[index].GetComponent<Renderer>().enabled = false;
                            gDogu[index].SetActive(false);
                            if (mDogu[index].del)
                            {
                                mDogu[index].del = false;
                                GraphicsUtils.Destroy(doguBObject[index]);
                                doguBObject.RemoveAt(index);
                            }
                            else if (mDogu[index].count > 0)
                            {
                                --mDogu[index].count;
                                if (doguBObject.Count > index && doguBObject[index] != null
                                                              && doguBObject[index].name.StartsWith("Particle/p"))
                                {
                                    if (mDogu[index].count == 1)
                                    {
                                        doguBObject[index].SetActive(false);
                                    }

                                    if (mDogu[index].count == 0)
                                    {
                                        doguBObject[index].SetActive(true);
                                        switch (doguBObject[index].name)
                                        {
                                            case "Particle/pLineY":
                                                mDogu[index].count = 180;
                                                break;
                                            case "Particle/pLineP02":
                                                mDogu[index].count = 115;
                                                break;
                                            case "Particle/pLine_act2":
                                                mDogu[index].count = 90;
                                                break;
                                            case "Particle/pHeart01":
                                                mDogu[index].count = 77;
                                                break;
                                        }
                                    }
                                }
                            }
                        }
                    }

                    ikMode2 = !Input.GetKey(KeyCode.Z) || !getModKeyPressing(modKey.Shift)
                                      ? (!Input.GetKey(KeyCode.Z) || !getModKeyPressing(modKey.Ctrl)
                                                 ? (!Input.GetKey(KeyCode.X) || !getModKeyPressing(modKey.Shift)
                                                            ? (!Input.GetKey(KeyCode.X)
                                                                       ? (!Input.GetKey(KeyCode.Z)
                                                                                  ? (!Input.GetKey(KeyCode.C)
                                                                                             ? (!Input.GetKey(KeyCode.D) ? 0 : 15)
                                                                                             : 13)
                                                                                  : 10)
                                                                       : 9)
                                                            : 14)
                                                 : 12)
                                      : 11;
                    if (gBg != null)
                    {
                        if (!isCube3)
                        {
                            gBg.GetComponent<Renderer>().enabled = false;
                            gBg.SetActive(false);
                        }
                        else
                        {
                            if (ikMode2 > 0 && ikMode2 != 15)
                            {
                                gBg.GetComponent<Renderer>().enabled = true;
                                gBg.SetActive(true);
                            }
                            else
                            {
                                gBg.GetComponent<Renderer>().enabled = false;
                                gBg.SetActive(false);
                            }

                            if (ikMode2 == 10 || ikMode2 == 11 || ikMode2 == 12)
                            {
                                gBg.GetComponent<Renderer>().material.color = new Color(0.4f, 0.4f, 1f, 0.5f);
                            }

                            if (ikMode2 == 9 || ikMode2 == 14)
                            {
                                gBg.GetComponent<Renderer>().material.color = new Color(0.3f, 0.7f, 0.3f, 0.5f);
                                mBg.Update();
                            }

                            if (ikMode2 == 13)
                            {
                                gBg.GetComponent<Renderer>().material.color = new Color(0.7f, 0.7f, 0.3f, 0.5f);
                                mBg.Update();
                            }

                            if (ikMode2 == 13)
                            {
                                if ((ikModeOld2 == 0 || ikModeOld2 >= 9) && ikModeOld2 != 13 && gBg)
                                {
                                    mBg.ido = 5;
                                    mBg.reset = true;
                                }
                                else
                                {
                                    gBg.transform.position = bg.position;
                                    gBg.transform.eulerAngles = bg.eulerAngles;
                                    mBg.maid = bgObject;
                                    mBg.ido = 5;
                                }
                            }
                            else if (ikMode2 == 11)
                            {
                                if ((ikModeOld2 == 0 || ikModeOld2 >= 9) && ikModeOld2 != 11 && gBg)
                                {
                                    mBg.ido = 3;
                                    mBg.reset = true;
                                }
                                else
                                {
                                    gBg.transform.position = bg.position;
                                    gBg.transform.eulerAngles = bg.eulerAngles;
                                    mBg.maid = bgObject;
                                    mBg.ido = 3;
                                }
                            }
                            else if (ikMode2 == 12)
                            {
                                if ((ikModeOld2 == 0 || ikModeOld2 >= 9) && ikModeOld2 != 12 && gBg)
                                {
                                    mBg.ido = 2;
                                    mBg.reset = true;
                                }
                                else
                                {
                                    gBg.transform.position = bg.position;
                                    gBg.transform.eulerAngles = bg.eulerAngles;
                                    mBg.maid = bgObject;
                                    mBg.ido = 2;
                                }
                            }
                            else if (ikMode2 == 10)
                            {
                                if ((ikModeOld2 == 0 || ikModeOld2 >= 9) && ikModeOld2 != 10 && gBg)
                                {
                                    mBg.ido = 1;
                                    mBg.reset = true;
                                }
                                else
                                {
                                    gBg.transform.position = bg.position;
                                    gBg.transform.eulerAngles = bg.eulerAngles;
                                    mBg.maid = bgObject;
                                    mBg.ido = 1;
                                }
                            }
                            else if (ikMode2 == 9)
                            {
                                if ((ikModeOld2 == 0 || ikModeOld2 >= 9) && ikModeOld2 != 9 && gBg)
                                {
                                    mBg.ido = 4;
                                    mBg.reset = true;
                                }
                                else
                                {
                                    gBg.transform.position = bg.position;
                                    gBg.transform.eulerAngles = bg.eulerAngles;
                                    mBg.maid = bgObject;
                                    mBg.ido = 4;
                                }
                            }
                            else if (ikMode2 == 14)
                            {
                                if ((ikModeOld2 == 0 || ikModeOld2 >= 9) && ikModeOld2 != 14 && gBg)
                                {
                                    mBg.ido = 6;
                                    mBg.reset = true;
                                }
                                else
                                {
                                    gBg.transform.position = bg.position;
                                    gBg.transform.eulerAngles = bg.eulerAngles;
                                    mBg.maid = bgObject;
                                    mBg.ido = 6;
                                }
                            }
                        }
                    }

                    for (int index = 0; index < lightIndex.Count; ++index)
                    {
                        if (gLight[0] == null)
                        {
                            gLight[0] = GameObject.CreatePrimitive(PrimitiveType.Cube);
                            gLight[0].GetComponent<Renderer>().material =
                                    new Material(Shader.Find("Transparent/Diffuse")) { color = new Color(0.5f, 0.5f, 1f, 0.8f) };
                            gLight[0].layer = 8;
                            gLight[0].GetComponent<Renderer>().enabled = false;
                            gLight[0].SetActive(false);
                            gLight[0].transform.position = GameMain.Instance.MainLight.transform.position;
                            mLight[0] = gLight[0].AddComponent<MouseDrag6>();
                            mLight[0].obj = gLight[0];
                            mLight[0].maid = GameMain.Instance.MainLight.gameObject;
                            mLight[0].angles = GameMain.Instance.MainLight.gameObject.transform.eulerAngles;
                            gLight[0].transform.localScale = new Vector3(0.12f, 0.12f, 0.12f);
                            mLight[0].ido = 1;
                            mLight[0].isScale = false;
                        }

                        if (gLight[index] != null)
                        {
                            if (!isCube4)
                            {
                                gLight[index].GetComponent<Renderer>().enabled = false;
                                gLight[index].SetActive(false);
                            }
                            else if (lightList[index].GetComponent<Light>().type == LightType.Spot
                                     || lightList[index].GetComponent<Light>().type == LightType.Point)
                            {
                                if (ikMode2 > 0 && ikMode2 != 15)
                                {
                                    gLight[index].GetComponent<Renderer>().enabled = true;
                                    gLight[index].SetActive(true);
                                }
                                else
                                {
                                    gLight[index].GetComponent<Renderer>().enabled = false;
                                    gLight[index].SetActive(false);
                                    mLight[index].isAlt = false;
                                }

                                if (ikMode2 == 10 || ikMode2 == 11 || ikMode2 == 12)
                                {
                                    gLight[index].GetComponent<Renderer>().material.color = new Color(0.4f, 0.4f, 1f, 0.5f);
                                    if (mLight[index].isAlt)
                                    {
                                        gLight[index].GetComponent<Renderer>().material.color = new Color(0.6f, 0.6f, 1f, 0.5f);
                                    }
                                }

                                if (ikMode2 == 9 || ikMode2 == 14)
                                {
                                    gLight[index].GetComponent<Renderer>().material.color = new Color(0.3f, 0.7f, 0.3f, 0.5f);
                                    mLight[index].Update();
                                }

                                if (ikMode2 == 13)
                                {
                                    gLight[index].GetComponent<Renderer>().material.color = new Color(0.7f, 0.7f, 0.3f, 0.5f);
                                    mLight[index].Update();
                                }

                                if (ikMode2 == 13)
                                {
                                    if ((ikModeOld2 == 0 || ikModeOld2 >= 9) && ikModeOld2 != 13 && gLight[index])
                                    {
                                        mLight[index].ido = 15;
                                        mLight[index].reset = true;
                                    }
                                    else
                                    {
                                        if (lightList[index].transform.localScale.x == 1.0)
                                        {
                                            lightList[index].transform.localScale =
                                                    new Vector3(lightRange[index], lightRange[index], lightRange[index]);
                                        }

                                        lightRange[index] = lightList[index].transform.localScale.x;
                                        gLight[index].transform.position = lightList[index].transform.position;
                                        gLight[index].transform.eulerAngles = lightList[index].transform.eulerAngles;
                                        mLight[index].maid = lightList[index];
                                        mLight[index].ido = 15;
                                    }
                                }
                                else if (ikMode2 == 11)
                                {
                                    if ((ikModeOld2 == 0 || ikModeOld2 >= 9) && ikModeOld2 != 11 && gLight[index])
                                    {
                                        mLight[index].ido = 3;
                                        mLight[index].reset = true;
                                    }
                                    else
                                    {
                                        gLight[index].transform.position = lightList[index].transform.position;
                                        gLight[index].transform.eulerAngles = lightList[index].transform.eulerAngles;
                                        lightX[index] = gLight[index].transform.eulerAngles.x;
                                        lightY[index] = gLight[index].transform.eulerAngles.y;
                                        mLight[index].maid = lightList[index];
                                        mLight[index].ido = 3;
                                    }
                                }
                                else if (ikMode2 == 12)
                                {
                                    if ((ikModeOld2 == 0 || ikModeOld2 >= 9) && ikModeOld2 != 12 && gLight[index])
                                    {
                                        mLight[index].ido = 2;
                                        mLight[index].reset = true;
                                    }
                                    else
                                    {
                                        gLight[index].transform.position = lightList[index].transform.position;
                                        gLight[index].transform.eulerAngles = lightList[index].transform.eulerAngles;
                                        mLight[index].maid = lightList[index];
                                        mLight[index].ido = 2;
                                    }
                                }
                                else if (ikMode2 == 10)
                                {
                                    if ((ikModeOld2 == 0 || ikModeOld2 >= 9) && ikModeOld2 != 10 && gLight[index])
                                    {
                                        mLight[index].ido = 1;
                                        mLight[index].reset = true;
                                    }
                                    else
                                    {
                                        gLight[index].transform.position = lightList[index].transform.position;
                                        gLight[index].transform.eulerAngles = lightList[index].transform.eulerAngles;
                                        mLight[index].maid = lightList[index];
                                        mLight[index].ido = 1;
                                    }
                                }
                                else if (ikMode2 == 9)
                                {
                                    if ((ikModeOld2 == 0 || ikModeOld2 >= 9) && ikModeOld2 != 9 && gLight[index])
                                    {
                                        mLight[index].ido = 4;
                                        mLight[index].reset = true;
                                    }
                                    else
                                    {
                                        gLight[index].transform.position = lightList[index].transform.position;
                                        gLight[index].transform.eulerAngles = lightList[index].transform.eulerAngles;
                                        lightX[index] = gLight[index].transform.eulerAngles.x;
                                        lightY[index] = gLight[index].transform.eulerAngles.y;
                                        mLight[index].maid = lightList[index];
                                        mLight[index].ido = 4;
                                    }
                                }
                                else if (ikMode2 == 14)
                                {
                                    if ((ikModeOld2 == 0 || ikModeOld2 >= 9) && ikModeOld2 != 14 && gLight[index])
                                    {
                                        mLight[index].ido = 6;
                                        mLight[index].reset = true;
                                    }
                                    else
                                    {
                                        gLight[index].transform.position = lightList[index].transform.position;
                                        gLight[index].transform.eulerAngles = lightList[index].transform.eulerAngles;
                                        lightX[index] = gLight[index].transform.eulerAngles.x;
                                        lightY[index] = gLight[index].transform.eulerAngles.y;
                                        mLight[index].maid = lightList[index];
                                        mLight[index].ido = 6;
                                    }
                                }
                            }
                        }
                    }

                    for (int index = 0; index < doguBObject.Count; ++index)
                    {
                        if (!isCube2)
                        {
                            gDogu[index].GetComponent<Renderer>().enabled = false;
                            gDogu[index].SetActive(false);
                        }
                        else
                        {
                            if (ikMode2 > 0)
                            {
                                gDogu[index].GetComponent<Renderer>().enabled = true;
                                gDogu[index].SetActive(true);
                            }
                            else
                            {
                                gDogu[index].GetComponent<Renderer>().enabled = false;
                                gDogu[index].SetActive(false);
                                mDogu[index].isAlt = false;
                            }

                            if (ikMode2 == 10 || ikMode2 == 11 || ikMode2 == 12)
                            {
                                gDogu[index].GetComponent<Renderer>().material.color = new Color(0.4f, 0.4f, 1f, 0.5f);
                                if (mDogu[index].isAlt)
                                {
                                    gDogu[index].GetComponent<Renderer>().material.color = new Color(0.6f, 0.6f, 1f, 0.5f);
                                }
                            }

                            if (ikMode2 == 9 || ikMode2 == 14)
                            {
                                gDogu[index].GetComponent<Renderer>().material.color = new Color(0.3f, 0.7f, 0.3f, 0.5f);
                                mDogu[index].Update();
                            }

                            if (ikMode2 == 15)
                            {
                                gDogu[index].GetComponent<Renderer>().material.color = new Color(1f, 0.3f, 0.3f, 0.5f);
                            }

                            if (ikMode2 == 13)
                            {
                                gDogu[index].GetComponent<Renderer>().material.color = new Color(0.7f, 0.7f, 0.3f, 0.5f);
                                mDogu[index].Update();
                            }

                            if (ikMode2 == 13)
                            {
                                if ((ikModeOld2 == 0 || ikModeOld2 >= 9) && ikModeOld2 != 13 && gDogu[index])
                                {
                                    mDogu[index].ido = 5;
                                    mDogu[index].reset = true;
                                }
                                else
                                {
                                    gDogu[index].transform.position = doguBObject[index].transform.position;
                                    gDogu[index].transform.eulerAngles = doguBObject[index].transform.eulerAngles;
                                    mDogu[index].maid = doguBObject[index];
                                    mDogu[index].ido = 5;
                                }
                            }
                            else if (ikMode2 == 11)
                            {
                                if ((ikModeOld2 == 0 || ikModeOld2 >= 9) && ikModeOld2 != 11 && gDogu[index])
                                {
                                    mDogu[index].ido = 3;
                                    mDogu[index].reset = true;
                                }
                                else
                                {
                                    gDogu[index].transform.position = doguBObject[index].transform.position;
                                    gDogu[index].transform.eulerAngles = doguBObject[index].transform.eulerAngles;
                                    mDogu[index].maid = doguBObject[index];
                                    mDogu[index].ido = 3;
                                }
                            }
                            else if (ikMode2 == 12)
                            {
                                if ((ikModeOld2 == 0 || ikModeOld2 >= 9) && ikModeOld2 != 12 && gDogu[index])
                                {
                                    mDogu[index].ido = 2;
                                    mDogu[index].reset = true;
                                }
                                else
                                {
                                    gDogu[index].transform.position = doguBObject[index].transform.position;
                                    gDogu[index].transform.eulerAngles = doguBObject[index].transform.eulerAngles;
                                    mDogu[index].maid = doguBObject[index];
                                    mDogu[index].ido = 2;
                                }
                            }
                            else if (ikMode2 == 10)
                            {
                                if ((ikModeOld2 == 0 || ikModeOld2 >= 9) && ikModeOld2 != 10 && gDogu[index])
                                {
                                    mDogu[index].ido = 1;
                                    mDogu[index].reset = true;
                                }
                                else
                                {
                                    gDogu[index].transform.position = doguBObject[index].transform.position;
                                    gDogu[index].transform.eulerAngles = doguBObject[index].transform.eulerAngles;
                                    mDogu[index].maid = doguBObject[index];
                                    mDogu[index].maidArray = doguBObject.ToArray();
                                    mDogu[index].mArray = ((IEnumerable<MouseDrag6>)mDogu).ToArray();
                                    mDogu[index].ido = 1;
                                }
                            }
                            else if (ikMode2 == 9)
                            {
                                if ((ikModeOld2 == 0 || ikModeOld2 >= 9) && ikModeOld2 != 9 && gDogu[index])
                                {
                                    mDogu[index].ido = 4;
                                    mDogu[index].reset = true;
                                }
                                else
                                {
                                    gDogu[index].transform.position = doguBObject[index].transform.position;
                                    gDogu[index].transform.eulerAngles = doguBObject[index].transform.eulerAngles;
                                    mDogu[index].maid = doguBObject[index];
                                    mDogu[index].ido = 4;
                                }
                            }
                            else if (ikMode2 == 14)
                            {
                                if ((ikModeOld2 == 0 || ikModeOld2 >= 9) && ikModeOld2 != 14 && gDogu[index])
                                {
                                    mDogu[index].ido = 6;
                                    mDogu[index].reset = true;
                                }
                                else
                                {
                                    gDogu[index].transform.position = doguBObject[index].transform.position;
                                    gDogu[index].transform.eulerAngles = doguBObject[index].transform.eulerAngles;
                                    mDogu[index].maid = doguBObject[index];
                                    mDogu[index].ido = 6;
                                }
                            }
                            else if (ikMode2 == 15)
                            {
                                if ((ikModeOld2 == 0 || ikModeOld2 >= 9) && ikModeOld2 != 15 && gDogu[index])
                                {
                                    mDogu[index].ido = 7;
                                    mDogu[index].reset = true;
                                }
                                else
                                {
                                    gDogu[index].transform.position = doguBObject[index].transform.position;
                                    gDogu[index].transform.eulerAngles = doguBObject[index].transform.eulerAngles;
                                    mDogu[index].maid = doguBObject[index];
                                    mDogu[index].ido = 7;
                                }
                            }
                        }
                    }

                    ikModeOld2 = ikMode2;
                    Vector3 vector3_2 = mainCameraTransform.TransformDirection(Vector3.forward);
                    Vector3 vector3_3 = mainCameraTransform.TransformDirection(Vector3.right);
                    vector3_1 = mainCameraTransform.TransformDirection(Vector3.up);
                    if (Input.GetKeyDown(KeyCode.Y) && getModKeyPressing(modKey.Shift))
                    {
                        keyFlg = true;
                        --bgIndex;
                        if (bgIndex <= -1)
                        {
                            bgIndex = bgArray.Length - 1;
                        }

                        if (!moveBg)
                        {
                            bg.localScale = new Vector3(1f, 1f, 1f);
                            if (bgArray[bgIndex].Length == 36)
                            {
                                GameMain.Instance.BgMgr.ChangeBgMyRoom(bgArray[bgIndex]);
                            }
                            else
                            {
                                GameMain.Instance.BgMgr.ChangeBg(bgArray[bgIndex]);
                            }

                            bgCombo.selectedItemIndex = bgIndex;
                        }
                    }
                    else if (Input.GetKey(KeyCode.Y) && Input.GetKey(KeyCode.E))
                    {
                        keyFlg = true;
                        bg.localScale = new Vector3(bg.localScale.x * 1.005f, bg.localScale.y * 1.005f, bg.localScale.z * 1.005f);
                    }
                    else if (Input.GetKey(KeyCode.Y) && Input.GetKey(KeyCode.D))
                    {
                        keyFlg = true;
                        bg.localScale = new Vector3(bg.localScale.x * 0.995f, bg.localScale.y * 0.995f, bg.localScale.z * 0.995f);
                    }
                    else if (Input.GetKey(KeyCode.Y) && Input.GetKeyDown(KeyCode.C))
                    {
                        keyFlg = true;
                        bg.localScale = new Vector3(1f, 1f, 1f);
                    }
                    else if ((Input.GetKey(KeyCode.Y) || Input.GetKey(KeyCode.V)) && Input.GetKey(KeyCode.I) && Input.GetKey(KeyCode.J))
                    {
                        bg.localPosition = bg.position + new Vector3(vector3_2.x, 0.0f, vector3_2.z) * -0.025f * speed
                                                       + new Vector3(vector3_3.x, 0.0f, vector3_3.z) * 0.025f * speed;
                        if (Input.GetKey(KeyCode.Y))
                        {
                            keyFlg = true;
                        }
                    }
                    else if ((Input.GetKey(KeyCode.Y) || Input.GetKey(KeyCode.V)) && Input.GetKey(KeyCode.I) && Input.GetKey(KeyCode.L))
                    {
                        bg.localPosition = bg.position + new Vector3(vector3_2.x, 0.0f, vector3_2.z) * -0.025f * speed
                                                       + new Vector3(vector3_3.x, 0.0f, vector3_3.z) * -0.025f * speed;
                        if (Input.GetKey(KeyCode.Y))
                        {
                            keyFlg = true;
                        }
                    }
                    else if ((Input.GetKey(KeyCode.Y) || Input.GetKey(KeyCode.V)) && Input.GetKey(KeyCode.K) && Input.GetKey(KeyCode.J))
                    {
                        bg.localPosition = bg.position + new Vector3(vector3_2.x, 0.0f, vector3_2.z) * 0.025f * speed
                                                       + new Vector3(vector3_3.x, 0.0f, vector3_3.z) * 0.025f * speed;
                        if (Input.GetKey(KeyCode.Y))
                        {
                            keyFlg = true;
                        }
                    }
                    else if ((Input.GetKey(KeyCode.Y) || Input.GetKey(KeyCode.V)) && Input.GetKey(KeyCode.K) && Input.GetKey(KeyCode.L))
                    {
                        bg.localPosition = bg.position + new Vector3(vector3_2.x, 0.0f, vector3_2.z) * 0.025f * speed
                                                       + new Vector3(vector3_3.x, 0.0f, vector3_3.z) * -0.025f * speed;
                        if (Input.GetKey(KeyCode.Y))
                        {
                            keyFlg = true;
                        }
                    }
                    else if ((Input.GetKey(KeyCode.Y) || Input.GetKey(KeyCode.V)) && Input.GetKey(KeyCode.I))
                    {
                        bg.localPosition = bg.position + new Vector3(vector3_2.x, 0.0f, vector3_2.z) * -0.025f * speed;
                        if (Input.GetKey(KeyCode.Y))
                        {
                            keyFlg = true;
                        }
                    }
                    else if ((Input.GetKey(KeyCode.Y) || Input.GetKey(KeyCode.V)) && Input.GetKey(KeyCode.K))
                    {
                        bg.localPosition = bg.position + new Vector3(vector3_2.x, 0.0f, vector3_2.z) * 0.025f * speed;
                        if (Input.GetKey(KeyCode.Y))
                        {
                            keyFlg = true;
                        }
                    }
                    else if ((Input.GetKey(KeyCode.Y) || Input.GetKey(KeyCode.V)) && Input.GetKey(KeyCode.J))
                    {
                        bg.localPosition = bg.position + new Vector3(vector3_3.x, 0.0f, vector3_3.z) * 0.025f * speed;
                        if (Input.GetKey(KeyCode.Y))
                        {
                            keyFlg = true;
                        }
                    }
                    else if ((Input.GetKey(KeyCode.Y) || Input.GetKey(KeyCode.V)) && Input.GetKey(KeyCode.L))
                    {
                        bg.localPosition = bg.position + new Vector3(vector3_3.x, 0.0f, vector3_3.z) * -0.025f * speed;
                        if (Input.GetKey(KeyCode.Y))
                        {
                            keyFlg = true;
                        }
                    }
                    else if ((Input.GetKey(KeyCode.Y) || Input.GetKey(KeyCode.V)) && Input.GetKey(KeyCode.Alpha0))
                    {
                        Vector3 position = bg.position;
                        position.y -= 0.015f * speed;
                        bg.localPosition = position;
                        if (Input.GetKey(KeyCode.Y))
                        {
                            keyFlg = true;
                        }
                    }
                    else if ((Input.GetKey(KeyCode.Y) || Input.GetKey(KeyCode.V)) && Input.GetKey(KeyCode.P))
                    {
                        Vector3 position = bg.position;
                        position.y += 0.015f * speed;
                        bg.localPosition = position;
                        if (Input.GetKey(KeyCode.Y))
                        {
                            keyFlg = true;
                        }
                    }
                    else if ((Input.GetKey(KeyCode.Y) || Input.GetKey(KeyCode.V)) && Input.GetKey(KeyCode.U))
                    {
                        bg.RotateAround(maidArray[0].transform.position, Vector3.up, 0.7f);
                        if (Input.GetKey(KeyCode.Y))
                        {
                            keyFlg = true;
                        }
                    }
                    else if ((Input.GetKey(KeyCode.Y) || Input.GetKey(KeyCode.V)) && Input.GetKey(KeyCode.O))
                    {
                        bg.RotateAround(maidArray[0].transform.position, Vector3.up, -0.7f);
                        if (Input.GetKey(KeyCode.Y))
                        {
                            keyFlg = true;
                        }
                    }
                    else if (Input.GetKeyUp(KeyCode.Y))
                    {
                        if (keyFlg)
                        {
                            keyFlg = false;
                        }
                        else
                        {
                            ++bgIndex;
                            if (bgIndex == bgArray.Length)
                            {
                                bgIndex = 0;
                            }

                            if (!moveBg)
                            {
                                bg.localScale = new Vector3(1f, 1f, 1f);
                                if (bgArray[bgIndex].Length == 36)
                                {
                                    GameMain.Instance.BgMgr.ChangeBgMyRoom(bgArray[bgIndex]);
                                }
                                else
                                {
                                    GameMain.Instance.BgMgr.ChangeBg(bgArray[bgIndex]);
                                }

                                bgCombo.selectedItemIndex = bgIndex;
                            }
                        }
                    }

                    speed = !getModKeyPressing(modKey.Shift)
                                    ? (float)(1.0 * Time.deltaTime * 60.0)
                                    : (float)(5.0 * Time.deltaTime * 60.0);
                    if (!isVR || isVR2)
                    {
                        if (!isVR)
                        {
                            if (isBloom)
                            {
                                Bloom fieldValue = GetFieldValue<CameraMain, Bloom>(mainCamera, "m_gcBloom");
                                fieldValue.enabled = true;
                                fieldValue.bloomIntensity = bloom1;
                                fieldValue.bloomBlurIterations = (int)bloom2;
                                fieldValue.bloomThreshholdColor = new Color(1f - bloom3, 1f - bloom4, 1f - bloom5);
                                fieldValue.hdr = !isBloomA ? Bloom.HDRBloomMode.Auto : Bloom.HDRBloomMode.On;
                                isBloom2 = true;
                            }
                            else if (isBloom2)
                            {
                                isBloom2 = false;
                                Bloom fieldValue = GetFieldValue<CameraMain, Bloom>(mainCamera, "m_gcBloom");
                                fieldValue.enabled = true;
                                fieldValue.bloomIntensity = 2.85f;
                                fieldValue.hdr = Bloom.HDRBloomMode.Auto;
                                fieldValue.bloomThreshholdColor = new Color(1f, 1f, 1f);
                                fieldValue.bloomBlurIterations = 3;
                            }

                            if (isDepth)
                            {
                                depth_field_.enabled = true;
                                depth_field_.focalLength = depth1;
                                depth_field_.focalSize = depth2;
                                depth_field_.aperture = depth3;
                                depth_field_.maxBlurSize = depth4;
                                depth_field_.visualizeFocus = isDepthA;
                            }
                            else
                            {
                                if (depth_field_ == null)
                                {
                                    depth_field_ = GameMain.Instance.MainCamera.gameObject.AddComponent<DepthOfFieldScatter>();
                                    if (depth_field_.dofHdrShader == null)
                                    {
                                        depth_field_.dofHdrShader = Shader.Find("Hidden/Dof/DepthOfFieldHdr");
                                    }

                                    if (depth_field_.dx11BokehShader == null)
                                    {
                                        depth_field_.dx11BokehShader = Shader.Find("Hidden/Dof/DX11Dof");
                                    }

                                    if (depth_field_.dx11BokehTexture == null)
                                    {
                                        depth_field_.dx11BokehTexture = Resources.Load("Textures/hexShape") as Texture2D;
                                    }
                                }

                                depth_field_.enabled = false;
                            }

                            if (isFog)
                            {
                                if (fog_.fogShader == null)
                                {
                                    fog_.fogShader = Shader.Find("Hidden/GlobalFog");
                                }

                                fog_.enabled = true;
                                fog_.startDistance = fog1;
                                fog_.globalDensity = fog2;
                                fog_.heightScale = fog3;
                                fog_.height = fog4;
                                fog_.globalFogColor.r = fog5;
                                fog_.globalFogColor.g = fog6;
                                fog_.globalFogColor.b = fog7;
                            }
                            else
                            {
                                if (fog_ == null)
                                {
                                    fog_ = GameMain.Instance.MainCamera.gameObject.AddComponent<GlobalFog>();
                                }

                                fog_.enabled = false;
                            }

                            if (isSepia)
                            {
                                if (sepia_tone_.shader == null)
                                {
                                    sepia_tone_.shader = Shader.Find("Hidden/Sepiatone Effect");
                                }

                                sepia_tone_.enabled = true;
                            }
                            else
                            {
                                if (sepia_tone_ == null)
                                {
                                    sepia_tone_ = GameMain.Instance.MainCamera.gameObject.AddComponent<SepiaToneEffect>();
                                }

                                sepia_tone_.enabled = false;
                            }

                            if (bokashi > 0.0)
                            {
                                Blur component = GameMain.Instance.MainCamera.gameObject.GetComponent<Blur>();
                                component.enabled = true;
                                component.blurSize = bokashi / 10f;
                                component.blurIterations = 0;
                                component.downsample = 0;
                                if (bokashi > 3.0)
                                {
                                    component.blurSize -= 0.3f;
                                    component.blurIterations = 1;
                                    component.downsample = 1;
                                }
                            }
                            else
                            {
                                GameMain.Instance.MainCamera.gameObject.GetComponent<Blur>().enabled = false;
                            }

                            if (kamiyure > 0.0)
                            {
                                for (int index1 = 0; index1 < maidCnt; ++index1)
                                {
                                    Maid maid = maidArray[index1];
                                    for (int index2 = 0; index2 < maid.body0.goSlot.Count; ++index2)
                                    {
                                        if (maid.body0.goSlot[index2].obj != null)
                                        {
                                            DynamicBone component = maid.body0.goSlot[index2].obj.GetComponent<DynamicBone>();
                                            if (component != null && component.enabled)
                                            {
                                                component.m_Gravity = new Vector3(softG.x * 5f, softG.y * 5f + kamiyure, softG.z * 5f);
                                            }
                                        }

                                        List<THair1> fieldValue =
                                                GetFieldValue<TBoneHair_, List<THair1>>(maid.body0.goSlot[index2].bonehair, "hair1list");
                                        for (int index3 = 0; index3 < fieldValue.Count; ++index3)
                                        {
                                            fieldValue[index3].SoftG = new Vector3(softG.x, softG.y + kamiyure, softG.z);
                                        }
                                    }
                                }
                            }

                            if (isBlur)
                            {
                                Vignetting component = GameMain.Instance.MainCamera.gameObject.GetComponent<Vignetting>();
                                component.mode = Vignetting.AberrationMode.Simple;
                                component.intensity = blur1;
                                component.chromaticAberration = blur4;
                                component.blur = blur2;
                                component.blurSpread = blur3;
                                component.enabled = true;
                                isBlur2 = true;
                            }
                            else if (isBlur2)
                            {
                                isBlur2 = false;
                                Vignetting component = GameMain.Instance.MainCamera.gameObject.GetComponent<Vignetting>();
                                component.mode = Vignetting.AberrationMode.Simple;
                                component.intensity = -3.98f;
                                component.chromaticAberration = -0.75f;
                                component.axialAberration = 1.18f;
                                component.blurSpread = 4.19f;
                                component.luminanceDependency = 0.494f;
                                component.blurDistance = 1.71f;
                                component.enabled = false;
                            }
                        }

                        if (Input.GetKey(KeyCode.R) && Input.GetKey(KeyCode.I))
                        {
                            GameMain.Instance.MainLight.transform.eulerAngles -= Vector3.right / 2f;
                            lightX[0] = GameMain.Instance.MainLight.transform.eulerAngles.x;
                        }
                        else if (Input.GetKey(KeyCode.R) && Input.GetKey(KeyCode.K))
                        {
                            if (GameMain.Instance.MainLight.transform.eulerAngles.x < 85.0)
                            {
                                GameMain.Instance.MainLight.transform.eulerAngles += Vector3.right / 2f;
                                lightX[0] = GameMain.Instance.MainLight.transform.eulerAngles.x;
                            }
                        }
                        else if (Input.GetKey(KeyCode.R) && Input.GetKey(KeyCode.J))
                        {
                            GameMain.Instance.MainLight.transform.eulerAngles -= Vector3.up / 1.5f;
                            lightY[0] = GameMain.Instance.MainLight.transform.eulerAngles.y;
                        }
                        else if (Input.GetKey(KeyCode.R) && Input.GetKey(KeyCode.L))
                        {
                            GameMain.Instance.MainLight.transform.eulerAngles += Vector3.up / 1.5f;
                            lightY[0] = GameMain.Instance.MainLight.transform.eulerAngles.y;
                        }
                        else if (Input.GetKey(KeyCode.R) && Input.GetKey(KeyCode.BackQuote))
                        {
                            GameMain.Instance.MainLight.Reset();
                            GameMain.Instance.MainLight.SetIntensity(0.95f);
                            GameMain.Instance.MainLight.GetComponent<Light>().type = LightType.Directional;
                            lightIndex[0] = 0;
                            lightColorR[0] = 1f;
                            lightColorG[0] = 1f;
                            lightColorB[0] = 1f;
                            lightX[0] = 40f;
                            lightY[0] = 180f;
                            lightAkarusa[0] = 0.95f;
                            lightKage[0] = 0.098f;
                            lightRange[0] = 50f;
                            bgObject.SetActive(true);
                            mainCamera.GetComponent<Camera>().backgroundColor = new Color(0.0f, 0.0f, 0.0f);
                            isIdx1 = false;
                            isIdx2 = false;
                            isIdx3 = false;
                            isIdx4 = false;
                        }
                        else if (Input.GetKey(KeyCode.R) && Input.GetKey(KeyCode.Minus) && getModKeyPressing(modKey.Shift))
                        {
                            List<float> lightColorR;
                            (lightColorR = this.lightColorR)[0] = lightColorR[0] + 0.01f;
                            if (this.lightColorR[0] > 1.0)
                            {
                                this.lightColorR[0] = 1f;
                            }

                            if (lightIndex[0] != 3)
                            {
                                GameMain.Instance.MainLight.GetComponent<Light>().color =
                                        new Color(this.lightColorR[0], lightColorG[0], lightColorB[0]);
                            }
                            else
                            {
                                mainCamera.GetComponent<Camera>().backgroundColor =
                                        new Color(this.lightColorR[0], lightColorG[0], lightColorB[0]);
                            }
                        }
                        else if (Input.GetKey(KeyCode.R) && Input.GetKey(KeyCode.Quote) && getModKeyPressing(modKey.Shift))
                        {
                            List<float> lightColorG;
                            (lightColorG = this.lightColorG)[0] = lightColorG[0] + 0.01f;
                            if (this.lightColorG[0] > 1.0)
                            {
                                this.lightColorG[0] = 1f;
                            }

                            if (lightIndex[0] != 3)
                            {
                                GameMain.Instance.MainLight.GetComponent<Light>().color =
                                        new Color(lightColorR[0], this.lightColorG[0], lightColorB[0]);
                            }
                            else
                            {
                                mainCamera.GetComponent<Camera>().backgroundColor =
                                        new Color(lightColorR[0], this.lightColorG[0], lightColorB[0]);
                            }
                        }
                        else if (Input.GetKey(KeyCode.R) && Input.GetKey(KeyCode.LeftBracket) && getModKeyPressing(modKey.Shift))
                        {
                            List<float> lightColorB;
                            (lightColorB = this.lightColorB)[0] = lightColorB[0] + 0.01f;
                            if (this.lightColorB[0] > 1.0)
                            {
                                this.lightColorB[0] = 1f;
                            }

                            if (lightIndex[0] != 3)
                            {
                                GameMain.Instance.MainLight.GetComponent<Light>().color =
                                        new Color(lightColorR[0], lightColorG[0], this.lightColorB[0]);
                            }
                            else
                            {
                                mainCamera.GetComponent<Camera>().backgroundColor =
                                        new Color(lightColorR[0], lightColorG[0], this.lightColorB[0]);
                            }
                        }
                        else if (Input.GetKey(KeyCode.R) && Input.GetKey(KeyCode.Minus))
                        {
                            List<float> lightColorR;
                            (lightColorR = this.lightColorR)[0] = lightColorR[0] - 0.01f;
                            if (this.lightColorR[0] < 0.0)
                            {
                                this.lightColorR[0] = 0.0f;
                            }

                            if (lightIndex[0] != 3)
                            {
                                GameMain.Instance.MainLight.GetComponent<Light>().color =
                                        new Color(this.lightColorR[0], lightColorG[0], lightColorB[0]);
                            }
                            else
                            {
                                mainCamera.GetComponent<Camera>().backgroundColor =
                                        new Color(this.lightColorR[0], lightColorG[0], lightColorB[0]);
                            }
                        }
                        else if (Input.GetKey(KeyCode.R) && Input.GetKey(KeyCode.Quote))
                        {
                            List<float> lightColorG;
                            (lightColorG = this.lightColorG)[0] = lightColorG[0] - 0.01f;
                            if (this.lightColorG[0] < 0.0)
                            {
                                this.lightColorG[0] = 0.0f;
                            }

                            if (lightIndex[0] != 3)
                            {
                                GameMain.Instance.MainLight.GetComponent<Light>().color =
                                        new Color(lightColorR[0], this.lightColorG[0], lightColorB[0]);
                            }
                            else
                            {
                                mainCamera.GetComponent<Camera>().backgroundColor =
                                        new Color(lightColorR[0], this.lightColorG[0], lightColorB[0]);
                            }
                        }
                        else if (Input.GetKey(KeyCode.R) && Input.GetKey(KeyCode.LeftBracket))
                        {
                            List<float> lightColorB;
                            (lightColorB = this.lightColorB)[0] = lightColorB[0] - 0.01f;
                            if (this.lightColorB[0] < 0.0)
                            {
                                this.lightColorB[0] = 0.0f;
                            }

                            if (lightIndex[0] != 3)
                            {
                                GameMain.Instance.MainLight.GetComponent<Light>().color =
                                        new Color(lightColorR[0], lightColorG[0], this.lightColorB[0]);
                            }
                            else
                            {
                                mainCamera.GetComponent<Camera>().backgroundColor =
                                        new Color(lightColorR[0], lightColorG[0], this.lightColorB[0]);
                            }
                        }
                        else if (Input.GetKey(KeyCode.R) && Input.GetKey(KeyCode.Alpha0))
                        {
                            GameMain.Instance.MainLight.GetComponent<Light>().intensity += 0.12f * Time.deltaTime;
                            lightAkarusa[0] = GameMain.Instance.MainLight.GetComponent<Light>().intensity;
                        }
                        else if (Input.GetKey(KeyCode.R) && Input.GetKey(KeyCode.P))
                        {
                            GameMain.Instance.MainLight.GetComponent<Light>().intensity -= 0.12f * Time.deltaTime;
                            lightAkarusa[0] = GameMain.Instance.MainLight.GetComponent<Light>().intensity;
                        }
                        else if (Input.GetKey(KeyCode.R) && Input.GetKey(KeyCode.Alpha9))
                        {
                            GameMain.Instance.MainLight.GetComponent<Light>().spotAngle += 0.2f;
                            GameMain.Instance.MainLight.GetComponent<Light>().range += 0.2f;
                            lightRange[0] = GameMain.Instance.MainLight.GetComponent<Light>().spotAngle;
                        }
                        else if (Input.GetKey(KeyCode.R) && Input.GetKey(KeyCode.O))
                        {
                            GameMain.Instance.MainLight.GetComponent<Light>().spotAngle -= 0.2f;
                            GameMain.Instance.MainLight.GetComponent<Light>().range -= 0.2f;
                            lightRange[0] = GameMain.Instance.MainLight.GetComponent<Light>().spotAngle;
                        }
                        else if (Input.GetKey(KeyCode.R) && Input.GetKeyDown(KeyCode.U))
                        {
                            List<int> lightIndex;
                            (lightIndex = this.lightIndex)[0] = lightIndex[0] + 1;
                            if (this.lightIndex[0] == 4)
                            {
                                this.lightIndex[0] = 0;
                            }

                            lightColorR[0] = 1f;
                            lightColorG[0] = 1f;
                            lightColorB[0] = 1f;
                            lightX[0] = 40f;
                            lightY[0] = 180f;
                            lightAkarusa[0] = 0.95f;
                            lightKage[0] = 0.098f;
                            lightRange[0] = 50f;
                            GameMain.Instance.MainLight.Reset();
                            GameMain.Instance.MainLight.SetIntensity(0.95f);
                            GameMain.Instance.MainLight.GetComponent<Light>().spotAngle = 50f;
                            GameMain.Instance.MainLight.GetComponent<Light>().range = 10f;
                            GameMain.Instance.MainLight.gameObject.transform.position = new Vector3(0.0f, 2f, 0.0f);
                            if (this.lightIndex[0] == 0)
                            {
                                GameMain.Instance.MainLight.GetComponent<Light>().type = LightType.Directional;
                                bgObject.SetActive(true);
                                mainCamera.GetComponent<Camera>().backgroundColor = new Color(0.0f, 0.0f, 0.0f);
                            }
                            else if (this.lightIndex[0] == 1)
                            {
                                GameMain.Instance.MainLight.transform.eulerAngles += Vector3.right * 40f;
                                lightX[0] = GameMain.Instance.MainLight.transform.eulerAngles.x;
                                GameMain.Instance.MainLight.GetComponent<Light>().type = LightType.Spot;
                                if (gLight[0] == null)
                                {
                                    gLight[0] = GameObject.CreatePrimitive(PrimitiveType.Cube);
                                    gLight[0].GetComponent<Renderer>().material =
                                            new Material(Shader.Find("Transparent/Diffuse")) { color = new Color(0.5f, 0.5f, 1f, 0.8f) };
                                    gLight[0].layer = 8;
                                    gLight[0].GetComponent<Renderer>().enabled = false;
                                    gLight[0].SetActive(false);
                                    gLight[0].transform.position = GameMain.Instance.MainLight.transform.position;
                                    mLight[0] = gLight[0].AddComponent<MouseDrag6>();
                                    mLight[0].obj = gLight[0];
                                    mLight[0].maid = GameMain.Instance.MainLight.gameObject;
                                    mLight[0].angles = GameMain.Instance.MainLight.gameObject.transform.eulerAngles;
                                    gLight[0].transform.localScale = new Vector3(0.12f, 0.12f, 0.12f);
                                    mLight[0].ido = 1;
                                    mLight[0].isScale = false;
                                }
                            }
                            else if (this.lightIndex[0] == 2)
                            {
                                GameMain.Instance.MainLight.GetComponent<Light>().type = LightType.Point;
                            }
                            else if (this.lightIndex[0] == 3)
                            {
                                GameMain.Instance.MainLight.GetComponent<Light>().type = LightType.Directional;
                                mainCamera.GetComponent<Camera>().backgroundColor =
                                        new Color(lightColorR[0], lightColorG[0], lightColorB[0]);
                                bgObject.SetActive(false);
                            }

                            isIdx1 = false;
                            isIdx2 = false;
                            isIdx3 = false;
                            isIdx4 = false;
                        }
                    }
                    else if (Input.GetKey(KeyCode.R) && Input.GetKey(KeyCode.Insert))
                    {
                        GameMain.Instance.MainLight.transform.eulerAngles -= Vector3.right / 2f;
                    }
                    else if (Input.GetKey(KeyCode.R) && Input.GetKey(KeyCode.Delete))
                    {
                        if (GameMain.Instance.MainLight.transform.eulerAngles.x < 85.0)
                        {
                            GameMain.Instance.MainLight.transform.eulerAngles += Vector3.right / 2f;
                        }
                    }
                    else if (Input.GetKey(KeyCode.R) && Input.GetKey(KeyCode.Home))
                    {
                        GameMain.Instance.MainLight.transform.eulerAngles -= Vector3.up / 1.5f;
                    }
                    else if (Input.GetKey(KeyCode.R) && Input.GetKey(KeyCode.End))
                    {
                        GameMain.Instance.MainLight.transform.eulerAngles += Vector3.up / 1.5f;
                    }
                    else if (Input.GetKey(KeyCode.R) && Input.GetKey(KeyCode.BackQuote))
                    {
                        GameMain.Instance.MainLight.Reset();
                        GameMain.Instance.MainLight.SetIntensity(0.95f);
                    }
                    else if (Input.GetKey(KeyCode.R) && Input.GetKey(KeyCode.PageUp))
                    {
                        GameMain.Instance.MainLight.GetComponent<Light>().intensity += 0.1f * Time.deltaTime;
                    }
                    else if (Input.GetKey(KeyCode.R) && Input.GetKey(KeyCode.PageDown))
                    {
                        GameMain.Instance.MainLight.GetComponent<Light>().intensity -= 0.1f * Time.deltaTime;
                    }
                    else if (Input.GetKey(KeyCode.R) && Input.GetKey(KeyCode.Quote))
                    {
                        if (lightIndex[0] == 1)
                        {
                            GameMain.Instance.MainLight.GetComponent<Light>().spotAngle += 0.2f;
                        }
                        else
                        {
                            GameMain.Instance.MainLight.GetComponent<Light>().range += 0.2f;
                        }
                    }
                    else if (Input.GetKey(KeyCode.R) && Input.GetKey(KeyCode.LeftBracket))
                    {
                        if (lightIndex[0] == 1)
                        {
                            GameMain.Instance.MainLight.GetComponent<Light>().spotAngle -= 0.2f;
                        }
                        else
                        {
                            GameMain.Instance.MainLight.GetComponent<Light>().range -= 0.2f;
                        }
                    }
                    else if (Input.GetKey(KeyCode.R) && Input.GetKeyDown(KeyCode.Minus))
                    {
                        List<int> lightIndex;
                        (lightIndex = this.lightIndex)[0] = lightIndex[0] + 1;
                        if (this.lightIndex[0] == 3)
                        {
                            this.lightIndex[0] = 0;
                        }

                        GameMain.Instance.MainLight.Reset();
                        GameMain.Instance.MainLight.SetIntensity(0.95f);
                        GameMain.Instance.MainLight.GetComponent<Light>().spotAngle = 50f;
                        GameMain.Instance.MainLight.GetComponent<Light>().range = 10f;
                        GameMain.Instance.MainLight.gameObject.transform.position = new Vector3(0.0f, 2f, 0.0f);
                        if (this.lightIndex[0] == 0)
                        {
                            GameMain.Instance.MainLight.GetComponent<Light>().type = LightType.Directional;
                        }
                        else if (this.lightIndex[0] == 1)
                        {
                            GameMain.Instance.MainLight.transform.eulerAngles += Vector3.right * 40f;
                            GameMain.Instance.MainLight.GetComponent<Light>().type = LightType.Spot;
                        }
                        else if (this.lightIndex[0] == 2)
                        {
                            GameMain.Instance.MainLight.GetComponent<Light>().type = LightType.Point;
                        }
                    }

                    for (int index = 0; index < lightList.Count; ++index)
                    {
                        if (index > 0)
                        {
                            lightList[index].GetComponent<Light>().color =
                                    new Color(lightColorR[index], lightColorG[index], lightColorB[index]);
                            lightList[index].GetComponent<Light>().intensity = lightAkarusa[index];
                            lightList[index].GetComponent<Light>().spotAngle = lightRange[index];
                            lightList[index].GetComponent<Light>().range = lightRange[index] / 5f;
                            if (!Input.GetKey(KeyCode.X) && (!Input.GetKey(KeyCode.Z) || !getModKeyPressing(modKey.Shift)))
                            {
                                lightList[index].transform.eulerAngles = new Vector3(lightX[index], lightY[index], 18f);
                            }
                        }
                        else
                        {
                            GameMain.Instance.MainLight.SetIntensity(lightAkarusa[0]);
                            GameMain.Instance.MainLight.GetComponent<Light>().shadowStrength = lightKage[0];
                            if (!Input.GetKey(KeyCode.X) && (!Input.GetKey(KeyCode.Z) || !getModKeyPressing(modKey.Shift)))
                            {
                                GameMain.Instance.MainLight.SetRotation(new Vector3(lightX[0], lightY[0], 18f));
                            }

                            GameMain.Instance.MainLight.GetComponent<Light>().spotAngle = lightRange[index];
                            GameMain.Instance.MainLight.GetComponent<Light>().range = lightRange[index] / 5f;
                            if (lightIndex[index] != 3)
                            {
                                GameMain.Instance.MainLight.GetComponent<Light>().color =
                                        new Color(lightColorR[0], lightColorG[0], lightColorB[0]);
                            }
                            else
                            {
                                mainCamera.GetComponent<Camera>().backgroundColor =
                                        new Color(lightColorR[0], lightColorG[0], lightColorB[0]);
                            }
                        }
                    }
                }

                if (isF6S)
                {
                    if (maidCnt < 1)
                    {
                        ++F6cnt;
                    }

                    if (F6cnt > 10)
                    {
                        maidCnt = 1;
                        F6cnt = 0;
                    }

                    for (int index1 = 0; index1 < maidCnt; ++index1)
                    {
                        if (maidArray[index1] && maidArray[index1].Visible && maidArray[index1].body0.isLoadedBody)
                        {
                            Maid maid = maidArray[index1];
                            for (int index2 = 0; index2 < maid.body0.goSlot.Count; ++index2)
                            {
                                if (maid.body0.goSlot[index2].bonehair.bodyhit != null
                                    && maid.body0.goSlot[index2].bonehair.bodyhit.spherelist.Count == 17 && (index2 == 3 || index2 == 4))
                                {
                                    Transform transform1 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 Spine", true);
                                    Transform transform2 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 Spine0a", true);
                                    Transform transform3 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 Spine1", true);
                                    Transform transform4 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 Spine1a", true);
                                    Transform transform5 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 Pelvis", true);
                                    Transform transform6 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L Hand", true);
                                    CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L UpperArm", true);
                                    Transform transform7 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L Forearm", true);
                                    Transform transform8 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R Hand", true);
                                    CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R UpperArm", true);
                                    Transform transform9 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R Forearm", true);
                                    CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L Foot", true);
                                    Transform transform10 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L Thigh", true);
                                    CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 L Calf", true);
                                    CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R Foot", true);
                                    Transform transform11 = CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R Thigh", true);
                                    CMT.SearchObjName(maid.body0.m_Bones.transform, "Bip01 R Calf", true);
                                    List<THitSphere> spherelist = maid.body0.goSlot[index2].bonehair.bodyhit.spherelist;
                                    THitSphere thitSphere1 = new THitSphere();
                                    THitSphere thitSphere2 = spherelist[0];
                                    THitSphere thitSphere3 = new THitSphere
                                    {
                                        wv = thitSphere2.wv,
                                        len = thitSphere2.len * 0.8f,
                                        t = thitSphere2.t,
                                        vs = thitSphere2.vs
                                    };
                                    thitSphere3.vs.y -= 0.04f;
                                    thitSphere3.vs.x += 0.05f;
                                    spherelist.Add(thitSphere3);
                                    THitSphere thitSphere4 = new THitSphere
                                    {
                                        len = 0.09f,
                                        t = transform4
                                    };
                                    thitSphere4.vs.z += 0.04f;
                                    thitSphere4.vs.x -= 0.04f;
                                    thitSphere4.vs.y -= 0.01f;
                                    spherelist.Add(thitSphere4);
                                    THitSphere thitSphere5 = new THitSphere
                                    {
                                        len = 0.09f,
                                        t = transform4
                                    };
                                    thitSphere5.vs.z -= 0.04f;
                                    thitSphere5.vs.x -= 0.04f;
                                    thitSphere5.vs.y -= 0.01f;
                                    spherelist.Add(thitSphere5);
                                    THitSphere thitSphere6 = new THitSphere
                                    {
                                        len = 0.09f,
                                        t = transform3
                                    };
                                    thitSphere6.vs.z += 0.035f;
                                    spherelist.Add(thitSphere6);
                                    THitSphere thitSphere7 = new THitSphere
                                    {
                                        len = 0.09f,
                                        t = transform3
                                    };
                                    thitSphere7.vs.z -= 0.035f;
                                    spherelist.Add(thitSphere7);
                                    THitSphere thitSphere8 = new THitSphere
                                    {
                                        len = 0.08f,
                                        t = transform2
                                    };
                                    thitSphere8.vs.z += 0.035f;
                                    spherelist.Add(thitSphere8);
                                    THitSphere thitSphere9 = new THitSphere
                                    {
                                        len = 0.08f,
                                        t = transform2
                                    };
                                    thitSphere9.vs.z -= 0.035f;
                                    spherelist.Add(thitSphere9);
                                    THitSphere thitSphere10 = new THitSphere
                                    {
                                        len = 0.09f,
                                        t = transform1
                                    };
                                    thitSphere10.vs.z += 0.04f;
                                    thitSphere10.vs.y -= 0.02f;
                                    spherelist.Add(thitSphere10);
                                    THitSphere thitSphere11 = new THitSphere
                                    {
                                        len = 0.09f,
                                        t = transform1
                                    };
                                    thitSphere11.vs.z -= 0.04f;
                                    thitSphere11.vs.y -= 0.02f;
                                    spherelist.Add(thitSphere11);
                                    THitSphere thitSphere12 = new THitSphere
                                    {
                                        len = 0.11f,
                                        t = transform5
                                    };
                                    thitSphere12.vs.z += 0.05f;
                                    thitSphere12.vs.y -= 0.03f;
                                    spherelist.Add(thitSphere12);
                                    THitSphere thitSphere13 = new THitSphere
                                    {
                                        len = 0.11f,
                                        t = transform5
                                    };
                                    thitSphere13.vs.z -= 0.05f;
                                    thitSphere13.vs.y -= 0.03f;
                                    spherelist.Add(thitSphere13);
                                    THitSphere thitSphere14 = new THitSphere
                                    {
                                        len = 0.11f,
                                        t = transform10
                                    };
                                    thitSphere14.vs.x -= 0.03f;
                                    spherelist.Add(thitSphere14);
                                    THitSphere thitSphere15 = new THitSphere
                                    {
                                        len = 0.11f,
                                        t = transform11
                                    };
                                    thitSphere15.vs.x -= 0.03f;
                                    spherelist.Add(thitSphere15);
                                    spherelist.Add(new THitSphere() { len = 0.05f, t = transform6 });
                                    spherelist.Add(new THitSphere() { len = 0.05f, t = transform8 });
                                    THitSphere thitSphere16 = new THitSphere
                                    {
                                        len = 0.05f,
                                        t = transform7
                                    };
                                    thitSphere16.vs.x -= 0.04f;
                                    spherelist.Add(thitSphere16);
                                    THitSphere thitSphere17 = new THitSphere
                                    {
                                        len = 0.05f,
                                        t = transform9
                                    };
                                    thitSphere17.vs.x -= 0.04f;
                                    spherelist.Add(thitSphere17);
                                    THitSphere thitSphere18 = new THitSphere
                                    {
                                        len = 0.05f,
                                        t = transform7
                                    };
                                    thitSphere18.vs.x -= 0.08f;
                                    spherelist.Add(thitSphere18);
                                    THitSphere thitSphere19 = new THitSphere
                                    {
                                        len = 0.05f,
                                        t = transform9
                                    };
                                    thitSphere19.vs.x -= 0.08f;
                                    spherelist.Add(thitSphere19);
                                    THitSphere thitSphere20 = new THitSphere
                                    {
                                        len = 0.05f,
                                        t = transform7
                                    };
                                    thitSphere20.vs.x -= 0.12f;
                                    spherelist.Add(thitSphere20);
                                    THitSphere thitSphere21 = new THitSphere
                                    {
                                        len = 0.05f,
                                        t = transform9
                                    };
                                    thitSphere21.vs.x -= 0.12f;
                                    spherelist.Add(thitSphere21);
                                    THitSphere thitSphere22 = new THitSphere
                                    {
                                        len = 0.05f,
                                        t = transform7
                                    };
                                    thitSphere22.vs.x -= 0.16f;
                                    spherelist.Add(thitSphere22);
                                    THitSphere thitSphere23 = new THitSphere
                                    {
                                        len = 0.05f,
                                        t = transform9
                                    };
                                    thitSphere23.vs.x -= 0.16f;
                                    spherelist.Add(thitSphere23);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}