VRCSDK3.cs

Go to the documentation of this file.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using Cysharp.Threading.Tasks;
using Cysharp.Threading.Tasks.CompilerServices;
using JetBrains.Annotations;
using Midi;
using TMPro;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.EventSystems;
using UnityEngine.Networking;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.Serialization;
using UnityEngine.UI;
using UnityEngine.Video;
using VRC.SDK3.Components;
using VRC.SDK3.Components.Video;
using VRC.SDK3.Midi;
using VRC.SDK3.Network;
using VRC.SDK3.Video.Components.Base;
using VRC.SDK3.Video.Interfaces;
using VRC.SDK3.Video.Interfaces.AVPro;
using VRC.SDKBase;
using VRC.SDKBase.Midi;
using VRC.SDKBase.Network;
using VRC.SDKBase.Platform;
using VRC.Udon.Common;
using VRC.Udon.Common.Attributes;
using VRC.Udon.Common.Enums;
using VRC.Udon.Common.Interfaces;
 
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(/*Could not decode attribute arguments.*/)]
[assembly: UnityAPICompatibilityVersion("2022.3.22f1", true)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("VRCSDK3")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+77370df7b4055abf7cc0fb1da3c3d290108e9941")]
[assembly: AssemblyProduct("VRCSDK3")]
[assembly: AssemblyTitle("VRCSDK3")]
[assembly: SecurityPermission(8, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
public class EnumFlagAttribute : PropertyAttribute
{
}
namespace Midi
{
    public class ParsedMidiFile : Object
    {
        private static class Reader : Object
        {
            public static int Read16(byte[] data, ref int i)
            {
                return (data[i++] << 8) | data[i++];
            }
 
            public static int Read32(byte[] data, ref int i)
            {
                return (data[i++] << 24) | (data[i++] << 16) | (data[i++] << 8) | data[i++];
            }
 
            public static byte Read8(byte[] data, ref int i)
            {
                return data[i++];
            }
 
            public static byte[] ReadAllBytesFromStream(Stream input)
            {
                //IL_000b: Unknown result type (might be due to invalid IL or missing references)
                //IL_0011: Expected O, but got Unknown
                byte[] array = (byte[])(object)new Byte[16384];
                MemoryStream val = new MemoryStream();
                try
                {
                    int num;
                    while ((num = input.Read(array, 0, array.Length)) > 0)
                    {
                        ((Stream)val).Write(array, 0, num);
                    }
                    return val.ToArray();
                }
                finally
                {
                    if (val != null)
                    {
                        ((IDisposable)val).Dispose();
                    }
                }
            }
 
            public static string ReadString(byte[] data, ref int i, int length)
            {
                string @string = Encoding.ASCII.GetString(data, i, length);
                i += length;
                return @string;
            }
 
            public static int ReadVarInt(byte[] data, ref int i)
            {
                int num = data[i++];
                if ((num & 0x80) == 0)
                {
                    return num;
                }
                num &= 0x7F;
                for (int j = 0; j < 3; j++)
                {
                    int num2 = data[i++];
                    num = (num << 7) | (num2 & 0x7F);
                    if ((num2 & 0x80) == 0)
                    {
                        break;
                    }
                }
                return num;
            }
        }
 
        public readonly int Format;
 
        public readonly int TicksPerQuarterNote;
 
        public readonly MidiRawData.MidiRawTrack[] Tracks;
 
        public readonly int TracksCount;
 
        public ParsedMidiFile(Stream stream)
            : this(Reader.ReadAllBytesFromStream(stream))
        {
        }
 
        public ParsedMidiFile(string path)
            : this(File.ReadAllBytes(path))
        {
        }
 
        public ParsedMidiFile(byte[] data)
        {
            //IL_0022: Unknown result type (might be due to invalid IL or missing references)
            //IL_0038: Unknown result type (might be due to invalid IL or missing references)
            //IL_007b: Unknown result type (might be due to invalid IL or missing references)
            int i = 0;
            if (Reader.ReadString(data, ref i, 4) != "MThd")
            {
                throw new FormatException("Invalid file header (expected MThd)");
            }
            if (Reader.Read32(data, ref i) != 6)
            {
                throw new FormatException("Invalid header length (expected 6)");
            }
            Format = Reader.Read16(data, ref i);
            TracksCount = Reader.Read16(data, ref i);
            TicksPerQuarterNote = Reader.Read16(data, ref i);
            if (((uint)TicksPerQuarterNote & 0x8000u) != 0)
            {
                throw new FormatException("Invalid timing mode (SMPTE timecode not supported)");
            }
            Tracks = new MidiRawData.MidiRawTrack[TracksCount];
            for (int j = 0; j < TracksCount; j++)
            {
                Tracks[j] = ParseTrack(j, data, ref i);
            }
        }
 
        private static bool ParseMetaEvent(byte[] data, ref int position, byte metaEventType, ref byte data1, ref byte data2)
        {
            switch (metaEventType)
            {
            case 81:
            {
                int num2 = (data[position + 1] << 16) | (data[position + 2] << 8) | data[position + 3];
                data1 = (byte)(60000000.0 / (double)num2);
                position += 4;
                return true;
            }
            case 88:
                data1 = data[position + 1];
                data2 = (byte)Math.Pow(2.0, (double)(int)data[position + 2]);
                position += 5;
                return true;
            case 89:
                data1 = data[position + 1];
                data2 = data[position + 2];
                position += 3;
                return true;
            default:
            {
                int num = Reader.ReadVarInt(data, ref position);
                position += num;
                return false;
            }
            }
        }
 
        private static MidiRawData.MidiRawTrack ParseTrack(int index, byte[] data, ref int position)
        {
            //IL_0019: Unknown result type (might be due to invalid IL or missing references)
            if (Reader.ReadString(data, ref position, 4) != "MTrk")
            {
                throw new FormatException("Invalid track header (expected MTrk)");
            }
            int num = Reader.Read32(data, ref position);
            int num2 = position + num;
            MidiRawData.MidiRawTrack midiRawTrack = new MidiRawData.MidiRawTrack
            {
                Index = index
            };
            int num3 = 0;
            byte b = 0;
            while (position < num2)
            {
                num3 += Reader.ReadVarInt(data, ref position);
                byte b2 = data[position];
                if ((b2 & 0x80u) != 0)
                {
                    b = b2;
                    position++;
                }
                if ((b & 0xF0) != 240)
                {
                    byte b3 = (byte)(b & 0xF0u);
                    byte arg = (byte)((b & 0xF) + 1);
                    byte arg2 = data[position++];
                    byte arg3 = (byte)(((b3 & 0xE0) != 192) ? data[position++] : 0);
                    midiRawTrack.MidiEvents.Add(new MidiRawData.MidiEvent
                    {
                        Time = num3,
                        Type = b3,
                        Arg1 = arg,
                        Arg2 = arg2,
                        Arg3 = arg3
                    });
                    continue;
                }
                switch (b)
                {
                case 255:
                {
                    byte b4 = Reader.Read8(data, ref position);
                    if (b4 >= 1 && b4 <= 15)
                    {
                        int length = Reader.ReadVarInt(data, ref position);
                        string value = Reader.ReadString(data, ref position, length);
                        MidiRawData.TextEvent textEvent = default(MidiRawData.TextEvent);
                        textEvent.Time = num3;
                        textEvent.Type = b4;
                        textEvent.Value = value;
                        MidiRawData.TextEvent textEvent2 = textEvent;
                        midiRawTrack.TextEvents.Add(textEvent2);
                        break;
                    }
                    byte data2 = 0;
                    byte data3 = 0;
                    if (ParseMetaEvent(data, ref position, b4, ref data2, ref data3))
                    {
                        midiRawTrack.MidiEvents.Add(new MidiRawData.MidiEvent
                        {
                            Time = num3,
                            Type = b,
                            Arg1 = b4,
                            Arg2 = data2,
                            Arg3 = data3
                        });
                    }
                    break;
                }
                case 240:
                case 247:
                {
                    int num4 = Reader.ReadVarInt(data, ref position);
                    position += num4;
                    break;
                }
                default:
                    position++;
                    break;
                }
            }
            return midiRawTrack;
        }
    }
}
namespace VRC.SDK3
{
    public interface IVRCNetworkId : INetworkID
    {
    }
    public class ControllerColliderPlayerHit : Object
    {
        public VRCPlayerApi player;
 
        public Vector3 moveDirection;
 
        public float moveLength;
 
        public Vector3 normal;
 
        public Vector3 point;
    }
}
namespace VRC.SDK3.Video.Interfaces
{
    public interface IVRCVideoPlayer
    {
        [PublicAPI]
        bool Loop { get; set; }
 
        [PublicAPI]
        bool IsPlaying { get; }
 
        [PublicAPI]
        bool IsReady { get; }
 
        [PublicAPI]
        int VideoWidth { get; }
 
        [PublicAPI]
        int VideoHeight { get; }
 
        [PublicAPI]
        void LoadURL(VRCUrl url);
 
        [PublicAPI]
        void PlayURL(VRCUrl url);
 
        [PublicAPI]
        void Play();
 
        [PublicAPI]
        void Pause();
 
        [PublicAPI]
        void Stop();
 
        [PublicAPI]
        void SetTime(float value);
 
        [PublicAPI]
        float GetTime();
 
        [PublicAPI]
        float GetDuration();
 
        [PublicAPI]
        [ExcludeFromUdonWrapper]
        void OnVideoReady();
 
        [PublicAPI]
        [ExcludeFromUdonWrapper]
        void OnVideoError(VideoError videoError);
 
        [PublicAPI]
        [ExcludeFromUdonWrapper]
        void OnVideoStart();
 
        [PublicAPI]
        [ExcludeFromUdonWrapper]
        void OnVideoLoop();
 
        [PublicAPI]
        [ExcludeFromUdonWrapper]
        void OnVideoEnd();
    }
}
namespace VRC.SDK3.Video.Interfaces.AVPro
{
    public interface IAVProVideoPlayerInternal
    {
        [PublicAPI]
        bool Loop { get; set; }
 
        [PublicAPI]
        bool IsPlaying { get; }
 
        [PublicAPI]
        bool IsReady { get; }
 
        [PublicAPI]
        bool UseLowLatency { get; }
 
        [PublicAPI]
        int VideoWidth { get; }
 
        [PublicAPI]
        int VideoHeight { get; }
 
        [PublicAPI]
        void LoadURL(VRCUrl url);
 
        [PublicAPI]
        void PlayURL(VRCUrl url);
 
        [PublicAPI]
        void Play();
 
        [PublicAPI]
        void Pause();
 
        [PublicAPI]
        void Stop();
 
        [PublicAPI]
        void SetTime(float value);
 
        [PublicAPI]
        float GetTime();
 
        [PublicAPI]
        float GetDuration();
    }
}
namespace VRC.SDK3.Video.Components
{
    [AddComponentMenu("VRChat/Video/VRC Unity Video Player")]
    public sealed class VRCUnityVideoPlayer : BaseVRCVideoPlayer
    {
        private enum VideoRenderMode : Enum
        {
            RenderTexture,
            MaterialOverride
        }
 
        [SerializeField]
        private VRCUrl videoURL;
 
        [SerializeField]
        private bool autoPlay = true;
 
        [SerializeField]
        private bool loop = true;
 
        [SerializeField]
        private VideoRenderMode renderMode;
 
        [SerializeField]
        private RenderTexture targetTexture;
 
        [SerializeField]
        private Renderer targetMaterialRenderer;
 
        [SerializeField]
        private string targetMaterialProperty;
 
        [SerializeField]
        private VideoAspectRatio aspectRatio = (VideoAspectRatio)2;
 
        [SerializeField]
        private AudioSource[] targetAudioSources = Array.Empty<AudioSource>();
 
        [SerializeField]
        [Tooltip("The maximum virtual resolution to retrieve from sites that support multiple resolutions.")]
        private int maximumResolution = 720;
 
        private VideoPlayer _unityPlayer;
 
        private bool _pauseOnStart;
 
        private Coroutine _playDelayedCoroutine;
 
        private Coroutine _onVideoReadyDelayedCoroutine;
 
        [PublicAPI]
        [ExcludeFromUdonWrapper]
        [field: CompilerGenerated]
        public static Action<VRCUrl, int, Object, Action<string>, Action<VideoError>> StartResolveURLCoroutine
        {
            [CompilerGenerated]
            get;
            [CompilerGenerated]
            set;
        }
 
        [PublicAPI]
        public VideoPlayer UnityPlayer
        {
            get
            {
                if ((Object)(object)_unityPlayer == (Object)null)
                {
                    SetupVideoPlayer();
                }
                return _unityPlayer;
            }
        }
 
        public override bool IsPlaying => UnityPlayer.isPlaying;
 
        public override bool IsReady => UnityPlayer.isPrepared;
 
        public override bool Loop
        {
            get
            {
                return loop;
            }
            set
            {
                loop = value;
            }
        }
 
        [PublicAPI]
        public override int VideoWidth => (int)UnityPlayer.width;
 
        [PublicAPI]
        public override int VideoHeight => (int)UnityPlayer.height;
 
        protected override void Start()
        {
            base.Start();
            SetupVideoPlayer();
            PlayDefaultVideo();
        }
 
        private void PlayDefaultVideo()
        {
            if (autoPlay && videoURL != null)
            {
                if (StartResolveURLCoroutine != null)
                {
                    StartResolveURLCoroutine.Invoke(videoURL, maximumResolution, (Object)(object)this, (Action<string>)PlayVideo, (Action<VideoError>)OnVideoError);
                }
                else
                {
                    PlayVideo(videoURL.Get());
                }
            }
            [CompilerGenerated]
            void PlayVideo(string resolvedURL)
            {
                UnityPlayer.url = resolvedURL;
            }
        }
 
        private void SetupVideoPlayer()
        {
            //IL_001e: Unknown result type (might be due to invalid IL or missing references)
            //IL_0028: Expected O, but got Unknown
            //IL_0035: Unknown result type (might be due to invalid IL or missing references)
            //IL_003f: Expected O, but got Unknown
            //IL_004c: Unknown result type (might be due to invalid IL or missing references)
            //IL_0056: Expected O, but got Unknown
            //IL_0063: Unknown result type (might be due to invalid IL or missing references)
            //IL_006d: Expected O, but got Unknown
            //IL_00f1: Unknown result type (might be due to invalid IL or missing references)
            //IL_00d8: Unknown result type (might be due to invalid IL or missing references)
            _unityPlayer = ((Component)this).gameObject.AddComponent<VideoPlayer>();
            _unityPlayer.prepareCompleted += new EventHandler(OnPrepared);
            _unityPlayer.started += new EventHandler(OnStarted);
            _unityPlayer.loopPointReached += new EventHandler(OnLoopPointReached);
            _unityPlayer.errorReceived += new ErrorEventHandler(OnError);
            _unityPlayer.isLooping = false;
            switch (renderMode)
            {
            case VideoRenderMode.RenderTexture:
                _unityPlayer.renderMode = (VideoRenderMode)2;
                _unityPlayer.targetTexture = targetTexture;
                break;
            case VideoRenderMode.MaterialOverride:
                _unityPlayer.renderMode = (VideoRenderMode)3;
                _unityPlayer.targetMaterialRenderer = targetMaterialRenderer;
                _unityPlayer.targetMaterialProperty = targetMaterialProperty;
                break;
            default:
                throw new ArgumentOutOfRangeException();
            }
            _unityPlayer.source = (VideoSource)1;
            _unityPlayer.aspectRatio = aspectRatio;
            _unityPlayer.audioOutputMode = (VideoAudioOutputMode)1;
            _unityPlayer.controlledAudioTrackCount = (ushort)targetAudioSources.Length;
            for (ushort num = 0; num < targetAudioSources.Length; num++)
            {
                _unityPlayer.SetTargetAudioSource(num, targetAudioSources[num]);
            }
            BaseVRCVideoPlayer.InitializeBase?.Invoke((BaseVRCVideoPlayer)this);
        }
 
        public override void LoadURL(VRCUrl url)
        {
            if (StartResolveURLCoroutine != null)
            {
                StartResolveURLCoroutine.Invoke(url, maximumResolution, (Object)(object)this, (Action<string>)PlayVideo, (Action<VideoError>)OnVideoError);
            }
            else
            {
                PlayVideo(url.Get());
            }
            [CompilerGenerated]
            void PlayVideo(string resolvedURL)
            {
                UnityPlayer.url = resolvedURL;
                _pauseOnStart = true;
            }
        }
 
        public override void PlayURL(VRCUrl url)
        {
            if (StartResolveURLCoroutine != null)
            {
                StartResolveURLCoroutine.Invoke(url, maximumResolution, (Object)(object)this, (Action<string>)PlayVideo, (Action<VideoError>)OnVideoError);
            }
            else
            {
                PlayVideo(url.Get());
            }
            base.PlayURL(url);
            [CompilerGenerated]
            void PlayVideo(string resolvedURL)
            {
                UnityPlayer.url = resolvedURL;
                _pauseOnStart = false;
            }
        }
 
        public override void Pause()
        {
            UnityPlayer.Pause();
        }
 
        public override void Play()
        {
            if (_playDelayedCoroutine != null)
            {
                ((MonoBehaviour)this).StopCoroutine(_playDelayedCoroutine);
                _playDelayedCoroutine = null;
            }
            _playDelayedCoroutine = ((MonoBehaviour)this).StartCoroutine(PlayDelayCoroutine());
        }
 
        [IteratorStateMachine(/*Could not decode attribute arguments.*/)]
        private IEnumerator PlayDelayCoroutine()
        {
            for (int attempts = 0; attempts < 5; attempts++)
            {
                if (!UnityPlayer.isPrepared)
                {
                    break;
                }
                if (UnityPlayer.isPlaying)
                {
                    break;
                }
                UnityPlayer.Play();
                base.Play();
                yield return null;
            }
            _playDelayedCoroutine = null;
        }
 
        public override float GetDuration()
        {
            return (float)UnityPlayer.length;
        }
 
        public override float GetTime()
        {
            return (float)UnityPlayer.time;
        }
 
        public override void SetTime(float value)
        {
            UnityPlayer.time = value;
            base.SetTime(value);
        }
 
        public override void Stop()
        {
            UnityPlayer.Stop();
        }
 
        private void OnPrepared(VideoPlayer source)
        {
            if (source.canSetSkipOnDrop)
            {
                source.skipOnDrop = true;
            }
            if (_onVideoReadyDelayedCoroutine != null)
            {
                ((MonoBehaviour)this).StopCoroutine(_onVideoReadyDelayedCoroutine);
                _onVideoReadyDelayedCoroutine = null;
            }
            _onVideoReadyDelayedCoroutine = ((MonoBehaviour)this).StartCoroutine(OnVideoReadyDelayCoroutine());
        }
 
        [IteratorStateMachine(/*Could not decode attribute arguments.*/)]
        private IEnumerator OnVideoReadyDelayCoroutine()
        {
            yield return new WaitForSecondsRealtime(0.25f);
            OnVideoReady();
            _onVideoReadyDelayedCoroutine = null;
        }
 
        private void OnError(VideoPlayer source, string message)
        {
            Object.Destroy((Object)(object)UnityPlayer);
            OnVideoError(VideoError.PlayerError);
        }
 
        private void OnStarted(VideoPlayer source)
        {
            if (!_pauseOnStart)
            {
                OnVideoStart();
                return;
            }
            UnityPlayer.Pause();
            _pauseOnStart = false;
        }
 
        private void OnLoopPointReached(VideoPlayer source)
        {
            if (loop)
            {
                UnityPlayer.Play();
                OnVideoLoop();
            }
            else
            {
                OnVideoEnd();
            }
        }
    }
}
namespace VRC.SDK3.Video.Components.AVPro
{
    [AddComponentMenu("VRChat/Video/VRC AVPro Video Player")]
    public sealed class VRCAVProVideoPlayer : BaseVRCVideoPlayer
    {
        [SerializeField]
        [Tooltip("The URL to the default video.")]
        private VRCUrl videoURL;
 
        [SerializeField]
        [Tooltip("If AutoPlay is enabled the default video will be played automatically.")]
        private bool autoPlay = true;
 
        [SerializeField]
        [Tooltip("If Loop is enabled the video will play repeatedly until the video player is stopped.")]
        private bool loop = true;
 
        [SerializeField]
        [Tooltip("The maximum virtual resolution to retrieve from sites that support multiple resolutions.")]
        private int maximumResolution = 720;
 
        [SerializeField]
        [Tooltip("Lower Latency for Live Streams from Advanced Sources. ")]
        private bool useLowLatency;
 
        private IAVProVideoPlayerInternal _playerInternal;
 
        [PublicAPI]
        [ExcludeFromUdonWrapper]
        [field: CompilerGenerated]
        public static Func<VRCAVProVideoPlayer, IAVProVideoPlayerInternal> Initialize
        {
            [CompilerGenerated]
            get;
            [CompilerGenerated]
            set;
        }
 
        [PublicAPI]
        [ExcludeFromUdonWrapper]
        public VRCUrl VideoURL => videoURL;
 
        [PublicAPI]
        [ExcludeFromUdonWrapper]
        public bool AutoPlay => autoPlay;
 
        [PublicAPI]
        [ExcludeFromUdonWrapper]
        public int MaximumResolution => maximumResolution;
 
        [PublicAPI]
        [ExcludeFromUdonWrapper]
        [field: CompilerGenerated]
        public bool Initialized
        {
            [CompilerGenerated]
            get;
            [CompilerGenerated]
            private set;
        }
 
        [PublicAPI]
        [ExcludeFromUdonWrapper]
        public bool UseLowLatency => useLowLatency;
 
        public override bool Loop
        {
            get
            {
                return _playerInternal?.Loop ?? false;
            }
            set
            {
                if (_playerInternal != null)
                {
                    _playerInternal.Loop = value;
                }
            }
        }
 
        public override bool IsPlaying => _playerInternal?.IsPlaying ?? false;
 
        public override bool IsReady => _playerInternal?.IsReady ?? false;
 
        [PublicAPI]
        public override int VideoWidth => _playerInternal?.VideoWidth ?? 0;
 
        [PublicAPI]
        public override int VideoHeight => _playerInternal?.VideoHeight ?? 0;
 
        private void OnValidate()
        {
            Loop = loop;
        }
 
        protected override void Start()
        {
            base.Start();
            _playerInternal = Initialize?.Invoke(this);
            if (_playerInternal != null)
            {
                _playerInternal.Loop = loop;
            }
            BaseVRCVideoPlayer.InitializeBase?.Invoke((BaseVRCVideoPlayer)this);
            Initialized = true;
        }
 
        public override void LoadURL(VRCUrl url)
        {
            _playerInternal?.LoadURL(url);
        }
 
        public override void PlayURL(VRCUrl url)
        {
            _playerInternal?.PlayURL(url);
            base.PlayURL(url);
        }
 
        public override void Play()
        {
            _playerInternal?.Play();
            base.Play();
        }
 
        public override void Pause()
        {
            _playerInternal?.Pause();
        }
 
        public override void Stop()
        {
            _playerInternal?.Stop();
        }
 
        public override float GetDuration()
        {
            return _playerInternal?.GetDuration() ?? 0f;
        }
 
        public override float GetTime()
        {
            return _playerInternal?.GetTime() ?? 0f;
        }
 
        public override void SetTime(float value)
        {
            _playerInternal?.SetTime(value);
            base.SetTime(value);
        }
    }
    [RequireComponent(/*Could not decode attribute arguments.*/)]
    [AddComponentMenu("VRChat/Video/VRC AVPro Video Screen")]
    public class VRCAVProVideoScreen : MonoBehaviour
    {
        [SerializeField]
        private VRCAVProVideoPlayer videoPlayer;
 
        [SerializeField]
        private int materialIndex;
 
        [SerializeField]
        private string textureProperty = "_MainTex";
 
        [SerializeField]
        private bool useSharedMaterial;
 
        [PublicAPI]
        [field: CompilerGenerated]
        public static Action<VRCAVProVideoScreen> Initialize
        {
            [CompilerGenerated]
            get;
            [CompilerGenerated]
            set;
        }
 
        [PublicAPI]
        public VRCAVProVideoPlayer VideoPlayer => videoPlayer;
 
        [PublicAPI]
        public int MaterialIndex => materialIndex;
 
        [PublicAPI]
        public string TextureProperty => textureProperty;
 
        [PublicAPI]
        public bool UseSharedMaterial => useSharedMaterial;
 
        private void Start()
        {
            if ((Object)(object)videoPlayer != (Object)null)
            {
                Initialize?.Invoke(this);
            }
        }
    }
    [RequireComponent(/*Could not decode attribute arguments.*/)]
    [DisallowMultipleComponent]
    [AddComponentMenu("VRChat/Video/VRC AVPro Video Speaker")]
    public class VRCAVProVideoSpeaker : MonoBehaviour
    {
        [Serializable]
        [PublicAPI]
        public enum ChannelMode : Enum
        {
            StereoMix,
            MonoLeft,
            MonoRight,
            Three,
            Four,
            Five,
            Six,
            Seven,
            Eight
        }
 
        [SerializeField]
        private VRCAVProVideoPlayer videoPlayer;
 
        [SerializeField]
        private ChannelMode mode;
 
        [PublicAPI]
        [field: CompilerGenerated]
        public static Action<VRCAVProVideoSpeaker> Initialize
        {
            [CompilerGenerated]
            get;
            [CompilerGenerated]
            set;
        }
 
        [PublicAPI]
        public VRCAVProVideoPlayer VideoPlayer => videoPlayer;
 
        [PublicAPI]
        public ChannelMode Mode => mode;
 
        private void Start()
        {
            if ((Object)(object)videoPlayer != (Object)null)
            {
                Initialize?.Invoke(this);
            }
        }
    }
}
namespace VRC.SDK3.Video.Components.Base
{
    public abstract class BaseVRCVideoPlayer : MonoBehaviour, IVRCVideoPlayer
    {
        private readonly List<IUdonBehaviour> _udonBehaviours = new List<IUdonBehaviour>();
 
        [HideInInspector]
        public bool EnableAutomaticResync;
 
        [PublicAPI]
        [field: CompilerGenerated]
        public static Action<BaseVRCVideoPlayer> InitializeBase
        {
            [CompilerGenerated]
            get;
            [CompilerGenerated]
            set;
        }
 
        [PublicAPI]
        [ExcludeFromUdonWrapper]
        [field: CompilerGenerated]
        public float SyncIndexTimeSet
        {
            [CompilerGenerated]
            get;
            [CompilerGenerated]
            private set;
        }
 
        [PublicAPI]
        [ExcludeFromUdonWrapper]
        [field: CompilerGenerated]
        public float SyncIndexPosition
        {
            [CompilerGenerated]
            get;
            [CompilerGenerated]
            private set;
        }
 
        public abstract bool Loop { get; set; }
 
        public abstract bool IsPlaying { get; }
 
        public abstract bool IsReady { get; }
 
        [PublicAPI]
        public abstract int VideoWidth { get; }
 
        [PublicAPI]
        public abstract int VideoHeight { get; }
 
        protected virtual void Start()
        {
            ((Component)this).GetComponents<IUdonBehaviour>(_udonBehaviours);
        }
 
        [ExcludeFromUdonWrapper]
        public void SetIndexMarker(float desiredTime)
        {
            SyncIndexTimeSet = Time.time;
            SyncIndexPosition = desiredTime;
        }
 
        [ExcludeFromUdonWrapper]
        public void SetIndexMarker()
        {
            SetIndexMarker(GetTime());
        }
 
        public virtual void PlayURL(VRCUrl url)
        {
            SetIndexMarker();
        }
 
        public virtual void Play()
        {
            SetIndexMarker();
        }
 
        public virtual void SetTime(float value)
        {
            SetIndexMarker();
        }
 
        public abstract void LoadURL(VRCUrl url);
 
        public abstract void Pause();
 
        public abstract void Stop();
 
        public abstract float GetTime();
 
        public abstract float GetDuration();
 
        [ExcludeFromUdonWrapper]
        public void OnVideoReady()
        {
            //IL_0006: Unknown result type (might be due to invalid IL or missing references)
            //IL_000b: Unknown result type (might be due to invalid IL or missing references)
            Enumerator<IUdonBehaviour> enumerator = _udonBehaviours.GetEnumerator();
            try
            {
                while (enumerator.MoveNext())
                {
                    ((IUdonEventReceiver)enumerator.Current).RunEvent("_onVideoReady");
                }
            }
            finally
            {
                ((IDisposable)enumerator).Dispose();
            }
        }
 
        [ExcludeFromUdonWrapper]
        public void OnVideoError(VideoError videoError)
        {
            //IL_0006: Unknown result type (might be due to invalid IL or missing references)
            //IL_000b: Unknown result type (might be due to invalid IL or missing references)
            //IL_0020: Unknown result type (might be due to invalid IL or missing references)
            Enumerator<IUdonBehaviour> enumerator = _udonBehaviours.GetEnumerator();
            try
            {
                while (enumerator.MoveNext())
                {
                    ((IUdonEventReceiver)enumerator.Current).RunEvent<VideoError>("_onVideoError", new ValueTuple<string, VideoError>("videoError", videoError));
                }
            }
            finally
            {
                ((IDisposable)enumerator).Dispose();
            }
        }
 
        [ExcludeFromUdonWrapper]
        public void OnVideoStart()
        {
            //IL_0006: Unknown result type (might be due to invalid IL or missing references)
            //IL_000b: Unknown result type (might be due to invalid IL or missing references)
            Enumerator<IUdonBehaviour> enumerator = _udonBehaviours.GetEnumerator();
            try
            {
                while (enumerator.MoveNext())
                {
                    ((IUdonEventReceiver)enumerator.Current).RunEvent("_onVideoStart");
                }
            }
            finally
            {
                ((IDisposable)enumerator).Dispose();
            }
        }
 
        [ExcludeFromUdonWrapper]
        public void OnVideoLoop()
        {
            //IL_000c: Unknown result type (might be due to invalid IL or missing references)
            //IL_0011: Unknown result type (might be due to invalid IL or missing references)
            SetIndexMarker();
            Enumerator<IUdonBehaviour> enumerator = _udonBehaviours.GetEnumerator();
            try
            {
                while (enumerator.MoveNext())
                {
                    ((IUdonEventReceiver)enumerator.Current).RunEvent("_onVideoLoop");
                }
            }
            finally
            {
                ((IDisposable)enumerator).Dispose();
            }
        }
 
        [ExcludeFromUdonWrapper]
        public void OnVideoEnd()
        {
            //IL_0006: Unknown result type (might be due to invalid IL or missing references)
            //IL_000b: Unknown result type (might be due to invalid IL or missing references)
            Enumerator<IUdonBehaviour> enumerator = _udonBehaviours.GetEnumerator();
            try
            {
                while (enumerator.MoveNext())
                {
                    ((IUdonEventReceiver)enumerator.Current).RunEvent("_onVideoEnd");
                }
            }
            finally
            {
                ((IDisposable)enumerator).Dispose();
            }
        }
    }
}
namespace VRC.SDK3.Midi
{
    [Serializable]
    public class MidiData : Object
    {
        [Serializable]
        public class MidiBlock : Object
        {
            public float startTimeMs;
 
            public float endTimeMs;
 
            public byte note;
 
            public byte velocity;
 
            public int channel;
 
            public float startTimeSec => startTimeMs / 1000f;
 
            public float endTimeSec => endTimeMs / 1000f;
 
            public float lengthSec => endTimeSec - startTimeSec;
 
            public override string ToString()
            {
                return String.Format("note: {0}, velocity: {1}, time: {2}s -> {3}s ({4}s)", (object[])(object)new Object[5]
                {
                    (object)note,
                    (object)velocity,
                    (object)startTimeSec,
                    (object)endTimeSec,
                    (object)(endTimeSec - startTimeSec)
                });
            }
        }
 
        [Serializable]
        public class MidiTrack : Object
        {
            public MidiBlock[] blocks;
 
            public byte minNote = 255;
 
            public byte maxNote;
 
            public byte minVelocity = 255;
 
            public byte maxVelocity;
 
            public void SetBlocks(List<MidiBlock> blocks)
            {
                //IL_0001: Unknown result type (might be due to invalid IL or missing references)
                //IL_0006: Unknown result type (might be due to invalid IL or missing references)
                Enumerator<MidiBlock> enumerator = blocks.GetEnumerator();
                try
                {
                    while (enumerator.MoveNext())
                    {
                        MidiBlock current = enumerator.Current;
                        minNote = (byte)Mathf.Min((int)minNote, (int)current.note);
                        maxNote = (byte)Mathf.Max((int)maxNote, (int)current.note);
                        minVelocity = (byte)Mathf.Min((int)minVelocity, (int)current.velocity);
                        maxVelocity = (byte)Mathf.Max((int)maxVelocity, (int)current.velocity);
                    }
                }
                finally
                {
                    ((IDisposable)enumerator).Dispose();
                }
                this.blocks = blocks.ToArray();
            }
        }
 
        public MidiTrack[] tracks;
 
        public byte bpm;
    }
    public class MidiFile : ScriptableObject
    {
        public MidiRawData rawData;
 
        public MidiData data;
 
        public AudioClip audioClip;
 
        public static MidiFile Create(string filePath, MidiImportSettings midiImportSettings)
        {
            MidiFile midiFile = ScriptableObject.CreateInstance<MidiFile>();
            ParsedMidiFile parsedMidiFile = new ParsedMidiFile(filePath);
            midiFile.rawData = new MidiRawData
            {
                Format = parsedMidiFile.Format,
                TicksPerQuarterNote = parsedMidiFile.TicksPerQuarterNote,
                Tracks = parsedMidiFile.Tracks,
                TracksCount = parsedMidiFile.TracksCount
            };
            MidiRawDataProcessor midiRawDataProcessor = new MidiRawDataProcessor(parsedMidiFile, midiImportSettings);
            midiFile.data = new MidiData
            {
                tracks = midiRawDataProcessor.tracks.ToArray(),
                bpm = midiRawDataProcessor.Bpm
            };
            if (Object.op_Implicit((Object)(object)midiImportSettings.AudioClip))
            {
                midiFile.audioClip = midiImportSettings.AudioClip;
            }
            return midiFile;
        }
 
        [ContextMenu("Print raw data")]
        public void PrintRawData()
        {
            //IL_0091: Unknown result type (might be due to invalid IL or missing references)
            //IL_0096: Unknown result type (might be due to invalid IL or missing references)
            Debug.Log((object)String.Format("Format: {0}", (object)rawData.Format));
            Debug.Log((object)String.Format("TicksPerQuarterNote: {0}", (object)rawData.TicksPerQuarterNote));
            Debug.Log((object)String.Format("TracksCount: {0}", (object)rawData.TracksCount));
            MidiRawData.MidiRawTrack[] tracks = rawData.Tracks;
            foreach (MidiRawData.MidiRawTrack midiRawTrack in tracks)
            {
                Debug.Log((object)String.Format("\nTrack: {0}\n", (object)midiRawTrack.Index));
                Enumerator<MidiRawData.MidiEvent> enumerator = midiRawTrack.MidiEvents.GetEnumerator();
                try
                {
                    while (enumerator.MoveNext())
                    {
                        Debug.Log((object)enumerator.Current);
                    }
                }
                finally
                {
                    ((IDisposable)enumerator).Dispose();
                }
            }
        }
 
        [ContextMenu("Print processed data")]
        public void PrintProcessedData()
        {
            Debug.Log((object)String.Format("TracksCount: {0}", (object)data.tracks.Length));
            for (int i = 0; i < data.tracks.Length; i++)
            {
                MidiData.MidiTrack midiTrack = data.tracks[i];
                Debug.Log((object)String.Format("\nTrack: {0}. note range: {1} -> {2}, velocity range: {3} -> {4}\n", (object[])(object)new Object[5]
                {
                    (object)i,
                    (object)midiTrack.minNote,
                    (object)midiTrack.maxNote,
                    (object)midiTrack.minVelocity,
                    (object)midiTrack.maxVelocity
                }));
                MidiData.MidiBlock[] blocks = midiTrack.blocks;
                for (int j = 0; j < blocks.Length; j++)
                {
                    Debug.Log((object)blocks[j]);
                }
            }
        }
    }
    [Serializable]
    public class MidiImportSettings : Object
    {
        public AudioClip AudioClip;
 
        public bool OverrideBpm;
 
        public byte Bpm = 120;
    }
    [AddComponentMenu("VRChat/Midi/VRC Midi Player")]
    public class VRCMidiPlayer : MonoBehaviour
    {
        public class TrackProgress : Object
        {
            public MidiData.MidiTrack track;
 
            public List<MidiData.MidiBlock> activeBlocks = new List<MidiData.MidiBlock>();
 
            public int currentBlockIndex = -1;
        }
 
        [Serializable]
        [CompilerGenerated]
        private sealed class <>c : Object
        {
            public static readonly <>c <>9 = new <>c();
 
            public static Action<MidiData.MidiBlock> <>9__14_0;
 
            public static Action<MidiData.MidiBlock> <>9__16_0;
 
            public static Action <>9__18_0;
 
            public static Action<bool> <>9__20_0;
 
            internal void <get_OnBlockStarted>b__14_0(MidiData.MidiBlock midiBlock)
            {
            }
 
            internal void <get_OnBlockCompleted>b__16_0(MidiData.MidiBlock midiBlock)
            {
            }
 
            internal void <get_OnPlayingStarted>b__18_0()
            {
            }
 
            internal void <get_OnPlayingStopped>b__20_0(bool completed)
            {
            }
        }
 
        public MidiFile midiFile;
 
        public AudioSource audioSource;
 
        public AbstractUdonBehaviour[] targetBehaviours;
 
        public readonly List<TrackProgress> activeTracks = new List<TrackProgress>();
 
        private float lastAudioSampleTime;
 
        private Coroutine _coroutine;
 
        private readonly ValueTuple<string, object>[] argsArray = new ValueTuple<string, object>[3];
 
        public MidiData MidiData => midiFile?.data;
 
        public float Time
        {
            get
            {
                return audioSource.time;
            }
            set
            {
                audioSource.time = value;
            }
        }
 
        public Coroutine Coroutine => _coroutine;
 
        public Action<MidiData.MidiBlock> OnBlockStarted => delegate
        {
        };
 
        public Action<MidiData.MidiBlock> OnBlockCompleted => delegate
        {
        };
 
        public Action OnPlayingStarted
        {
            get
            {
                //IL_0014: Unknown result type (might be due to invalid IL or missing references)
                //IL_0019: Unknown result type (might be due to invalid IL or missing references)
                //IL_001f: Expected O, but got Unknown
                object obj = <>c.<>9__18_0;
                if (obj == null)
                {
                    Action val = delegate
                    {
                    };
                    <>c.<>9__18_0 = val;
                    obj = (object)val;
                }
                return (Action)obj;
            }
        }
 
        public Action<bool> OnPlayingStopped => delegate
        {
        };
 
        private void Awake()
        {
            if (!Object.op_Implicit((Object)(object)audioSource))
            {
                Debug.LogWarning((object)"Cannot use VRCMidiPlayer without AudioSource");
                ((Component)this).gameObject.SetActive(false);
            }
        }
 
        public void Play()
        {
            //IL_0018: Unknown result type (might be due to invalid IL or missing references)
            Stop();
            if (!Object.op_Implicit((Object)(object)midiFile))
            {
                throw new Exception("MidiPlayer MidiAsset is null");
            }
            _coroutine = ((MonoBehaviour)this).StartCoroutine(MidiEnumerator(midiFile));
            if (Object.op_Implicit((Object)(object)audioSource))
            {
                audioSource.Play();
            }
        }
 
        public void Stop()
        {
            if (_coroutine != null)
            {
                OnPlayingStopped?.Invoke(false);
                ((MonoBehaviour)this).StopCoroutine(_coroutine);
                _coroutine = null;
            }
            if (Object.op_Implicit((Object)(object)audioSource))
            {
                audioSource.Stop();
            }
        }
 
        [IteratorStateMachine(/*Could not decode attribute arguments.*/)]
        private IEnumerator MidiEnumerator(MidiFile midiAsset)
        {
            Action onPlayingStarted = OnPlayingStarted;
            if (onPlayingStarted != null)
            {
                onPlayingStarted.Invoke();
            }
            activeTracks.Clear();
            float maxEndTime = 0f;
            MidiData.MidiTrack[] tracks = midiAsset.data.tracks;
            foreach (MidiData.MidiTrack midiTrack in tracks)
            {
                activeTracks.Add(new TrackProgress
                {
                    track = midiTrack
                });
                if (midiTrack.blocks.Length != 0)
                {
                    float endTimeSec = midiTrack.blocks[midiTrack.blocks.Length - 1].endTimeSec;
                    if (endTimeSec > maxEndTime)
                    {
                        maxEndTime = endTimeSec;
                    }
                }
            }
            while (true)
            {
                float time = audioSource.time;
                bool flag = false;
                Enumerator<TrackProgress> enumerator = activeTracks.GetEnumerator();
                try
                {
                    while (enumerator.MoveNext())
                    {
                        TrackProgress current = enumerator.Current;
                        bool flag2;
                        do
                        {
                            flag2 = false;
                            int num = current.currentBlockIndex + 1;
                            if (num < current.track.blocks.Length)
                            {
                                flag = true;
                                MidiData.MidiBlock midiBlock = current.track.blocks[num];
                                if (time >= midiBlock.startTimeSec)
                                {
                                    current.activeBlocks.Add(midiBlock);
                                    current.currentBlockIndex = num;
                                    OnBlockStart(midiBlock);
                                    flag2 = true;
                                }
                            }
                        }
                        while (flag2);
                        for (int num2 = current.activeBlocks.Count - 1; num2 >= 0; num2--)
                        {
                            MidiData.MidiBlock midiBlock2 = current.activeBlocks[num2];
                            if (time >= midiBlock2.endTimeSec)
                            {
                                current.activeBlocks.RemoveAt(num2);
                                OnBlockEnd(midiBlock2);
                            }
                        }
                    }
                }
                finally
                {
                    ((IDisposable)enumerator).Dispose();
                }
                if (!flag && time >= maxEndTime)
                {
                    enumerator = activeTracks.GetEnumerator();
                    try
                    {
                        while (enumerator.MoveNext())
                        {
                            Enumerator<MidiData.MidiBlock> enumerator2 = enumerator.Current.activeBlocks.GetEnumerator();
                            try
                            {
                                while (enumerator2.MoveNext())
                                {
                                    MidiData.MidiBlock current2 = enumerator2.Current;
                                    OnBlockEnd(current2);
                                }
                            }
                            finally
                            {
                                ((IDisposable)enumerator2).Dispose();
                            }
                        }
                    }
                    finally
                    {
                        ((IDisposable)enumerator).Dispose();
                    }
                    if (!audioSource.loop)
                    {
                        break;
                    }
                }
                else if ((float)audioSource.timeSamples < lastAudioSampleTime)
                {
                    enumerator = activeTracks.GetEnumerator();
                    try
                    {
                        while (enumerator.MoveNext())
                        {
                            TrackProgress current3 = enumerator.Current;
                            current3.currentBlockIndex = -1;
                            current3.activeBlocks.Clear();
                        }
                    }
                    finally
                    {
                        ((IDisposable)enumerator).Dispose();
                    }
                }
                lastAudioSampleTime = audioSource.timeSamples;
                yield return null;
            }
        }
 
        private void OnBlockStart(MidiData.MidiBlock block)
        {
            //IL_0043: Unknown result type (might be due to invalid IL or missing references)
            //IL_0048: Unknown result type (might be due to invalid IL or missing references)
            //IL_0064: Unknown result type (might be due to invalid IL or missing references)
            //IL_0069: Unknown result type (might be due to invalid IL or missing references)
            //IL_0085: Unknown result type (might be due to invalid IL or missing references)
            //IL_008a: Unknown result type (might be due to invalid IL or missing references)
            OnBlockStarted?.Invoke(block);
            AbstractUdonBehaviour[] array = targetBehaviours;
            foreach (AbstractUdonBehaviour abstractUdonBehaviour in array)
            {
                if (Utilities.IsValid((object)abstractUdonBehaviour))
                {
                    argsArray[0] = new ValueTuple<string, object>("channel", (object)block.channel);
                    argsArray[1] = new ValueTuple<string, object>("number", (object)(Int32)block.note);
                    argsArray[2] = new ValueTuple<string, object>("velocity", (object)(Int32)block.velocity);
                    abstractUdonBehaviour.RunEvent("_midiNoteOn", argsArray);
                }
            }
        }
 
        private void OnBlockEnd(MidiData.MidiBlock block)
        {
            //IL_0029: Unknown result type (might be due to invalid IL or missing references)
            //IL_002e: Unknown result type (might be due to invalid IL or missing references)
            //IL_004a: Unknown result type (might be due to invalid IL or missing references)
            //IL_004f: Unknown result type (might be due to invalid IL or missing references)
            //IL_006b: Unknown result type (might be due to invalid IL or missing references)
            //IL_0070: Unknown result type (might be due to invalid IL or missing references)
            OnBlockCompleted?.Invoke(block);
            argsArray[0] = new ValueTuple<string, object>("channel", (object)block.channel);
            argsArray[1] = new ValueTuple<string, object>("number", (object)(Int32)block.note);
            argsArray[2] = new ValueTuple<string, object>("velocity", (object)(Int32)block.velocity);
            AbstractUdonBehaviour[] array = targetBehaviours;
            foreach (AbstractUdonBehaviour abstractUdonBehaviour in array)
            {
                if (Utilities.IsValid((object)abstractUdonBehaviour))
                {
                    abstractUdonBehaviour.RunEvent("_midiNoteOff", argsArray);
                }
            }
        }
    }
    [Serializable]
    public class MidiRawData : Object
    {
        [Serializable]
        public class MidiRawTrack : Object
        {
            public int Index;
 
            public List<MidiEvent> MidiEvents = new List<MidiEvent>();
 
            public List<TextEvent> TextEvents = new List<TextEvent>();
        }
 
        [Serializable]
        public struct MidiEvent : ValueType
        {
            public int Time;
 
            public byte Type;
 
            public byte Arg1;
 
            public byte Arg2;
 
            public byte Arg3;
 
            public MidiEventType MidiEventType => (MidiEventType)Type;
 
            public MetaEventType MetaEventType => (MetaEventType)Arg1;
 
            public int Channel => Arg1;
 
            public int Note => Arg2;
 
            public int Velocity => Arg3;
 
            public ControlChangeType ControlChangeType => (ControlChangeType)Arg2;
 
            public int Value => Arg3;
 
            public override string ToString()
            {
                if (MidiEventType != MidiEventType.MetaEvent)
                {
                    return String.Format("event type: {0}, channel: {1}, time: {2}, note: {3}, velocity: {4}", (object[])(object)new Object[5]
                    {
                        (object)MidiEventType,
                        (object)Channel,
                        (object)Time,
                        (object)Note,
                        (object)Velocity
                    });
                }
                return String.Format("event type: {0}, channel: -, time: {1}, note: {2}, velocity: {3}", (object[])(object)new Object[4]
                {
                    (object)MetaEventType,
                    (object)Time,
                    (object)Note,
                    (object)Velocity
                });
            }
        }
 
        [Serializable]
        public struct TextEvent : ValueType
        {
            public int Time;
 
            public byte Type;
 
            public string Value;
 
            public TextEventType TextEventType => (TextEventType)Type;
        }
 
        public enum MidiEventType : Enum
        {
            NoteOff = 128,
            NoteOn = 144,
            KeyAfterTouch = 160,
            ControlChange = 176,
            ProgramChange = 192,
            ChannelAfterTouch = 208,
            PitchBendChange = 224,
            MetaEvent = 255
        }
 
        public enum ControlChangeType : Enum
        {
            BankSelect = 0,
            Modulation = 1,
            Volume = 7,
            Balance = 8,
            Pan = 10,
            Sustain = 64
        }
 
        public enum TextEventType : Enum
        {
            Text = 1,
            TrackName = 3,
            Lyric = 5
        }
 
        public enum MetaEventType : Enum
        {
            Tempo = 81,
            TimeSignature = 88,
            KeySignature = 89
        }
 
        public int Format;
 
        public int TicksPerQuarterNote;
 
        public MidiRawTrack[] Tracks;
 
        public int TracksCount;
    }
    public class MidiRawDataProcessor : Object
    {
        private struct NoteOnEvent : ValueType
        {
            public float StartTimeMs;
 
            public byte Velocity;
 
            public int Count;
 
            public bool Equals(NoteOnEvent other)
            {
                return StartTimeMs == other.StartTimeMs;
            }
 
            public override int GetHashCode()
            {
                return ((Single)(ref StartTimeMs)).GetHashCode();
            }
        }
 
        public readonly List<MidiData.MidiBlock> allBlocks = new List<MidiData.MidiBlock>();
 
        public readonly List<MidiData.MidiTrack> tracks;
 
        private readonly List<Dictionary<byte, NoteOnEvent>> _noteTimeMap = new List<Dictionary<byte, NoteOnEvent>>();
 
        [field: CompilerGenerated]
        public byte Bpm
        {
            [CompilerGenerated]
            get;
            [CompilerGenerated]
            private set;
        } = 120;
 
 
        public MidiRawDataProcessor(ParsedMidiFile midiFile, MidiImportSettings midiImportSettings)
        {
            //IL_00ac: Unknown result type (might be due to invalid IL or missing references)
            //IL_00b1: Unknown result type (might be due to invalid IL or missing references)
            //IL_0351: Unknown result type (might be due to invalid IL or missing references)
            //IL_0356: Unknown result type (might be due to invalid IL or missing references)
            //IL_0234: Unknown result type (might be due to invalid IL or missing references)
            //IL_0304: Unknown result type (might be due to invalid IL or missing references)
            //IL_02fe: Unknown result type (might be due to invalid IL or missing references)
            tracks = new List<MidiData.MidiTrack>(midiFile.TracksCount);
            for (int i = 0; i < midiFile.TracksCount; i++)
            {
                tracks.Add(new MidiData.MidiTrack());
                _noteTimeMap.Add(new Dictionary<byte, NoteOnEvent>());
            }
            if (midiImportSettings.OverrideBpm)
            {
                Bpm = midiImportSettings.Bpm;
            }
            MidiRawData.MidiRawTrack[] array = midiFile.Tracks;
            NoteOnEvent noteOnEvent3 = default(NoteOnEvent);
            NoteOnEvent noteOnEvent = default(NoteOnEvent);
            foreach (MidiRawData.MidiRawTrack midiRawTrack in array)
            {
                Dictionary<byte, NoteOnEvent> val = _noteTimeMap[midiRawTrack.Index];
                List<MidiData.MidiBlock> val2 = new List<MidiData.MidiBlock>();
                Enumerator<MidiRawData.MidiEvent> enumerator = midiRawTrack.MidiEvents.GetEnumerator();
                try
                {
                    while (enumerator.MoveNext())
                    {
                        MidiRawData.MidiEvent current = enumerator.Current;
                        float num = MidiUtilities.MidiTimeToMs(Bpm, midiFile.TicksPerQuarterNote, current.Time);
                        byte arg = current.Arg2;
                        switch ((MidiRawData.MidiEventType)current.Type)
                        {
                        case MidiRawData.MidiEventType.NoteOff:
                        {
                            NoteOnEvent noteOnEvent2 = val[arg];
                            MidiData.MidiBlock midiBlock = new MidiData.MidiBlock
                            {
                                startTimeMs = noteOnEvent2.StartTimeMs,
                                endTimeMs = num,
                                note = arg,
                                velocity = noteOnEvent2.Velocity,
                                channel = current.Channel
                            };
                            val2.Add(midiBlock);
                            if (val.TryGetValue(arg, ref noteOnEvent3))
                            {
                                if (noteOnEvent3.Count == 1)
                                {
                                    val.Remove(arg);
                                }
                                else
                                {
                                    val[arg] = new NoteOnEvent
                                    {
                                        Count = noteOnEvent3.Count - 1,
                                        Velocity = noteOnEvent3.Velocity,
                                        StartTimeMs = noteOnEvent3.StartTimeMs
                                    };
                                }
                                allBlocks.Add(midiBlock);
                                break;
                            }
                            throw new Exception("note off event - could not find matching on event");
                        }
                        case MidiRawData.MidiEventType.NoteOn:
                            if (val.TryGetValue(arg, ref noteOnEvent))
                            {
                                val[arg] = new NoteOnEvent
                                {
                                    StartTimeMs = num,
                                    Velocity = current.Arg3,
                                    Count = noteOnEvent.Count + 1
                                };
                            }
                            else
                            {
                                val.Add(arg, new NoteOnEvent
                                {
                                    StartTimeMs = num,
                                    Velocity = current.Arg3,
                                    Count = 1
                                });
                            }
                            break;
                        case MidiRawData.MidiEventType.MetaEvent:
                            switch (current.MetaEventType)
                            {
                            case MidiRawData.MetaEventType.Tempo:
                                if (!midiImportSettings.OverrideBpm)
                                {
                                    Bpm = (byte)current.Note;
                                }
                                break;
                            default:
                                throw new ArgumentOutOfRangeException();
                            case MidiRawData.MetaEventType.TimeSignature:
                            case MidiRawData.MetaEventType.KeySignature:
                                break;
                            }
                            break;
                        default:
                            throw new ArgumentOutOfRangeException();
                        case MidiRawData.MidiEventType.KeyAfterTouch:
                        case MidiRawData.MidiEventType.ControlChange:
                        case MidiRawData.MidiEventType.ProgramChange:
                        case MidiRawData.MidiEventType.ChannelAfterTouch:
                        case MidiRawData.MidiEventType.PitchBendChange:
                            break;
                        }
                    }
                }
                finally
                {
                    ((IDisposable)enumerator).Dispose();
                }
                tracks[midiRawTrack.Index].SetBlocks(val2);
            }
            Enumerator<MidiData.MidiTrack> enumerator2 = tracks.GetEnumerator();
            try
            {
                while (enumerator2.MoveNext())
                {
                    MidiData.MidiTrack current2 = enumerator2.Current;
                    if (current2.blocks.Length == 0)
                    {
                        current2.minNote = (current2.maxNote = 0);
                        current2.minVelocity = (current2.maxVelocity = 0);
                    }
                }
            }
            finally
            {
                ((IDisposable)enumerator2).Dispose();
            }
        }
    }
    public static class MidiUtilities : Object
    {
        public static float MidiTimeToMs(int bpm, int ppq, int time)
        {
            return 60000f / (float)(bpm * ppq) * (float)time;
        }
    }
    [AddComponentMenu("VRChat/Midi/VRC Midi Handler")]
    public class VRCMidiHandler : MonoBehaviour
    {
        public const int STATUS_NOTE_OFF = 128;
 
        public const int STATUS_NOTE_ON = 144;
 
        public const int STATUS_CONTROL_CHANGE = 176;
 
        private IVRCMidiInput _midiIn;
 
        [CompilerGenerated]
        private MidiVoiceMessageDelegate m_OnNoteOn;
 
        [CompilerGenerated]
        private MidiVoiceMessageDelegate m_OnNoteOff;
 
        [CompilerGenerated]
        private MidiVoiceMessageDelegate m_OnControlChange;
 
        private static VRCMidiHandler _instance;
 
        private IVRCMidiInput MidiIn
        {
            get
            {
                //IL_0044: Unknown result type (might be due to invalid IL or missing references)
                //IL_004e: Expected O, but got Unknown
                if (_midiIn == null)
                {
                    _instance._midiIn = Initialize?.Invoke();
                    if (_instance._midiIn != null)
                    {
                        _instance._midiIn.OnMidiVoiceMessage += new MidiVoiceMessageDelegate(_instance.SendMidiMessage);
                    }
                }
                return _midiIn;
            }
        }
 
        [PublicAPI]
        [field: CompilerGenerated]
        public static Func<IVRCMidiInput> Initialize
        {
            [CompilerGenerated]
            get;
            [CompilerGenerated]
            set;
        }
 
        [PublicAPI]
        [field: CompilerGenerated]
        public static Action<string> OnLog
        {
            [CompilerGenerated]
            get;
            [CompilerGenerated]
            set;
        }
 
        public static VRCMidiHandler Instance
        {
            get
            {
                //IL_0029: Unknown result type (might be due to invalid IL or missing references)
                if ((Object)(object)_instance == (Object)null)
                {
                    _instance = Object.FindObjectOfType<VRCMidiHandler>();
                    if ((Object)(object)_instance == (Object)null)
                    {
                        _instance = new GameObject("VRCMidiHandler").AddComponent<VRCMidiHandler>();
                    }
                }
                return _instance;
            }
            set
            {
                _instance = value;
            }
        }
 
        public event MidiVoiceMessageDelegate OnNoteOn
        {
            [CompilerGenerated]
            add
            {
                //IL_0010: Unknown result type (might be due to invalid IL or missing references)
                //IL_0016: Expected O, but got Unknown
                MidiVoiceMessageDelegate val = this.m_OnNoteOn;
                MidiVoiceMessageDelegate val2;
                do
                {
                    val2 = val;
                    MidiVoiceMessageDelegate val3 = (MidiVoiceMessageDelegate)Delegate.Combine((Delegate)(object)val2, (Delegate)(object)value);
                    val = Interlocked.CompareExchange<MidiVoiceMessageDelegate>(ref this.m_OnNoteOn, val3, val2);
                }
                while (val != val2);
            }
            [CompilerGenerated]
            remove
            {
                //IL_0010: Unknown result type (might be due to invalid IL or missing references)
                //IL_0016: Expected O, but got Unknown
                MidiVoiceMessageDelegate val = this.m_OnNoteOn;
                MidiVoiceMessageDelegate val2;
                do
                {
                    val2 = val;
                    MidiVoiceMessageDelegate val3 = (MidiVoiceMessageDelegate)Delegate.Remove((Delegate)(object)val2, (Delegate)(object)value);
                    val = Interlocked.CompareExchange<MidiVoiceMessageDelegate>(ref this.m_OnNoteOn, val3, val2);
                }
                while (val != val2);
            }
        }
 
        public event MidiVoiceMessageDelegate OnNoteOff
        {
            [CompilerGenerated]
            add
            {
                //IL_0010: Unknown result type (might be due to invalid IL or missing references)
                //IL_0016: Expected O, but got Unknown
                MidiVoiceMessageDelegate val = this.m_OnNoteOff;
                MidiVoiceMessageDelegate val2;
                do
                {
                    val2 = val;
                    MidiVoiceMessageDelegate val3 = (MidiVoiceMessageDelegate)Delegate.Combine((Delegate)(object)val2, (Delegate)(object)value);
                    val = Interlocked.CompareExchange<MidiVoiceMessageDelegate>(ref this.m_OnNoteOff, val3, val2);
                }
                while (val != val2);
            }
            [CompilerGenerated]
            remove
            {
                //IL_0010: Unknown result type (might be due to invalid IL or missing references)
                //IL_0016: Expected O, but got Unknown
                MidiVoiceMessageDelegate val = this.m_OnNoteOff;
                MidiVoiceMessageDelegate val2;
                do
                {
                    val2 = val;
                    MidiVoiceMessageDelegate val3 = (MidiVoiceMessageDelegate)Delegate.Remove((Delegate)(object)val2, (Delegate)(object)value);
                    val = Interlocked.CompareExchange<MidiVoiceMessageDelegate>(ref this.m_OnNoteOff, val3, val2);
                }
                while (val != val2);
            }
        }
 
        public event MidiVoiceMessageDelegate OnControlChange
        {
            [CompilerGenerated]
            add
            {
                //IL_0010: Unknown result type (might be due to invalid IL or missing references)
                //IL_0016: Expected O, but got Unknown
                MidiVoiceMessageDelegate val = this.m_OnControlChange;
                MidiVoiceMessageDelegate val2;
                do
                {
                    val2 = val;
                    MidiVoiceMessageDelegate val3 = (MidiVoiceMessageDelegate)Delegate.Combine((Delegate)(object)val2, (Delegate)(object)value);
                    val = Interlocked.CompareExchange<MidiVoiceMessageDelegate>(ref this.m_OnControlChange, val3, val2);
                }
                while (val != val2);
            }
            [CompilerGenerated]
            remove
            {
                //IL_0010: Unknown result type (might be due to invalid IL or missing references)
                //IL_0016: Expected O, but got Unknown
                MidiVoiceMessageDelegate val = this.m_OnControlChange;
                MidiVoiceMessageDelegate val2;
                do
                {
                    val2 = val;
                    MidiVoiceMessageDelegate val3 = (MidiVoiceMessageDelegate)Delegate.Remove((Delegate)(object)val2, (Delegate)(object)value);
                    val = Interlocked.CompareExchange<MidiVoiceMessageDelegate>(ref this.m_OnControlChange, val3, val2);
                }
                while (val != val2);
            }
        }
 
        public static IVRCMidiInput OpenMidiInput<T>(string deviceName = null) where T : IVRCMidiInput, new()
        {
            T val = new T();
            if (((IVRCMidiInput)val).OpenDevice(deviceName))
            {
                Log(String.Concat("Opened Midi Device ", ((IVRCMidiInput)val).Name));
            }
            else
            {
                Log(String.Concat("Could Not Open Midi Device ", deviceName));
            }
            return (IVRCMidiInput)(object)val;
        }
 
        private void SendMidiMessage(object sender, MidiVoiceEventArgs args)
        {
            //IL_0000: Unknown result type (might be due to invalid IL or missing references)
            //IL_0020: Unknown result type (might be due to invalid IL or missing references)
            //IL_0040: Unknown result type (might be due to invalid IL or missing references)
            //IL_0019: Unknown result type (might be due to invalid IL or missing references)
            //IL_0039: Unknown result type (might be due to invalid IL or missing references)
            //IL_0059: Unknown result type (might be due to invalid IL or missing references)
            if (args.command == 144)
            {
                MidiVoiceMessageDelegate onNoteOn = this.OnNoteOn;
                if (onNoteOn != null)
                {
                    onNoteOn.Invoke((object)this, args);
                }
            }
            else if (args.command == 128)
            {
                MidiVoiceMessageDelegate onNoteOff = this.OnNoteOff;
                if (onNoteOff != null)
                {
                    onNoteOff.Invoke((object)this, args);
                }
            }
            else if (args.command == 176)
            {
                MidiVoiceMessageDelegate onControlChange = this.OnControlChange;
                if (onControlChange != null)
                {
                    onControlChange.Invoke((object)this, args);
                }
            }
        }
 
        private void Update()
        {
            IVRCMidiInput midiIn = MidiIn;
            if (midiIn != null)
            {
                midiIn.Update();
            }
        }
 
        private void OnDestroy()
        {
            //IL_0015: Unknown result type (might be due to invalid IL or missing references)
            //IL_001f: Expected O, but got Unknown
            if (_midiIn != null)
            {
                _midiIn.OnMidiVoiceMessage -= new MidiVoiceMessageDelegate(SendMidiMessage);
                _midiIn.Close();
                _midiIn = null;
            }
            _instance = null;
        }
 
        private static void Log(string message)
        {
            OnLog?.Invoke(message);
        }
    }
    [AddComponentMenu("VRChat/Midi/VRC Midi Listener")]
    public class VRCMidiListener : MonoBehaviour
    {
        [Flags]
        public enum MidiEvents : Enum
        {
            NoteOn = 1,
            NoteOff = 2,
            CC = 4
        }
 
        private VRCMidiHandler _plugin;
 
        private readonly ValueTuple<string, object>[] argsArray = new ValueTuple<string, object>[3];
 
        [SerializeField]
        private AbstractUdonBehaviour behaviour;
 
        [EnumFlag]
        public MidiEvents activeEvents;
 
        private void OnEnable()
        {
            //IL_0022: Unknown result type (might be due to invalid IL or missing references)
            //IL_002c: Expected O, but got Unknown
            //IL_0043: Unknown result type (might be due to invalid IL or missing references)
            //IL_004d: Expected O, but got Unknown
            //IL_0064: Unknown result type (might be due to invalid IL or missing references)
            //IL_006e: Expected O, but got Unknown
            _plugin = VRCMidiHandler.Instance;
            if ((activeEvents & MidiEvents.NoteOn) != 0)
            {
                _plugin.OnNoteOn += new MidiVoiceMessageDelegate(NoteOn);
            }
            if ((activeEvents & MidiEvents.NoteOff) != 0)
            {
                _plugin.OnNoteOff += new MidiVoiceMessageDelegate(NoteOff);
            }
            if ((activeEvents & MidiEvents.CC) != 0)
            {
                _plugin.OnControlChange += new MidiVoiceMessageDelegate(ControlChange);
            }
        }
 
        private void NoteOn(object sender, MidiVoiceEventArgs args)
        {
            //IL_001a: Unknown result type (might be due to invalid IL or missing references)
            //IL_0025: Unknown result type (might be due to invalid IL or missing references)
            //IL_002a: Unknown result type (might be due to invalid IL or missing references)
            //IL_003b: Unknown result type (might be due to invalid IL or missing references)
            //IL_0046: Unknown result type (might be due to invalid IL or missing references)
            //IL_004b: Unknown result type (might be due to invalid IL or missing references)
            //IL_005c: Unknown result type (might be due to invalid IL or missing references)
            //IL_0067: Unknown result type (might be due to invalid IL or missing references)
            //IL_006c: Unknown result type (might be due to invalid IL or missing references)
            if ((Object)(object)behaviour != (Object)null)
            {
                argsArray[0] = new ValueTuple<string, object>("channel", (object)args.channel);
                argsArray[1] = new ValueTuple<string, object>("number", (object)args.number);
                argsArray[2] = new ValueTuple<string, object>("velocity", (object)args.value);
                behaviour.RunEvent("_midiNoteOn", argsArray);
            }
        }
 
        private void NoteOff(object sender, MidiVoiceEventArgs args)
        {
            //IL_001a: Unknown result type (might be due to invalid IL or missing references)
            //IL_0025: Unknown result type (might be due to invalid IL or missing references)
            //IL_002a: Unknown result type (might be due to invalid IL or missing references)
            //IL_003b: Unknown result type (might be due to invalid IL or missing references)
            //IL_0046: Unknown result type (might be due to invalid IL or missing references)
            //IL_004b: Unknown result type (might be due to invalid IL or missing references)
            //IL_005c: Unknown result type (might be due to invalid IL or missing references)
            //IL_0067: Unknown result type (might be due to invalid IL or missing references)
            //IL_006c: Unknown result type (might be due to invalid IL or missing references)
            if ((Object)(object)behaviour != (Object)null)
            {
                argsArray[0] = new ValueTuple<string, object>("channel", (object)args.channel);
                argsArray[1] = new ValueTuple<string, object>("number", (object)args.number);
                argsArray[2] = new ValueTuple<string, object>("velocity", (object)args.value);
                behaviour.RunEvent("_midiNoteOff", argsArray);
            }
        }
 
        private void ControlChange(object sender, MidiVoiceEventArgs args)
        {
            //IL_001a: Unknown result type (might be due to invalid IL or missing references)
            //IL_0025: Unknown result type (might be due to invalid IL or missing references)
            //IL_002a: Unknown result type (might be due to invalid IL or missing references)
            //IL_003b: Unknown result type (might be due to invalid IL or missing references)
            //IL_0046: Unknown result type (might be due to invalid IL or missing references)
            //IL_004b: Unknown result type (might be due to invalid IL or missing references)
            //IL_005c: Unknown result type (might be due to invalid IL or missing references)
            //IL_0067: Unknown result type (might be due to invalid IL or missing references)
            //IL_006c: Unknown result type (might be due to invalid IL or missing references)
            if ((Object)(object)behaviour != (Object)null)
            {
                argsArray[0] = new ValueTuple<string, object>("channel", (object)args.channel);
                argsArray[1] = new ValueTuple<string, object>("number", (object)args.number);
                argsArray[2] = new ValueTuple<string, object>("value", (object)args.value);
                behaviour.RunEvent("_midiControlChange", argsArray);
            }
        }
 
        private void OnDisable()
        {
            //IL_0017: Unknown result type (might be due to invalid IL or missing references)
            //IL_0021: Expected O, but got Unknown
            //IL_0038: Unknown result type (might be due to invalid IL or missing references)
            //IL_0042: Expected O, but got Unknown
            //IL_0059: Unknown result type (might be due to invalid IL or missing references)
            //IL_0063: Expected O, but got Unknown
            if ((activeEvents & MidiEvents.NoteOn) != 0)
            {
                _plugin.OnNoteOn -= new MidiVoiceMessageDelegate(NoteOn);
            }
            if ((activeEvents & MidiEvents.NoteOff) != 0)
            {
                _plugin.OnNoteOff -= new MidiVoiceMessageDelegate(NoteOff);
            }
            if ((activeEvents & MidiEvents.CC) != 0)
            {
                _plugin.OnControlChange -= new MidiVoiceMessageDelegate(ControlChange);
            }
        }
    }
}
namespace VRC.SDK3.StringLoading
{
    public interface IVRCStringDownload
    {
        string Result { get; }
 
        byte[] ResultBytes { get; }
 
        string Error { get; }
 
        int ErrorCode { get; }
 
        VRCUrl Url { get; }
 
        IUdonEventReceiver UdonBehaviour { get; }
 
        [ExcludeFromUdonWrapper]
        void StartDownload();
 
        [ExcludeFromUdonWrapper]
        void CancelDownload();
    }
    public class MaxBufferDownloadHandler : DownloadHandlerScript
    {
        private int _max;
 
        private int _current;
 
        private List<byte> _buffer = new List<byte>();
 
        public bool lengthFail;
 
        private string _convertedText;
 
        public byte[] downloadedBytes => _buffer.ToArray();
 
        public string downloadedText => _convertedText ?? (_convertedText = Encoding.UTF8.GetString(downloadedBytes));
 
        public MaxBufferDownloadHandler(int max)
        {
            _max = max;
        }
 
        public MaxBufferDownloadHandler(int max, byte[] buffer)
            : base(buffer)
        {
            _max = max;
        }
 
        protected override void ReceiveContentLengthHeader(ulong contentLength)
        {
            lengthFail = contentLength > (ulong)_max;
            if (!lengthFail)
            {
                _buffer.Capacity = (int)contentLength;
            }
        }
 
        protected override bool ReceiveData(byte[] data, int dataLength)
        {
            _current += dataLength;
            if (_current > _max || lengthFail)
            {
                return false;
            }
            for (int i = 0; i < dataLength; i++)
            {
                _buffer.Add(data[i]);
            }
            return ((DownloadHandler)this).ReceiveData(data, dataLength);
        }
    }
    public class VRCStringDownload : Object, IVRCStringDownload
    {
        [StructLayout(3)]
        [CompilerGenerated]
        private struct <StartAtCorrectTime>d__33 : ValueType, IAsyncStateMachine
        {
            public int <>1__state;
 
            public AsyncUniTaskMethodBuilder <>t__builder;
 
            public CancellationToken cancellationToken;
 
            public VRCStringDownload <>4__this;
 
            private Awaiter <>u__1;
 
            private void MoveNext()
            {
                //IL_011f: Expected O, but got Unknown
                //IL_0075: Unknown result type (might be due to invalid IL or missing references)
                //IL_007a: Unknown result type (might be due to invalid IL or missing references)
                //IL_0081: Unknown result type (might be due to invalid IL or missing references)
                //IL_0035: Unknown result type (might be due to invalid IL or missing references)
                //IL_003a: Unknown result type (might be due to invalid IL or missing references)
                //IL_003f: Unknown result type (might be due to invalid IL or missing references)
                //IL_0042: Unknown result type (might be due to invalid IL or missing references)
                //IL_0047: Unknown result type (might be due to invalid IL or missing references)
                //IL_005b: Unknown result type (might be due to invalid IL or missing references)
                //IL_005c: Unknown result type (might be due to invalid IL or missing references)
                int num = <>1__state;
                VRCStringDownload CS$<>8__locals0 = <>4__this;
                try
                {
                    try
                    {
                        Awaiter awaiter;
                        if (num != 0)
                        {
                            UniTask val = UniTask.WaitWhile((Func<bool>)(() => Time.realtimeSinceStartup - _lastStringRequest < 5f), (PlayerLoopTiming)8, cancellationToken);
                            awaiter = ((UniTask)(ref val)).GetAwaiter();
                            if (!((Awaiter)(ref awaiter)).IsCompleted)
                            {
                                num = (<>1__state = 0);
                                <>u__1 = awaiter;
                                ((AsyncUniTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<Awaiter, <StartAtCorrectTime>d__33>(ref awaiter, ref this);
                                return;
                            }
                        }
                        else
                        {
                            awaiter = <>u__1;
                            <>u__1 = default(Awaiter);
                            num = (<>1__state = -1);
                        }
                        ((Awaiter)(ref awaiter)).GetResult();
                        _lastStringRequest = Time.realtimeSinceStartup;
                        UnityWebRequest.ClearCookieCache(CS$<>8__locals0._webRequest.uri);
                        CS$<>8__locals0._asyncOperation = CS$<>8__locals0._webRequest.SendWebRequest();
                        ((AsyncOperation)CS$<>8__locals0._asyncOperation).completed += [CompilerGenerated] (AsyncOperation _) =>
                        {
                            CS$<>8__locals0.CompletedRequest();
                        };
                    }
                    catch (OperationCanceledException)
                    {
                        UnityWebRequest webRequest = CS$<>8__locals0._webRequest;
                        if (webRequest != null)
                        {
                            webRequest.Dispose();
                        }
                        CS$<>8__locals0._webRequest = null;
                        CS$<>8__locals0._asyncOperation = null;
                        CancellationTokenSource cancellationTokenSource = CS$<>8__locals0._cancellationTokenSource;
                        if (cancellationTokenSource != null)
                        {
                            cancellationTokenSource.Dispose();
                        }
                        CS$<>8__locals0._cancellationTokenSource = null;
                        VRCStringDownloader.RemoveFromManager(CS$<>8__locals0);
                    }
                }
                catch (Exception val3)
                {
                    Exception exception = val3;
                    <>1__state = -2;
                    ((AsyncUniTaskMethodBuilder)(ref <>t__builder)).SetException(exception);
                    return;
                }
                <>1__state = -2;
                ((AsyncUniTaskMethodBuilder)(ref <>t__builder)).SetResult();
            }
 
            [DebuggerHidden]
            private void SetStateMachine(IAsyncStateMachine stateMachine)
            {
                ((AsyncUniTaskMethodBuilder)(ref <>t__builder)).SetStateMachine(stateMachine);
            }
        }
 
        private const float MINIMUM_DELAY_BETWEEN_REQUESTS = 5f;
 
        private const int MAXIMUM_DOWNLOAD_SIZE_MB = 104857600;
 
        private static float _lastStringRequest = -5f;
 
        private UnityWebRequest _webRequest;
 
        private MaxBufferDownloadHandler _DownloadHandler;
 
        private UnityWebRequestAsyncOperation _asyncOperation;
 
        protected CancellationTokenSource _cancellationTokenSource;
 
        [field: CompilerGenerated]
        public string Result
        {
            [CompilerGenerated]
            get;
            [CompilerGenerated]
            private set;
        }
 
        [field: CompilerGenerated]
        public byte[] ResultBytes
        {
            [CompilerGenerated]
            get;
            [CompilerGenerated]
            private set;
        }
 
        [field: CompilerGenerated]
        public string Error
        {
            [CompilerGenerated]
            get;
            [CompilerGenerated]
            private set;
        }
 
        [field: CompilerGenerated]
        public int ErrorCode
        {
            [CompilerGenerated]
            get;
            [CompilerGenerated]
            private set;
        }
 
        [field: CompilerGenerated]
        public VRCUrl Url
        {
            [CompilerGenerated]
            get;
            [CompilerGenerated]
            private set;
        }
 
        [field: CompilerGenerated]
        public IUdonEventReceiver UdonBehaviour
        {
            [CompilerGenerated]
            get;
            [CompilerGenerated]
            private set;
        }
 
        public VRCStringDownload(VRCUrl url, IUdonEventReceiver udonbehavior)
        {
            //IL_0015: Unknown result type (might be due to invalid IL or missing references)
            //IL_001f: Expected O, but got Unknown
            Url = url;
            UdonBehaviour = udonbehavior;
            _cancellationTokenSource = new CancellationTokenSource();
        }
 
        public void StartDownload()
        {
            //IL_0077: Unknown result type (might be due to invalid IL or missing references)
            //IL_002f: Unknown result type (might be due to invalid IL or missing references)
            //IL_0047: Unknown result type (might be due to invalid IL or missing references)
            //IL_004d: Expected O, but got Unknown
            //IL_00e0: Unknown result type (might be due to invalid IL or missing references)
            //IL_0103: Unknown result type (might be due to invalid IL or missing references)
            //IL_010d: Expected O, but got Unknown
            //IL_0141: Unknown result type (might be due to invalid IL or missing references)
            //IL_0146: Unknown result type (might be due to invalid IL or missing references)
            if (!VRCStringDownloader.AddToManager(this))
            {
                ErrorCode = 429;
                Error = "Client has too many requests (limit is 1000).";
                UdonBehaviour.RunEvent<VRCStringDownload>("_onStringLoadError", new ValueTuple<string, VRCStringDownload>("IVRCStringDownload", this));
                return;
            }
            Uri val;
            try
            {
                val = new Uri(Url.Get());
            }
            catch (Exception)
            {
                ErrorCode = 400;
                Error = "Invalid URL";
                UdonBehaviour.RunEvent<VRCStringDownload>("_onStringLoadError", new ValueTuple<string, VRCStringDownload>("IVRCStringDownload", this));
                VRCStringDownloader.RemoveFromManager(this);
                return;
            }
            if (!val.IsAbsoluteUri || (val.Scheme != Uri.UriSchemeHttps && val.Scheme != Uri.UriSchemeHttp))
            {
                ErrorCode = 400;
                Error = "Strings may only be downloaded from HTTP(S) URLs.";
                UdonBehaviour.RunEvent<VRCStringDownload>("_onStringLoadError", new ValueTuple<string, VRCStringDownload>("IVRCStringDownload", this));
                VRCStringDownloader.RemoveFromManager(this);
            }
            else
            {
                _webRequest = new UnityWebRequest(Url.Get(), "GET");
                _webRequest.redirectLimit = 0;
                _DownloadHandler = new MaxBufferDownloadHandler(104857600);
                _webRequest.downloadHandler = (DownloadHandler)(object)_DownloadHandler;
                UniTaskExtensions.Forget(StartAtCorrectTime(_cancellationTokenSource.Token));
            }
        }
 
        [AsyncStateMachine(/*Could not decode attribute arguments.*/)]
        private UniTask StartAtCorrectTime(CancellationToken cancellationToken)
        {
            //IL_0002: Unknown result type (might be due to invalid IL or missing references)
            //IL_0007: Unknown result type (might be due to invalid IL or missing references)
            //IL_0016: Unknown result type (might be due to invalid IL or missing references)
            //IL_0017: Unknown result type (might be due to invalid IL or missing references)
            //IL_0039: Unknown result type (might be due to invalid IL or missing references)
            <StartAtCorrectTime>d__33 <StartAtCorrectTime>d__ = default(<StartAtCorrectTime>d__33);
            <StartAtCorrectTime>d__.<>t__builder = AsyncUniTaskMethodBuilder.Create();
            <StartAtCorrectTime>d__.<>4__this = this;
            <StartAtCorrectTime>d__.cancellationToken = cancellationToken;
            <StartAtCorrectTime>d__.<>1__state = -1;
            ((AsyncUniTaskMethodBuilder)(ref <StartAtCorrectTime>d__.<>t__builder)).Start<<StartAtCorrectTime>d__33>(ref <StartAtCorrectTime>d__);
            return ((AsyncUniTaskMethodBuilder)(ref <StartAtCorrectTime>d__.<>t__builder)).Task;
        }
 
        private void CompletedRequest()
        {
            //IL_000f: Unknown result type (might be due to invalid IL or missing references)
            //IL_0015: Invalid comparison between Unknown and I4
            //IL_001d: Unknown result type (might be due to invalid IL or missing references)
            //IL_0023: Invalid comparison between Unknown and I4
            //IL_00eb: Unknown result type (might be due to invalid IL or missing references)
            //IL_0079: Unknown result type (might be due to invalid IL or missing references)
            if (_webRequest == null)
            {
                return;
            }
            if ((int)_webRequest.result != 2 && (int)_webRequest.result != 3 && !_DownloadHandler.lengthFail)
            {
                Result = ((MaxBufferDownloadHandler)(object)_webRequest.downloadHandler).downloadedText;
                ResultBytes = ((MaxBufferDownloadHandler)(object)_webRequest.downloadHandler).downloadedBytes;
                UdonBehaviour.RunEvent<VRCStringDownload>("_onStringLoadSuccess", new ValueTuple<string, VRCStringDownload>("IVRCStringDownload", this));
            }
            else
            {
                if (_DownloadHandler.lengthFail)
                {
                    ErrorCode = 413;
                    Error = String.Format("Content longer than {0}MB", (object)100);
                }
                else
                {
                    Error = _webRequest.error;
                    ErrorCode = (int)_webRequest.responseCode;
                }
                UdonBehaviour.RunEvent<VRCStringDownload>("_onStringLoadError", new ValueTuple<string, VRCStringDownload>("IVRCStringDownload", this));
            }
            UnityWebRequest webRequest = _webRequest;
            if (webRequest != null)
            {
                webRequest.Dispose();
            }
            _webRequest = null;
            _asyncOperation = null;
            CancellationTokenSource cancellationTokenSource = _cancellationTokenSource;
            if (cancellationTokenSource != null)
            {
                cancellationTokenSource.Dispose();
            }
            _cancellationTokenSource = null;
            VRCStringDownloader.RemoveFromManager(this);
        }
 
        public void CancelDownload()
        {
            UnityWebRequest webRequest = _webRequest;
            if (webRequest != null)
            {
                webRequest.Abort();
            }
            UnityWebRequest webRequest2 = _webRequest;
            if (webRequest2 != null)
            {
                webRequest2.Dispose();
            }
            _webRequest = null;
            _asyncOperation = null;
            CancellationTokenSource cancellationTokenSource = _cancellationTokenSource;
            if (cancellationTokenSource != null)
            {
                cancellationTokenSource.Cancel();
            }
            CancellationTokenSource cancellationTokenSource2 = _cancellationTokenSource;
            if (cancellationTokenSource2 != null)
            {
                cancellationTokenSource2.Dispose();
            }
            _cancellationTokenSource = null;
            VRCStringDownloader.RemoveFromManager(this);
        }
    }
    public static class VRCStringDownloader : Object
    {
        private static List<IVRCStringDownload> _stringDownloads = new List<IVRCStringDownload>();
 
        [ExcludeFromUdonWrapper]
        [field: CompilerGenerated]
        public static Action<VRCUrl, IUdonEventReceiver> StartDownload
        {
            [CompilerGenerated]
            get;
            [CompilerGenerated]
            set;
        } = LoadUrlInternal;
 
 
        public static void LoadUrl(VRCUrl url, IUdonEventReceiver udonBehaviour = null)
        {
            StartDownload.Invoke(url, udonBehaviour);
        }
 
        [ExcludeFromUdonWrapper]
        private static void LoadUrlInternal(VRCUrl url, IUdonEventReceiver udonBehaviour)
        {
            new VRCStringDownload(url, udonBehaviour).StartDownload();
        }
 
        [ExcludeFromUdonWrapper]
        public static bool AddToManager(IVRCStringDownload download)
        {
            if (_stringDownloads.Count < 1000)
            {
                _stringDownloads.Add(download);
                return true;
            }
            return false;
        }
 
        [ExcludeFromUdonWrapper]
        public static void RemoveFromManager(IVRCStringDownload download)
        {
            _stringDownloads.Remove(download);
        }
 
        [ExcludeFromUdonWrapper]
        public static void ClearQueue()
        {
            Debug.Log((object)"[String Download] Clearing string download queue");
            for (int num = _stringDownloads.Count - 1; num >= 0; num--)
            {
                _stringDownloads[num].CancelDownload();
            }
            _stringDownloads.Clear();
        }
    }
}
namespace VRC.SDK3.Image
{
    [PublicAPI]
    public interface IVRCImageDownload : IDisposable
    {
        VRCImageDownloadState State { get; }
 
        VRCImageDownloadError Error { get; }
 
        string ErrorMessage { get; }
 
        Texture2D Result { get; }
 
        int SizeInMemoryBytes { get; }
 
        float Progress { get; }
 
        VRCUrl Url { get; }
 
        Material Material { get; }
 
        IUdonEventReceiver UdonBehaviour { get; }
 
        TextureInfo TextureInfo { get; }
 
        [ExcludeFromUdonWrapper]
        void StartDownload();
 
        [ExcludeFromUdonWrapper]
        void CancelDownload();
    }
    [Serializable]
    public class TextureInfo : Object
    {
        public TextureWrapMode WrapModeU;
 
        public TextureWrapMode WrapModeV;
 
        public TextureWrapMode WrapModeW;
 
        public FilterMode FilterMode = (FilterMode)2;
 
        public int AnisoLevel = 9;
 
        public string MaterialProperty = "_MainTex";
 
        public bool GenerateMipMaps;
    }
    [PublicAPI]
    public sealed class VRCImageDownloader : Object, IDisposable
    {
        public class ImageDownloader : Object, IVRCImageDownload, IDisposable
        {
            [PublicAPI]
            public enum ImageError : Enum
            {
                Unknown,
                MaximumDimensionExceeded,
                LoadFailure,
                DecodeFailure,
                IoError,
                LimitsExceeded,
                UnsupportedOperation,
                UnknownFormat,
                OutputBufferTooSmall,
                Panic,
                UnsupportedLimits,
                MemoryLimitExceeded,
                BadDecoderParameters
            }
 
            [PublicAPI]
            public enum ImageFormat : Enum
            {
                Unknown,
                R8,
                RG16,
                RGB24,
                RGBA32,
                R16,
                RG32,
                RGB48,
                RGBA64,
                RGBAFloat
            }
 
            [Serializable]
            public struct ImageInfo : ValueType
            {
                public uint width;
 
                public uint height;
 
                public ImageFormat format;
            }
 
            [Serializable]
            public struct ImageResult : ValueType
            {
                public byte success;
 
                public ImageInfo info;
 
                public ImageError error;
            }
 
            [Flags]
            public enum ImageLoadSettingsFlags : Enum
            {
                None = 0u,
                LimitAllocation = 1u,
                LimitResolution = 2u,
                VerticalFlip = 4u,
                OverrideOutputFormat = 8u,
                ResizeOutput = 0x10u,
                FastResize = 0x20u,
                GenerateMipMaps = 0x40u
            }
 
            [Serializable]
            public readonly struct ImageLoadSettings : ValueType
            {
                private readonly ImageLoadSettingsFlags _flags;
 
                private readonly uint _allocationLimit;
 
                private readonly uint _resolutionLimit;
 
                private readonly uint _targetWidth;
 
                private readonly uint _targetHeight;
 
                private readonly ImageFormat _outputFormatOverride;
 
                private ImageLoadSettings(ImageLoadSettingsFlags flags, uint allocationLimit, uint resolutionLimit, uint targetWidth, uint targetHeight, ImageFormat outputFormatOverride)
                {
                    _flags = flags;
                    _allocationLimit = allocationLimit;
                    _resolutionLimit = resolutionLimit;
                    _targetWidth = targetWidth;
                    _targetHeight = targetHeight;
                    _outputFormatOverride = outputFormatOverride;
                }
 
                public Nullable<uint> GetAllocationLimit()
                {
                    //IL_0019: Unknown result type (might be due to invalid IL or missing references)
                    //IL_000b: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0011: Unknown result type (might be due to invalid IL or missing references)
                    if (!HasFlag(ImageLoadSettingsFlags.LimitAllocation))
                    {
                        return default(Nullable<uint>);
                    }
                    return new Nullable<uint>(_allocationLimit);
                }
 
                public ImageLoadSettings SetAllocationLimit(Nullable<uint> allocationLimit)
                {
                    return new ImageLoadSettings(allocationLimit.HasValue ? (_flags | ImageLoadSettingsFlags.LimitAllocation) : (_flags & ~ImageLoadSettingsFlags.LimitAllocation), allocationLimit.GetValueOrDefault(), _resolutionLimit, _targetWidth, _targetHeight, _outputFormatOverride);
                }
 
                public Nullable<uint> GetResolutionLimit()
                {
                    //IL_0019: Unknown result type (might be due to invalid IL or missing references)
                    //IL_000b: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0011: Unknown result type (might be due to invalid IL or missing references)
                    if (!HasFlag(ImageLoadSettingsFlags.LimitResolution))
                    {
                        return default(Nullable<uint>);
                    }
                    return new Nullable<uint>(_resolutionLimit);
                }
 
                public ImageLoadSettings SetResolutionLimit(Nullable<uint> resolutionLimit)
                {
                    return new ImageLoadSettings(resolutionLimit.HasValue ? (_flags | ImageLoadSettingsFlags.LimitResolution) : (_flags & ~ImageLoadSettingsFlags.LimitResolution), _allocationLimit, resolutionLimit.GetValueOrDefault(), _targetWidth, _targetHeight, _outputFormatOverride);
                }
 
                public bool GetVerticalFlip()
                {
                    return HasFlag(ImageLoadSettingsFlags.VerticalFlip);
                }
 
                public ImageLoadSettings SetVerticalFlip(bool flip)
                {
                    return new ImageLoadSettings(flip ? (_flags | ImageLoadSettingsFlags.VerticalFlip) : (_flags & ~ImageLoadSettingsFlags.VerticalFlip), _allocationLimit, _resolutionLimit, _targetWidth, _targetHeight, _outputFormatOverride);
                }
 
                public Nullable<ValueTuple<uint, uint>> GetResizeResolution()
                {
                    //IL_0020: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0025: Unknown result type (might be due to invalid IL or missing references)
                    //IL_000c: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0012: Unknown result type (might be due to invalid IL or missing references)
                    if (!HasFlag(ImageLoadSettingsFlags.ResizeOutput))
                    {
                        return default(Nullable<ValueTuple<uint, uint>>);
                    }
                    return new Nullable<ValueTuple<uint, uint>>(new ValueTuple<uint, uint>(_targetWidth, _targetHeight));
                }
 
                public ImageLoadSettings SetResizeResolution(Nullable<ValueTuple<uint, uint>> targetResolution)
                {
                    //IL_002b: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0037: Unknown result type (might be due to invalid IL or missing references)
                    return new ImageLoadSettings(targetResolution.HasValue ? (_flags | ImageLoadSettingsFlags.ResizeOutput) : (_flags & ~ImageLoadSettingsFlags.ResizeOutput), _allocationLimit, _resolutionLimit, targetResolution.GetValueOrDefault().Item1, targetResolution.GetValueOrDefault().Item2, _outputFormatOverride);
                }
 
                public ImageLoadSettings SetFastResize(bool fast)
                {
                    return new ImageLoadSettings(fast ? (_flags | ImageLoadSettingsFlags.FastResize) : (_flags & ~ImageLoadSettingsFlags.FastResize), _allocationLimit, _resolutionLimit, _targetWidth, _targetHeight, _outputFormatOverride);
                }
 
                public bool GetFastResize()
                {
                    return HasFlag(ImageLoadSettingsFlags.FastResize);
                }
 
                public Nullable<ImageFormat> GetOutputFormatOverride()
                {
                    //IL_0019: Unknown result type (might be due to invalid IL or missing references)
                    //IL_000b: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0011: Unknown result type (might be due to invalid IL or missing references)
                    if (!HasFlag(ImageLoadSettingsFlags.OverrideOutputFormat))
                    {
                        return default(Nullable<ImageFormat>);
                    }
                    return new Nullable<ImageFormat>(_outputFormatOverride);
                }
 
                public ImageLoadSettings SetOutputFormatOverride(Nullable<ImageFormat> outputFormatOverride)
                {
                    return new ImageLoadSettings(outputFormatOverride.HasValue ? (_flags | ImageLoadSettingsFlags.OverrideOutputFormat) : (_flags & ~ImageLoadSettingsFlags.OverrideOutputFormat), _allocationLimit, _resolutionLimit, _targetWidth, _targetHeight, outputFormatOverride.GetValueOrDefault());
                }
 
                public ImageLoadSettings SetGenerateMipMaps(bool enable)
                {
                    return new ImageLoadSettings(enable ? (_flags | ImageLoadSettingsFlags.GenerateMipMaps) : (_flags & ~ImageLoadSettingsFlags.GenerateMipMaps), _allocationLimit, _resolutionLimit, _targetWidth, _targetHeight, _outputFormatOverride);
                }
 
                public bool GetGenerateMipMaps()
                {
                    return HasFlag(ImageLoadSettingsFlags.GenerateMipMaps);
                }
 
                private bool HasFlag(ImageLoadSettingsFlags flag)
                {
                    return (_flags & flag) != 0;
                }
            }
 
            [StructLayout(3)]
            [CompilerGenerated]
            private struct <<Dispose>g__DestroyAsync|53_0>d : ValueType, IAsyncStateMachine
            {
                public int <>1__state;
 
                public AsyncUniTaskVoidMethodBuilder <>t__builder;
 
                public Object obj;
 
                private Awaiter <>u__1;
 
                private void MoveNext()
                {
                    //IL_009e: Expected O, but got Unknown
                    //IL_004b: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0050: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0057: Unknown result type (might be due to invalid IL or missing references)
                    //IL_000c: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0012: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0013: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0018: Unknown result type (might be due to invalid IL or missing references)
                    //IL_001b: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0020: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0034: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0035: Unknown result type (might be due to invalid IL or missing references)
                    int num = <>1__state;
                    try
                    {
                        Awaiter awaiter;
                        if (num != 0)
                        {
                            SwitchToMainThreadAwaitable val = UniTask.SwitchToMainThread(default(CancellationToken));
                            awaiter = ((SwitchToMainThreadAwaitable)(ref val)).GetAwaiter();
                            if (!((Awaiter)(ref awaiter)).IsCompleted)
                            {
                                num = (<>1__state = 0);
                                <>u__1 = awaiter;
                                ((AsyncUniTaskVoidMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<Awaiter, <<Dispose>g__DestroyAsync|53_0>d>(ref awaiter, ref this);
                                return;
                            }
                        }
                        else
                        {
                            awaiter = <>u__1;
                            <>u__1 = default(Awaiter);
                            num = (<>1__state = -1);
                        }
                        ((Awaiter)(ref awaiter)).GetResult();
                        if (obj != (Object)null)
                        {
                            if (Application.isPlaying)
                            {
                                Object.Destroy(obj);
                            }
                            else
                            {
                                Object.DestroyImmediate(obj);
                            }
                        }
                    }
                    catch (Exception val2)
                    {
                        Exception exception = val2;
                        <>1__state = -2;
                        ((AsyncUniTaskVoidMethodBuilder)(ref <>t__builder)).SetException(exception);
                        return;
                    }
                    <>1__state = -2;
                    ((AsyncUniTaskVoidMethodBuilder)(ref <>t__builder)).SetResult();
                }
 
                [DebuggerHidden]
                private void SetStateMachine(IAsyncStateMachine stateMachine)
                {
                    ((AsyncUniTaskVoidMethodBuilder)(ref <>t__builder)).SetStateMachine(stateMachine);
                }
            }
 
            [StructLayout(3)]
            [CompilerGenerated]
            private struct <<DownloadImage>g__SlicedTextureUpload|51_0>d : ValueType, IAsyncStateMachine
            {
                public int <>1__state;
 
                public AsyncUniTaskMethodBuilder <>t__builder;
 
                public int width;
 
                public int bytesPerPixel;
 
                public int height;
 
                public TextureFormat format;
 
                public NativeSlice<byte> outputBuffer;
 
                public Texture2D outputTexture;
 
                public int mipLevel;
 
                private int <sliceHeight>5__2;
 
                private Texture2D <sliceTexture>5__3;
 
                private Texture2D <uploadTexture>5__4;
 
                private Awaiter <>u__1;
 
                private int <sliceCount>5__5;
 
                private int <bytesPerRow>5__6;
 
                private int <sliceIndex>5__7;
 
                private unsafe void MoveNext()
                {
                    //IL_031a: Expected O, but got Unknown
                    //IL_0109: Unknown result type (might be due to invalid IL or missing references)
                    //IL_010e: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0115: Unknown result type (might be due to invalid IL or missing references)
                    //IL_006c: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0071: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0078: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0080: Unknown result type (might be due to invalid IL or missing references)
                    //IL_00cd: Unknown result type (might be due to invalid IL or missing references)
                    //IL_00d2: Unknown result type (might be due to invalid IL or missing references)
                    //IL_00d6: Unknown result type (might be due to invalid IL or missing references)
                    //IL_00db: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0162: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0168: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0172: Expected O, but got Unknown
                    //IL_004f: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0055: Unknown result type (might be due to invalid IL or missing references)
                    //IL_005f: Expected O, but got Unknown
                    //IL_00ef: Unknown result type (might be due to invalid IL or missing references)
                    //IL_00f0: Unknown result type (might be due to invalid IL or missing references)
                    //IL_02ab: Unknown result type (might be due to invalid IL or missing references)
                    //IL_02b0: Unknown result type (might be due to invalid IL or missing references)
                    //IL_02b7: Unknown result type (might be due to invalid IL or missing references)
                    //IL_01fd: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0206: Unknown result type (might be due to invalid IL or missing references)
                    //IL_020b: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0213: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0226: Unknown result type (might be due to invalid IL or missing references)
                    //IL_026f: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0274: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0278: Unknown result type (might be due to invalid IL or missing references)
                    //IL_027d: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0291: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0292: Unknown result type (might be due to invalid IL or missing references)
                    int num = <>1__state;
                    try
                    {
                        if (num == 0)
                        {
                            goto IL_0060;
                        }
                        if (num != 1)
                        {
                            <sliceHeight>5__2 = Mathf.CeilToInt(1048576f / (float)(width * bytesPerPixel));
                            if (<sliceHeight>5__2 >= height)
                            {
                                <uploadTexture>5__4 = new Texture2D(width, height, format, false);
                                goto IL_0060;
                            }
                            <sliceTexture>5__3 = new Texture2D(width, <sliceHeight>5__2, format, false);
                        }
                        Awaiter awaiter;
                        YieldAwaitable val2;
                        try
                        {
                            if (num != 1)
                            {
                                <sliceCount>5__5 = Mathf.CeilToInt((float)height / (float)<sliceHeight>5__2);
                                <bytesPerRow>5__6 = width * bytesPerPixel;
                                <sliceIndex>5__7 = 0;
                                goto IL_02df;
                            }
                            awaiter = <>u__1;
                            <>u__1 = default(Awaiter);
                            num = (<>1__state = -1);
                            goto IL_02c6;
                            IL_02c6:
                            ((Awaiter)(ref awaiter)).GetResult();
                            <sliceIndex>5__7++;
                            goto IL_02df;
                            IL_02df:
                            if (<sliceIndex>5__7 < <sliceCount>5__5)
                            {
                                int num2 = <sliceIndex>5__7 * <sliceHeight>5__2;
                                int num3 = ((num2 + <sliceHeight>5__2 < height) ? <sliceHeight>5__2 : (height - num2));
                                int num4 = num2 * <bytesPerRow>5__6;
                                int num5 = num3 * <bytesPerRow>5__6;
                                NativeSlice<byte> val = NativeSliceExtensions.Slice<byte>(outputBuffer, num4, num5);
                                NativeArray<byte> rawTextureData = <sliceTexture>5__3.GetRawTextureData<byte>();
                                int num6 = UnsafeUtility.SizeOf<byte>();
                                UnsafeUtility.MemCpyStride(NativeArrayUnsafeUtility.GetUnsafePtr<byte>(rawTextureData), num6, NativeSliceUnsafeUtility.GetUnsafeReadOnlyPtr<byte>(val), num6, num6, val.Length);
                                <sliceTexture>5__3.Apply();
                                Graphics.CopyTexture((Texture)(object)<sliceTexture>5__3, 0, 0, 0, 0, width, num3, (Texture)(object)outputTexture, 0, mipLevel, 0, num2);
                                val2 = UniTask.Yield();
                                awaiter = ((YieldAwaitable)(ref val2)).GetAwaiter();
                                if (!((Awaiter)(ref awaiter)).IsCompleted)
                                {
                                    num = (<>1__state = 1);
                                    <>u__1 = awaiter;
                                    ((AsyncUniTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<Awaiter, <<DownloadImage>g__SlicedTextureUpload|51_0>d>(ref awaiter, ref this);
                                    return;
                                }
                                goto IL_02c6;
                            }
                        }
                        finally
                        {
                            if (num < 0)
                            {
                                if (Application.isPlaying)
                                {
                                    Object.Destroy((Object)(object)<sliceTexture>5__3);
                                }
                                else
                                {
                                    Object.DestroyImmediate((Object)(object)<sliceTexture>5__3);
                                }
                            }
                        }
                        goto end_IL_0007;
                        IL_0060:
                        try
                        {
                            if (num != 0)
                            {
                                NativeArray<byte> rawTextureData2 = <uploadTexture>5__4.GetRawTextureData<byte>();
                                int num7 = UnsafeUtility.SizeOf<byte>();
                                UnsafeUtility.MemCpyStride(NativeArrayUnsafeUtility.GetUnsafePtr<byte>(rawTextureData2), num7, NativeSliceUnsafeUtility.GetUnsafeReadOnlyPtr<byte>(outputBuffer), num7, num7, rawTextureData2.Length);
                                <uploadTexture>5__4.Apply();
                                Graphics.CopyTexture((Texture)(object)<uploadTexture>5__4, 0, 0, 0, 0, width, height, (Texture)(object)outputTexture, 0, mipLevel, 0, 0);
                                val2 = UniTask.Yield();
                                awaiter = ((YieldAwaitable)(ref val2)).GetAwaiter();
                                if (!((Awaiter)(ref awaiter)).IsCompleted)
                                {
                                    num = (<>1__state = 0);
                                    <>u__1 = awaiter;
                                    ((AsyncUniTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<Awaiter, <<DownloadImage>g__SlicedTextureUpload|51_0>d>(ref awaiter, ref this);
                                    return;
                                }
                            }
                            else
                            {
                                awaiter = <>u__1;
                                <>u__1 = default(Awaiter);
                                num = (<>1__state = -1);
                            }
                            ((Awaiter)(ref awaiter)).GetResult();
                        }
                        finally
                        {
                            if (num < 0)
                            {
                                if (Application.isPlaying)
                                {
                                    Object.Destroy((Object)(object)<uploadTexture>5__4);
                                }
                                else
                                {
                                    Object.DestroyImmediate((Object)(object)<uploadTexture>5__4);
                                }
                            }
                        }
                        end_IL_0007:;
                    }
                    catch (Exception val3)
                    {
                        Exception exception = val3;
                        <>1__state = -2;
                        <sliceTexture>5__3 = null;
                        ((AsyncUniTaskMethodBuilder)(ref <>t__builder)).SetException(exception);
                        return;
                    }
                    <>1__state = -2;
                    <sliceTexture>5__3 = null;
                    ((AsyncUniTaskMethodBuilder)(ref <>t__builder)).SetResult();
                }
 
                [DebuggerHidden]
                private void SetStateMachine(IAsyncStateMachine stateMachine)
                {
                    ((AsyncUniTaskMethodBuilder)(ref <>t__builder)).SetStateMachine(stateMachine);
                }
            }
 
            [StructLayout(3)]
            [CompilerGenerated]
            private struct <DownloadImage>d__51 : ValueType, IAsyncStateMachine
            {
                public int <>1__state;
 
                public AsyncUniTaskMethodBuilder <>t__builder;
 
                public CancellationToken cancellationToken;
 
                public ImageDownloader <>4__this;
 
                public Uri uri;
 
                private object <>7__wrap1;
 
                private int <>7__wrap2;
 
                private NativeArray<byte> <outputBuffer>5__4;
 
                private UnityWebRequest <webRequest>5__5;
 
                private ReadOnly<byte> <downloadBuffer>5__6;
 
                private ImageInfo <imageInfo>5__7;
 
                private TextureFormat <format>5__8;
 
                private int <bytesPerPixel>5__9;
 
                private Texture2D <outputTexture>5__10;
 
                private NativeArray<byte> <outputTextureRawData>5__11;
 
                private int <mipLevelWidth>5__12;
 
                private int <mipLevelHeight>5__13;
 
                private NativeSlice<byte> <outputSlice>5__14;
 
                private Awaiter <>u__1;
 
                private Awaiter<UnityWebRequest> <>u__2;
 
                private Awaiter <>u__3;
 
                private Awaiter <>u__4;
 
                private int <mipLevel>5__15;
 
                private unsafe void MoveNext()
                {
                    //IL_0b57: Expected O, but got Unknown
                    //IL_0b6a: Expected O, but got Unknown
                    //IL_0da0: Expected O, but got Unknown
                    //IL_0bf7: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0bfc: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0c04: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0cc3: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0cc8: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0cd0: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0d72: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0d77: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0d7f: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0bb3: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0bb8: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0bbd: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0bc1: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0bc6: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0bdc: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0bde: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0c25: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0c2c: Expected O, but got Unknown
                    //IL_00de: Unknown result type (might be due to invalid IL or missing references)
                    //IL_00e3: Unknown result type (might be due to invalid IL or missing references)
                    //IL_00eb: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0d31: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0d36: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0d3b: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0d3f: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0d44: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0c7f: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0c84: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0c89: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0c8d: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0c92: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0d5a: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0d5c: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0ca8: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0caa: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0170: Unknown result type (might be due to invalid IL or missing references)
                    //IL_017b: Expected O, but got Unknown
                    //IL_0176: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0180: Expected O, but got Unknown
                    //IL_009b: Unknown result type (might be due to invalid IL or missing references)
                    //IL_00a0: Unknown result type (might be due to invalid IL or missing references)
                    //IL_00a5: Unknown result type (might be due to invalid IL or missing references)
                    //IL_00a9: Unknown result type (might be due to invalid IL or missing references)
                    //IL_00ae: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0152: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0157: Unknown result type (might be due to invalid IL or missing references)
                    //IL_00c3: Unknown result type (might be due to invalid IL or missing references)
                    //IL_00c5: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0229: Unknown result type (might be due to invalid IL or missing references)
                    //IL_022e: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0236: Unknown result type (might be due to invalid IL or missing references)
                    //IL_02da: Unknown result type (might be due to invalid IL or missing references)
                    //IL_02df: Unknown result type (might be due to invalid IL or missing references)
                    //IL_02e7: Unknown result type (might be due to invalid IL or missing references)
                    //IL_03a3: Unknown result type (might be due to invalid IL or missing references)
                    //IL_03a8: Unknown result type (might be due to invalid IL or missing references)
                    //IL_03b0: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0409: Unknown result type (might be due to invalid IL or missing references)
                    //IL_040e: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0416: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0524: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0529: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0531: Unknown result type (might be due to invalid IL or missing references)
                    //IL_06b4: Unknown result type (might be due to invalid IL or missing references)
                    //IL_06b9: Unknown result type (might be due to invalid IL or missing references)
                    //IL_06c1: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0724: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0729: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0731: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0880: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0885: Unknown result type (might be due to invalid IL or missing references)
                    //IL_088d: Unknown result type (might be due to invalid IL or missing references)
                    //IL_093e: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0943: Unknown result type (might be due to invalid IL or missing references)
                    //IL_094b: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0ac0: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0ac5: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0acd: Unknown result type (might be due to invalid IL or missing references)
                    //IL_01e6: Unknown result type (might be due to invalid IL or missing references)
                    //IL_01eb: Unknown result type (might be due to invalid IL or missing references)
                    //IL_01f0: Unknown result type (might be due to invalid IL or missing references)
                    //IL_01f4: Unknown result type (might be due to invalid IL or missing references)
                    //IL_01f9: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0253: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0259: Invalid comparison between Unknown and I4
                    //IL_043a: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0464: Unknown result type (might be due to invalid IL or missing references)
                    //IL_047f: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0767: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0777: Unknown result type (might be due to invalid IL or missing references)
                    //IL_077c: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0792: Unknown result type (might be due to invalid IL or missing references)
                    //IL_07a3: Unknown result type (might be due to invalid IL or missing references)
                    //IL_07aa: Unknown result type (might be due to invalid IL or missing references)
                    //IL_07b4: Unknown result type (might be due to invalid IL or missing references)
                    //IL_07bb: Unknown result type (might be due to invalid IL or missing references)
                    //IL_07c5: Unknown result type (might be due to invalid IL or missing references)
                    //IL_07cc: Unknown result type (might be due to invalid IL or missing references)
                    //IL_07d6: Unknown result type (might be due to invalid IL or missing references)
                    //IL_07dd: Unknown result type (might be due to invalid IL or missing references)
                    //IL_07ec: Expected O, but got Unknown
                    //IL_07f3: Unknown result type (might be due to invalid IL or missing references)
                    //IL_07f8: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0963: Unknown result type (might be due to invalid IL or missing references)
                    //IL_097c: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0981: Unknown result type (might be due to invalid IL or missing references)
                    //IL_020e: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0210: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0297: Unknown result type (might be due to invalid IL or missing references)
                    //IL_029c: Unknown result type (might be due to invalid IL or missing references)
                    //IL_02a1: Unknown result type (might be due to invalid IL or missing references)
                    //IL_02a5: Unknown result type (might be due to invalid IL or missing references)
                    //IL_02aa: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0261: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0267: Invalid comparison between Unknown and I4
                    //IL_04e1: Unknown result type (might be due to invalid IL or missing references)
                    //IL_04e6: Unknown result type (might be due to invalid IL or missing references)
                    //IL_04eb: Unknown result type (might be due to invalid IL or missing references)
                    //IL_04ef: Unknown result type (might be due to invalid IL or missing references)
                    //IL_04f4: Unknown result type (might be due to invalid IL or missing references)
                    //IL_08ba: Unknown result type (might be due to invalid IL or missing references)
                    //IL_08bf: Unknown result type (might be due to invalid IL or missing references)
                    //IL_08c4: Unknown result type (might be due to invalid IL or missing references)
                    //IL_083d: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0842: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0847: Unknown result type (might be due to invalid IL or missing references)
                    //IL_084b: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0850: Unknown result type (might be due to invalid IL or missing references)
                    //IL_02bf: Unknown result type (might be due to invalid IL or missing references)
                    //IL_02c1: Unknown result type (might be due to invalid IL or missing references)
                    //IL_030e: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0313: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0318: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0671: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0676: Unknown result type (might be due to invalid IL or missing references)
                    //IL_067b: Unknown result type (might be due to invalid IL or missing references)
                    //IL_067f: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0684: Unknown result type (might be due to invalid IL or missing references)
                    //IL_059c: Unknown result type (might be due to invalid IL or missing references)
                    //IL_05b0: Unknown result type (might be due to invalid IL or missing references)
                    //IL_05c3: Unknown result type (might be due to invalid IL or missing references)
                    //IL_05d6: Unknown result type (might be due to invalid IL or missing references)
                    //IL_05ea: Unknown result type (might be due to invalid IL or missing references)
                    //IL_05fe: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0612: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0626: Unknown result type (might be due to invalid IL or missing references)
                    //IL_063a: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0509: Unknown result type (might be due to invalid IL or missing references)
                    //IL_050b: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0865: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0867: Unknown result type (might be due to invalid IL or missing references)
                    //IL_08e8: Unknown result type (might be due to invalid IL or missing references)
                    //IL_08f4: Unknown result type (might be due to invalid IL or missing references)
                    //IL_08ff: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0904: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0908: Unknown result type (might be due to invalid IL or missing references)
                    //IL_090d: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0b1b: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0b2e: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0b41: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0b4d: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0360: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0365: Unknown result type (might be due to invalid IL or missing references)
                    //IL_036a: Unknown result type (might be due to invalid IL or missing references)
                    //IL_036e: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0373: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0699: Unknown result type (might be due to invalid IL or missing references)
                    //IL_069b: Unknown result type (might be due to invalid IL or missing references)
                    //IL_06de: Unknown result type (might be due to invalid IL or missing references)
                    //IL_06e4: Unknown result type (might be due to invalid IL or missing references)
                    //IL_06e6: Unknown result type (might be due to invalid IL or missing references)
                    //IL_06eb: Unknown result type (might be due to invalid IL or missing references)
                    //IL_06ef: Unknown result type (might be due to invalid IL or missing references)
                    //IL_06f4: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0923: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0925: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0388: Unknown result type (might be due to invalid IL or missing references)
                    //IL_038a: Unknown result type (might be due to invalid IL or missing references)
                    //IL_03cb: Unknown result type (might be due to invalid IL or missing references)
                    //IL_03d0: Unknown result type (might be due to invalid IL or missing references)
                    //IL_03d4: Unknown result type (might be due to invalid IL or missing references)
                    //IL_03d9: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0709: Unknown result type (might be due to invalid IL or missing references)
                    //IL_070b: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0a7c: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0a81: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0a86: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0a8a: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0a8f: Unknown result type (might be due to invalid IL or missing references)
                    //IL_03ee: Unknown result type (might be due to invalid IL or missing references)
                    //IL_03f0: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0aa5: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0aa7: Unknown result type (might be due to invalid IL or missing references)
                    int num = <>1__state;
                    ImageDownloader imageDownloader = <>4__this;
                    try
                    {
                        UniTask val;
                        Awaiter awaiter;
                        int num2;
                        switch (num)
                        {
                        default:
                            <>7__wrap2 = 0;
                            goto case 0;
                        case 0:
                        case 1:
                        case 2:
                        case 3:
                        case 4:
                        case 5:
                        case 6:
                        case 7:
                        case 8:
                        case 9:
                        case 10:
                            try
                            {
                                if (num != 0)
                                {
                                    if ((uint)(num - 1) <= 9u)
                                    {
                                        goto IL_015d;
                                    }
                                    if (CanBypassDelay != null && CanBypassDelay.Invoke())
                                    {
                                        goto IL_0101;
                                    }
                                    val = UniTask.WaitWhile((Func<bool>)(() => Time.realtimeSinceStartup - _lastImageRequest < 5f), (PlayerLoopTiming)8, cancellationToken);
                                    awaiter = ((UniTask)(ref val)).GetAwaiter();
                                    if (!((Awaiter)(ref awaiter)).IsCompleted)
                                    {
                                        num = (<>1__state = 0);
                                        <>u__1 = awaiter;
                                        ((AsyncUniTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<Awaiter, <DownloadImage>d__51>(ref awaiter, ref this);
                                        return;
                                    }
                                }
                                else
                                {
                                    awaiter = <>u__1;
                                    <>u__1 = default(Awaiter);
                                    num = (<>1__state = -1);
                                }
                                ((Awaiter)(ref awaiter)).GetResult();
                                goto IL_0101;
                                IL_0101:
                                if (!((CancellationToken)(ref cancellationToken)).IsCancellationRequested && imageDownloader.State != VRCImageDownloadState.Unloaded)
                                {
                                    Debug.Log((object)String.Concat("[Image Download] Attempting to load image from URL '", uri.AbsoluteUri, "'"));
                                    _lastImageRequest = Time.realtimeSinceStartup;
                                    <outputBuffer>5__4 = new NativeArray<byte>(33554432, (Allocator)4, (NativeArrayOptions)0);
                                    goto IL_015d;
                                }
                                goto end_IL_0054;
                                IL_015d:
                                try
                                {
                                    if ((uint)(num - 1) > 9u)
                                    {
                                        <webRequest>5__5 = new UnityWebRequest(uri, "GET", (DownloadHandler)new DownloadHandlerBuffer(), (UploadHandler)null);
                                    }
                                    try
                                    {
                                        Awaiter<UnityWebRequest> awaiter4;
                                        Awaiter awaiter3;
                                        Awaiter awaiter2;
                                        SwitchToThreadPoolAwaitable val2;
                                        int width;
                                        int height;
                                        ImageLoadSettings settings;
                                        ImageResult imageResult;
                                        SwitchToMainThreadAwaitable val3;
                                        switch (num)
                                        {
                                        default:
                                            <webRequest>5__5.redirectLimit = 0;
                                            UnityWebRequest.ClearCookieCache(uri);
                                            awaiter4 = UnityAsyncExtensions.ToUniTask(<webRequest>5__5.SendWebRequest(), (IProgress<float>)(object)new Progress<float>((Action<float>)imageDownloader.SetProgress), (PlayerLoopTiming)8, cancellationToken).GetAwaiter();
                                            if (!awaiter4.IsCompleted)
                                            {
                                                num = (<>1__state = 1);
                                                <>u__2 = awaiter4;
                                                ((AsyncUniTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<Awaiter<UnityWebRequest>, <DownloadImage>d__51>(ref awaiter4, ref this);
                                                return;
                                            }
                                            goto IL_0245;
                                        case 1:
                                            awaiter4 = <>u__2;
                                            <>u__2 = default(Awaiter<UnityWebRequest>);
                                            num = (<>1__state = -1);
                                            goto IL_0245;
                                        case 2:
                                            awaiter = <>u__1;
                                            <>u__1 = default(Awaiter);
                                            num = (<>1__state = -1);
                                            goto IL_02f6;
                                        case 3:
                                            awaiter = <>u__1;
                                            <>u__1 = default(Awaiter);
                                            num = (<>1__state = -1);
                                            goto IL_03bf;
                                        case 4:
                                            awaiter3 = <>u__3;
                                            <>u__3 = default(Awaiter);
                                            num = (<>1__state = -1);
                                            goto IL_0425;
                                        case 5:
                                            awaiter = <>u__1;
                                            <>u__1 = default(Awaiter);
                                            num = (<>1__state = -1);
                                            goto IL_0540;
                                        case 6:
                                            awaiter = <>u__1;
                                            <>u__1 = default(Awaiter);
                                            num = (<>1__state = -1);
                                            goto IL_06d0;
                                        case 7:
                                            awaiter2 = <>u__4;
                                            <>u__4 = default(Awaiter);
                                            num = (<>1__state = -1);
                                            goto IL_0740;
                                        case 8:
                                            awaiter = <>u__1;
                                            <>u__1 = default(Awaiter);
                                            num = (<>1__state = -1);
                                            goto IL_089c;
                                        case 9:
                                            awaiter = <>u__1;
                                            <>u__1 = default(Awaiter);
                                            num = (<>1__state = -1);
                                            goto IL_095a;
                                        case 10:
                                            {
                                                awaiter = <>u__1;
                                                <>u__1 = default(Awaiter);
                                                num = (<>1__state = -1);
                                                break;
                                            }
                                            IL_0540:
                                            ((Awaiter)(ref awaiter)).GetResult();
                                            goto end_IL_0054;
                                            IL_0245:
                                            awaiter4.GetResult();
                                            if ((int)<webRequest>5__5.result == 3 || (int)<webRequest>5__5.result == 2)
                                            {
                                                imageDownloader.State = VRCImageDownloadState.Error;
                                                imageDownloader.Error = VRCImageDownloadError.DownloadError;
                                                imageDownloader.ErrorMessage = <webRequest>5__5.error;
                                                val = imageDownloader.RunUdonEventOnMainThreadAndRemoveFromQueue("_onImageLoadError", new ValueTuple<string, object>("IVRCImageDownload", (object)imageDownloader));
                                                awaiter = ((UniTask)(ref val)).GetAwaiter();
                                                if (!((Awaiter)(ref awaiter)).IsCompleted)
                                                {
                                                    num = (<>1__state = 2);
                                                    <>u__1 = awaiter;
                                                    ((AsyncUniTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<Awaiter, <DownloadImage>d__51>(ref awaiter, ref this);
                                                    return;
                                                }
                                                goto IL_02f6;
                                            }
                                            <downloadBuffer>5__6 = ((DownloadHandler)(DownloadHandlerBuffer)<webRequest>5__5.downloadHandler).nativeData;
                                            if (!<downloadBuffer>5__6.IsCreated || <downloadBuffer>5__6.Length <= 0)
                                            {
                                                imageDownloader.State = VRCImageDownloadState.Error;
                                                imageDownloader.Error = VRCImageDownloadError.DownloadError;
                                                imageDownloader.ErrorMessage = "Failed to retrieve any data.";
                                                val = imageDownloader.RunUdonEventOnMainThreadAndRemoveFromQueue("_onImageLoadError", new ValueTuple<string, object>("IVRCImageDownload", (object)imageDownloader));
                                                awaiter = ((UniTask)(ref val)).GetAwaiter();
                                                if (!((Awaiter)(ref awaiter)).IsCompleted)
                                                {
                                                    num = (<>1__state = 3);
                                                    <>u__1 = awaiter;
                                                    ((AsyncUniTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<Awaiter, <DownloadImage>d__51>(ref awaiter, ref this);
                                                    return;
                                                }
                                                goto IL_03bf;
                                            }
                                            val2 = UniTask.SwitchToThreadPool();
                                            awaiter3 = ((SwitchToThreadPoolAwaitable)(ref val2)).GetAwaiter();
                                            if (!((Awaiter)(ref awaiter3)).IsCompleted)
                                            {
                                                num = (<>1__state = 4);
                                                <>u__3 = awaiter3;
                                                ((AsyncUniTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<Awaiter, <DownloadImage>d__51>(ref awaiter3, ref this);
                                                return;
                                            }
                                            goto IL_0425;
                                            IL_02f6:
                                            ((Awaiter)(ref awaiter)).GetResult();
                                            goto end_IL_0054;
                                            IL_089c:
                                            ((Awaiter)(ref awaiter)).GetResult();
                                            goto end_IL_0054;
                                            IL_0740:
                                            ((Awaiter)(ref awaiter2)).GetResult();
                                            width = (int)<imageInfo>5__7.width;
                                            height = (int)<imageInfo>5__7.height;
                                            <outputTexture>5__10 = new Texture2D(width, height, <format>5__8, imageDownloader.TextureInfo.GenerateMipMaps)
                                            {
                                                name = String.Format("ImageFrom:{0}", (object)uri),
                                                anisoLevel = imageDownloader.TextureInfo.AnisoLevel,
                                                filterMode = imageDownloader.TextureInfo.FilterMode,
                                                wrapModeU = imageDownloader.TextureInfo.WrapModeU,
                                                wrapModeV = imageDownloader.TextureInfo.WrapModeV,
                                                wrapModeW = imageDownloader.TextureInfo.WrapModeW
                                            };
                                            <outputTextureRawData>5__11 = <outputTexture>5__10.GetRawTextureData<byte>();
                                            if (<outputTextureRawData>5__11.Length > <outputBuffer>5__4.Length)
                                            {
                                                imageDownloader.State = VRCImageDownloadState.Error;
                                                imageDownloader.Error = VRCImageDownloadError.DownloadError;
                                                imageDownloader.ErrorMessage = "Decoded image was smaller than expected.";
                                                val = imageDownloader.RunUdonEventOnMainThreadAndRemoveFromQueue("_onImageLoadError", new ValueTuple<string, object>("IVRCImageDownload", (object)imageDownloader));
                                                awaiter = ((UniTask)(ref val)).GetAwaiter();
                                                if (!((Awaiter)(ref awaiter)).IsCompleted)
                                                {
                                                    num = (<>1__state = 8);
                                                    <>u__1 = awaiter;
                                                    ((AsyncUniTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<Awaiter, <DownloadImage>d__51>(ref awaiter, ref this);
                                                    return;
                                                }
                                                goto IL_089c;
                                            }
                                            <mipLevelWidth>5__12 = width;
                                            <mipLevelHeight>5__13 = height;
                                            <outputSlice>5__14 = NativeSlice<byte>.op_Implicit(<outputBuffer>5__4);
                                            <mipLevel>5__15 = 0;
                                            goto IL_09d4;
                                            IL_03bf:
                                            ((Awaiter)(ref awaiter)).GetResult();
                                            goto end_IL_0054;
                                            IL_06d0:
                                            ((Awaiter)(ref awaiter)).GetResult();
                                            goto end_IL_0054;
                                            IL_0425:
                                            ((Awaiter)(ref awaiter3)).GetResult();
                                            settings = default(ImageLoadSettings).SetResolutionLimit(new Nullable<uint>(2048u)).SetVerticalFlip(flip: true).SetGenerateMipMaps(imageDownloader.TextureInfo.GenerateMipMaps);
                                            imageResult = LoadImage((System.IntPtr)NativeArrayUnsafeUtility.GetUnsafeReadOnlyPtr<byte>(<downloadBuffer>5__6), (uint)<downloadBuffer>5__6.Length, (System.IntPtr)NativeArrayUnsafeUtility.GetUnsafePtr<byte>(<outputBuffer>5__4), (uint)<outputBuffer>5__4.Length, settings);
                                            if (imageResult.success < 1)
                                            {
                                                imageDownloader.State = VRCImageDownloadState.Error;
                                                imageDownloader.Error = VRCImageDownloadError.InvalidImage;
                                                imageDownloader.ErrorMessage = String.Format("Failed to load file: {0}", (object)imageResult.error);
                                                val = imageDownloader.RunUdonEventOnMainThreadAndRemoveFromQueue("_onImageLoadError", new ValueTuple<string, object>("IVRCImageDownload", (object)imageDownloader));
                                                awaiter = ((UniTask)(ref val)).GetAwaiter();
                                                if (!((Awaiter)(ref awaiter)).IsCompleted)
                                                {
                                                    num = (<>1__state = 5);
                                                    <>u__1 = awaiter;
                                                    ((AsyncUniTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<Awaiter, <DownloadImage>d__51>(ref awaiter, ref this);
                                                    return;
                                                }
                                                goto IL_0540;
                                            }
                                            <imageInfo>5__7 = imageResult.info;
                                            switch (<imageInfo>5__7.format)
                                            {
                                            case ImageFormat.R8:
                                                <format>5__8 = (TextureFormat)63;
                                                <bytesPerPixel>5__9 = 1;
                                                goto IL_06dc;
                                            case ImageFormat.RG16:
                                                <format>5__8 = (TextureFormat)62;
                                                <bytesPerPixel>5__9 = 2;
                                                goto IL_06dc;
                                            case ImageFormat.RGB24:
                                                <format>5__8 = (TextureFormat)3;
                                                <bytesPerPixel>5__9 = 3;
                                                goto IL_06dc;
                                            case ImageFormat.RGBA32:
                                                <format>5__8 = (TextureFormat)4;
                                                <bytesPerPixel>5__9 = 4;
                                                goto IL_06dc;
                                            case ImageFormat.R16:
                                                <format>5__8 = (TextureFormat)9;
                                                <bytesPerPixel>5__9 = 2;
                                                goto IL_06dc;
                                            case ImageFormat.RG32:
                                                <format>5__8 = (TextureFormat)72;
                                                <bytesPerPixel>5__9 = 4;
                                                goto IL_06dc;
                                            case ImageFormat.RGB48:
                                                <format>5__8 = (TextureFormat)73;
                                                <bytesPerPixel>5__9 = 6;
                                                goto IL_06dc;
                                            case ImageFormat.RGBA64:
                                                <format>5__8 = (TextureFormat)74;
                                                <bytesPerPixel>5__9 = 8;
                                                goto IL_06dc;
                                            case ImageFormat.RGBAFloat:
                                                {
                                                    <format>5__8 = (TextureFormat)20;
                                                    <bytesPerPixel>5__9 = 16;
                                                    goto IL_06dc;
                                                }
                                                IL_06dc:
                                                val3 = UniTask.SwitchToMainThread(default(CancellationToken));
                                                awaiter2 = ((SwitchToMainThreadAwaitable)(ref val3)).GetAwaiter();
                                                if (!((Awaiter)(ref awaiter2)).IsCompleted)
                                                {
                                                    num = (<>1__state = 7);
                                                    <>u__4 = awaiter2;
                                                    ((AsyncUniTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<Awaiter, <DownloadImage>d__51>(ref awaiter2, ref this);
                                                    return;
                                                }
                                                goto IL_0740;
                                            }
                                            imageDownloader.State = VRCImageDownloadState.Error;
                                            imageDownloader.Error = VRCImageDownloadError.DownloadError;
                                            imageDownloader.ErrorMessage = "Invalid image file.";
                                            val = imageDownloader.RunUdonEventOnMainThreadAndRemoveFromQueue("_onImageLoadError", new ValueTuple<string, object>("IVRCImageDownload", (object)imageDownloader));
                                            awaiter = ((UniTask)(ref val)).GetAwaiter();
                                            if (!((Awaiter)(ref awaiter)).IsCompleted)
                                            {
                                                num = (<>1__state = 6);
                                                <>u__1 = awaiter;
                                                ((AsyncUniTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<Awaiter, <DownloadImage>d__51>(ref awaiter, ref this);
                                                return;
                                            }
                                            goto IL_06d0;
                                            IL_09d4:
                                            if (<mipLevel>5__15 < ((Texture)<outputTexture>5__10).mipmapCount)
                                            {
                                                val = <DownloadImage>g__SlicedTextureUpload|51_0(<mipLevelWidth>5__12, <mipLevelHeight>5__13, <bytesPerPixel>5__9, <format>5__8, <mipLevel>5__15, <outputSlice>5__14, <outputTexture>5__10);
                                                awaiter = ((UniTask)(ref val)).GetAwaiter();
                                                if (!((Awaiter)(ref awaiter)).IsCompleted)
                                                {
                                                    num = (<>1__state = 9);
                                                    <>u__1 = awaiter;
                                                    ((AsyncUniTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<Awaiter, <DownloadImage>d__51>(ref awaiter, ref this);
                                                    return;
                                                }
                                                goto IL_095a;
                                            }
                                            imageDownloader._sizeInMemoryBytes = <outputTextureRawData>5__11.Length;
                                            imageDownloader.Result = <outputTexture>5__10;
                                            if ((Object)(object)<outputTexture>5__10 != (Object)null)
                                            {
                                                DPIDMipmapper.GenerateDPIDMipmapsFast(<outputTexture>5__10, true, true, false, false);
                                            }
                                            imageDownloader.State = VRCImageDownloadState.Complete;
                                            if ((Object)(object)imageDownloader.Material != (Object)null)
                                            {
                                                if (imageDownloader.TextureInfo != null)
                                                {
                                                    imageDownloader.Material.SetTexture(imageDownloader.TextureInfo.MaterialProperty, (Texture)(object)imageDownloader.Result);
                                                }
                                                else
                                                {
                                                    imageDownloader.Material.mainTexture = (Texture)(object)imageDownloader.Result;
                                                }
                                            }
                                            val = imageDownloader.RunUdonEventOnMainThreadAndRemoveFromQueue("_onImageLoadSuccess", new ValueTuple<string, object>("IVRCImageDownload", (object)imageDownloader));
                                            awaiter = ((UniTask)(ref val)).GetAwaiter();
                                            if (!((Awaiter)(ref awaiter)).IsCompleted)
                                            {
                                                num = (<>1__state = 10);
                                                <>u__1 = awaiter;
                                                ((AsyncUniTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<Awaiter, <DownloadImage>d__51>(ref awaiter, ref this);
                                                return;
                                            }
                                            break;
                                            IL_095a:
                                            ((Awaiter)(ref awaiter)).GetResult();
                                            <outputSlice>5__14 = NativeSliceExtensions.Slice<byte>(<outputSlice>5__14, <mipLevelWidth>5__12 * <mipLevelHeight>5__13 * <bytesPerPixel>5__9);
                                            <mipLevelWidth>5__12 = Mathf.Max(1, Mathf.FloorToInt((float)<mipLevelWidth>5__12 / 2f));
                                            <mipLevelHeight>5__13 = Mathf.Max(1, Mathf.FloorToInt((float)<mipLevelHeight>5__13 / 2f));
                                            <mipLevel>5__15++;
                                            goto IL_09d4;
                                        }
                                        ((Awaiter)(ref awaiter)).GetResult();
                                    }
                                    finally
                                    {
                                        if (num < 0 && <webRequest>5__5 != null)
                                        {
                                            ((IDisposable)<webRequest>5__5).Dispose();
                                        }
                                    }
                                }
                                finally
                                {
                                    if (num < 0)
                                    {
                                        ((IDisposable)<outputBuffer>5__4).Dispose();
                                    }
                                }
                                <outputBuffer>5__4 = default(NativeArray<byte>);
                                <webRequest>5__5 = null;
                                <downloadBuffer>5__6 = default(ReadOnly<byte>);
                                <outputTexture>5__10 = null;
                                <outputTextureRawData>5__11 = default(NativeArray<byte>);
                                <outputSlice>5__14 = default(NativeSlice<byte>);
                                goto IL_0b7b;
                                end_IL_0054:;
                            }
                            catch (OperationCanceledException val4)
                            {
                                OperationCanceledException val5 = val4;
                                <>7__wrap1 = val5;
                                <>7__wrap2 = 1;
                                goto IL_0b7b;
                            }
                            catch (UnityWebRequestException val6)
                            {
                                UnityWebRequestException val7 = val6;
                                <>7__wrap1 = val7;
                                <>7__wrap2 = 2;
                                goto IL_0b7b;
                            }
                            goto end_IL_000e;
                        case 11:
                            awaiter = <>u__1;
                            <>u__1 = default(Awaiter);
                            num = (<>1__state = -1);
                            goto IL_0c13;
                        case 12:
                            awaiter = <>u__1;
                            <>u__1 = default(Awaiter);
                            num = (<>1__state = -1);
                            goto IL_0cdf;
                        case 13:
                            {
                                awaiter = <>u__1;
                                <>u__1 = default(Awaiter);
                                num = (<>1__state = -1);
                                goto IL_0d8e;
                            }
                            IL_0b7b:
                            num2 = <>7__wrap2;
                            if (num2 != 1)
                            {
                                if (num2 != 2)
                                {
                                    break;
                                }
                                UnityWebRequestException val8 = (UnityWebRequestException)<>7__wrap1;
                                if (((Exception)val8).Message == "Unable to write data")
                                {
                                    Debug.Log((object)String.Concat("[Image Download] Loading image from URL '", uri.AbsoluteUri, "' failed because the image was too large."));
                                    imageDownloader.Error = VRCImageDownloadError.DownloadError;
                                    imageDownloader.ErrorMessage = "image was too large";
                                    val = imageDownloader.RunUdonEventOnMainThreadAndRemoveFromQueue("_onImageLoadError", new ValueTuple<string, object>("IVRCImageDownload", (object)imageDownloader));
                                    awaiter = ((UniTask)(ref val)).GetAwaiter();
                                    if (!((Awaiter)(ref awaiter)).IsCompleted)
                                    {
                                        num = (<>1__state = 12);
                                        <>u__1 = awaiter;
                                        ((AsyncUniTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<Awaiter, <DownloadImage>d__51>(ref awaiter, ref this);
                                        return;
                                    }
                                    goto IL_0cdf;
                                }
                                Debug.Log((object)String.Concat("[Image Download] A web request exception occurred while loading image from URL '", uri.AbsoluteUri, "'. Exception: ", val8.Error));
                                imageDownloader.Error = VRCImageDownloadError.DownloadError;
                                imageDownloader.ErrorMessage = val8.Error;
                                val = imageDownloader.RunUdonEventOnMainThreadAndRemoveFromQueue("_onImageLoadError", new ValueTuple<string, object>("IVRCImageDownload", (object)imageDownloader));
                                awaiter = ((UniTask)(ref val)).GetAwaiter();
                                if (!((Awaiter)(ref awaiter)).IsCompleted)
                                {
                                    num = (<>1__state = 13);
                                    <>u__1 = awaiter;
                                    ((AsyncUniTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<Awaiter, <DownloadImage>d__51>(ref awaiter, ref this);
                                    return;
                                }
                                goto IL_0d8e;
                            }
                            imageDownloader.Error = VRCImageDownloadError.Unknown;
                            imageDownloader.ErrorMessage = "Canceled loading image";
                            val = imageDownloader.RunUdonEventOnMainThreadAndRemoveFromQueue("_onImageLoadError", new ValueTuple<string, object>("IVRCImageDownload", (object)imageDownloader));
                            awaiter = ((UniTask)(ref val)).GetAwaiter();
                            if (!((Awaiter)(ref awaiter)).IsCompleted)
                            {
                                num = (<>1__state = 11);
                                <>u__1 = awaiter;
                                ((AsyncUniTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<Awaiter, <DownloadImage>d__51>(ref awaiter, ref this);
                                return;
                            }
                            goto IL_0c13;
                            IL_0cdf:
                            ((Awaiter)(ref awaiter)).GetResult();
                            goto end_IL_000e;
                            IL_0d8e:
                            ((Awaiter)(ref awaiter)).GetResult();
                            break;
                            IL_0c13:
                            ((Awaiter)(ref awaiter)).GetResult();
                            break;
                        }
                        <>7__wrap1 = null;
                        end_IL_000e:;
                    }
                    catch (Exception val9)
                    {
                        Exception exception = val9;
                        <>1__state = -2;
                        ((AsyncUniTaskMethodBuilder)(ref <>t__builder)).SetException(exception);
                        return;
                    }
                    <>1__state = -2;
                    ((AsyncUniTaskMethodBuilder)(ref <>t__builder)).SetResult();
                }
 
                [DebuggerHidden]
                private void SetStateMachine(IAsyncStateMachine stateMachine)
                {
                    ((AsyncUniTaskMethodBuilder)(ref <>t__builder)).SetStateMachine(stateMachine);
                }
            }
 
            [StructLayout(3)]
            [CompilerGenerated]
            private struct <RunUdonEventOnMainThreadAndRemoveFromQueue>d__52 : ValueType, IAsyncStateMachine
            {
                public int <>1__state;
 
                public AsyncUniTaskMethodBuilder <>t__builder;
 
                public ImageDownloader <>4__this;
 
                public string eventName;
 
                public ValueTuple<string, object> argument;
 
                private Awaiter <>u__1;
 
                private void MoveNext()
                {
                    //IL_00a4: Expected O, but got Unknown
                    //IL_0053: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0058: Unknown result type (might be due to invalid IL or missing references)
                    //IL_005f: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0013: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0019: Unknown result type (might be due to invalid IL or missing references)
                    //IL_001a: Unknown result type (might be due to invalid IL or missing references)
                    //IL_001f: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0023: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0028: Unknown result type (might be due to invalid IL or missing references)
                    //IL_008a: Unknown result type (might be due to invalid IL or missing references)
                    //IL_008f: Unknown result type (might be due to invalid IL or missing references)
                    //IL_003c: Unknown result type (might be due to invalid IL or missing references)
                    //IL_003d: Unknown result type (might be due to invalid IL or missing references)
                    int num = <>1__state;
                    ImageDownloader imageDownloader = <>4__this;
                    try
                    {
                        Awaiter awaiter;
                        if (num != 0)
                        {
                            SwitchToMainThreadAwaitable val = UniTask.SwitchToMainThread(default(CancellationToken));
                            awaiter = ((SwitchToMainThreadAwaitable)(ref val)).GetAwaiter();
                            if (!((Awaiter)(ref awaiter)).IsCompleted)
                            {
                                num = (<>1__state = 0);
                                <>u__1 = awaiter;
                                ((AsyncUniTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<Awaiter, <RunUdonEventOnMainThreadAndRemoveFromQueue>d__52>(ref awaiter, ref this);
                                return;
                            }
                        }
                        else
                        {
                            awaiter = <>u__1;
                            <>u__1 = default(Awaiter);
                            num = (<>1__state = -1);
                        }
                        ((Awaiter)(ref awaiter)).GetResult();
                        imageDownloader.UdonBehaviour.RunEvent(eventName, new ValueTuple<string, object>[1] { argument });
                        RemoveImageDownloadFromQueue(imageDownloader);
                    }
                    catch (Exception val2)
                    {
                        Exception exception = val2;
                        <>1__state = -2;
                        ((AsyncUniTaskMethodBuilder)(ref <>t__builder)).SetException(exception);
                        return;
                    }
                    <>1__state = -2;
                    ((AsyncUniTaskMethodBuilder)(ref <>t__builder)).SetResult();
                }
 
                [DebuggerHidden]
                private void SetStateMachine(IAsyncStateMachine stateMachine)
                {
                    ((AsyncUniTaskMethodBuilder)(ref <>t__builder)).SetStateMachine(stateMachine);
                }
            }
 
            private const string NATIVE_LIB = "vrc_image_loader";
 
            private const float MINIMUM_DELAY_BETWEEN_REQUESTS = 5f;
 
            private const int MAXIMUM_DIMENSION = 2048;
 
            private const int MAX_BUFFER_SIZE = 33554432;
 
            private const int SLICE_SIZE_BYTES = 1048576;
 
            private static float _lastImageRequest;
 
            protected CancellationTokenSource _cancellationTokenSource;
 
            private int _sizeInMemoryBytes;
 
            [field: CompilerGenerated]
            public VRCImageDownloadState State
            {
                [CompilerGenerated]
                get;
                [CompilerGenerated]
                protected set;
            }
 
            [field: CompilerGenerated]
            public VRCImageDownloadError Error
            {
                [CompilerGenerated]
                get;
                [CompilerGenerated]
                protected set;
            }
 
            [field: CompilerGenerated]
            public string ErrorMessage
            {
                [CompilerGenerated]
                get;
                [CompilerGenerated]
                protected set;
            }
 
            [field: CompilerGenerated]
            public Texture2D Result
            {
                [CompilerGenerated]
                get;
                [CompilerGenerated]
                protected set;
            }
 
            public int SizeInMemoryBytes
            {
                get
                {
                    if (!((Object)(object)Result != (Object)null))
                    {
                        return 0;
                    }
                    return _sizeInMemoryBytes;
                }
            }
 
            [field: CompilerGenerated]
            public float Progress
            {
                [CompilerGenerated]
                get;
                [CompilerGenerated]
                protected set;
            }
 
            [field: CompilerGenerated]
            public VRCUrl Url
            {
                [CompilerGenerated]
                get;
                [CompilerGenerated]
                protected set;
            }
 
            [field: CompilerGenerated]
            public Material Material
            {
                [CompilerGenerated]
                get;
                [CompilerGenerated]
                protected set;
            }
 
            [field: CompilerGenerated]
            public IUdonEventReceiver UdonBehaviour
            {
                [CompilerGenerated]
                get;
                [CompilerGenerated]
                protected set;
            }
 
            [field: CompilerGenerated]
            public TextureInfo TextureInfo
            {
                [CompilerGenerated]
                get;
                [CompilerGenerated]
                protected set;
            }
 
            [DllImport("vrc_image_loader", CallingConvention = 2, EntryPoint = "load_image")]
            private static extern ImageResult LoadImage(System.IntPtr inputBytes, uint inputBytesLength, System.IntPtr outputBuffer, uint outputBufferLength, ImageLoadSettings settings);
 
            public static IVRCImageDownload DownloadImage(VRCUrl url, Material material, IUdonEventReceiver udonBehaviour, TextureInfo textureInfo)
            {
                return new ImageDownloader(url, material, udonBehaviour, textureInfo);
            }
 
            public ImageDownloader(VRCUrl url, Material material, IUdonEventReceiver udonBehaviour = null, TextureInfo textureInfo = null)
            {
                //IL_000e: Unknown result type (might be due to invalid IL or missing references)
                //IL_0018: Expected O, but got Unknown
                Url = url;
                _cancellationTokenSource = new CancellationTokenSource();
                Material = material;
                UdonBehaviour = udonBehaviour;
                TextureInfo = textureInfo ?? new TextureInfo();
            }
 
            public virtual void StartDownload()
            {
                //IL_0083: Unknown result type (might be due to invalid IL or missing references)
                //IL_0032: Unknown result type (might be due to invalid IL or missing references)
                //IL_0050: Unknown result type (might be due to invalid IL or missing references)
                //IL_0056: Expected O, but got Unknown
                //IL_00ec: Unknown result type (might be due to invalid IL or missing references)
                //IL_0106: Unknown result type (might be due to invalid IL or missing references)
                //IL_010b: Unknown result type (might be due to invalid IL or missing references)
                if (!AddImageDownloadToQueue(this))
                {
                    State = VRCImageDownloadState.Error;
                    Error = VRCImageDownloadError.TooManyRequests;
                    ErrorMessage = "Client has too many requests (limit is 1000).";
                    UdonBehaviour.RunEvent<ImageDownloader>("_onImageLoadError", new ValueTuple<string, ImageDownloader>("IVRCImageDownload", this));
                    return;
                }
                State = VRCImageDownloadState.Pending;
                Uri val;
                try
                {
                    val = new Uri(Url.Get());
                }
                catch (Exception)
                {
                    State = VRCImageDownloadState.Error;
                    Error = VRCImageDownloadError.InvalidURL;
                    ErrorMessage = "Invalid URL";
                    UdonBehaviour.RunEvent<ImageDownloader>("_onImageLoadError", new ValueTuple<string, ImageDownloader>("IVRCImageDownload", this));
                    RemoveImageDownloadFromQueue(this);
                    return;
                }
                if (!val.IsAbsoluteUri || (val.Scheme != Uri.UriSchemeHttps && val.Scheme != Uri.UriSchemeHttp))
                {
                    State = VRCImageDownloadState.Error;
                    Error = VRCImageDownloadError.InvalidURL;
                    ErrorMessage = "Images may only be downloaded from HTTP(S) URLs.";
                    UdonBehaviour.RunEvent<ImageDownloader>("_onImageLoadError", new ValueTuple<string, ImageDownloader>("IVRCImageDownload", this));
                    RemoveImageDownloadFromQueue(this);
                }
                else
                {
                    UniTaskExtensions.Forget(DownloadImage(val, _cancellationTokenSource.Token));
                }
            }
 
            private void SetProgress(float progress)
            {
                Progress = progress;
            }
 
            [AsyncStateMachine(/*Could not decode attribute arguments.*/)]
            protected UniTask DownloadImage(Uri uri, CancellationToken cancellationToken)
            {
                //IL_0002: Unknown result type (might be due to invalid IL or missing references)
                //IL_0007: Unknown result type (might be due to invalid IL or missing references)
                //IL_001e: Unknown result type (might be due to invalid IL or missing references)
                //IL_001f: Unknown result type (might be due to invalid IL or missing references)
                //IL_0041: Unknown result type (might be due to invalid IL or missing references)
                <DownloadImage>d__51 <DownloadImage>d__ = default(<DownloadImage>d__51);
                <DownloadImage>d__.<>t__builder = AsyncUniTaskMethodBuilder.Create();
                <DownloadImage>d__.<>4__this = this;
                <DownloadImage>d__.uri = uri;
                <DownloadImage>d__.cancellationToken = cancellationToken;
                <DownloadImage>d__.<>1__state = -1;
                ((AsyncUniTaskMethodBuilder)(ref <DownloadImage>d__.<>t__builder)).Start<<DownloadImage>d__51>(ref <DownloadImage>d__);
                return ((AsyncUniTaskMethodBuilder)(ref <DownloadImage>d__.<>t__builder)).Task;
            }
 
            [AsyncStateMachine(/*Could not decode attribute arguments.*/)]
            private UniTask RunUdonEventOnMainThreadAndRemoveFromQueue(string eventName, ValueTuple<string, object> argument)
            {
                //IL_0002: Unknown result type (might be due to invalid IL or missing references)
                //IL_0007: Unknown result type (might be due to invalid IL or missing references)
                //IL_001e: Unknown result type (might be due to invalid IL or missing references)
                //IL_001f: Unknown result type (might be due to invalid IL or missing references)
                //IL_0041: Unknown result type (might be due to invalid IL or missing references)
                <RunUdonEventOnMainThreadAndRemoveFromQueue>d__52 <RunUdonEventOnMainThreadAndRemoveFromQueue>d__ = default(<RunUdonEventOnMainThreadAndRemoveFromQueue>d__52);
                <RunUdonEventOnMainThreadAndRemoveFromQueue>d__.<>t__builder = AsyncUniTaskMethodBuilder.Create();
                <RunUdonEventOnMainThreadAndRemoveFromQueue>d__.<>4__this = this;
                <RunUdonEventOnMainThreadAndRemoveFromQueue>d__.eventName = eventName;
                <RunUdonEventOnMainThreadAndRemoveFromQueue>d__.argument = argument;
                <RunUdonEventOnMainThreadAndRemoveFromQueue>d__.<>1__state = -1;
                ((AsyncUniTaskMethodBuilder)(ref <RunUdonEventOnMainThreadAndRemoveFromQueue>d__.<>t__builder)).Start<<RunUdonEventOnMainThreadAndRemoveFromQueue>d__52>(ref <RunUdonEventOnMainThreadAndRemoveFromQueue>d__);
                return ((AsyncUniTaskMethodBuilder)(ref <RunUdonEventOnMainThreadAndRemoveFromQueue>d__.<>t__builder)).Task;
            }
 
            public void Dispose()
            {
                //IL_003c: Unknown result type (might be due to invalid IL or missing references)
                //IL_0041: Unknown result type (might be due to invalid IL or missing references)
                CancellationTokenSource cancellationTokenSource = _cancellationTokenSource;
                if (cancellationTokenSource != null)
                {
                    cancellationTokenSource.Cancel();
                }
                CancellationTokenSource cancellationTokenSource2 = _cancellationTokenSource;
                if (cancellationTokenSource2 != null)
                {
                    cancellationTokenSource2.Dispose();
                }
                _cancellationTokenSource = null;
                State = VRCImageDownloadState.Unloaded;
                RemoveImageDownloadFromQueue(this);
                UniTaskVoid val = DestroyAsync((Object)(object)Result);
                ((UniTaskVoid)(ref val)).Forget();
                Result = null;
                GC.SuppressFinalize((object)this);
                [AsyncStateMachine(/*Could not decode attribute arguments.*/)]
                [CompilerGenerated]
                static UniTaskVoid DestroyAsync(Object obj)
                {
                    //IL_0002: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0007: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0031: Unknown result type (might be due to invalid IL or missing references)
                    <<Dispose>g__DestroyAsync|53_0>d <<Dispose>g__DestroyAsync|53_0>d = default(<<Dispose>g__DestroyAsync|53_0>d);
                    <<Dispose>g__DestroyAsync|53_0>d.<>t__builder = AsyncUniTaskVoidMethodBuilder.Create();
                    <<Dispose>g__DestroyAsync|53_0>d.obj = obj;
                    <<Dispose>g__DestroyAsync|53_0>d.<>1__state = -1;
                    ((AsyncUniTaskVoidMethodBuilder)(ref <<Dispose>g__DestroyAsync|53_0>d.<>t__builder)).Start<<<Dispose>g__DestroyAsync|53_0>d>(ref <<Dispose>g__DestroyAsync|53_0>d);
                    return ((AsyncUniTaskVoidMethodBuilder)(ref <<Dispose>g__DestroyAsync|53_0>d.<>t__builder)).Task;
                }
            }
 
            public void CancelDownload()
            {
                CancellationTokenSource cancellationTokenSource = _cancellationTokenSource;
                if (cancellationTokenSource != null)
                {
                    cancellationTokenSource.Cancel();
                }
                State = VRCImageDownloadState.Unloaded;
            }
 
            ~ImageDownloader()
            {
                try
                {
                    Dispose();
                }
                finally
                {
                    ((Object)this).Finalize();
                }
            }
 
            [AsyncStateMachine(/*Could not decode attribute arguments.*/)]
            [CompilerGenerated]
            internal static UniTask <DownloadImage>g__SlicedTextureUpload|51_0(int width, int height, int bytesPerPixel, TextureFormat format, int mipLevel, NativeSlice<byte> outputBuffer, Texture2D outputTexture)
            {
                //IL_0002: Unknown result type (might be due to invalid IL or missing references)
                //IL_0007: Unknown result type (might be due to invalid IL or missing references)
                //IL_0026: Unknown result type (might be due to invalid IL or missing references)
                //IL_0027: Unknown result type (might be due to invalid IL or missing references)
                //IL_0037: Unknown result type (might be due to invalid IL or missing references)
                //IL_0039: Unknown result type (might be due to invalid IL or missing references)
                //IL_0064: Unknown result type (might be due to invalid IL or missing references)
                <<DownloadImage>g__SlicedTextureUpload|51_0>d <<DownloadImage>g__SlicedTextureUpload|51_0>d = default(<<DownloadImage>g__SlicedTextureUpload|51_0>d);
                <<DownloadImage>g__SlicedTextureUpload|51_0>d.<>t__builder = AsyncUniTaskMethodBuilder.Create();
                <<DownloadImage>g__SlicedTextureUpload|51_0>d.width = width;
                <<DownloadImage>g__SlicedTextureUpload|51_0>d.height = height;
                <<DownloadImage>g__SlicedTextureUpload|51_0>d.bytesPerPixel = bytesPerPixel;
                <<DownloadImage>g__SlicedTextureUpload|51_0>d.format = format;
                <<DownloadImage>g__SlicedTextureUpload|51_0>d.mipLevel = mipLevel;
                <<DownloadImage>g__SlicedTextureUpload|51_0>d.outputBuffer = outputBuffer;
                <<DownloadImage>g__SlicedTextureUpload|51_0>d.outputTexture = outputTexture;
                <<DownloadImage>g__SlicedTextureUpload|51_0>d.<>1__state = -1;
                ((AsyncUniTaskMethodBuilder)(ref <<DownloadImage>g__SlicedTextureUpload|51_0>d.<>t__builder)).Start<<<DownloadImage>g__SlicedTextureUpload|51_0>d>(ref <<DownloadImage>g__SlicedTextureUpload|51_0>d);
                return ((AsyncUniTaskMethodBuilder)(ref <<DownloadImage>g__SlicedTextureUpload|51_0>d.<>t__builder)).Task;
            }
        }
 
        private bool _disposed;
 
        private List<IVRCImageDownload> _imageDownloads = new List<IVRCImageDownload>();
 
        private static List<IVRCImageDownload> _imageDownloadQueue = new List<IVRCImageDownload>();
 
        [ExcludeFromUdonWrapper]
        private static Func<bool> CanBypassDelay = null;
 
        [PublicAPI]
        [ExcludeFromUdonWrapper]
        [field: CompilerGenerated]
        public static Func<VRCUrl, Material, IUdonEventReceiver, TextureInfo, IVRCImageDownload> StartDownload
        {
            [CompilerGenerated]
            get;
            [CompilerGenerated]
            set;
        } = ImageDownloader.DownloadImage;
 
 
        [ExcludeFromUdonWrapper]
        public static bool HasAnyQueuedDownloads => _imageDownloadQueue.Count > 0;
 
        public IVRCImageDownload DownloadImage(VRCUrl url, Material material, IUdonEventReceiver udonBehaviour, TextureInfo textureInfo = null)
        {
            //IL_000d: Unknown result type (might be due to invalid IL or missing references)
            if (_disposed)
            {
                throw new ObjectDisposedException("Attempted to use a disposed VRCImageDownloader.");
            }
            IVRCImageDownload iVRCImageDownload = StartDownload.Invoke(url, material, udonBehaviour, textureInfo);
            iVRCImageDownload.StartDownload();
            _imageDownloads.Add(iVRCImageDownload);
            return iVRCImageDownload;
        }
 
        public void Dispose()
        {
            //IL_0006: Unknown result type (might be due to invalid IL or missing references)
            //IL_000b: Unknown result type (might be due to invalid IL or missing references)
            Enumerator<IVRCImageDownload> enumerator = _imageDownloads.GetEnumerator();
            try
            {
                while (enumerator.MoveNext())
                {
                    IVRCImageDownload current = enumerator.Current;
                    if (current.State != VRCImageDownloadState.Unloaded)
                    {
                        ((IDisposable)current).Dispose();
                    }
                }
            }
            finally
            {
                ((IDisposable)enumerator).Dispose();
            }
            _imageDownloads.Clear();
            GC.SuppressFinalize((object)this);
        }
 
        ~VRCImageDownloader()
        {
            try
            {
                Dispose();
                Debug.LogWarning((object)"[Image Download] Leaked a VRCImageDownloader!");
            }
            finally
            {
                ((Object)this).Finalize();
            }
        }
 
        [ExcludeFromUdonWrapper]
        public static bool AddImageDownloadToQueue(IVRCImageDownload imageDownload)
        {
            if (_imageDownloadQueue.Count < 1000)
            {
                _imageDownloadQueue.Add(imageDownload);
                return true;
            }
            return false;
        }
 
        [ExcludeFromUdonWrapper]
        public static void RemoveImageDownloadFromQueue(IVRCImageDownload imageDownload)
        {
            _imageDownloadQueue.Remove(imageDownload);
        }
 
        [ExcludeFromUdonWrapper]
        public static void ClearQueue()
        {
            Debug.Log((object)"[Image Download] Clearing download queue");
            for (int num = _imageDownloadQueue.Count - 1; num >= 0; num--)
            {
                _imageDownloadQueue[num].CancelDownload();
                ((IDisposable)_imageDownloadQueue[num]).Dispose();
            }
            _imageDownloadQueue.Clear();
        }
    }
    [PublicAPI]
    public enum VRCImageDownloadError : Enum
    {
        Unknown,
        InvalidURL,
        AccessDenied,
        DownloadError,
        InvalidImage,
        TooManyRequests
    }
    [PublicAPI]
    public enum VRCImageDownloadState : Enum
    {
        Unknown,
        Pending,
        Error,
        Complete,
        Unloaded
    }
}
namespace VRC.SDK3.Rendering
{
    public static class VRCAsyncGPUReadback : Object
    {
        public static VRCAsyncGPUReadbackRequest Request(Texture src, int mipIndex, IUdonEventReceiver udonBehaviour)
        {
            //IL_0014: Unknown result type (might be due to invalid IL or missing references)
            //IL_0019: Unknown result type (might be due to invalid IL or missing references)
            //IL_001b: Unknown result type (might be due to invalid IL or missing references)
            //IL_001c: Unknown result type (might be due to invalid IL or missing references)
            VRCAsyncGPUReadbackRequest vRCAsyncGPUReadbackRequest = new VRCAsyncGPUReadbackRequest();
            AsyncGPUReadbackRequest request = AsyncGPUReadback.Request(src, mipIndex, (Action<AsyncGPUReadbackRequest>)vRCAsyncGPUReadbackRequest.HandleCallback);
            vRCAsyncGPUReadbackRequest.Request = request;
            vRCAsyncGPUReadbackRequest.UdonBehaviour = udonBehaviour;
            return vRCAsyncGPUReadbackRequest;
        }
 
        public static VRCAsyncGPUReadbackRequest Request(Texture src, int mipIndex, TextureFormat dstFormat, IUdonEventReceiver udonBehaviour)
        {
            //IL_0008: Unknown result type (might be due to invalid IL or missing references)
            //IL_0015: Unknown result type (might be due to invalid IL or missing references)
            //IL_001a: Unknown result type (might be due to invalid IL or missing references)
            //IL_001c: Unknown result type (might be due to invalid IL or missing references)
            //IL_001d: Unknown result type (might be due to invalid IL or missing references)
            VRCAsyncGPUReadbackRequest vRCAsyncGPUReadbackRequest = new VRCAsyncGPUReadbackRequest();
            AsyncGPUReadbackRequest request = AsyncGPUReadback.Request(src, mipIndex, dstFormat, (Action<AsyncGPUReadbackRequest>)vRCAsyncGPUReadbackRequest.HandleCallback);
            vRCAsyncGPUReadbackRequest.Request = request;
            vRCAsyncGPUReadbackRequest.UdonBehaviour = udonBehaviour;
            return vRCAsyncGPUReadbackRequest;
        }
 
        public static VRCAsyncGPUReadbackRequest Request(Texture src, int mipIndex, int x, int width, int y, int height, int z, int depth, IUdonEventReceiver udonBehaviour)
        {
            //IL_001e: Unknown result type (might be due to invalid IL or missing references)
            //IL_0023: Unknown result type (might be due to invalid IL or missing references)
            //IL_0025: Unknown result type (might be due to invalid IL or missing references)
            //IL_0026: Unknown result type (might be due to invalid IL or missing references)
            VRCAsyncGPUReadbackRequest vRCAsyncGPUReadbackRequest = new VRCAsyncGPUReadbackRequest();
            AsyncGPUReadbackRequest request = AsyncGPUReadback.Request(src, mipIndex, x, width, y, height, z, depth, (Action<AsyncGPUReadbackRequest>)vRCAsyncGPUReadbackRequest.HandleCallback);
            vRCAsyncGPUReadbackRequest.Request = request;
            vRCAsyncGPUReadbackRequest.UdonBehaviour = udonBehaviour;
            return vRCAsyncGPUReadbackRequest;
        }
 
        public static VRCAsyncGPUReadbackRequest Request(Texture src, int mipIndex, int x, int width, int y, int height, int z, int depth, TextureFormat dstFormat, IUdonEventReceiver udonBehaviour)
        {
            //IL_0012: Unknown result type (might be due to invalid IL or missing references)
            //IL_0020: Unknown result type (might be due to invalid IL or missing references)
            //IL_0025: Unknown result type (might be due to invalid IL or missing references)
            //IL_0027: Unknown result type (might be due to invalid IL or missing references)
            //IL_0028: Unknown result type (might be due to invalid IL or missing references)
            VRCAsyncGPUReadbackRequest vRCAsyncGPUReadbackRequest = new VRCAsyncGPUReadbackRequest();
            AsyncGPUReadbackRequest request = AsyncGPUReadback.Request(src, mipIndex, x, width, y, height, z, depth, dstFormat, (Action<AsyncGPUReadbackRequest>)vRCAsyncGPUReadbackRequest.HandleCallback);
            vRCAsyncGPUReadbackRequest.Request = request;
            vRCAsyncGPUReadbackRequest.UdonBehaviour = udonBehaviour;
            return vRCAsyncGPUReadbackRequest;
        }
    }
    [PublicAPI]
    public class VRCAsyncGPUReadbackRequest : Object
    {
        internal AsyncGPUReadbackRequest Request;
 
        internal IUdonEventReceiver UdonBehaviour;
 
        public bool done => ((AsyncGPUReadbackRequest)(ref Request)).done;
 
        public bool hasError => ((AsyncGPUReadbackRequest)(ref Request)).hasError;
 
        public int width => ((AsyncGPUReadbackRequest)(ref Request)).width;
 
        public int height => ((AsyncGPUReadbackRequest)(ref Request)).height;
 
        public int depth => ((AsyncGPUReadbackRequest)(ref Request)).depth;
 
        public int layerCount => ((AsyncGPUReadbackRequest)(ref Request)).layerCount;
 
        public int layerDataSize => ((AsyncGPUReadbackRequest)(ref Request)).layerDataSize;
 
        internal VRCAsyncGPUReadbackRequest()
        {
        }
 
        internal void HandleCallback(AsyncGPUReadbackRequest request)
        {
            //IL_0016: Unknown result type (might be due to invalid IL or missing references)
            IUdonEventReceiver udonBehaviour = UdonBehaviour;
            if (udonBehaviour != null)
            {
                udonBehaviour.RunEvent<VRCAsyncGPUReadbackRequest>("_onAsyncGpuReadbackComplete", new ValueTuple<string, VRCAsyncGPUReadbackRequest>("request", this));
            }
        }
 
        public bool TryGetData(byte[] data, int layer = 0)
        {
            return TryGetData<byte>(data, layer);
        }
 
        public bool TryGetData(float[] data, int layer = 0)
        {
            return TryGetData<float>(data, layer);
        }
 
        public bool TryGetData(Color32[] data, int layer = 0)
        {
            return TryGetData<Color32>(data, layer);
        }
 
        public bool TryGetData(Color[] data, int layer = 0)
        {
            return TryGetData<Color>(data, layer);
        }
 
        private bool TryGetData<T>(T[] data, int layer = 0) where T : struct, ValueType
        {
            //IL_0094: Unknown result type (might be due to invalid IL or missing references)
            //IL_0099: Unknown result type (might be due to invalid IL or missing references)
            //IL_009a: Unknown result type (might be due to invalid IL or missing references)
            if (!done)
            {
                return false;
            }
            if (hasError)
            {
                return false;
            }
            if (layer < 0 || layer >= layerCount)
            {
                Debug.LogError((object)String.Format("[VRCGraphics_AsyncGPUReadback] TryGetData Failed: Requested layer index {0} is invalid. Data has {1} layers.", (object)layer, (object)layerCount));
                return false;
            }
            if (data == null)
            {
                Debug.LogError((object)"[VRCGraphics_AsyncGPUReadback] TryGetData Failed: Provided data array is null.");
                return false;
            }
            if (data.Length < layerDataSize / UnsafeUtility.SizeOf<T>())
            {
                Debug.LogError((object)String.Format("[VRCGraphics_AsyncGPUReadback] TryGetData Failed: Provided array of length {0} is too small. Expected array with length of at least {1}", (object)data.Length, (object)(layerDataSize / UnsafeUtility.SizeOf<T>())));
                return false;
            }
            NativeArray<T> data2 = ((AsyncGPUReadbackRequest)(ref Request)).GetData<T>(0);
            NativeArray<T>.Copy(data2, data, data2.Length);
            return true;
        }
    }
}
namespace VRC.SDK3.Platform
{
    [PublicAPI]
    public enum ScreenUpdateType : Enum
    {
        OrientationChanged
    }
    public struct ScreenUpdateData : ValueType
    {
        public ScreenUpdateType type;
 
        public VRCOrientation orientation;
 
        public Vector2 resolution;
    }
}
namespace VRC.SDK3.Persistence
{
    public static class PlayerData : Object
    {
        public enum State : Enum
        {
            Unchanged,
            Added,
            Removed,
            Changed,
            Restored
        }
 
        public readonly struct Info : ValueType
        {
            public readonly State State;
 
            public readonly string Key;
 
            public Info(string key, State state)
            {
                State = state;
                Key = key;
            }
        }
 
        private static Func<VRCPlayerApi, IEnumerable<string>> _getKeys;
 
        private static Func<VRCPlayerApi, string, bool> _hasKey;
 
        private static Func<VRCPlayerApi, string, Type> _getType;
 
        private static Action<string, bool> _setBool;
 
        private static Func<VRCPlayerApi, string, bool> _getBool;
 
        private static Action<string, sbyte> _setSByte;
 
        private static Func<VRCPlayerApi, string, sbyte> _getSByte;
 
        private static Action<string, byte> _setByte;
 
        private static Func<VRCPlayerApi, string, byte> _getByte;
 
        private static Action<string, byte[]> _setBytes;
 
        private static Func<VRCPlayerApi, string, byte[]> _getBytes;
 
        private static Action<string, string> _setString;
 
        private static Func<VRCPlayerApi, string, string> _getString;
 
        private static Action<string, short> _setShort;
 
        private static Func<VRCPlayerApi, string, short> _getShort;
 
        private static Action<string, ushort> _setUShort;
 
        private static Func<VRCPlayerApi, string, ushort> _getUShort;
 
        private static Action<string, int> _setInt;
 
        private static Func<VRCPlayerApi, string, int> _getInt;
 
        private static Action<string, uint> _setUInt;
 
        private static Func<VRCPlayerApi, string, uint> _getUInt;
 
        private static Action<string, long> _setLong;
 
        private static Func<VRCPlayerApi, string, long> _getLong;
 
        private static Action<string, ulong> _setULong;
 
        private static Func<VRCPlayerApi, string, ulong> _getULong;
 
        private static Action<string, float> _setFloat;
 
        private static Func<VRCPlayerApi, string, float> _getFloat;
 
        private static Action<string, double> _setDouble;
 
        private static Func<VRCPlayerApi, string, double> _getDouble;
 
        private static Action<string, Vector2> _setVector2;
 
        private static Func<VRCPlayerApi, string, Vector2> _getVector2;
 
        private static Action<string, Vector3> _setVector3;
 
        private static Func<VRCPlayerApi, string, Vector3> _getVector3;
 
        private static Action<string, Vector4> _setVector4;
 
        private static Func<VRCPlayerApi, string, Vector4> _getVector4;
 
        private static Action<string, Quaternion> _setQuaternion;
 
        private static Func<VRCPlayerApi, string, Quaternion> _getQuaternion;
 
        private static Action<string, Color> _setColor;
 
        private static Func<VRCPlayerApi, string, Color> _getColor;
 
        private static Action<string, Color32> _setColor32;
 
        private static Func<VRCPlayerApi, string, Color32> _getColor32;
 
        public static bool HasKey(VRCPlayerApi player, string key)
        {
            return _hasKey?.Invoke(player, key) ?? false;
        }
 
        public static Type GetType(VRCPlayerApi player, string key)
        {
            return _getType?.Invoke(player, key);
        }
 
        public static bool TryGetType(VRCPlayerApi player, string key, out Type t)
        {
            t = GetType(player, key);
            return t != (Type)null;
        }
 
        public static bool IsType(VRCPlayerApi player, string key, Type t)
        {
            return GetType(player, key) == t;
        }
 
        public static void SetString(string key, string value)
        {
            _setString?.Invoke(key, value);
        }
 
        public static string GetString(VRCPlayerApi player, string key)
        {
            return _getString?.Invoke(player, key);
        }
 
        public static bool TryGetString(VRCPlayerApi player, string key, out string value)
        {
            if (GetType(player, key) == typeof(String))
            {
                value = GetString(player, key);
                return true;
            }
            value = null;
            return false;
        }
 
        public static void SetBool(string key, bool value)
        {
            _setBool?.Invoke(key, value);
        }
 
        public static bool GetBool(VRCPlayerApi player, string key)
        {
            return _getBool?.Invoke(player, key) ?? false;
        }
 
        public static bool TryGetBool(VRCPlayerApi player, string key, out bool value)
        {
            if (GetType(player, key) == typeof(Boolean))
            {
                value = GetBool(player, key);
                return true;
            }
            value = false;
            return false;
        }
 
        public static void SetSByte(string key, sbyte value)
        {
            _setSByte?.Invoke(key, value);
        }
 
        public static sbyte GetSByte(VRCPlayerApi player, string key)
        {
            return _getSByte?.Invoke(player, key) ?? 0;
        }
 
        public static bool TryGetSByte(VRCPlayerApi player, string key, out sbyte value)
        {
            if (GetType(player, key) == typeof(SByte))
            {
                value = GetSByte(player, key);
                return true;
            }
            value = 0;
            return false;
        }
 
        public static void SetByte(string key, byte value)
        {
            _setByte?.Invoke(key, value);
        }
 
        public static byte GetByte(VRCPlayerApi player, string key)
        {
            return _getByte?.Invoke(player, key) ?? 0;
        }
 
        public static bool TryGetByte(VRCPlayerApi player, string key, out byte value)
        {
            if (GetType(player, key) == typeof(Byte))
            {
                value = GetByte(player, key);
                return true;
            }
            value = 0;
            return false;
        }
 
        public static void SetBytes(string key, byte[] value)
        {
            _setBytes?.Invoke(key, value);
        }
 
        public static byte[] GetBytes(VRCPlayerApi player, string key)
        {
            return _getBytes?.Invoke(player, key);
        }
 
        public static bool TryGetBytes(VRCPlayerApi player, string key, out byte[] value)
        {
            if (GetType(player, key) == typeof(byte[]))
            {
                value = GetBytes(player, key);
                return true;
            }
            value = null;
            return false;
        }
 
        public static void SetShort(string key, short value)
        {
            _setShort?.Invoke(key, value);
        }
 
        public static short GetShort(VRCPlayerApi player, string key)
        {
            return _getShort?.Invoke(player, key) ?? 0;
        }
 
        public static bool TryGetShort(VRCPlayerApi player, string key, out short value)
        {
            if (GetType(player, key) == typeof(Int16))
            {
                value = GetShort(player, key);
                return true;
            }
            value = 0;
            return false;
        }
 
        public static void SetUShort(string key, ushort value)
        {
            _setUShort?.Invoke(key, value);
        }
 
        public static ushort GetUShort(VRCPlayerApi player, string key)
        {
            return _getUShort?.Invoke(player, key) ?? 0;
        }
 
        public static bool TryGetUShort(VRCPlayerApi player, string key, out ushort value)
        {
            if (GetType(player, key) == typeof(UInt16))
            {
                value = GetUShort(player, key);
                return true;
            }
            value = 0;
            return false;
        }
 
        public static void SetInt(string key, int value)
        {
            _setInt?.Invoke(key, value);
        }
 
        public static int GetInt(VRCPlayerApi player, string key)
        {
            return _getInt?.Invoke(player, key) ?? 0;
        }
 
        public static bool TryGetInt(VRCPlayerApi player, string key, out int value)
        {
            if (GetType(player, key) == typeof(Int32))
            {
                value = GetInt(player, key);
                return true;
            }
            value = 0;
            return false;
        }
 
        public static void SetUInt(string key, uint value)
        {
            _setUInt?.Invoke(key, value);
        }
 
        public static uint GetUInt(VRCPlayerApi player, string key)
        {
            return _getUInt?.Invoke(player, key) ?? 0;
        }
 
        public static bool TryGetUInt(VRCPlayerApi player, string key, out uint value)
        {
            if (GetType(player, key) == typeof(UInt32))
            {
                value = GetUInt(player, key);
                return true;
            }
            value = 0u;
            return false;
        }
 
        public static void SetLong(string key, long value)
        {
            _setLong?.Invoke(key, value);
        }
 
        public static long GetLong(VRCPlayerApi player, string key)
        {
            return _getLong?.Invoke(player, key) ?? 0;
        }
 
        public static bool TryGetLong(VRCPlayerApi player, string key, out long value)
        {
            if (GetType(player, key) == typeof(Int64))
            {
                value = GetLong(player, key);
                return true;
            }
            value = 0L;
            return false;
        }
 
        public static void SetULong(string key, ulong value)
        {
            _setULong?.Invoke(key, value);
        }
 
        public static ulong GetULong(VRCPlayerApi player, string key)
        {
            return _getULong?.Invoke(player, key) ?? 0;
        }
 
        public static bool TryGetULong(VRCPlayerApi player, string key, out ulong value)
        {
            if (GetType(player, key) == typeof(UInt64))
            {
                value = GetULong(player, key);
                return true;
            }
            value = 0uL;
            return false;
        }
 
        public static void SetFloat(string key, float value)
        {
            _setFloat?.Invoke(key, value);
        }
 
        public static float GetFloat(VRCPlayerApi player, string key)
        {
            return _getFloat?.Invoke(player, key) ?? 0f;
        }
 
        public static void SetDouble(string key, double value)
        {
            _setDouble?.Invoke(key, value);
        }
 
        public static double GetDouble(VRCPlayerApi player, string key)
        {
            return _getDouble?.Invoke(player, key) ?? 0.0;
        }
 
        public static bool TryGetDouble(VRCPlayerApi player, string key, out double value)
        {
            if (GetType(player, key) == typeof(Double))
            {
                value = GetDouble(player, key);
                return true;
            }
            value = 0.0;
            return false;
        }
 
        public static bool TryGetFloat(VRCPlayerApi player, string key, out float value)
        {
            if (GetType(player, key) == typeof(Single))
            {
                value = GetFloat(player, key);
                return true;
            }
            value = 0f;
            return false;
        }
 
        public static void SetQuaternion(string key, Quaternion value)
        {
            //IL_000b: Unknown result type (might be due to invalid IL or missing references)
            _setQuaternion?.Invoke(key, value);
        }
 
        public static Quaternion GetQuaternion(VRCPlayerApi player, string key)
        {
            //IL_0015: Unknown result type (might be due to invalid IL or missing references)
            //IL_000b: Unknown result type (might be due to invalid IL or missing references)
            //IL_0011: Unknown result type (might be due to invalid IL or missing references)
            return (Quaternion)(((??)_getQuaternion?.Invoke(player, key)) ?? default(Quaternion));
        }
 
        public static bool TryGetQuaternion(VRCPlayerApi player, string key, out Quaternion value)
        {
            //IL_0028: Unknown result type (might be due to invalid IL or missing references)
            //IL_001b: Unknown result type (might be due to invalid IL or missing references)
            //IL_0020: Unknown result type (might be due to invalid IL or missing references)
            if (GetType(player, key) == typeof(Quaternion))
            {
                value = GetQuaternion(player, key);
                return true;
            }
            value = default(Quaternion);
            return false;
        }
 
        public static void SetVector4(string key, Vector4 value)
        {
            //IL_000b: Unknown result type (might be due to invalid IL or missing references)
            _setVector4?.Invoke(key, value);
        }
 
        public static Vector4 GetVector4(VRCPlayerApi player, string key)
        {
            //IL_0015: Unknown result type (might be due to invalid IL or missing references)
            //IL_000b: Unknown result type (might be due to invalid IL or missing references)
            //IL_0011: Unknown result type (might be due to invalid IL or missing references)
            return (Vector4)(((??)_getVector4?.Invoke(player, key)) ?? default(Vector4));
        }
 
        public static bool TryGetVector4(VRCPlayerApi player, string key, out Vector4 value)
        {
            //IL_0028: Unknown result type (might be due to invalid IL or missing references)
            //IL_001b: Unknown result type (might be due to invalid IL or missing references)
            //IL_0020: Unknown result type (might be due to invalid IL or missing references)
            if (GetType(player, key) == typeof(Vector4))
            {
                value = GetVector4(player, key);
                return true;
            }
            value = default(Vector4);
            return false;
        }
 
        public static void SetVector3(string key, Vector3 value)
        {
            //IL_000b: Unknown result type (might be due to invalid IL or missing references)
            _setVector3?.Invoke(key, value);
        }
 
        public static Vector3 GetVector3(VRCPlayerApi player, string key)
        {
            //IL_0015: Unknown result type (might be due to invalid IL or missing references)
            //IL_000b: Unknown result type (might be due to invalid IL or missing references)
            //IL_0011: Unknown result type (might be due to invalid IL or missing references)
            return (Vector3)(((??)_getVector3?.Invoke(player, key)) ?? default(Vector3));
        }
 
        public static bool TryGetVector3(VRCPlayerApi player, string key, out Vector3 value)
        {
            //IL_0028: Unknown result type (might be due to invalid IL or missing references)
            //IL_001b: Unknown result type (might be due to invalid IL or missing references)
            //IL_0020: Unknown result type (might be due to invalid IL or missing references)
            if (GetType(player, key) == typeof(Vector3))
            {
                value = GetVector3(player, key);
                return true;
            }
            value = default(Vector3);
            return false;
        }
 
        public static void SetVector2(string key, Vector2 value)
        {
            //IL_000b: Unknown result type (might be due to invalid IL or missing references)
            _setVector2?.Invoke(key, value);
        }
 
        public static Vector2 GetVector2(VRCPlayerApi player, string key)
        {
            //IL_0015: Unknown result type (might be due to invalid IL or missing references)
            //IL_000b: Unknown result type (might be due to invalid IL or missing references)
            //IL_0011: Unknown result type (might be due to invalid IL or missing references)
            return (Vector2)(((??)_getVector2?.Invoke(player, key)) ?? default(Vector2));
        }
 
        public static bool TryGetVector2(VRCPlayerApi player, string key, out Vector2 value)
        {
            //IL_0028: Unknown result type (might be due to invalid IL or missing references)
            //IL_001b: Unknown result type (might be due to invalid IL or missing references)
            //IL_0020: Unknown result type (might be due to invalid IL or missing references)
            if (GetType(player, key) == typeof(Vector2))
            {
                value = GetVector2(player, key);
                return true;
            }
            value = default(Vector2);
            return false;
        }
 
        public static void SetColor(string key, Color value)
        {
            //IL_000b: Unknown result type (might be due to invalid IL or missing references)
            _setColor?.Invoke(key, value);
        }
 
        public static Color GetColor(VRCPlayerApi player, string key)
        {
            //IL_0015: Unknown result type (might be due to invalid IL or missing references)
            //IL_000b: Unknown result type (might be due to invalid IL or missing references)
            //IL_0011: Unknown result type (might be due to invalid IL or missing references)
            return (Color)(((??)_getColor?.Invoke(player, key)) ?? default(Color));
        }
 
        public static bool TryGetColor(VRCPlayerApi player, string key, out Color value)
        {
            //IL_0028: Unknown result type (might be due to invalid IL or missing references)
            //IL_001b: Unknown result type (might be due to invalid IL or missing references)
            //IL_0020: Unknown result type (might be due to invalid IL or missing references)
            if (GetType(player, key) == typeof(Color))
            {
                value = GetColor(player, key);
                return true;
            }
            value = default(Color);
            return false;
        }
 
        public static void SetColor32(string key, Color32 value)
        {
            //IL_000b: Unknown result type (might be due to invalid IL or missing references)
            _setColor32?.Invoke(key, value);
        }
 
        public static Color32 GetColor32(VRCPlayerApi player, string key)
        {
            //IL_0015: Unknown result type (might be due to invalid IL or missing references)
            //IL_000b: Unknown result type (might be due to invalid IL or missing references)
            //IL_0011: Unknown result type (might be due to invalid IL or missing references)
            return (Color32)(((??)_getColor32?.Invoke(player, key)) ?? default(Color32));
        }
 
        public static bool TryGetColor32(VRCPlayerApi player, string key, out Color32 value)
        {
            //IL_0028: Unknown result type (might be due to invalid IL or missing references)
            //IL_001b: Unknown result type (might be due to invalid IL or missing references)
            //IL_0020: Unknown result type (might be due to invalid IL or missing references)
            if (GetType(player, key) == typeof(Color32))
            {
                value = GetColor32(player, key);
                return true;
            }
            value = default(Color32);
            return false;
        }
 
        public static IEnumerable<string> GetKeys(VRCPlayerApi player)
        {
            return _getKeys?.Invoke(player) ?? Enumerable.Empty<string>();
        }
    }
}
namespace VRC.SDK3.Network
{
    public abstract class VRCNetworkBehaviour : VRCNetworkBehaviour
    {
        [CompilerGenerated]
        private static Action<VRCNetworkBehaviour> m_OnNetworkBehaviourAwake;
 
        public static event Action<VRCNetworkBehaviour> OnNetworkBehaviourAwake
        {
            [CompilerGenerated]
            add
            {
                Action<VRCNetworkBehaviour> val = VRCNetworkBehaviour.m_OnNetworkBehaviourAwake;
                Action<VRCNetworkBehaviour> val2;
                do
                {
                    val2 = val;
                    Action<VRCNetworkBehaviour> val3 = (Action<VRCNetworkBehaviour>)(object)Delegate.Combine((Delegate)(object)val2, (Delegate)(object)value);
                    val = Interlocked.CompareExchange<Action<VRCNetworkBehaviour>>(ref VRCNetworkBehaviour.m_OnNetworkBehaviourAwake, val3, val2);
                }
                while (val != val2);
            }
            [CompilerGenerated]
            remove
            {
                Action<VRCNetworkBehaviour> val = VRCNetworkBehaviour.m_OnNetworkBehaviourAwake;
                Action<VRCNetworkBehaviour> val2;
                do
                {
                    val2 = val;
                    Action<VRCNetworkBehaviour> val3 = (Action<VRCNetworkBehaviour>)(object)Delegate.Remove((Delegate)(object)val2, (Delegate)(object)value);
                    val = Interlocked.CompareExchange<Action<VRCNetworkBehaviour>>(ref VRCNetworkBehaviour.m_OnNetworkBehaviourAwake, val3, val2);
                }
                while (val != val2);
            }
        }
 
        [ExcludeFromUdonWrapper]
        public abstract void NetworkConfigure();
 
        [ExcludeFromUdonWrapper]
        public virtual void Awake()
        {
            VRCNetworkBehaviour.OnNetworkBehaviourAwake?.Invoke(this);
        }
    }
}
namespace VRC.SDK3.Data
{
    [Serializable]
    [DefaultMember("Item")]
    public class DataDictionary : Object, ICollection<KeyValuePair<DataToken, DataToken>>, IEnumerable<KeyValuePair<DataToken, DataToken>>, IEnumerable
    {
        internal Dictionary<DataToken, DataToken> _values = new Dictionary<DataToken, DataToken>();
 
        internal DataList keyCache;
 
        internal bool keysDirty = true;
 
        internal DataList valueCache;
 
        internal bool valuesDirty = true;
 
        public virtual int Count => _values.Count;
 
        [ExcludeFromUdonWrapper]
        [field: CompilerGenerated]
        public bool IsReadOnly
        {
            [CompilerGenerated]
            get;
        }
 
        public DataToken this[DataToken key]
        {
            get
            {
                TryGetValue(key, out var value);
                return value;
            }
            set
            {
                SetValue(key, value);
            }
        }
 
        public virtual void SetValue(DataToken key, DataToken value)
        {
            //IL_0037: Unknown result type (might be due to invalid IL or missing references)
            valuesDirty = true;
            if (!keysDirty && !_values.ContainsKey(key))
            {
                keysDirty = true;
            }
            if (key.IsNull)
            {
                throw new ArgumentNullException("key", "Key of dictionary cannot be null");
            }
            _values[key] = value;
        }
 
        public bool TryGetValue(DataToken key, TokenType type, out DataToken value)
        {
            if (!TryGetValue(key, out value))
            {
                return false;
            }
            if (value.TokenType != type)
            {
                value = new DataToken(DataError.TypeMismatch, String.Format("Expected TokenType {0} but found {1} instead", (object)type, (object)value.TokenType));
                return false;
            }
            return true;
        }
 
        public bool TryGetValue(DataToken key, out DataToken value)
        {
            value = GetValue(key, out var success);
            return success;
        }
 
        protected virtual DataToken GetValue(DataToken key, out bool success)
        {
            if (_values.ContainsKey(key))
            {
                success = true;
                return _values[key];
            }
            success = false;
            return DataError.KeyDoesNotExist;
        }
 
        public DataDictionary ShallowClone()
        {
            ParseAll();
            DataList keys = GetKeys();
            DataDictionary dataDictionary = new DataDictionary();
            for (int i = 0; i < keys.Count; i++)
            {
                dataDictionary[keys[i]] = _values[keys[i]];
            }
            return dataDictionary;
        }
 
        public DataDictionary DeepClone()
        {
            ParseAll();
            DataList keys = GetKeys();
            DataDictionary dataDictionary = new DataDictionary();
            for (int i = 0; i < keys.Count; i++)
            {
                switch (_values[keys[i]].TokenType)
                {
                case TokenType.DataDictionary:
                    dataDictionary[keys[i]] = _values[keys[i]].DataDictionary.DeepClone();
                    break;
                case TokenType.DataList:
                    dataDictionary[keys[i]] = _values[keys[i]].DataList.DeepClone();
                    break;
                default:
                    dataDictionary[keys[i]] = _values[keys[i]];
                    break;
                }
            }
            return dataDictionary;
        }
 
        public virtual void Clear()
        {
            keysDirty = true;
            valuesDirty = true;
            _values.Clear();
        }
 
        public virtual bool Remove(DataToken key)
        {
            keysDirty = true;
            valuesDirty = true;
            return _values.Remove(key);
        }
 
        public bool Remove(DataToken key, out DataToken value)
        {
            keysDirty = true;
            valuesDirty = true;
            bool result = TryGetValue(key, out value);
            _values.Remove(key);
            return result;
        }
 
        public virtual bool ContainsKey(DataToken key)
        {
            return _values.ContainsKey(key);
        }
 
        public virtual bool ContainsValue(DataToken value)
        {
            ParseAll();
            return _values.ContainsValue(value);
        }
 
        internal virtual void ParseAll()
        {
        }
 
        public virtual DataList GetKeys()
        {
            if (keysDirty)
            {
                keyCache = new DataList((IEnumerable<DataToken>)(object)_values.Keys);
                keysDirty = false;
                return keyCache;
            }
            return keyCache;
        }
 
        public DataList GetValues()
        {
            if (valuesDirty)
            {
                ParseAll();
                valueCache = new DataList((IEnumerable<DataToken>)(object)_values.Values);
                valuesDirty = false;
                return valueCache;
            }
            return valueCache;
        }
 
        [ExcludeFromUdonWrapper]
        public IEnumerator<KeyValuePair<DataToken, DataToken>> GetEnumerator()
        {
            //IL_000c: Unknown result type (might be due to invalid IL or missing references)
            ParseAll();
            return (IEnumerator<KeyValuePair<DataToken, DataToken>>)(object)_values.GetEnumerator();
        }
 
        [ExcludeFromUdonWrapper]
        IEnumerator IEnumerable.GetEnumerator()
        {
            return (IEnumerator)(object)GetEnumerator();
        }
 
        [ExcludeFromUdonWrapper]
        public void Add(KeyValuePair<DataToken, DataToken> item)
        {
            //IL_001b: Unknown result type (might be due to invalid IL or missing references)
            if (item.Key.IsNull)
            {
                throw new ArgumentNullException("item", "Key of dictionary cannot be null");
            }
            keysDirty = true;
            valuesDirty = true;
            _values.Add(item.Key, item.Value);
        }
 
        public virtual void Add(DataToken key, DataToken value)
        {
            //IL_0013: Unknown result type (might be due to invalid IL or missing references)
            if (key.IsNull)
            {
                throw new ArgumentNullException("key", "Key of dictionary cannot be null");
            }
            keysDirty = true;
            valuesDirty = true;
            _values.Add(key, value);
        }
 
        [ExcludeFromUdonWrapper]
        public bool Contains(KeyValuePair<DataToken, DataToken> item)
        {
            ParseAll();
            if (!_values.ContainsKey(item.Key))
            {
                return false;
            }
            DataToken lhs = _values[item.Key];
            DataToken rhs = item.Value;
            if (lhs != rhs)
            {
                return false;
            }
            return true;
        }
 
        [ExcludeFromUdonWrapper]
        public void CopyTo(KeyValuePair<DataToken, DataToken>[] array, int arrayIndex)
        {
            //IL_0000: Unknown result type (might be due to invalid IL or missing references)
            throw new NotImplementedException();
        }
 
        [ExcludeFromUdonWrapper]
        public bool Remove(KeyValuePair<DataToken, DataToken> item)
        {
            //IL_0001: Unknown result type (might be due to invalid IL or missing references)
            if (!Contains(item))
            {
                return false;
            }
            return Remove(item.Key);
        }
    }
    [Serializable]
    [DefaultMember("Item")]
    public class DataList : Object, ICollection<DataToken>, IEnumerable<DataToken>, IEnumerable
    {
        [SerializeField]
        internal List<DataToken> _values = new List<DataToken>();
 
        public int Count => _values.Count;
 
        public int Capacity
        {
            get
            {
                return _values.Capacity;
            }
            set
            {
                _values.Capacity = value;
            }
        }
 
        [ExcludeFromUdonWrapper]
        [field: CompilerGenerated]
        public bool IsReadOnly
        {
            [CompilerGenerated]
            get;
        }
 
        public DataToken this[int index]
        {
            get
            {
                TryGetValue(index, out var value);
                return value;
            }
            set
            {
                SetValue(index, value);
            }
        }
 
        public DataList()
        {
        }
 
        public DataList(params DataToken[] array)
        {
            for (int i = 0; i < array.Length; i++)
            {
                _values.Add(array[i]);
            }
        }
 
        internal DataList(IEnumerable<DataToken> values)
        {
            IEnumerator<DataToken> enumerator = values.GetEnumerator();
            try
            {
                while (((IEnumerator)enumerator).MoveNext())
                {
                    DataToken current = enumerator.Current;
                    _values.Add(current);
                }
            }
            finally
            {
                if (enumerator != null)
                {
                    ((IDisposable)enumerator).Dispose();
                }
            }
        }
 
        internal DataList(List<DataToken> list)
        {
            _values = list;
        }
 
        public void TrimExcess()
        {
            _values.TrimExcess();
        }
 
        public virtual bool SetValue(int index, DataToken value)
        {
            _values[index] = value;
            return true;
        }
 
        public virtual bool TryGetValue(int index, TokenType type, out DataToken value)
        {
            if (!TryGetValue(index, out value))
            {
                return false;
            }
            if (value.TokenType != type)
            {
                value = new DataToken(DataError.TypeMismatch, String.Format("Expected TokenType {0} but found {1} instead", (object)type, (object)value.TokenType));
                return false;
            }
            return true;
        }
 
        public virtual bool TryGetValue(int index, out DataToken value)
        {
            value = GetValue(index, out var success);
            return success;
        }
 
        protected virtual DataToken GetValue(int index, out bool success)
        {
            if (index < 0 || index >= Count)
            {
                success = false;
                return DataError.IndexOutOfRange;
            }
            success = true;
            return _values[index];
        }
 
        public virtual void Insert(int index, DataToken value)
        {
            _values.Insert(index, value);
        }
 
        public virtual void InsertRange(int index, DataList input)
        {
            _values.InsertRange(index, (IEnumerable<DataToken>)(object)input._values);
        }
 
        public DataList GetRange(int index, int count)
        {
            ParseAll();
            return new DataList(_values.GetRange(index, count));
        }
 
        public DataList ShallowClone()
        {
            ParseAll();
            return new DataList(_values.GetRange(0, Count))
            {
                Capacity = Capacity
            };
        }
 
        public DataList DeepClone()
        {
            ParseAll();
            DataList dataList = new DataList();
            dataList.Capacity = Capacity;
            for (int i = 0; i < _values.Count; i++)
            {
                switch (_values[i].TokenType)
                {
                case TokenType.DataDictionary:
                    dataList.Add(_values[i].DataDictionary.DeepClone());
                    break;
                case TokenType.DataList:
                    dataList.Add(_values[i].DataList.DeepClone());
                    break;
                default:
                    dataList.Add(_values[i]);
                    break;
                }
            }
            return dataList;
        }
 
        public DataToken[] ToArray()
        {
            ParseAll();
            return _values.ToArray();
        }
 
        public virtual void Add(DataToken value)
        {
            _values.Add(value);
        }
 
        public void AddRange(DataList list)
        {
            ParseAll();
            _values.AddRange((IEnumerable<DataToken>)(object)list._values);
        }
 
        internal void AddRange(IEnumerable<DataToken> values)
        {
            ParseAll();
            IEnumerator<DataToken> enumerator = values.GetEnumerator();
            try
            {
                while (((IEnumerator)enumerator).MoveNext())
                {
                    DataToken current = enumerator.Current;
                    Add(current);
                }
            }
            finally
            {
                if (enumerator != null)
                {
                    ((IDisposable)enumerator).Dispose();
                }
            }
        }
 
        public bool Contains(DataToken value)
        {
            ParseAll();
            return _values.Contains(value);
        }
 
        public int IndexOf(DataToken value)
        {
            ParseAll();
            return _values.IndexOf(value);
        }
 
        public int IndexOf(DataToken item, int index)
        {
            ParseAll();
            return _values.IndexOf(item, index);
        }
 
        public int IndexOf(DataToken item, int index, int count)
        {
            ParseAll();
            return _values.IndexOf(item, index, count);
        }
 
        public int LastIndexOf(DataToken item)
        {
            ParseAll();
            return _values.LastIndexOf(item);
        }
 
        public int LastIndexOf(DataToken item, int index)
        {
            ParseAll();
            return _values.LastIndexOf(item, index);
        }
 
        public int LastIndexOf(DataToken item, int index, int count)
        {
            ParseAll();
            return _values.LastIndexOf(item, index, count);
        }
 
        public bool Remove(DataToken value)
        {
            ParseAll();
            return _values.Remove(value);
        }
 
        public bool RemoveAll(DataToken value)
        {
            ParseAll();
            bool result = false;
            while (Remove(value))
            {
                result = true;
            }
            return result;
        }
 
        public virtual void Clear()
        {
            _values.Clear();
        }
 
        public virtual void RemoveAt(int index)
        {
            _values.RemoveAt(index);
        }
 
        public virtual void RemoveRange(int index, int count)
        {
            _values.RemoveRange(index, count);
        }
 
        public virtual void Reverse()
        {
            _values.Reverse();
        }
 
        public virtual void Reverse(int index, int count)
        {
            _values.Reverse(index, count);
        }
 
        public void Sort()
        {
            ParseAll();
            _values.Sort();
        }
 
        public void Sort(int index, int count)
        {
            ParseAll();
            _values.Sort(index, count, (IComparer<DataToken>)null);
        }
 
        public int BinarySearch(DataToken token)
        {
            ParseAll();
            return _values.BinarySearch(token);
        }
 
        public int BinarySearch(int index, int count, DataToken token)
        {
            ParseAll();
            return _values.BinarySearch(index, count, token, (IComparer<DataToken>)null);
        }
 
        protected virtual void ParseAll()
        {
            ParseInRange(0, Count);
        }
 
        protected virtual void ParseInRange(int startIndex)
        {
            ParseInRange(startIndex, Count);
        }
 
        protected virtual void ParseInRange(int startIndex, int stopIndex)
        {
        }
 
        [ExcludeFromUdonWrapper]
        public void CopyTo(DataToken[] array, int arrayIndex)
        {
            _values.CopyTo(array, arrayIndex);
        }
 
        [ExcludeFromUdonWrapper]
        public IEnumerator<DataToken> GetEnumerator()
        {
            //IL_000c: Unknown result type (might be due to invalid IL or missing references)
            ParseAll();
            return (IEnumerator<DataToken>)(object)_values.GetEnumerator();
        }
 
        [ExcludeFromUdonWrapper]
        IEnumerator IEnumerable.GetEnumerator()
        {
            return (IEnumerator)(object)GetEnumerator();
        }
    }
    public enum DataError : Enum
    {
        None,
        KeyDoesNotExist,
        TypeMismatch,
        TypeUnsupported,
        ValueUnsupported,
        UnableToParse,
        IndexOutOfRange
    }
    public enum TokenType : Enum
    {
        Null,
        Boolean,
        SByte,
        Byte,
        Short,
        UShort,
        Int,
        UInt,
        Long,
        ULong,
        Float,
        Double,
        String,
        DataList,
        DataDictionary,
        Reference,
        Error
    }
    [Serializable]
    [StructLayout(2)]
    public struct DataToken : ValueType, IComparable, IComparable<DataToken>, IEquatable<DataToken>, IEquatable<string>, IEquatable<object>, IEquatable<bool>, IEquatable<sbyte>, IEquatable<byte>, IEquatable<short>, IEquatable<ushort>, IEquatable<int>, IEquatable<uint>, IEquatable<long>, IEquatable<ulong>, IEquatable<float>, IEquatable<double>, IEquatable<DataList>, IEquatable<DataDictionary>, IEquatable<DataError>
    {
        [FieldOffset(0)]
        private string _string;
 
        [FieldOffset(0)]
        private object _reference;
 
        [FieldOffset(8)]
        private bool _boolean;
 
        [FieldOffset(8)]
        private sbyte _sbyte;
 
        [FieldOffset(8)]
        private byte _byte;
 
        [FieldOffset(8)]
        private short _short;
 
        [FieldOffset(8)]
        private ushort _ushort;
 
        [FieldOffset(8)]
        private int _int;
 
        [FieldOffset(8)]
        private uint _uint;
 
        [FieldOffset(8)]
        private long _long;
 
        [FieldOffset(8)]
        private ulong _ulong;
 
        [FieldOffset(8)]
        private float _float;
 
        [FieldOffset(8)]
        private double _double;
 
        [FieldOffset(8)]
        private DataError _error;
 
        [FieldOffset(16)]
        [SerializeField]
        private TokenType _tokenType;
 
        public TokenType TokenType => _tokenType;
 
        public bool IsEmpty => _tokenType == TokenType.Null;
 
        public bool Boolean
        {
            get
            {
                //IL_002b: Unknown result type (might be due to invalid IL or missing references)
                if (_tokenType == TokenType.Boolean)
                {
                    return _boolean;
                }
                throw new InvalidOperationException(String.Format("Attempted to access {0} token as {1}", (object)_tokenType, (object)TokenType.Boolean));
            }
        }
 
        public sbyte SByte
        {
            get
            {
                //IL_002b: Unknown result type (might be due to invalid IL or missing references)
                if (_tokenType == TokenType.SByte)
                {
                    return _sbyte;
                }
                throw new InvalidOperationException(String.Format("Attempted to access {0} token as {1}", (object)_tokenType, (object)TokenType.SByte));
            }
        }
 
        public byte Byte
        {
            get
            {
                //IL_002b: Unknown result type (might be due to invalid IL or missing references)
                if (_tokenType == TokenType.Byte)
                {
                    return _byte;
                }
                throw new InvalidOperationException(String.Format("Attempted to access {0} token as {1}", (object)_tokenType, (object)TokenType.Byte));
            }
        }
 
        public short Short
        {
            get
            {
                //IL_004b: Unknown result type (might be due to invalid IL or missing references)
                if (_tokenType == TokenType.Short)
                {
                    return _short;
                }
                if (_tokenType == TokenType.SByte)
                {
                    return _sbyte;
                }
                if (_tokenType == TokenType.Byte)
                {
                    return _byte;
                }
                throw new InvalidOperationException(String.Format("Attempted to access {0} token as {1}", (object)_tokenType, (object)TokenType.Short));
            }
        }
 
        public ushort UShort
        {
            get
            {
                //IL_003b: Unknown result type (might be due to invalid IL or missing references)
                if (_tokenType == TokenType.UShort)
                {
                    return _ushort;
                }
                if (_tokenType == TokenType.Byte)
                {
                    return _byte;
                }
                throw new InvalidOperationException(String.Format("Attempted to access {0} token as {1}", (object)_tokenType, (object)TokenType.UShort));
            }
        }
 
        public int Int
        {
            get
            {
                //IL_006b: Unknown result type (might be due to invalid IL or missing references)
                if (_tokenType == TokenType.Int)
                {
                    return _int;
                }
                if (_tokenType == TokenType.SByte)
                {
                    return _sbyte;
                }
                if (_tokenType == TokenType.Byte)
                {
                    return _byte;
                }
                if (_tokenType == TokenType.Short)
                {
                    return _short;
                }
                if (_tokenType == TokenType.UShort)
                {
                    return _ushort;
                }
                throw new InvalidOperationException(String.Format("Attempted to access {0} token as {1}", (object)_tokenType, (object)TokenType.Int));
            }
        }
 
        public uint UInt
        {
            get
            {
                //IL_004b: Unknown result type (might be due to invalid IL or missing references)
                if (_tokenType == TokenType.UInt)
                {
                    return _uint;
                }
                if (_tokenType == TokenType.Byte)
                {
                    return _byte;
                }
                if (_tokenType == TokenType.UShort)
                {
                    return _ushort;
                }
                throw new InvalidOperationException(String.Format("Attempted to access {0} token as {1}", (object)_tokenType, (object)TokenType.UInt));
            }
        }
 
        public long Long
        {
            get
            {
                //IL_0080: Unknown result type (might be due to invalid IL or missing references)
                if (_tokenType == TokenType.Long)
                {
                    return _long;
                }
                if (_tokenType == TokenType.SByte)
                {
                    return _sbyte;
                }
                if (_tokenType == TokenType.Byte)
                {
                    return _byte;
                }
                if (_tokenType == TokenType.Short)
                {
                    return _short;
                }
                if (_tokenType == TokenType.UShort)
                {
                    return _ushort;
                }
                if (_tokenType == TokenType.Int)
                {
                    return _uint;
                }
                throw new InvalidOperationException(String.Format("Attempted to access {0} token as {1}", (object)_tokenType, (object)TokenType.Long));
            }
        }
 
        public ulong ULong
        {
            get
            {
                //IL_0060: Unknown result type (might be due to invalid IL or missing references)
                if (_tokenType == TokenType.ULong)
                {
                    return _ulong;
                }
                if (_tokenType == TokenType.Byte)
                {
                    return _byte;
                }
                if (_tokenType == TokenType.UShort)
                {
                    return _ushort;
                }
                if (_tokenType == TokenType.UInt)
                {
                    return _uint;
                }
                throw new InvalidOperationException(String.Format("Attempted to access {0} token as {1}", (object)_tokenType, (object)TokenType.ULong));
            }
        }
 
        public float Float
        {
            get
            {
                //IL_00b8: Unknown result type (might be due to invalid IL or missing references)
                if (_tokenType == TokenType.Float)
                {
                    return _float;
                }
                if (_tokenType == TokenType.SByte)
                {
                    return _sbyte;
                }
                if (_tokenType == TokenType.Byte)
                {
                    return (int)_byte;
                }
                if (_tokenType == TokenType.Short)
                {
                    return _short;
                }
                if (_tokenType == TokenType.UShort)
                {
                    return (int)_ushort;
                }
                if (_tokenType == TokenType.Int)
                {
                    return _int;
                }
                if (_tokenType == TokenType.UInt)
                {
                    return _uint;
                }
                if (_tokenType == TokenType.Long)
                {
                    return _long;
                }
                if (_tokenType == TokenType.ULong)
                {
                    return _ulong;
                }
                throw new InvalidOperationException(String.Format("Attempted to access {0} token as {1}", (object)_tokenType, (object)TokenType.Float));
            }
        }
 
        public double Double
        {
            get
            {
                //IL_00ca: Unknown result type (might be due to invalid IL or missing references)
                if (_tokenType == TokenType.Double)
                {
                    return _double;
                }
                if (_tokenType == TokenType.SByte)
                {
                    return _sbyte;
                }
                if (_tokenType == TokenType.Byte)
                {
                    return (int)_byte;
                }
                if (_tokenType == TokenType.Short)
                {
                    return _short;
                }
                if (_tokenType == TokenType.UShort)
                {
                    return (int)_ushort;
                }
                if (_tokenType == TokenType.Int)
                {
                    return _int;
                }
                if (_tokenType == TokenType.UInt)
                {
                    return _uint;
                }
                if (_tokenType == TokenType.Long)
                {
                    return _long;
                }
                if (_tokenType == TokenType.ULong)
                {
                    return _ulong;
                }
                if (_tokenType == TokenType.Float)
                {
                    return _float;
                }
                throw new InvalidOperationException(String.Format("Attempted to access {0} token as {1}", (object)_tokenType, (object)TokenType.Double));
            }
        }
 
        public double Number
        {
            get
            {
                //IL_00ca: Unknown result type (might be due to invalid IL or missing references)
                if (_tokenType == TokenType.Double)
                {
                    return _double;
                }
                if (_tokenType == TokenType.SByte)
                {
                    return _sbyte;
                }
                if (_tokenType == TokenType.Byte)
                {
                    return (int)_byte;
                }
                if (_tokenType == TokenType.Short)
                {
                    return _short;
                }
                if (_tokenType == TokenType.UShort)
                {
                    return (int)_ushort;
                }
                if (_tokenType == TokenType.Int)
                {
                    return _int;
                }
                if (_tokenType == TokenType.UInt)
                {
                    return _uint;
                }
                if (_tokenType == TokenType.Long)
                {
                    return _long;
                }
                if (_tokenType == TokenType.ULong)
                {
                    return _ulong;
                }
                if (_tokenType == TokenType.Float)
                {
                    return _float;
                }
                throw new InvalidOperationException(String.Format("Attempted to access {0} token as {1}", (object)_tokenType, (object)TokenType.Double));
            }
        }
 
        public string String
        {
            get
            {
                //IL_0030: Unknown result type (might be due to invalid IL or missing references)
                if (_tokenType != TokenType.String && _tokenType != TokenType.Error)
                {
                    throw new InvalidOperationException(String.Format("Attempted to access {0} token as {1}", (object)_tokenType, (object)TokenType.String));
                }
                return _string;
            }
        }
 
        public DataList DataList
        {
            get
            {
                //IL_0026: Unknown result type (might be due to invalid IL or missing references)
                if (_tokenType != TokenType.DataList)
                {
                    throw new InvalidOperationException(String.Format("Attempted to access {0} token as {1}", (object)_tokenType, (object)TokenType.DataList));
                }
                return (DataList)_reference;
            }
        }
 
        public DataDictionary DataDictionary
        {
            get
            {
                //IL_0026: Unknown result type (might be due to invalid IL or missing references)
                if (_tokenType != TokenType.DataDictionary)
                {
                    throw new InvalidOperationException(String.Format("Attempted to access {0} token as {1}", (object)_tokenType, (object)TokenType.DataDictionary));
                }
                return (DataDictionary)_reference;
            }
        }
 
        public object Reference
        {
            get
            {
                //IL_0026: Unknown result type (might be due to invalid IL or missing references)
                if (_tokenType != TokenType.Reference)
                {
                    throw new InvalidOperationException(String.Format("Attempted to access {0} token as {1}", (object)_tokenType, (object)TokenType.Reference));
                }
                return _reference;
            }
        }
 
        public DataError Error
        {
            get
            {
                if (_tokenType != TokenType.Error)
                {
                    return DataError.None;
                }
                return _error;
            }
        }
 
        public bool IsNumber => TokenType switch
        {
            TokenType.SByte => true, 
            TokenType.Byte => true, 
            TokenType.Short => true, 
            TokenType.UShort => true, 
            TokenType.Int => true, 
            TokenType.UInt => true, 
            TokenType.Long => true, 
            TokenType.ULong => true, 
            TokenType.Float => true, 
            TokenType.Double => true, 
            _ => false, 
        };
 
        public bool IsNull
        {
            get
            {
                //IL_0084: Unknown result type (might be due to invalid IL or missing references)
                switch (TokenType)
                {
                case TokenType.Boolean:
                case TokenType.SByte:
                case TokenType.Byte:
                case TokenType.Short:
                case TokenType.UShort:
                case TokenType.Int:
                case TokenType.UInt:
                case TokenType.Long:
                case TokenType.ULong:
                case TokenType.Float:
                case TokenType.Double:
                case TokenType.Error:
                    return false;
                case TokenType.Null:
                    return true;
                case TokenType.String:
                    return String == null;
                case TokenType.DataList:
                    return DataList == null;
                case TokenType.DataDictionary:
                    return DataDictionary == null;
                case TokenType.Reference:
                    return !Utilities.IsValid(Reference);
                default:
                    throw new ArgumentOutOfRangeException();
                }
            }
        }
 
        public DataToken(bool b)
        {
            this = default(DataToken);
            _boolean = b;
            _tokenType = TokenType.Boolean;
        }
 
        public DataToken(sbyte number)
        {
            this = default(DataToken);
            _sbyte = number;
            _tokenType = TokenType.SByte;
        }
 
        public DataToken(byte number)
        {
            this = default(DataToken);
            _byte = number;
            _tokenType = TokenType.Byte;
        }
 
        public DataToken(short number)
        {
            this = default(DataToken);
            _short = number;
            _tokenType = TokenType.Short;
        }
 
        public DataToken(ushort number)
        {
            this = default(DataToken);
            _ushort = number;
            _tokenType = TokenType.UShort;
        }
 
        public DataToken(int number)
        {
            this = default(DataToken);
            _int = number;
            _tokenType = TokenType.Int;
        }
 
        public DataToken(uint number)
        {
            this = default(DataToken);
            _uint = number;
            _tokenType = TokenType.UInt;
        }
 
        public DataToken(long number)
        {
            this = default(DataToken);
            _long = number;
            _tokenType = TokenType.Long;
        }
 
        public DataToken(ulong number)
        {
            this = default(DataToken);
            _ulong = number;
            _tokenType = TokenType.ULong;
        }
 
        public DataToken(float number)
        {
            this = default(DataToken);
            _float = number;
            _tokenType = TokenType.Float;
        }
 
        public DataToken(double number)
        {
            this = default(DataToken);
            _double = number;
            _tokenType = TokenType.Double;
        }
 
        public DataToken(string str)
        {
            this = default(DataToken);
            if (str == null)
            {
                _tokenType = TokenType.Null;
                return;
            }
            _string = str;
            _tokenType = TokenType.String;
        }
 
        public DataToken(DataList list)
        {
            this = default(DataToken);
            if (list == null)
            {
                _tokenType = TokenType.Null;
                return;
            }
            _reference = list;
            _tokenType = TokenType.DataList;
        }
 
        public DataToken(DataDictionary obj)
        {
            this = default(DataToken);
            if (obj == null)
            {
                _tokenType = TokenType.Null;
                return;
            }
            _reference = obj;
            _tokenType = TokenType.DataDictionary;
        }
 
        public DataToken(object reference)
        {
            this = default(DataToken);
            _reference = reference;
            _tokenType = TokenType.Reference;
        }
 
        public DataToken(Object reference)
        {
            this = default(DataToken);
            _reference = reference;
            _tokenType = TokenType.Reference;
        }
 
        public DataToken(DataError error)
        {
            this = default(DataToken);
            _error = error;
            _tokenType = TokenType.Error;
        }
 
        public DataToken(DataError error, string errorMessage)
        {
            this = default(DataToken);
            _error = error;
            _string = errorMessage;
            _tokenType = TokenType.Error;
        }
 
        public static explicit operator bool(DataToken value)
        {
            return value.Boolean;
        }
 
        public static explicit operator sbyte(DataToken value)
        {
            return value.SByte;
        }
 
        public static explicit operator byte(DataToken value)
        {
            return value.Byte;
        }
 
        public static explicit operator short(DataToken value)
        {
            return value.Short;
        }
 
        public static explicit operator ushort(DataToken value)
        {
            return value.UShort;
        }
 
        public static explicit operator int(DataToken value)
        {
            return value.Int;
        }
 
        public static explicit operator uint(DataToken value)
        {
            return value.UInt;
        }
 
        public static explicit operator long(DataToken value)
        {
            return value.Long;
        }
 
        public static explicit operator ulong(DataToken value)
        {
            return value.ULong;
        }
 
        public static explicit operator float(DataToken value)
        {
            return value.Float;
        }
 
        public static explicit operator double(DataToken value)
        {
            return value.Double;
        }
 
        public static explicit operator string(DataToken value)
        {
            return value.String;
        }
 
        public static explicit operator DataDictionary(DataToken value)
        {
            return value.DataDictionary;
        }
 
        public static explicit operator DataList(DataToken value)
        {
            return value.DataList;
        }
 
        public static explicit operator DataError(DataToken value)
        {
            return value.Error;
        }
 
        public static implicit operator DataToken(Object value)
        {
            return new DataToken(value);
        }
 
        public static implicit operator DataToken(bool value)
        {
            return new DataToken(value);
        }
 
        public static implicit operator DataToken(sbyte value)
        {
            return new DataToken(value);
        }
 
        public static implicit operator DataToken(byte value)
        {
            return new DataToken(value);
        }
 
        public static implicit operator DataToken(short value)
        {
            return new DataToken(value);
        }
 
        public static implicit operator DataToken(ushort value)
        {
            return new DataToken(value);
        }
 
        public static implicit operator DataToken(int value)
        {
            return new DataToken(value);
        }
 
        public static implicit operator DataToken(uint value)
        {
            return new DataToken(value);
        }
 
        public static implicit operator DataToken(long value)
        {
            return new DataToken(value);
        }
 
        public static implicit operator DataToken(ulong value)
        {
            return new DataToken(value);
        }
 
        public static implicit operator DataToken(float value)
        {
            return new DataToken(value);
        }
 
        public static implicit operator DataToken(double value)
        {
            return new DataToken(value);
        }
 
        public static implicit operator DataToken(string value)
        {
            return new DataToken(value);
        }
 
        public static implicit operator DataToken(DataDictionary value)
        {
            return new DataToken(value);
        }
 
        public static implicit operator DataToken(DataList value)
        {
            return new DataToken(value);
        }
 
        public static implicit operator DataToken(DataError value)
        {
            return new DataToken(value);
        }
 
        public override string ToString()
        {
            switch (TokenType)
            {
            case TokenType.Null:
                return "Null";
            case TokenType.Boolean:
            {
                bool boolean = Boolean;
                return ((Boolean)(ref boolean)).ToString();
            }
            case TokenType.SByte:
            {
                sbyte sByte = SByte;
                return ((SByte)(ref sByte)).ToString();
            }
            case TokenType.Byte:
            {
                byte @byte = Byte;
                return ((Byte)(ref @byte)).ToString();
            }
            case TokenType.Short:
            {
                short @short = Short;
                return ((Int16)(ref @short)).ToString();
            }
            case TokenType.UShort:
            {
                ushort uShort = UShort;
                return ((UInt16)(ref uShort)).ToString();
            }
            case TokenType.Int:
            {
                int @int = Int;
                return ((Int32)(ref @int)).ToString();
            }
            case TokenType.UInt:
            {
                uint uInt = UInt;
                return ((UInt32)(ref uInt)).ToString();
            }
            case TokenType.Long:
            {
                long @long = Long;
                return ((Int64)(ref @long)).ToString();
            }
            case TokenType.ULong:
            {
                ulong uLong = ULong;
                return ((UInt64)(ref uLong)).ToString();
            }
            case TokenType.Float:
            {
                float @float = Float;
                return ((Single)(ref @float)).ToString("G", (IFormatProvider)(object)CultureInfo.InvariantCulture);
            }
            case TokenType.Double:
            {
                double @double = Double;
                return ((Double)(ref @double)).ToString("G", (IFormatProvider)(object)CultureInfo.InvariantCulture);
            }
            case TokenType.String:
                return String;
            case TokenType.DataList:
                if (DataList == null)
                {
                    return "Null";
                }
                return ((Object)DataList).ToString();
            case TokenType.DataDictionary:
                if (DataDictionary == null)
                {
                    return "Null";
                }
                return ((Object)DataDictionary).ToString();
            case TokenType.Reference:
                if (Reference == null)
                {
                    return "Null";
                }
                return Reference.ToString();
            case TokenType.Error:
                if (String.IsNullOrEmpty(String))
                {
                    return ((Object)Error).ToString();
                }
                return String.Concat(((Object)Error).ToString(), ": ", String);
            default:
                return String.Format("DataToken({0})", (object)_tokenType);
            }
        }
 
        public override int GetHashCode()
        {
            //IL_0159: Unknown result type (might be due to invalid IL or missing references)
            switch (TokenType)
            {
            case TokenType.Null:
                return ((Object)TokenType.Null).GetHashCode();
            case TokenType.Boolean:
                return ((Boolean)(ref _boolean)).GetHashCode();
            case TokenType.SByte:
                return ((SByte)(ref _sbyte)).GetHashCode();
            case TokenType.Byte:
                return ((Byte)(ref _byte)).GetHashCode();
            case TokenType.Short:
                return ((Int16)(ref _short)).GetHashCode();
            case TokenType.UShort:
                return ((UInt16)(ref _ushort)).GetHashCode();
            case TokenType.Int:
                return ((Int32)(ref _int)).GetHashCode();
            case TokenType.UInt:
                return ((UInt32)(ref _uint)).GetHashCode();
            case TokenType.Long:
                return ((Int64)(ref _long)).GetHashCode();
            case TokenType.ULong:
                return ((UInt64)(ref _ulong)).GetHashCode();
            case TokenType.Float:
                return ((Single)(ref _float)).GetHashCode();
            case TokenType.Double:
                return ((Double)(ref _double)).GetHashCode();
            case TokenType.String:
                if (_string == null)
                {
                    return ((Object)TokenType.Null).GetHashCode();
                }
                return ((Object)_string).GetHashCode();
            case TokenType.DataList:
            case TokenType.DataDictionary:
            case TokenType.Reference:
                if (_reference == null)
                {
                    return ((Object)TokenType.Null).GetHashCode();
                }
                return _reference.GetHashCode();
            case TokenType.Error:
                return ((Object)_error).GetHashCode();
            default:
                throw new NotImplementedException(String.Format("GetHashCode not implemented for TokenType {0}", (object)_tokenType));
            }
        }
 
        public int CompareTo(object obj)
        {
            if (obj is DataToken other)
            {
                return CompareTo(other);
            }
            return 1;
        }
 
        public int CompareTo(DataToken other)
        {
            int num;
            if (IsNumber && other.IsNumber)
            {
                double @double;
                if (TokenType == other.TokenType)
                {
                    switch (TokenType)
                    {
                    case TokenType.Byte:
                    {
                        byte @byte = Byte;
                        return ((Byte)(ref @byte)).CompareTo(other.Byte);
                    }
                    case TokenType.Short:
                    {
                        short @short = Short;
                        return ((Int16)(ref @short)).CompareTo(other.Short);
                    }
                    case TokenType.UShort:
                    {
                        ushort uShort = UShort;
                        return ((UInt16)(ref uShort)).CompareTo(other.UShort);
                    }
                    case TokenType.Int:
                        num = Int;
                        return ((Int32)(ref num)).CompareTo(other.Int);
                    case TokenType.UInt:
                    {
                        uint uInt = UInt;
                        return ((UInt32)(ref uInt)).CompareTo(other.UInt);
                    }
                    case TokenType.Long:
                    {
                        long @long = Long;
                        return ((Int64)(ref @long)).CompareTo(other.Long);
                    }
                    case TokenType.ULong:
                    {
                        ulong uLong = ULong;
                        return ((UInt64)(ref uLong)).CompareTo(other.ULong);
                    }
                    case TokenType.Float:
                    {
                        float @float = Float;
                        return ((Single)(ref @float)).CompareTo(other.Float);
                    }
                    case TokenType.Double:
                        @double = Double;
                        return ((Double)(ref @double)).CompareTo(other.Double);
                    }
                }
                @double = Double;
                return ((Double)(ref @double)).CompareTo(other.Double);
            }
            if (TokenType == other.TokenType)
            {
                switch (TokenType)
                {
                case TokenType.String:
                    return String.Compare(_string, other._string, (StringComparison)2);
                case TokenType.DataList:
                    num = DataList.Count;
                    return ((Int32)(ref num)).CompareTo(other.DataList.Count);
                case TokenType.DataDictionary:
                    num = DataDictionary.Count;
                    return ((Int32)(ref num)).CompareTo(other.DataDictionary.Count);
                case TokenType.Error:
                    return ((Enum)Error).CompareTo((object)other.Error);
                }
            }
            return ((Enum)TokenType).CompareTo((object)other.TokenType);
        }
 
        public static bool operator ==(in DataToken lhs, in DataToken rhs)
        {
            return lhs.Equals(rhs);
        }
 
        public static bool operator !=(in DataToken lhs, in DataToken rhs)
        {
            return !lhs.Equals(rhs);
        }
 
        public bool Equals(DataToken other)
        {
            if (TokenType != other.TokenType)
            {
                return false;
            }
            return TokenType switch
            {
                TokenType.Null => true, 
                TokenType.Boolean => ((Boolean)(ref _boolean)).Equals(other._boolean), 
                TokenType.SByte => ((SByte)(ref _sbyte)).Equals(other._sbyte), 
                TokenType.Byte => ((Byte)(ref _byte)).Equals(other._byte), 
                TokenType.Short => ((Int16)(ref _short)).Equals(other._short), 
                TokenType.UShort => ((UInt16)(ref _ushort)).Equals(other._ushort), 
                TokenType.Int => ((Int32)(ref _int)).Equals(other._int), 
                TokenType.UInt => ((UInt32)(ref _uint)).Equals(other._uint), 
                TokenType.Long => ((Int64)(ref _long)).Equals(other._long), 
                TokenType.ULong => ((UInt64)(ref _ulong)).Equals(other._ulong), 
                TokenType.Float => ((Single)(ref _float)).Equals(other._float), 
                TokenType.Double => ((Double)(ref _double)).Equals(other._double), 
                TokenType.String => _string == other._string, 
                TokenType.DataList => _reference == other._reference, 
                TokenType.DataDictionary => _reference == other._reference, 
                TokenType.Reference => _reference == other._reference, 
                TokenType.Error => _error == other._error, 
                _ => false, 
            };
        }
 
        public static bool operator ==(in DataToken lhs, in object rhs)
        {
            return ((Object)lhs).Equals(rhs);
        }
 
        public static bool operator !=(in DataToken lhs, in object rhs)
        {
            return !((Object)lhs).Equals(rhs);
        }
 
        public static bool operator ==(in object lhs, in DataToken rhs)
        {
            return ((Object)rhs).Equals(lhs);
        }
 
        public static bool operator !=(in object lhs, in DataToken rhs)
        {
            return !((Object)rhs).Equals(lhs);
        }
 
        public override bool Equals(object obj)
        {
            if (obj is DataToken other)
            {
                return Equals(other);
            }
            if (TokenType == TokenType.Null)
            {
                return obj == null;
            }
            if (TokenType == TokenType.Reference && _reference != null)
            {
                return _reference.Equals(obj);
            }
            if (TokenType == TokenType.Reference && _reference == null && obj == null)
            {
                return true;
            }
            return false;
        }
 
        public static bool operator ==(in DataToken lhs, in DataList rhs)
        {
            return lhs.Equals(rhs);
        }
 
        public static bool operator !=(in DataToken lhs, in DataList rhs)
        {
            return !lhs.Equals(rhs);
        }
 
        public static bool operator ==(in DataList lhs, in DataToken rhs)
        {
            return rhs.Equals(lhs);
        }
 
        public static bool operator !=(in DataList lhs, in DataToken rhs)
        {
            return !rhs.Equals(lhs);
        }
 
        public bool Equals(DataList other)
        {
            if (TokenType == TokenType.DataList)
            {
                return DataList == other;
            }
            return false;
        }
 
        public static bool operator ==(in DataToken lhs, in DataDictionary rhs)
        {
            return lhs.Equals(rhs);
        }
 
        public static bool operator !=(in DataToken lhs, in DataDictionary rhs)
        {
            return !lhs.Equals(rhs);
        }
 
        public static bool operator ==(in DataDictionary lhs, in DataToken rhs)
        {
            return rhs.Equals(lhs);
        }
 
        public static bool operator !=(in DataDictionary lhs, in DataToken rhs)
        {
            return !rhs.Equals(lhs);
        }
 
        public bool Equals(DataDictionary other)
        {
            if (TokenType == TokenType.DataDictionary)
            {
                return DataDictionary == other;
            }
            return false;
        }
 
        public bool Equals(bool other)
        {
            if (TokenType == TokenType.Boolean)
            {
                return Boolean == other;
            }
            return false;
        }
 
        public static bool operator ==(in DataToken lhs, in string rhs)
        {
            return lhs.Equals(rhs);
        }
 
        public static bool operator !=(in DataToken lhs, in string rhs)
        {
            return !lhs.Equals(rhs);
        }
 
        public static bool operator ==(in string lhs, in DataToken rhs)
        {
            return rhs.Equals(lhs);
        }
 
        public static bool operator !=(in string lhs, in DataToken rhs)
        {
            return !rhs.Equals(lhs);
        }
 
        public bool Equals(string other)
        {
            if (TokenType == TokenType.String)
            {
                return String == other;
            }
            return false;
        }
 
        public static bool operator ==(in DataToken lhs, in sbyte rhs)
        {
            return lhs.Equals(rhs);
        }
 
        public static bool operator !=(in DataToken lhs, in sbyte rhs)
        {
            return !lhs.Equals(rhs);
        }
 
        public static bool operator ==(in sbyte lhs, in DataToken rhs)
        {
            return rhs.Equals(lhs);
        }
 
        public static bool operator !=(in sbyte lhs, in DataToken rhs)
        {
            return !rhs.Equals(lhs);
        }
 
        public bool Equals(sbyte other)
        {
            if (TokenType == TokenType.SByte)
            {
                return SByte == other;
            }
            if (IsNumber)
            {
                return Double == (double)other;
            }
            return false;
        }
 
        public static bool operator ==(in DataToken lhs, in byte rhs)
        {
            return lhs.Equals(rhs);
        }
 
        public static bool operator !=(in DataToken lhs, in byte rhs)
        {
            return !lhs.Equals(rhs);
        }
 
        public static bool operator ==(in byte lhs, in DataToken rhs)
        {
            return rhs.Equals(lhs);
        }
 
        public static bool operator !=(in byte lhs, in DataToken rhs)
        {
            return !rhs.Equals(lhs);
        }
 
        public bool Equals(byte other)
        {
            if (TokenType == TokenType.Byte)
            {
                return Byte == other;
            }
            if (IsNumber)
            {
                return Double == (double)(int)other;
            }
            return false;
        }
 
        public static bool operator ==(in DataToken lhs, in short rhs)
        {
            return lhs.Equals(rhs);
        }
 
        public static bool operator !=(in DataToken lhs, in short rhs)
        {
            return !lhs.Equals(rhs);
        }
 
        public static bool operator ==(in short lhs, in DataToken rhs)
        {
            return rhs.Equals(lhs);
        }
 
        public static bool operator !=(in short lhs, in DataToken rhs)
        {
            return !rhs.Equals(lhs);
        }
 
        public bool Equals(short other)
        {
            if (TokenType == TokenType.Short)
            {
                return Short == other;
            }
            if (IsNumber)
            {
                return Double == (double)other;
            }
            return false;
        }
 
        public static bool operator ==(in DataToken lhs, in ushort rhs)
        {
            return lhs.Equals(rhs);
        }
 
        public static bool operator !=(in DataToken lhs, in ushort rhs)
        {
            return !lhs.Equals(rhs);
        }
 
        public static bool operator ==(in ushort lhs, in DataToken rhs)
        {
            return rhs.Equals(lhs);
        }
 
        public static bool operator !=(in ushort lhs, in DataToken rhs)
        {
            return !rhs.Equals(lhs);
        }
 
        public bool Equals(ushort other)
        {
            if (TokenType == TokenType.UShort)
            {
                return UShort == other;
            }
            if (IsNumber)
            {
                return Double == (double)(int)other;
            }
            return false;
        }
 
        public static bool operator ==(in DataToken lhs, in int rhs)
        {
            return lhs.Equals(rhs);
        }
 
        public static bool operator !=(in DataToken lhs, in int rhs)
        {
            return !lhs.Equals(rhs);
        }
 
        public static bool operator ==(in int lhs, in DataToken rhs)
        {
            return rhs.Equals(lhs);
        }
 
        public static bool operator !=(in int lhs, in DataToken rhs)
        {
            return !rhs.Equals(lhs);
        }
 
        public bool Equals(int other)
        {
            if (TokenType == TokenType.Int)
            {
                return Int == other;
            }
            if (IsNumber)
            {
                return Double == (double)other;
            }
            return false;
        }
 
        public static bool operator ==(in DataToken lhs, in uint rhs)
        {
            return lhs.Equals(rhs);
        }
 
        public static bool operator !=(in DataToken lhs, in uint rhs)
        {
            return !lhs.Equals(rhs);
        }
 
        public static bool operator ==(in uint lhs, in DataToken rhs)
        {
            return rhs.Equals(lhs);
        }
 
        public static bool operator !=(in uint lhs, in DataToken rhs)
        {
            return !rhs.Equals(lhs);
        }
 
        public bool Equals(uint other)
        {
            if (TokenType == TokenType.UInt)
            {
                return UInt == other;
            }
            if (IsNumber)
            {
                return Double == (double)other;
            }
            return false;
        }
 
        public static bool operator ==(in DataToken lhs, in ulong rhs)
        {
            return lhs.Equals(rhs);
        }
 
        public static bool operator !=(in DataToken lhs, in ulong rhs)
        {
            return !lhs.Equals(rhs);
        }
 
        public static bool operator ==(in ulong lhs, in DataToken rhs)
        {
            return rhs.Equals(lhs);
        }
 
        public static bool operator !=(in ulong lhs, in DataToken rhs)
        {
            return !rhs.Equals(lhs);
        }
 
        public bool Equals(ulong other)
        {
            if (TokenType == TokenType.ULong)
            {
                return ULong == other;
            }
            if (IsNumber)
            {
                return Double == (double)other;
            }
            return false;
        }
 
        public static bool operator ==(in DataToken lhs, in long rhs)
        {
            return lhs.Equals(rhs);
        }
 
        public static bool operator !=(in DataToken lhs, in long rhs)
        {
            return !lhs.Equals(rhs);
        }
 
        public static bool operator ==(in long lhs, in DataToken rhs)
        {
            return rhs.Equals(lhs);
        }
 
        public static bool operator !=(in long lhs, in DataToken rhs)
        {
            return !rhs.Equals(lhs);
        }
 
        public bool Equals(long other)
        {
            if (TokenType == TokenType.Long)
            {
                return Long == other;
            }
            if (IsNumber)
            {
                return Double == (double)other;
            }
            return false;
        }
 
        public static bool operator ==(in DataToken lhs, in float rhs)
        {
            return lhs.Equals(rhs);
        }
 
        public static bool operator !=(in DataToken lhs, in float rhs)
        {
            return !lhs.Equals(rhs);
        }
 
        public static bool operator ==(in float lhs, in DataToken rhs)
        {
            return rhs.Equals(lhs);
        }
 
        public static bool operator !=(in float lhs, in DataToken rhs)
        {
            return !rhs.Equals(lhs);
        }
 
        public bool Equals(float other)
        {
            if (TokenType == TokenType.Float)
            {
                return Float == other;
            }
            if (IsNumber)
            {
                return Double == (double)other;
            }
            return false;
        }
 
        public static bool operator ==(in DataToken lhs, in double rhs)
        {
            return lhs.Equals(rhs);
        }
 
        public static bool operator !=(in DataToken lhs, in double rhs)
        {
            return !lhs.Equals(rhs);
        }
 
        public static bool operator ==(in double lhs, in DataToken rhs)
        {
            return rhs.Equals(lhs);
        }
 
        public static bool operator !=(in double lhs, in DataToken rhs)
        {
            return !rhs.Equals(lhs);
        }
 
        public bool Equals(double other)
        {
            if (TokenType == TokenType.Double)
            {
                return Double == other;
            }
            if (IsNumber)
            {
                return Double == other;
            }
            return false;
        }
 
        public static bool operator ==(in DataToken lhs, in DataError rhs)
        {
            return lhs.Equals(rhs);
        }
 
        public static bool operator !=(in DataToken lhs, in DataError rhs)
        {
            return !lhs.Equals(rhs);
        }
 
        public static bool operator ==(in DataError lhs, in DataToken rhs)
        {
            return rhs.Equals(lhs);
        }
 
        public static bool operator !=(in DataError lhs, in DataToken rhs)
        {
            return !rhs.Equals(lhs);
        }
 
        public bool Equals(DataError other)
        {
            if (TokenType == TokenType.Error)
            {
                return Error == other;
            }
            return Equals(new DataToken(other));
        }
 
        public readonly DataToken Bitcast(TokenType targetType)
        {
            //IL_0023: Unknown result type (might be due to invalid IL or missing references)
            //IL_00ef: Unknown result type (might be due to invalid IL or missing references)
            TokenType tokenType = _tokenType;
            if (tokenType - 1 > TokenType.Float)
            {
                throw new InvalidOperationException(String.Format("Attempted to bitcast from {0} token", (object)_tokenType));
            }
            DataToken dataToken = default(DataToken);
            dataToken._tokenType = targetType;
            DataToken result = dataToken;
            switch (targetType)
            {
            case TokenType.Boolean:
                result._boolean = _boolean;
                break;
            case TokenType.SByte:
            case TokenType.Byte:
                result._sbyte = _sbyte;
                break;
            case TokenType.Short:
            case TokenType.UShort:
                result._short = _short;
                break;
            case TokenType.Int:
            case TokenType.UInt:
                result._int = _int;
                break;
            case TokenType.Long:
            case TokenType.ULong:
                result._long = _long;
                break;
            case TokenType.Float:
                result._float = _float;
                break;
            case TokenType.Double:
                result._double = _double;
                break;
            default:
                throw new InvalidOperationException(String.Format("Attempted to bitcast to {0} token", (object)_tokenType));
            }
            return result;
        }
 
        [ExcludeFromUdonWrapper]
        public void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            info.AddValue("_type", (object)_tokenType);
            switch (_tokenType)
            {
            case TokenType.Boolean:
                info.AddValue("_boolean", _boolean);
                break;
            case TokenType.SByte:
                info.AddValue("_sbyte", _sbyte);
                break;
            case TokenType.Byte:
                info.AddValue("_byte", _byte);
                break;
            case TokenType.Short:
                info.AddValue("_short", _short);
                break;
            case TokenType.UShort:
                info.AddValue("_ushort", _ushort);
                break;
            case TokenType.Int:
                info.AddValue("_int", _int);
                break;
            case TokenType.UInt:
                info.AddValue("_uint", _uint);
                break;
            case TokenType.Long:
                info.AddValue("_long", _long);
                break;
            case TokenType.ULong:
                info.AddValue("_ulong", _ulong);
                break;
            case TokenType.Float:
                info.AddValue("_float", _float);
                break;
            case TokenType.Double:
                info.AddValue("_double", _double);
                break;
            case TokenType.String:
                info.AddValue("_string", (object)_string);
                break;
            case TokenType.DataDictionary:
                info.AddValue("_reference", _reference);
                break;
            case TokenType.DataList:
                info.AddValue("_reference", _reference);
                break;
            case TokenType.Reference:
                info.AddValue("_reference", _reference);
                break;
            case TokenType.Error:
                info.AddValue("_error", (object)_error);
                break;
            }
        }
 
        public DataToken(SerializationInfo info, StreamingContext context)
        {
            //IL_008d: Unknown result type (might be due to invalid IL or missing references)
            //IL_0097: Expected I4, but got Unknown
            //IL_00ae: Unknown result type (might be due to invalid IL or missing references)
            //IL_00b8: Expected I4, but got Unknown
            //IL_00cf: Unknown result type (might be due to invalid IL or missing references)
            //IL_00d9: Expected I4, but got Unknown
            //IL_00f0: Unknown result type (might be due to invalid IL or missing references)
            //IL_00fa: Expected I4, but got Unknown
            //IL_0111: Unknown result type (might be due to invalid IL or missing references)
            //IL_011b: Expected I4, but got Unknown
            //IL_0132: Unknown result type (might be due to invalid IL or missing references)
            //IL_013c: Expected I4, but got Unknown
            //IL_0153: Unknown result type (might be due to invalid IL or missing references)
            //IL_015d: Expected I4, but got Unknown
            //IL_0174: Unknown result type (might be due to invalid IL or missing references)
            //IL_017e: Expected I8, but got Unknown
            //IL_0195: Unknown result type (might be due to invalid IL or missing references)
            //IL_019f: Expected I8, but got Unknown
            //IL_01b6: Unknown result type (might be due to invalid IL or missing references)
            //IL_01c0: Expected F4, but got Unknown
            //IL_01d7: Unknown result type (might be due to invalid IL or missing references)
            //IL_01e1: Expected F8, but got Unknown
            //IL_01f8: Unknown result type (might be due to invalid IL or missing references)
            //IL_0202: Expected O, but got Unknown
            this = default(DataToken);
            _tokenType = (TokenType)info.GetValue("_type", typeof(TokenType));
            switch (_tokenType)
            {
            case TokenType.Boolean:
                _boolean = (byte)(int)(Boolean)info.GetValue("_boolean", typeof(Boolean)) != 0;
                break;
            case TokenType.SByte:
                _sbyte = (sbyte)(int)(SByte)info.GetValue("_sbyte", typeof(SByte));
                break;
            case TokenType.Byte:
                _byte = (byte)(int)(Byte)info.GetValue("_byte", typeof(Byte));
                break;
            case TokenType.Short:
                _short = (short)(int)(Int16)info.GetValue("_short", typeof(Int16));
                break;
            case TokenType.UShort:
                _ushort = (ushort)(int)(UInt16)info.GetValue("_ushort", typeof(UInt16));
                break;
            case TokenType.Int:
                _int = (int)(Int32)info.GetValue("_int", typeof(Int32));
                break;
            case TokenType.UInt:
                _uint = (uint)(int)(UInt32)info.GetValue("_uint", typeof(UInt32));
                break;
            case TokenType.Long:
                _long = (long)(Int64)info.GetValue("_long", typeof(Int64));
                break;
            case TokenType.ULong:
                _ulong = (ulong)(long)(UInt64)info.GetValue("_ulong", typeof(UInt64));
                break;
            case TokenType.Float:
                _float = (float)(Single)info.GetValue("_float", typeof(Single));
                break;
            case TokenType.Double:
                _double = (double)(Double)info.GetValue("_double", typeof(Double));
                break;
            case TokenType.String:
                _string = (string)(String)info.GetValue("_string", typeof(String));
                break;
            case TokenType.DataDictionary:
                _reference = info.GetValue("_reference", typeof(Object));
                break;
            case TokenType.DataList:
                _reference = info.GetValue("_reference", typeof(Object));
                break;
            case TokenType.Reference:
                _reference = info.GetValue("_reference", typeof(Object));
                break;
            case TokenType.Error:
                _reference = info.GetValue("_error", typeof(DataError));
                break;
            }
        }
    }
    public class JsonDictionary : DataDictionary
    {
        private string _source;
 
        private Dictionary<DataToken, ValueTuple<JsonType, int>> _lazyValues = new Dictionary<DataToken, ValueTuple<JsonType, int>>();
 
        public override int Count => _lazyValues.Count + _values.Count;
 
        public JsonDictionary(string source)
        {
            _source = source;
        }
 
        public override void SetValue(DataToken key, DataToken value)
        {
            if (_lazyValues.Remove(key))
            {
                keysDirty = true;
            }
            base.SetValue(key, value);
        }
 
        protected override DataToken GetValue(DataToken key, out bool success)
        {
            //IL_003b: Unknown result type (might be due to invalid IL or missing references)
            //IL_004c: Unknown result type (might be due to invalid IL or missing references)
            if (!_lazyValues.ContainsKey(key))
            {
                return base.GetValue(key, out success);
            }
            if (String.IsNullOrEmpty(_source))
            {
                success = false;
                return DataError.UnableToParse;
            }
            DataToken result;
            bool num = VRCJson.TryParseToken(_source, _lazyValues[key].Item1, _lazyValues[key].Item2, out result);
            _lazyValues.Remove(key);
            _values.Add(key, result);
            if (!num)
            {
                success = false;
                return DataError.UnableToParse;
            }
            success = true;
            return result;
        }
 
        public override void Clear()
        {
            _lazyValues.Clear();
            base.Clear();
        }
 
        public override bool ContainsKey(DataToken key)
        {
            if (_lazyValues.ContainsKey(key))
            {
                return true;
            }
            return base.ContainsKey(key);
        }
 
        public override bool Remove(DataToken key)
        {
            if (_lazyValues.Remove(key))
            {
                return true;
            }
            return base.Remove(key);
        }
 
        internal override void ParseAll()
        {
            //IL_0014: Unknown result type (might be due to invalid IL or missing references)
            //IL_0019: Unknown result type (might be due to invalid IL or missing references)
            //IL_001e: Unknown result type (might be due to invalid IL or missing references)
            //IL_0023: Unknown result type (might be due to invalid IL or missing references)
            //IL_002c: Unknown result type (might be due to invalid IL or missing references)
            //IL_0038: Unknown result type (might be due to invalid IL or missing references)
            if (_lazyValues.Count == 0)
            {
                return;
            }
            Enumerator<DataToken, ValueTuple<JsonType, int>> enumerator = _lazyValues.GetEnumerator();
            try
            {
                while (enumerator.MoveNext())
                {
                    KeyValuePair<DataToken, ValueTuple<JsonType, int>> current = enumerator.Current;
                    if (VRCJson.TryParseToken(_source, current.Value.Item1, current.Value.Item2, out var result))
                    {
                        _values[current.Key] = result;
                    }
                }
            }
            finally
            {
                ((IDisposable)enumerator).Dispose();
            }
            _lazyValues.Clear();
        }
 
        public override DataList GetKeys()
        {
            if (keysDirty)
            {
                keyCache = new DataList((IEnumerable<DataToken>)(object)_values.Keys);
                keyCache.AddRange((IEnumerable<DataToken>)(object)_lazyValues.Keys);
                keysDirty = false;
                return keyCache;
            }
            return keyCache;
        }
 
        public override void Add(DataToken key, DataToken value)
        {
            //IL_0023: Unknown result type (might be due to invalid IL or missing references)
            if (_lazyValues.ContainsKey(key))
            {
                throw new ArgumentException(String.Format("Key {0} already exists in the dictionary", (object)key), "key");
            }
            base.Add(key, value);
        }
 
        internal void AddLazyValue(DataToken key, JsonType type, int index)
        {
            //IL_0009: Unknown result type (might be due to invalid IL or missing references)
            _lazyValues.Add(key, new ValueTuple<JsonType, int>(type, index));
        }
    }
    public class JsonList : DataList
    {
        private List<ValueTuple<JsonType, string>> _lazyValues = new List<ValueTuple<JsonType, string>>();
 
        internal JsonList()
        {
        }
 
        protected override DataToken GetValue(int index, out bool success)
        {
            //IL_0052: Unknown result type (might be due to invalid IL or missing references)
            //IL_007b: Unknown result type (might be due to invalid IL or missing references)
            //IL_008c: Unknown result type (might be due to invalid IL or missing references)
            if (index < 0 || index >= _values.Count)
            {
                success = false;
                return DataError.IndexOutOfRange;
            }
            if (_values[index].TokenType == TokenType.Null)
            {
                if (_lazyValues == null || index > _lazyValues.Count || String.IsNullOrEmpty(_lazyValues[index].Item2))
                {
                    success = true;
                    return _values[index];
                }
                success = VRCJson.TryParseToken(_lazyValues[index].Item2, _lazyValues[index].Item1, 0, out var result);
                if (!success)
                {
                    return DataError.UnableToParse;
                }
                _values[index] = result;
            }
            success = true;
            ClearLazyValue(index);
            return _values[index];
        }
 
        public override void Insert(int index, DataToken value)
        {
            //IL_001a: Unknown result type (might be due to invalid IL or missing references)
            _values.Insert(index, value);
            _lazyValues.Insert(index, new ValueTuple<JsonType, string>(JsonType.Invalid, String.Empty));
        }
 
        public override void InsertRange(int index, DataList input)
        {
            _lazyValues.InsertRange(index, (IEnumerable<ValueTuple<JsonType, string>>)(object)new ValueTuple<JsonType, string>[input.Count]);
            _values.InsertRange(index, (IEnumerable<DataToken>)(object)input._values);
        }
 
        public override void Add(DataToken value)
        {
            //IL_0018: Unknown result type (might be due to invalid IL or missing references)
            _values.Add(value);
            _lazyValues.Add(new ValueTuple<JsonType, string>(JsonType.Invalid, String.Empty));
        }
 
        public override void RemoveAt(int index)
        {
            base.RemoveAt(index);
            _lazyValues.RemoveAt(index);
        }
 
        public override void Clear()
        {
            _lazyValues.Clear();
            base.Clear();
        }
 
        public override void RemoveRange(int index, int count)
        {
            _lazyValues.RemoveRange(index, count);
            _values.RemoveRange(index, count);
        }
 
        public override void Reverse()
        {
            _lazyValues.Reverse();
            base.Reverse();
        }
 
        public override void Reverse(int index, int count)
        {
            _lazyValues.Reverse(index, count);
            _values.Reverse(index, count);
        }
 
        protected override void ParseInRange(int startIndex, int stopIndex)
        {
            //IL_0021: Unknown result type (might be due to invalid IL or missing references)
            //IL_0039: Unknown result type (might be due to invalid IL or missing references)
            //IL_004a: Unknown result type (might be due to invalid IL or missing references)
            for (int i = startIndex; i < stopIndex; i++)
            {
                if (_values[i].TokenType == TokenType.Null && !String.IsNullOrEmpty(_lazyValues[i].Item2) && VRCJson.TryParseToken(_lazyValues[i].Item2, _lazyValues[i].Item1, 0, out var result))
                {
                    _values[i] = result;
                    ClearLazyValue(i);
                }
            }
        }
 
        internal void AddLazyValue(JsonType type, string source)
        {
            //IL_0008: Unknown result type (might be due to invalid IL or missing references)
            _lazyValues.Add(new ValueTuple<JsonType, string>(type, source));
            _values.Add(default(DataToken));
        }
 
        internal void ClearLazyValue(int index)
        {
            //IL_0009: Unknown result type (might be due to invalid IL or missing references)
            _lazyValues[index] = new ValueTuple<JsonType, string>(JsonType.Invalid, (string)null);
        }
    }
    public enum JsonType : Enum
    {
        Invalid,
        Null,
        Object,
        Array,
        String,
        Boolean,
        Number
    }
    public enum ParseState : Enum
    {
        Key,
        Value,
        EndOfKey,
        EndOfValue
    }
    public enum JsonExportType : Enum
    {
        Beautify,
        Minify
    }
    public static class VRCJson : Object
    {
        private static readonly char[] parseArrayChars;
 
        private static readonly char[] scanObjectChars;
 
        private static readonly char[] scanArrayChars;
 
        private static readonly char[] scanStringChars;
 
        private static readonly char[] scanWordChars;
 
        private static readonly char[] whitespaceChars;
 
        private static readonly char[] numberChars;
 
        private static HashSet<DataToken> seenContainers;
 
        public static bool TryDeserializeFromJson(string source, out DataToken result)
        {
            if (String.IsNullOrEmpty(source))
            {
                result = new DataToken(DataError.UnableToParse, "Unable to Deserialize from Json: string was null or empty");
                return false;
            }
            int i;
            for (i = 0; i < source.Length && source[i] == '\ufeff'; i++)
            {
            }
            if (TryIdentifyType(source, i, out var result2))
            {
                switch (result2)
                {
                case JsonType.Object:
                    return TryParseObject(source, i, out result);
                case JsonType.Array:
                    return TryParseArray(source, i, out result);
                }
            }
            result = new DataToken(DataError.TypeUnsupported, String.Format("Unable to Deserialize from Json: Root object must be a list or dictionary, was {0} instead", (object)result2));
            return false;
        }
 
        public static bool TrySerializeToJson(DataToken input, JsonExportType jsonExportType, out DataToken result)
        {
            //IL_000a: Unknown result type (might be due to invalid IL or missing references)
            //IL_0010: Expected O, but got Unknown
            seenContainers.Clear();
            StringBuilder val = new StringBuilder();
            if (input.TokenType == TokenType.DataDictionary)
            {
                if (SerializeObject(input.DataDictionary, jsonExportType, val, 0, out var error))
                {
                    result = ((Object)val).ToString();
                    seenContainers.Clear();
                    return true;
                }
                result = error;
                seenContainers.Clear();
                return false;
            }
            if (input.TokenType == TokenType.DataList)
            {
                if (SerializeArray(input.DataList, jsonExportType, val, 0, out var error2))
                {
                    result = ((Object)val).ToString();
                    seenContainers.Clear();
                    return true;
                }
                result = error2;
                seenContainers.Clear();
                return false;
            }
            seenContainers.Clear();
            result = new DataToken(DataError.TypeUnsupported, String.Format("Unable to serialize to Json: Root object must be a list or dictionary, was {0} instead", (object)input.TokenType));
            return false;
        }
 
        private static bool SerializeObject(DataDictionary dataDictionary, JsonExportType jsonExportType, StringBuilder builder, int indent, out DataToken error)
        {
            if (seenContainers.Contains((DataToken)dataDictionary))
            {
                error = new DataToken(DataError.ValueUnsupported, "Unable to serialize to JSON: Recursive containers found");
                return false;
            }
            seenContainers.Add((DataToken)dataDictionary);
            if (jsonExportType == JsonExportType.Beautify)
            {
                indent++;
                builder.Append("{\n");
                AppendIndent(builder, indent);
            }
            else
            {
                builder.Append("{");
            }
            DataList keys = dataDictionary.GetKeys();
            bool flag = true;
            for (int i = 0; i < keys.Count; i++)
            {
                if (keys[i].TokenType != TokenType.String)
                {
                    error = new DataToken(DataError.TypeUnsupported, String.Format("Unable to serialize to JSON: {0} {1} unsupported key type", (object)keys[i].TokenType, (object)((Object)keys[i]).ToString()));
                    return false;
                }
                if (!flag)
                {
                    if (jsonExportType == JsonExportType.Beautify)
                    {
                        builder.Append(",\n");
                        AppendIndent(builder, indent);
                    }
                    else
                    {
                        builder.Append(", ");
                    }
                }
                flag = false;
                if (!dataDictionary.TryGetValue(keys[i], out var value))
                {
                    continue;
                }
                builder.Append('"');
                builder.Append(keys[i].String);
                builder.Append("\": ");
                switch (value.TokenType)
                {
                case TokenType.DataDictionary:
                    if (!SerializeObject(value.DataDictionary, jsonExportType, builder, indent, out error))
                    {
                        return false;
                    }
                    break;
                case TokenType.DataList:
                    if (!SerializeArray(value.DataList, jsonExportType, builder, indent, out error))
                    {
                        return false;
                    }
                    break;
                case TokenType.String:
                    builder.Append('"');
                    builder.Append(EscapeString(((Object)value).ToString()));
                    builder.Append('"');
                    break;
                case TokenType.SByte:
                case TokenType.Byte:
                case TokenType.Short:
                case TokenType.UShort:
                case TokenType.Int:
                case TokenType.UInt:
                case TokenType.Long:
                case TokenType.ULong:
                case TokenType.Float:
                case TokenType.Double:
                    if (Double.IsNaN(value.Number) || Double.IsInfinity(value.Number))
                    {
                        error = new DataToken(DataError.ValueUnsupported, String.Concat("Unable to serialize to JSON: ", ((Object)keys[i]).ToString(), " contains an unsupported NaN or Infinity value"));
                        return false;
                    }
                    builder.Append(((Object)value).ToString());
                    break;
                case TokenType.Boolean:
                    builder.Append(value.Boolean ? "true" : "false");
                    break;
                case TokenType.Null:
                    builder.Append("null");
                    break;
                default:
                    error = new DataToken(DataError.TypeUnsupported, String.Format("Unable to serialize to JSON: {0} contains an unsupported type {1}", (object)((Object)keys[i]).ToString(), (object)value.TokenType));
                    return false;
                }
            }
            if (jsonExportType == JsonExportType.Beautify)
            {
                indent--;
                builder.Append("\n");
                AppendIndent(builder, indent);
                builder.Append("}");
            }
            else
            {
                builder.Append("}");
            }
            seenContainers.Remove((DataToken)dataDictionary);
            error = DataError.None;
            return true;
        }
 
        private static bool SerializeArray(DataList dataList, JsonExportType jsonExportType, StringBuilder builder, int indent, out DataToken error)
        {
            if (seenContainers.Contains((DataToken)dataList))
            {
                error = new DataToken(DataError.ValueUnsupported, "Unable to serialize to JSON: Recursive containers found");
                return false;
            }
            seenContainers.Add((DataToken)dataList);
            if (jsonExportType == JsonExportType.Beautify)
            {
                indent++;
                builder.Append("[\n");
                AppendIndent(builder, indent);
            }
            else
            {
                builder.Append("[");
            }
            for (int i = 0; i < dataList.Count; i++)
            {
                if (i > 0)
                {
                    if (jsonExportType == JsonExportType.Beautify)
                    {
                        builder.Append(",\n");
                        AppendIndent(builder, indent);
                    }
                    else
                    {
                        builder.Append(", ");
                    }
                }
                if (!dataList.TryGetValue(i, out var value))
                {
                    continue;
                }
                switch (value.TokenType)
                {
                case TokenType.DataDictionary:
                {
                    if (!SerializeObject(value.DataDictionary, jsonExportType, builder, indent, out var error2))
                    {
                        error = error2;
                        return false;
                    }
                    break;
                }
                case TokenType.DataList:
                {
                    if (!SerializeArray(value.DataList, jsonExportType, builder, indent, out var error3))
                    {
                        error = error3;
                        return false;
                    }
                    break;
                }
                case TokenType.String:
                    builder.Append('"');
                    builder.Append(EscapeString(((Object)value).ToString()));
                    builder.Append('"');
                    break;
                case TokenType.SByte:
                case TokenType.Byte:
                case TokenType.Short:
                case TokenType.UShort:
                case TokenType.Int:
                case TokenType.UInt:
                case TokenType.Long:
                case TokenType.ULong:
                case TokenType.Float:
                case TokenType.Double:
                    if (Double.IsNaN(value.Number) || Double.IsInfinity(value.Number))
                    {
                        error = new DataToken(DataError.ValueUnsupported, String.Format("Unable to serialize to JSON: index {0} contains an unsupported NaN or Infinity value", (object)i));
                        return false;
                    }
                    builder.Append(((Object)value).ToString());
                    break;
                case TokenType.Boolean:
                    builder.Append(value.Boolean ? "true" : "false");
                    break;
                case TokenType.Null:
                    builder.Append("null");
                    break;
                default:
                    error = new DataToken(DataError.TypeUnsupported, String.Format("Unable to serialize to JSON: index {0} unsupported type {1}", (object)i, (object)value.TokenType));
                    return false;
                }
            }
            if (jsonExportType == JsonExportType.Beautify)
            {
                indent--;
                builder.Append("\n");
                AppendIndent(builder, indent);
                builder.Append("]");
            }
            else
            {
                builder.Append("]");
            }
            seenContainers.Remove((DataToken)dataList);
            error = DataError.None;
            return true;
        }
 
        private static void AppendIndent(StringBuilder builder, int indent)
        {
            for (int i = 0; i < indent; i++)
            {
                builder.Append("\t");
            }
        }
 
        internal static bool TryParseToken(string source, JsonType type, int index, out DataToken result)
        {
            switch (type)
            {
            case JsonType.Object:
                return TryParseObject(source, index, out result);
            case JsonType.Array:
                return TryParseArray(source, index, out result);
            case JsonType.String:
                return TryParseString(source, ref index, out result);
            case JsonType.Number:
                return TryParseNumber(source, index, out result);
            case JsonType.Boolean:
                return TryParseBool(source, index, out result);
            case JsonType.Null:
                result = default(DataToken);
                return true;
            default:
                result = default(DataToken);
                return false;
            }
        }
 
        internal static bool TryParseObject(string source, int index, out DataToken result)
        {
            index++;
            ParseState parseState = ParseState.Key;
            JsonDictionary jsonDictionary = new JsonDictionary(source);
            DataToken result2 = default(DataToken);
            while (index < source.Length)
            {
                SkipWhitespace(source, ref index);
                if (source[index] == '}')
                {
                    if (parseState == ParseState.EndOfValue || parseState == ParseState.Key)
                    {
                        result = jsonDictionary;
                        return true;
                    }
                    result = new DataToken(DataError.UnableToParse, String.Format("Unable to Deserialize from Json: Found unexpected end of object while looking for {0}", (object)parseState));
                    return false;
                }
                switch (parseState)
                {
                case ParseState.Key:
                {
                    bool flag = TryIdentifyType(source, index, out var result3);
                    if (!flag)
                    {
                        result = new DataToken(DataError.UnableToParse, String.Format("Unable to Deserialize from Json: Unable to identify type at character {0}", (object)index));
                        return flag;
                    }
                    if (result3 == JsonType.String)
                    {
                        parseState = ParseState.EndOfKey;
                        flag = TryParseString(source, ref index, out result2);
                        if (!flag)
                        {
                            result = new DataToken(DataError.UnableToParse, String.Format("Unable to Deserialize from Json: Failed to parse string at character {0}", (object)index));
                            return flag;
                        }
                        break;
                    }
                    index++;
                    result = new DataToken(DataError.UnableToParse, String.Format("Unable to Deserialize from Json: Found unexpected type {0} while looking for key", (object)result3));
                    return false;
                }
                case ParseState.EndOfKey:
                    if (source[index] == ':')
                    {
                        index++;
                        parseState = ParseState.Value;
                        break;
                    }
                    result = new DataToken(DataError.UnableToParse, String.Format("Unable to Deserialize from Json: Found unexpected character {0} while looking for ':'", (object)source[index]));
                    return false;
                case ParseState.Value:
                {
                    JsonType result4;
                    bool success = TryIdentifyType(source, index, out result4);
                    if (!success)
                    {
                        result = new DataToken(DataError.UnableToParse, String.Format("Unable to Deserialize from Json: Unable to identify type at character {0}", (object)index));
                        return false;
                    }
                    int index2;
                    switch (result4)
                    {
                    case JsonType.String:
                        parseState = ParseState.EndOfValue;
                        index2 = index;
                        ScanString(out success, source, ref index);
                        if (!success)
                        {
                            result = new DataToken(DataError.UnableToParse, "Unable to Deserialize from Json: String is not valid");
                            return false;
                        }
                        break;
                    case JsonType.Number:
                        parseState = ParseState.EndOfValue;
                        index2 = index;
                        ScanNumber(out success, source, ref index);
                        if (!success)
                        {
                            result = new DataToken(DataError.UnableToParse, "Unable to Deserialize from Json: Number is not valid");
                            return false;
                        }
                        break;
                    case JsonType.Array:
                        parseState = ParseState.EndOfValue;
                        index2 = index;
                        ScanArray(out success, source, ref index);
                        if (!success)
                        {
                            result = new DataToken(DataError.UnableToParse, "Unable to Deserialize from Json: Array is not valid");
                            return false;
                        }
                        break;
                    case JsonType.Object:
                        parseState = ParseState.EndOfValue;
                        index2 = index;
                        ScanObject(out success, source, ref index);
                        if (!success)
                        {
                            result = new DataToken(DataError.UnableToParse, "Unable to Deserialize from Json: Object is not valid");
                            return false;
                        }
                        break;
                    case JsonType.Boolean:
                        parseState = ParseState.EndOfValue;
                        index2 = index;
                        ScanBool(out success, source, ref index);
                        if (!success)
                        {
                            result = new DataToken(DataError.UnableToParse, "Unable to Deserialize from Json: Boolean is not valid");
                            return false;
                        }
                        break;
                    case JsonType.Null:
                        parseState = ParseState.EndOfValue;
                        index2 = index;
                        ScanNull(out success, source, ref index);
                        if (!success)
                        {
                            result = new DataToken(DataError.UnableToParse, "Unable to Deserialize from Json: Null is not valid");
                            return false;
                        }
                        break;
                    case JsonType.Invalid:
                        parseState = ParseState.EndOfValue;
                        index2 = index;
                        ScanUnknown(source, ref index);
                        break;
                    default:
                        parseState = ParseState.EndOfValue;
                        index2 = index;
                        index++;
                        break;
                    }
                    jsonDictionary.AddLazyValue(result2, result4, index2);
                    break;
                }
                case ParseState.EndOfValue:
                    if (source[index] == ',')
                    {
                        parseState = ParseState.Key;
                        index++;
                        break;
                    }
                    result = new DataToken(DataError.UnableToParse, String.Format("Unable to Deserialize from Json: Found unexpected character '{0}' while looking for character ','", (object)source[index]));
                    return false;
                }
            }
            result = new DataToken(DataError.UnableToParse, "Unable to Deserialize from Json: Found end of string before finishing object");
            return false;
        }
 
        internal static bool TryParseArray(string source, int index, out DataToken result)
        {
            if (!IsComplexArray(source, index))
            {
                index++;
                int num = index;
                SkipToCharacter(source, ref index, ']');
                string text = source.Substring(num, index - num);
                index++;
                if (String.IsNullOrEmpty(text))
                {
                    result = new DataList();
                    return true;
                }
                string[] array = text.Split((char[])(object)new Char[1] { (Char)44 }, (StringSplitOptions)1);
                JsonList jsonList = new JsonList();
                for (int i = 0; i < array.Length; i++)
                {
                    array[i] = TrimWhitespace(array[i]);
                    if (!String.IsNullOrEmpty(array[i]))
                    {
                        if (!TryIdentifyType(array[i], 0, out var result2))
                        {
                            result = new DataToken(DataError.UnableToParse, String.Format("Unable to Deserialize from Json: Unable to identify type at character {0}", (object)index));
                            return false;
                        }
                        jsonList.AddLazyValue(result2, array[i]);
                    }
                }
                result = jsonList;
                return true;
            }
            JsonList jsonList2 = new JsonList();
            index++;
            int num2 = index;
            int num3 = 0;
            bool flag = false;
            while (index < source.Length)
            {
                SkipToAnyCharacter(source, ref index, parseArrayChars);
                switch (source[index])
                {
                case '\\':
                    if (flag)
                    {
                        index++;
                    }
                    break;
                case '"':
                    flag = !flag;
                    break;
                case '{':
                    num3++;
                    break;
                case '}':
                    num3--;
                    break;
                case ',':
                    if (num3 == 0 && !flag)
                    {
                        string input2 = source.Substring(num2, index - num2);
                        input2 = TrimWhitespace(input2);
                        if (!TryIdentifyType(input2, 0, out var result4))
                        {
                            result = new DataToken(DataError.UnableToParse, String.Format("Unable to Deserialize from Json: Unable to identify type at character {0}", (object)index));
                            return false;
                        }
                        jsonList2.AddLazyValue(result4, input2);
                        num2 = index + 1;
                    }
                    break;
                case '[':
                    num3++;
                    break;
                case ']':
                    if (num3 == 0)
                    {
                        if (!flag)
                        {
                            string input = source.Substring(num2, index - num2);
                            input = TrimWhitespace(input);
                            if (String.IsNullOrEmpty(input))
                            {
                                result = jsonList2;
                                return true;
                            }
                            if (!TryIdentifyType(input, 0, out var result3))
                            {
                                result = new DataToken(DataError.UnableToParse, String.Format("Unable to Deserialize from Json: Unable to identify type at character {0}", (object)index));
                                return false;
                            }
                            jsonList2.AddLazyValue(result3, input);
                            index++;
                            result = jsonList2;
                            return true;
                        }
                    }
                    else
                    {
                        num3--;
                    }
                    break;
                }
                index++;
            }
            result = new DataToken(DataError.UnableToParse, "Unable to Deserialize from Json: Found end of string before finishing array");
            return false;
        }
 
        internal static bool TryParseString(string source, ref int index, out DataToken result)
        {
            //IL_0036: Unknown result type (might be due to invalid IL or missing references)
            //IL_003c: Expected O, but got Unknown
            int stringEnd = GetStringEnd(source, index);
            if (stringEnd != -1)
            {
                int num = index + 1;
                index = stringEnd + 1;
                result = source.Substring(num, stringEnd - num);
                return true;
            }
            index++;
            bool flag = false;
            StringBuilder val = new StringBuilder();
            while (index < source.Length)
            {
                if (flag)
                {
                    val.Append(UnEscapeCharacter(out var success, source, ref index));
                    flag = false;
                    if (!success)
                    {
                        result = new DataToken(DataError.UnableToParse, "Unable to Deserialize from Json: String had invalid escape characters");
                        return false;
                    }
                    continue;
                }
                string text = source.Substring(index, 1);
                if (text == "\\")
                {
                    flag = true;
                    index++;
                    continue;
                }
                if (text == "\"")
                {
                    index++;
                    result = ((Object)val).ToString();
                    return true;
                }
                val.Append(text);
                index++;
            }
            result = default(DataToken);
            return false;
        }
 
        internal static bool TryParseNumber(string source, int index, out DataToken result)
        {
            int num = index;
            while (index < source.Length)
            {
                char c = source[index];
                if (Array.IndexOf<char>(numberChars, c) != -1 || Char.IsNumber(c) || Char.IsWhiteSpace(c))
                {
                    index++;
                    continue;
                }
                switch (c)
                {
                }
                break;
            }
            string text = source.Substring(num, index - num);
            double num2 = default(double);
            if (Double.TryParse(text, (NumberStyles)167, (IFormatProvider)(object)CultureInfo.InvariantCulture, ref num2))
            {
                result = num2;
                return true;
            }
            text = text.ToLower();
            if (text.Contains("e"))
            {
                int num3 = text.IndexOf("e");
                if (num3 > 1 && num3 < text.Length - 1)
                {
                    string text2 = text.Substring(0, num3 - 1);
                    string text3 = text.Substring(num3 + 1);
                    double num4 = default(double);
                    if (!Double.TryParse(text2, (NumberStyles)167, (IFormatProvider)(object)CultureInfo.InvariantCulture, ref num4))
                    {
                        result = new DataToken(DataError.UnableToParse, String.Concat("Unable to Deserialize Json: Failed to parse number '", text, "'"));
                        return false;
                    }
                    double num5 = default(double);
                    if (!Double.TryParse(text3, (NumberStyles)167, (IFormatProvider)(object)CultureInfo.InvariantCulture, ref num5))
                    {
                        result = new DataToken(DataError.UnableToParse, String.Concat("Unable to Deserialize Json: Failed to parse number '", text, "'"));
                        return false;
                    }
                    num2 = num4 * Math.Pow(10.0, num5);
                    result = num2;
                    return true;
                }
            }
            else if (text.EndsWith("0"))
            {
                string text4 = text.TrimEnd('0');
                int num6 = text.Length - text4.Length;
                if (Double.TryParse(text4, (NumberStyles)167, (IFormatProvider)(object)CultureInfo.InvariantCulture, ref num2))
                {
                    num2 *= Math.Pow(10.0, (double)num6);
                    if (Double.IsPositiveInfinity(num2))
                    {
                        num2 = 1.7976931348623157E+308;
                    }
                    else if (Double.IsNegativeInfinity(num2))
                    {
                        num2 = -1.7976931348623157E+308;
                    }
                    result = num2;
                    return true;
                }
            }
            result = new DataToken(DataError.UnableToParse, String.Concat("Unable to Deserialize Json: Failed to parse number '", text, "'"));
            return false;
        }
 
        internal static bool TryParseBool(string source, int index, out DataToken result)
        {
            int num = index;
            SkipToAnyCharacter(source, ref index, scanWordChars);
            string text = source.Substring(num, index - num).ToLower();
            if (text == "true")
            {
                result = true;
                return true;
            }
            if (text == "false")
            {
                result = false;
                return true;
            }
            result = new DataToken(DataError.UnableToParse, String.Concat("Unable to Deserialize Json: Failed to parse bool '", text, "'"));
            return false;
        }
 
        private static void ScanObject(out bool success, string source, ref int index)
        {
            int num = 0;
            bool flag = false;
            while (index < source.Length)
            {
                SkipToAnyCharacter(source, ref index, scanObjectChars);
                if (index >= source.Length)
                {
                    success = false;
                    break;
                }
                switch (source[index])
                {
                case '\\':
                    if (flag)
                    {
                        index++;
                    }
                    else
                    {
                        success = false;
                    }
                    break;
                case '"':
                    flag = !flag;
                    break;
                case '{':
                    if (!flag)
                    {
                        num++;
                    }
                    break;
                case '}':
                    if (!flag)
                    {
                        num--;
                        if (num == 0)
                        {
                            index++;
                            success = true;
                            return;
                        }
                    }
                    break;
                }
                index++;
            }
            if (num > 0)
            {
                success = false;
            }
            else
            {
                success = false;
            }
        }
 
        private static void ScanArray(out bool success, string source, ref int index)
        {
            if (!IsComplexArray(source, index))
            {
                index++;
                SkipToCharacter(source, ref index, ']');
                index++;
                success = true;
                return;
            }
            index++;
            int num = 0;
            int num2 = 0;
            bool flag = false;
            while (index < source.Length)
            {
                SkipToAnyCharacter(source, ref index, scanArrayChars);
                if (index >= source.Length)
                {
                    success = false;
                    break;
                }
                switch (source[index])
                {
                case '\\':
                    if (flag)
                    {
                        index++;
                    }
                    else
                    {
                        success = false;
                    }
                    break;
                case '"':
                    flag = !flag;
                    break;
                case '[':
                    if (!flag)
                    {
                        num2++;
                    }
                    break;
                case ']':
                    if (!flag)
                    {
                        if (num2 == 0)
                        {
                            num++;
                            index++;
                            success = true;
                            return;
                        }
                        num2--;
                    }
                    break;
                }
                index++;
            }
            success = false;
        }
 
        private static void ScanString(out bool success, string source, ref int index)
        {
            int stringEnd = GetStringEnd(source, index);
            if (stringEnd != -1)
            {
                index = stringEnd + 1;
                success = true;
                return;
            }
            index++;
            bool flag = false;
            while (index < source.Length)
            {
                SkipToAnyCharacter(source, ref index, scanStringChars);
                if (index >= source.Length)
                {
                    success = false;
                    return;
                }
                if (flag)
                {
                    flag = false;
                    continue;
                }
                switch (source[index])
                {
                case '\\':
                    flag = true;
                    index++;
                    index++;
                    break;
                case '"':
                    index++;
                    success = true;
                    return;
                default:
                    index++;
                    break;
                }
            }
            success = false;
        }
 
        private static void ScanNumber(out bool success, string source, ref int index)
        {
            while (index < source.Length)
            {
                char c = source[index];
                if (Array.IndexOf<char>(numberChars, c) != -1 || Char.IsNumber(c) || Char.IsWhiteSpace(c))
                {
                    index++;
                    continue;
                }
                if (c != ',' && c != '}' && c != ']')
                {
                    success = false;
                }
                break;
            }
            success = true;
        }
 
        private static void ScanBool(out bool success, string source, ref int index)
        {
            int num = index;
            SkipToAnyCharacter(source, ref index, scanWordChars);
            string text = source.Substring(num, index - num).ToLower();
            if (text != "true" && text != "false")
            {
                success = false;
            }
            success = true;
        }
 
        private static void ScanNull(out bool success, string source, ref int index)
        {
            int num = index;
            SkipToAnyCharacter(source, ref index, scanWordChars);
            if (source.Substring(num, index - num) != "null")
            {
                success = false;
            }
            success = true;
        }
 
        private static void ScanUnknown(string source, ref int index)
        {
            SkipToAnyCharacter(source, ref index, scanWordChars);
        }
 
        private static void SkipWhitespace(string source, ref int index)
        {
            while (index + 1 < source.Length && Char.IsWhiteSpace(source, index))
            {
                index++;
            }
        }
 
        private static bool IsComplexObject(string source, int index)
        {
            for (index++; index < source.Length; index++)
            {
                switch (source[index])
                {
                case '{':
                    return false;
                case '[':
                    return false;
                case '\\':
                    return false;
                }
            }
            return false;
        }
 
        private static int GetStringEnd(string source, int index)
        {
            index++;
            while (index + 1 < source.Length)
            {
                switch (source[index])
                {
                case '"':
                    return index;
                case '\\':
                    return -1;
                }
                index++;
            }
            return -1;
        }
 
        private static bool IsComplexArray(string source, int index)
        {
            for (index++; index < source.Length; index++)
            {
                switch (source[index])
                {
                case ']':
                    return false;
                case '"':
                case '[':
                case '{':
                    return true;
                }
            }
            return false;
        }
 
        private static void SkipToCharacter(string source, ref int index, char character)
        {
            while (index < source.Length && source[index] != character)
            {
                index++;
            }
        }
 
        private static bool SkipToAnyCharacter(string source, ref int index, char[] characters)
        {
            while (index < source.Length)
            {
                if (Array.IndexOf<char>(characters, source[index]) == -1)
                {
                    index++;
                    continue;
                }
                return true;
            }
            return false;
        }
 
        private static string UnEscapeCharacter(out bool success, string source, ref int index)
        {
            char c = source[index];
            char c2;
            switch (c)
            {
            case '"':
                index++;
                success = true;
                return "\"";
            case '/':
                index++;
                success = true;
                return "/";
            case '\\':
                index++;
                success = true;
                return "\\";
            case 'b':
                index++;
                success = true;
                c2 = '\b';
                return ((Char)(ref c2)).ToString();
            case 'f':
                index++;
                success = true;
                c2 = '\f';
                return ((Char)(ref c2)).ToString();
            case 'n':
                index++;
                success = true;
                c2 = '\n';
                return ((Char)(ref c2)).ToString();
            case 'r':
                index++;
                success = true;
                c2 = '\r';
                return ((Char)(ref c2)).ToString();
            case 't':
                index++;
                success = true;
                c2 = '\t';
                return ((Char)(ref c2)).ToString();
            case 'u':
            {
                if (index + 4 >= source.Length)
                {
                    success = false;
                    break;
                }
                string text = source.Substring(index + 1, 4);
                index += 5;
                int num = default(int);
                if (Int32.TryParse(text, (NumberStyles)515, (IFormatProvider)null, ref num))
                {
                    try
                    {
                        success = true;
                        return Char.ConvertFromUtf32(num);
                    }
                    catch (Object)
                    {
                        success = false;
                    }
                }
                else
                {
                    success = false;
                }
                break;
            }
            }
            success = true;
            index++;
            return String.Concat("\\", ((Char)(ref c)).ToString());
        }
 
        private static string EscapeString(string input)
        {
            return input.Replace("\"", "\\\"").Replace("\n", "\\n").Replace("\r", "\\r")
                .Replace("\t", "\\t");
        }
 
        private static string TrimWhitespace(string input)
        {
            input = input.TrimStart(whitespaceChars);
            input = input.TrimEnd(whitespaceChars);
            return input;
        }
 
        internal static bool TryIdentifyType(string source, int index, out JsonType result)
        {
            if (String.IsNullOrEmpty(source))
            {
                result = JsonType.Invalid;
                return false;
            }
            if (index < 0 || index >= source.Length)
            {
                result = JsonType.Invalid;
                return false;
            }
            char c = source[index];
            if (Char.IsWhiteSpace(c))
            {
                SkipWhitespace(source, ref index);
                if (index < 0 || index >= source.Length)
                {
                    result = JsonType.Invalid;
                    return false;
                }
                c = source[index];
            }
            c = Char.ToLower(c);
            switch (c)
            {
            case '{':
                result = JsonType.Object;
                return true;
            case '[':
                result = JsonType.Array;
                return true;
            case '"':
                result = JsonType.String;
                return true;
            case 'n':
                result = JsonType.Null;
                return true;
            case 't':
                result = JsonType.Boolean;
                return true;
            case 'f':
                result = JsonType.Boolean;
                return true;
            case '-':
                result = JsonType.Number;
                return true;
            default:
                if (Char.IsNumber(c))
                {
                    result = JsonType.Number;
                    return true;
                }
                result = JsonType.Invalid;
                return false;
            }
        }
 
        static VRCJson()
        {
            Char[] array = new Char[7];
            RuntimeHelpers.InitializeArray((Array)(object)array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
            parseArrayChars = (char[])(object)array;
            Char[] array2 = new Char[3];
            RuntimeHelpers.InitializeArray((Array)(object)array2, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
            scanObjectChars = (char[])(object)array2;
            Char[] array3 = new Char[4];
            RuntimeHelpers.InitializeArray((Array)(object)array3, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
            scanArrayChars = (char[])(object)array3;
            scanStringChars = (char[])(object)new Char[2]
            {
                (Char)92,
                (Char)34
            };
            Char[] array4 = new Char[7];
            RuntimeHelpers.InitializeArray((Array)(object)array4, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
            scanWordChars = (char[])(object)array4;
            Char[] array5 = new Char[4];
            RuntimeHelpers.InitializeArray((Array)(object)array5, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
            whitespaceChars = (char[])(object)array5;
            Char[] array6 = new Char[5];
            RuntimeHelpers.InitializeArray((Array)(object)array6, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
            numberChars = (char[])(object)array6;
            seenContainers = new HashSet<DataToken>();
        }
    }
}
namespace VRC.SDK3.Components
{
    public abstract class AbstractUdonBehaviour : VRCInteractable, IUdonBehaviour, IUdonEventReceiver, IUdonProgramVariableAccessTarget, IUdonSyncTarget, IVRCNetworkId, INetworkID
    {
        public abstract bool DisableInteractive { get; set; }
 
        public abstract bool DisableEventProcessing { get; set; }
 
        public abstract IUdonSyncMetadataTable SyncMetadataTable { get; }
 
        public abstract bool IsNetworkingSupported { get; set; }
 
        public abstract string InteractionText { get; set; }
 
        public abstract Type GetProgramVariableType(string symbolName);
 
        public abstract T GetProgramVariable<T>(string symbolName);
 
        public abstract object GetProgramVariable(string symbolName);
 
        public abstract bool TryGetProgramVariable<T>(string symbolName, out T value);
 
        public abstract bool TryGetProgramVariable(string symbolName, out object value);
 
        public abstract void SetProgramVariable<T>(string symbolName, T value);
 
        public abstract void SetProgramVariable(string symbolName, object value);
 
        public abstract void SendCustomEvent(string eventName);
 
        public abstract void SendCustomNetworkEvent(NetworkEventTarget target, string eventName);
 
        public abstract void SendCustomEventDelayedSeconds(string eventName, float delaySeconds, EventTiming eventTiming = 0);
 
        public abstract void SendCustomEventDelayedFrames(string eventName, int delayFrames, EventTiming eventTiming = 0);
 
        public abstract void InitializeUdonContent();
 
        public abstract void RunProgram(string eventName);
 
        public abstract bool RunEvent(string eventName);
 
        public abstract bool RunEvent<T0>(string eventName, ValueTuple<string, T0> parameter0);
 
        public abstract bool RunEvent<T0, T1>(string eventName, ValueTuple<string, T0> parameter0, ValueTuple<string, T1> parameter1);
 
        public abstract bool RunEvent<T0, T1, T2>(string eventName, ValueTuple<string, T0> parameter0, ValueTuple<string, T1> parameter1, ValueTuple<string, T2> parameter2);
 
        public abstract bool RunEvent(string eventName, params ValueTuple<string, object>[] programVariables);
 
        public abstract void RunInputEvent(string eventName, UdonInputEventArgs args);
 
        public abstract void RequestSerialization();
 
        bool IUdonEventReceiver.get_enabled()
        {
            return ((Behaviour)this).enabled;
        }
 
        void IUdonEventReceiver.set_enabled(bool value)
        {
            ((Behaviour)this).enabled = value;
        }
    }
    public interface IUdonSignatureHolder
    {
        byte[] Signature { get; set; }
 
        byte[] SignedData { get; }
 
        bool IsInternallyValidated { get; }
 
        void EnsureGZipFormat();
    }
    [AttributeUsage(/*Could not decode attribute arguments.*/)]
    public class UdonSignatureHolderMarker : Attribute
    {
        [field: CompilerGenerated]
        public Type type
        {
            [CompilerGenerated]
            get;
        }
 
        public UdonSignatureHolderMarker(Type type)
        {
            this.type = type;
        }
    }
    public abstract class VRCInteractable : VRC_Interactable
    {
    }
    [HelpURL("https://creators.vrchat.com/worlds/udon/persistence/player-object/")]
    [AddComponentMenu("VRChat/Persistence/VRC Enable Persistence")]
    public class VRCEnablePersistence : MonoBehaviour
    {
        private void Awake()
        {
            if (!Object.op_Implicit((Object)(object)((Component)this).gameObject.GetComponentInParent<VRCPlayerObject>()))
            {
                Debug.LogError((object)"VRCEnablePersistence must be a child of a VRCPlayerObject to enable persistence.", (Object)(object)((Component)this).gameObject);
            }
        }
    }
    [HelpURL("https://creators.vrchat.com/worlds/udon/persistence/player-object/")]
    [AddComponentMenu("VRChat/Persistence/VRC Player Object")]
    public class VRCPlayerObject : VRCNetworkBehaviour
    {
        public static Func<VRCPlayerObject, VRCPlayerApi> _GetPlayer;
 
        public VRCPlayerApi GetPlayer()
        {
            return _GetPlayer?.Invoke(this) ?? null;
        }
 
        [ExcludeFromUdonWrapper]
        public override void NetworkConfigure()
        {
        }
    }
    [ExecuteInEditMode]
    [RequireComponent(/*Could not decode attribute arguments.*/)]
    [DisallowMultipleComponent]
    [AddComponentMenu("VRChat/VRC Spatial Audio Source")]
    public class VRCSpatialAudioSource : VRC_SpatialAudioSource
    {
    }
    [AddComponentMenu("VRChat/VRC Object Pool")]
    [HelpURL("https://creators.vrchat.com/worlds/examples/udon-example-scene/#objectpool")]
    public class VRCObjectPool : VRCNetworkBehaviour
    {
        public GameObject[] Pool = (GameObject[])(object)new GameObject[0];
 
        [ExcludeFromUdonWrapper]
        public static Action<VRCObjectPool> OnInit;
 
        [ExcludeFromUdonWrapper]
        public static Action<VRCObjectPool, int> OnSpawn;
 
        [ExcludeFromUdonWrapper]
        public static Action<VRCObjectPool, int> OnReturn;
 
        private Dictionary<GameObject, int> _indices = new Dictionary<GameObject, int>();
 
        private int _lastSpawnIndex = -1;
 
        private int[] _spawnOrder;
 
        private bool didInit;
 
        [ExcludeFromUdonWrapper]
        [HideInInspector]
        public Vector3[] StartPositions;
 
        [ExcludeFromUdonWrapper]
        [HideInInspector]
        public Quaternion[] StartRotations;
 
        [ExcludeFromUdonWrapper]
        public override void NetworkConfigure()
        {
            //IL_00b6: Unknown result type (might be due to invalid IL or missing references)
            //IL_00bb: Unknown result type (might be due to invalid IL or missing references)
            //IL_00d4: Unknown result type (might be due to invalid IL or missing references)
            //IL_00d9: Unknown result type (might be due to invalid IL or missing references)
            if (!didInit)
            {
                if (OnInit != null)
                {
                    OnInit.Invoke(this);
                }
                if (Pool == null)
                {
                    Pool = (GameObject[])(object)new GameObject[0];
                }
                StartPositions = (Vector3[])(object)new Vector3[Pool.Length];
                StartRotations = (Quaternion[])(object)new Quaternion[Pool.Length];
                _spawnOrder = (int[])(object)new Int32[Pool.Length];
                _indices.Clear();
                for (int i = 0; i < Pool.Length; i++)
                {
                    Pool[i].SetActive(false);
                    _indices.Add(Pool[i], i);
                    _spawnOrder[i] = i;
                    StartRotations[i] = Pool[i].transform.rotation;
                    StartPositions[i] = Pool[i].transform.position;
                }
                didInit = true;
            }
        }
 
        public void Shuffle()
        {
            Utilities.ShuffleArray(_spawnOrder);
        }
 
        public GameObject TryToSpawn()
        {
            if (!didInit)
            {
                Debug.LogError((object)String.Concat("TryToSpawn on ", ((Object)((Component)this).gameObject).name, " called before initialized"));
                return null;
            }
            if (Pool == null || Pool.Length == 0 || _indices == null)
            {
                return null;
            }
            if (Pool.Length != _indices.Count)
            {
                Debug.LogError((object)String.Concat("Pool size on ", ((Object)((Component)this).gameObject).name, " has changed since Awake()"));
                return null;
            }
            if (!Networking.IsOwner(((Component)this).gameObject))
            {
                Debug.LogError((object)String.Concat("Non-owner attempted to spawn object from ", ((Object)((Component)this).gameObject).name));
                return null;
            }
            int num = _lastSpawnIndex;
            for (int i = 0; i < Pool.Length; i++)
            {
                num = (num + 1) % Pool.Length;
                int num2 = _spawnOrder[num];
                GameObject val = Pool[num2];
                if (Object.op_Implicit((Object)(object)val) && !val.activeInHierarchy)
                {
                    GameObject obj = Pool[num2];
                    obj.SetActive(true);
                    if (OnSpawn != null)
                    {
                        OnSpawn.Invoke(this, num2);
                    }
                    _lastSpawnIndex = num;
                    return obj;
                }
            }
            return null;
        }
 
        public void Return(GameObject obj)
        {
            //IL_0060: Unknown result type (might be due to invalid IL or missing references)
            //IL_0077: Unknown result type (might be due to invalid IL or missing references)
            if (!Object.op_Implicit((Object)(object)obj))
            {
                return;
            }
            int num = default(int);
            if (!Networking.IsOwner(((Component)this).gameObject))
            {
                Debug.LogError((object)String.Concat("Non-owner attempted to return ", ((Object)obj).name, " to ", ((Object)((Component)this).gameObject).name));
            }
            else if (_indices.TryGetValue(obj, ref num))
            {
                obj.SetActive(false);
                obj.transform.position = StartPositions[num];
                obj.transform.rotation = StartRotations[num];
                if (OnReturn != null)
                {
                    OnReturn.Invoke(this, num);
                }
            }
        }
    }
    public interface IVRCDestructible : IVRC_Destructible
    {
    }
    public class VRCVisualDamage : VRC_VisualDamage
    {
    }
    [AddComponentMenu("VRChat/VRC Avatar Pedestal")]
    [HelpURL("https://creators.vrchat.com/worlds/components/vrc_avatarpedestal/")]
    public class VRCAvatarPedestal : VRC_AvatarPedestal
    {
        [RPC(/*Could not decode attribute arguments.*/)]
        [ExcludeFromUdonWrapper]
        public override void SwitchAvatar(string id, VRCPlayerApi instigator)
        {
            if (instigator != null && instigator.isLocal)
            {
                ((VRC_AvatarPedestal)this).SwitchAvatar(id, instigator);
            }
        }
 
        public override void SwitchAvatar(string id)
        {
            ((VRC_AvatarPedestal)this).SwitchAvatar(id);
        }
    }
    [AddComponentMenu("VRChat/VRC Object Sync")]
    [HelpURL("https://creators.vrchat.com/worlds/components/vrc_objectsync")]
    public class VRCObjectSync : VRCNetworkBehaviour
    {
        public delegate void AwakeDelegate(VRCObjectSync obj);
 
        public bool AllowCollisionOwnershipTransfer = true;
 
        [ExcludeFromUdonWrapper]
        public static Action<VRCObjectSync, Vector3, Quaternion> TeleportHandler = null;
 
        [ExcludeFromUdonWrapper]
        public static Action<VRCObjectSync> RespawnHandler = null;
 
        [ExcludeFromUdonWrapper]
        public static AwakeDelegate OnAwake;
 
        private bool didInit;
 
        [ExcludeFromUdonWrapper]
        [field: CompilerGenerated]
        public static Action<VRCObjectSync, bool> SetKinematicHook
        {
            [CompilerGenerated]
            get;
            [CompilerGenerated]
            set;
        } = EditorSetKinematic;
 
 
        [ExcludeFromUdonWrapper]
        [field: CompilerGenerated]
        public static Action<VRCObjectSync, bool> SetGravityHook
        {
            [CompilerGenerated]
            get;
            [CompilerGenerated]
            set;
        } = EditorSetGravity;
 
 
        [ExcludeFromUdonWrapper]
        [field: CompilerGenerated]
        public static Action<VRCObjectSync> FlagDiscontinuityHook
        {
            [CompilerGenerated]
            get;
            [CompilerGenerated]
            set;
        } = null;
 
 
        public void SetKinematic(bool value)
        {
            SetKinematicHook?.Invoke(this, value);
        }
 
        private static void EditorSetKinematic(VRCObjectSync target, bool value)
        {
            Rigidbody component = ((Component)target).GetComponent<Rigidbody>();
            if (Object.op_Implicit((Object)(object)component))
            {
                component.isKinematic = value;
            }
        }
 
        public void SetGravity(bool value)
        {
            SetGravityHook?.Invoke(this, value);
        }
 
        private static void EditorSetGravity(VRCObjectSync target, bool value)
        {
            Rigidbody component = ((Component)target).GetComponent<Rigidbody>();
            if (Object.op_Implicit((Object)(object)component))
            {
                component.useGravity = value;
            }
        }
 
        public void FlagDiscontinuity()
        {
            FlagDiscontinuityHook?.Invoke(this);
        }
 
        public void TeleportTo(Transform targetLocation)
        {
            //IL_000c: Unknown result type (might be due to invalid IL or missing references)
            //IL_0012: Unknown result type (might be due to invalid IL or missing references)
            TeleportHandler?.Invoke(this, targetLocation.position, targetLocation.rotation);
        }
 
        public void Respawn()
        {
            RespawnHandler?.Invoke(this);
        }
 
        [ExcludeFromUdonWrapper]
        public override void NetworkConfigure()
        {
            if (!didInit)
            {
                if (OnAwake != null)
                {
                    OnAwake(this);
                }
                didInit = true;
            }
        }
    }
    [AddComponentMenu("VRChat/VRC Pickup")]
    [HelpURL("https://creators.vrchat.com/worlds/components/vrc_pickup")]
    public class VRCPickup : VRC_Pickup
    {
    }
    [AddComponentMenu("VRChat/VRC Portal Marker")]
    [HelpURL("https://creators.vrchat.com/worlds/components/vrc_portalmarker")]
    public class VRCPortalMarker : VRC_PortalMarker
    {
    }
    [ExecuteInEditMode]
    [HelpURL("https://creators.vrchat.com/worlds/components/vrc_mirrorreflection")]
    [AddComponentMenu("VRChat/VRC Mirror Reflection")]
    public class VRCMirrorReflection : VRC_MirrorReflection
    {
        [Tooltip("The mirror camera can be set to use a custom skybox shader or a solid clear color. By default it renders the same as the reference camera.")]
        public MirrorClearFlags cameraClearFlags;
 
        [Tooltip("Overrides the skybox material used by the mirror camera. Only used if clear flags are set to CustomSkybox.")]
        public Material customSkybox;
 
        [Tooltip("Set the solid clear color used by the mirror camera if clear flags are set to SolidColor.")]
        public Color customClearColor = new Color(0f, 0f, 0f, 1f);
 
        protected override void UpdateCameraClearing(Camera src, Camera mirrorCamera, Skybox mirrorSkybox)
        {
            //IL_0028: Unknown result type (might be due to invalid IL or missing references)
            //IL_0034: Unknown result type (might be due to invalid IL or missing references)
            //IL_003f: Unknown result type (might be due to invalid IL or missing references)
            //IL_0045: Invalid comparison between Unknown and I4
            //IL_00e9: Unknown result type (might be due to invalid IL or missing references)
            //IL_00ce: Unknown result type (might be due to invalid IL or missing references)
            //IL_0112: Unknown result type (might be due to invalid IL or missing references)
            switch (cameraClearFlags)
            {
            case MirrorClearFlags.FromReferenceCamera:
                mirrorCamera.clearFlags = src.clearFlags;
                mirrorCamera.backgroundColor = src.backgroundColor;
                if ((int)src.clearFlags == 1)
                {
                    Component component = ((Component)src).GetComponent(typeof(Skybox));
                    Skybox val = (Skybox)(object)((component is Skybox) ? component : null);
                    if (!Object.op_Implicit((Object)(object)val) || !Object.op_Implicit((Object)(object)val.material))
                    {
                        ((Behaviour)mirrorSkybox).enabled = false;
                        break;
                    }
                    ((Behaviour)mirrorSkybox).enabled = true;
                    mirrorSkybox.material = val.material;
                }
                else
                {
                    ((Behaviour)mirrorSkybox).enabled = false;
                }
                break;
            case MirrorClearFlags.CustomSkybox:
                if ((Object)(object)customSkybox != (Object)null)
                {
                    ((Behaviour)mirrorSkybox).enabled = true;
                    mirrorSkybox.material = customSkybox;
                    mirrorCamera.clearFlags = (CameraClearFlags)1;
                }
                else
                {
                    ((Behaviour)mirrorSkybox).enabled = false;
                    mirrorCamera.clearFlags = (CameraClearFlags)2;
                    mirrorCamera.backgroundColor = Color.black;
                }
                break;
            case MirrorClearFlags.SolidColor:
                ((Behaviour)mirrorSkybox).enabled = false;
                mirrorCamera.clearFlags = (CameraClearFlags)2;
                mirrorCamera.backgroundColor = customClearColor;
                break;
            case MirrorClearFlags.Nothing:
                ((Behaviour)mirrorSkybox).enabled = false;
                mirrorCamera.clearFlags = (CameraClearFlags)4;
                break;
            case MirrorClearFlags.Depth:
                ((Behaviour)mirrorSkybox).enabled = false;
                mirrorCamera.clearFlags = (CameraClearFlags)3;
                break;
            default:
                throw new ArgumentOutOfRangeException();
            }
        }
    }
    [PublicAPI]
    public enum MirrorClearFlags : Enum
    {
        FromReferenceCamera,
        CustomSkybox,
        SolidColor,
        Nothing,
        Depth
    }
    [AddComponentMenu("VRChat/VRC Scene Descriptor")]
    [HelpURL("https://creators.vrchat.com/worlds/components/vrc_scenedescriptor/")]
    public class VRCSceneDescriptor : VRC_SceneDescriptor
    {
        [HideInInspector]
        public VRCPlayerObject[] PlayerPersistence;
 
        [HideInInspector]
        public float[] NavigationAreas;
 
        public override void Awake()
        {
            ((VRC_SceneDescriptor)this).Awake();
            VRCPlayerObject[] playerPersistence = PlayerPersistence;
            PlayerPersistence = ((playerPersistence != null) ? Enumerable.ToArray<VRCPlayerObject>(Enumerable.Where<VRCPlayerObject>((IEnumerable<VRCPlayerObject>)(object)playerPersistence, (Func<VRCPlayerObject, bool>)((VRCPlayerObject pp) => (Object)(object)pp != (Object)null && (Object)null == (Object)(object)((Component)pp).GetComponentInParent<VRCPlayerObject>()))) : null);
        }
    }
    [AddComponentMenu("VRChat/VRC Station")]
    [HelpURL("https://creators.vrchat.com/worlds/components/vrc_station")]
    public class VRCStation : VRCStation
    {
        public readonly string OnRemotePlayerEnterStation = "_onStationEntered";
 
        public readonly string OnLocalPlayerEnterStation = "_onStationEntered";
 
        public readonly string OnRemotePlayerExitStation = "_onStationExited";
 
        public readonly string OnLocalPlayerExitStation = "_onStationExited";
    }
    internal static class MultipleDisplayUtilities : Object
    {
        public static bool GetRelativeMousePositionForDrag(PointerEventData eventData, ref Vector2 position)
        {
            //IL_0001: Unknown result type (might be due to invalid IL or missing references)
            //IL_000d: Unknown result type (might be due to invalid IL or missing references)
            //IL_0012: Unknown result type (might be due to invalid IL or missing references)
            //IL_0017: Unknown result type (might be due to invalid IL or missing references)
            //IL_001c: Unknown result type (might be due to invalid IL or missing references)
            //IL_001d: Unknown result type (might be due to invalid IL or missing references)
            //IL_0035: Unknown result type (might be due to invalid IL or missing references)
            //IL_0036: Unknown result type (might be due to invalid IL or missing references)
            //IL_002e: Unknown result type (might be due to invalid IL or missing references)
            //IL_003b: Unknown result type (might be due to invalid IL or missing references)
            int displayIndex = eventData.pointerPressRaycast.displayIndex;
            Vector3 val = Display.RelativeMouseAt(Vector2.op_Implicit(eventData.position));
            if ((int)val.z != displayIndex)
            {
                return false;
            }
            position = ((displayIndex != 0) ? Vector2.op_Implicit(val) : eventData.position);
            return true;
        }
 
        public static Vector2 GetMousePositionRelativeToMainDisplayResolution()
        {
            //IL_0000: Unknown result type (might be due to invalid IL or missing references)
            //IL_0005: Unknown result type (might be due to invalid IL or missing references)
            //IL_0085: Unknown result type (might be due to invalid IL or missing references)
            //IL_0086: Unknown result type (might be due to invalid IL or missing references)
            //IL_001c: Unknown result type (might be due to invalid IL or missing references)
            //IL_005c: Unknown result type (might be due to invalid IL or missing references)
            //IL_0062: Invalid comparison between Unknown and I4
            //IL_0029: Unknown result type (might be due to invalid IL or missing references)
            //IL_003c: Unknown result type (might be due to invalid IL or missing references)
            //IL_0049: Unknown result type (might be due to invalid IL or missing references)
            Vector3 mousePosition = Input.mousePosition;
            if (Display.main.renderingHeight != Display.main.systemHeight && (mousePosition.y < 0f || mousePosition.y > (float)Display.main.renderingHeight || mousePosition.x < 0f || mousePosition.x > (float)Display.main.renderingWidth) && (int)Screen.fullScreenMode != 3)
            {
                mousePosition.y += Display.main.systemHeight - Display.main.renderingHeight;
            }
            return Vector2.op_Implicit(mousePosition);
        }
    }
    internal static class SetPropertyUtility : Object
    {
        public static bool SetColor(ref Color currentValue, Color newValue)
        {
            //IL_0006: Unknown result type (might be due to invalid IL or missing references)
            //IL_003b: Unknown result type (might be due to invalid IL or missing references)
            //IL_003c: Unknown result type (might be due to invalid IL or missing references)
            //IL_0014: Unknown result type (might be due to invalid IL or missing references)
            //IL_0022: Unknown result type (might be due to invalid IL or missing references)
            //IL_0030: Unknown result type (might be due to invalid IL or missing references)
            if (currentValue.r == newValue.r && currentValue.g == newValue.g && currentValue.b == newValue.b && currentValue.a == newValue.a)
            {
                return false;
            }
            currentValue = newValue;
            return true;
        }
 
        public static bool SetStruct<T>(ref T currentValue, T newValue) where T : struct, ValueType
        {
            if (EqualityComparer<T>.Default.Equals(currentValue, newValue))
            {
                return false;
            }
            currentValue = newValue;
            return true;
        }
 
        public static bool SetClass<T>(ref T currentValue, T newValue) where T : class
        {
            if ((currentValue == null && newValue == null) || (currentValue != null && ((Object)currentValue).Equals((object)newValue)))
            {
                return false;
            }
            currentValue = newValue;
            return true;
        }
    }
    [AddComponentMenu("VRChat/UI/VRC InputField Keyboard Override")]
    [HelpURL("https://creators.vrchat.com/worlds/components/vrc_uishape/#if-youd-like-a-textfield-not-to-show-vrchats-keyboard")]
    public class VRCInputFieldKeyboardOverride : MonoBehaviour
    {
        public enum OverrideBehaviorType : Enum
        {
            Default,
            Override
        }
 
        [SerializeField]
        private OverrideBehaviorType _overrideBehavior;
 
        public OverrideBehaviorType OverrideBehavior => _overrideBehavior;
    }
    public static class VRCTMPDropdownExtension : Object
    {
        public static void AddOptions(this TMP_Dropdown dropdown, string[] options)
        {
            dropdown.AddOptions(Enumerable.ToList<string>((IEnumerable<string>)(object)options));
        }
 
        public static void AddOptions(this TMP_Dropdown dropdown, OptionData[] options)
        {
            dropdown.AddOptions(Enumerable.ToList<OptionData>((IEnumerable<OptionData>)(object)options));
        }
 
        public static void AddOptions(this TMP_Dropdown dropdown, Sprite[] options)
        {
            dropdown.AddOptions(Enumerable.ToList<Sprite>((IEnumerable<Sprite>)(object)options));
        }
    }
    [AddComponentMenu("VRChat/UI/VRC UI Shape")]
    [HelpURL("https://creators.vrchat.com/worlds/components/vrc_uishape")]
    public class VRCUiShape : VRC_UiShape
    {
    }
    [AddComponentMenu("VRChat/UI/VRC URL Input Field")]
    [HelpURL("https://udonsharp.docs.vrchat.com/vrchat-api/#vrcurlinputfield")]
    public class VRCUrlInputField : Selectable, IUpdateSelectedHandler, IEventSystemHandler, IBeginDragHandler, IDragHandler, IEndDragHandler, IPointerClickHandler, ISubmitHandler, ICanvasElement, ILayoutElement
    {
        public enum ContentType : Enum
        {
            Standard,
            Autocorrected,
            IntegerNumber,
            DecimalNumber,
            Alphanumeric,
            Name,
            EmailAddress,
            Password,
            Pin,
            Custom
        }
 
        public enum InputType : Enum
        {
            Standard,
            AutoCorrect,
            Password
        }
 
        public enum CharacterValidation : Enum
        {
            None,
            Integer,
            Decimal,
            Alphanumeric,
            Name,
            EmailAddress
        }
 
        public enum LineType : Enum
        {
            SingleLine,
            MultiLineSubmit,
            MultiLineNewline
        }
 
        public delegate char OnValidateInput(string text, int charIndex, char addedChar);
 
        [Serializable]
        public class SubmitEvent : UnityEvent<string>
        {
        }
 
        [Serializable]
        public class OnChangeEvent : UnityEvent<string>
        {
        }
 
        protected enum EditState : Enum
        {
            Continue,
            Finish
        }
 
        [CompilerGenerated]
        private Action m_onSelected;
 
        protected TouchScreenKeyboard m_Keyboard;
 
        private static readonly char[] kSeparators;
 
        private static bool s_AreDevicesEvaluated;
 
        private static bool s_IsQuestDevice;
 
        private static bool s_IsPicoDevice;
 
        [SerializeField]
        [FormerlySerializedAs("text")]
        protected Text m_TextComponent;
 
        [SerializeField]
        protected Graphic m_Placeholder;
 
        [SerializeField]
        private ContentType m_ContentType;
 
        [FormerlySerializedAs("inputType")]
        [SerializeField]
        private InputType m_InputType;
 
        [FormerlySerializedAs("asteriskChar")]
        [SerializeField]
        private char m_AsteriskChar = '*';
 
        [FormerlySerializedAs("keyboardType")]
        [SerializeField]
        private TouchScreenKeyboardType m_KeyboardType;
 
        [SerializeField]
        private LineType m_LineType;
 
        [FormerlySerializedAs("hideMobileInput")]
        [SerializeField]
        private bool m_HideMobileInput;
 
        [FormerlySerializedAs("validation")]
        [SerializeField]
        private CharacterValidation m_CharacterValidation;
 
        [FormerlySerializedAs("characterLimit")]
        [SerializeField]
        private int m_CharacterLimit;
 
        [FormerlySerializedAs("onSubmit")]
        [FormerlySerializedAs("m_OnSubmit")]
        [FormerlySerializedAs("m_EndEdit")]
        [SerializeField]
        private SubmitEvent m_OnEndEdit = new SubmitEvent();
 
        [FormerlySerializedAs("onValueChange")]
        [FormerlySerializedAs("m_OnValueChange")]
        [SerializeField]
        private OnChangeEvent m_OnValueChanged = new OnChangeEvent();
 
        [FormerlySerializedAs("onValidateInput")]
        [SerializeField]
        private OnValidateInput m_OnValidateInput;
 
        [FormerlySerializedAs("selectionColor")]
        [SerializeField]
        private Color m_CaretColor = new Color(10f / 51f, 10f / 51f, 10f / 51f, 1f);
 
        [SerializeField]
        private bool m_CustomCaretColor;
 
        [SerializeField]
        private Color m_SelectionColor = new Color(56f / 85f, 0.80784315f, 1f, 64f / 85f);
 
        [SerializeField]
        [FormerlySerializedAs("mValue")]
        protected string m_Text = String.Empty;
 
        [SerializeField]
        [Range(0f, 4f)]
        private float m_CaretBlinkRate = 0.85f;
 
        [SerializeField]
        [Range(1f, 5f)]
        private int m_CaretWidth = 1;
 
        [SerializeField]
        private bool m_ReadOnly;
 
        [SerializeField]
        private bool m_ShouldActivateOnSelect = true;
 
        protected int m_CaretPosition;
 
        protected int m_CaretSelectPosition;
 
        private RectTransform caretRectTrans;
 
        protected UIVertex[] m_CursorVerts;
 
        private TextGenerator m_InputTextCache;
 
        private CanvasRenderer m_CachedInputRenderer;
 
        private bool m_PreventFontCallback;
 
        [NonSerialized]
        protected Mesh m_Mesh;
 
        private bool m_AllowInput;
 
        private bool m_ShouldActivateNextUpdate;
 
        private bool m_UpdateDrag;
 
        private bool m_DragPositionOutOfBounds;
 
        private const float kHScrollSpeed = 0.05f;
 
        private const float kVScrollSpeed = 0.1f;
 
        protected bool m_CaretVisible;
 
        private Coroutine m_BlinkCoroutine;
 
        private float m_BlinkStartTime;
 
        protected int m_DrawStart;
 
        protected int m_DrawEnd;
 
        private Coroutine m_DragCoroutine;
 
        private string m_OriginalText = "";
 
        private bool m_WasCanceled;
 
        private bool m_HasDoneFocusTransition;
 
        private WaitForSecondsRealtime m_WaitForSecondsRealtime;
 
        private bool m_TouchKeyboardAllowsInPlaceEditing;
 
        private const string kEmailSpecialCharacters = "!#$%&'*+-/=?^_`{|}~";
 
        private const string kOculusQuestDeviceModel = "Oculus Quest";
 
        private const string kPicoDeviceModel = "Pico";
 
        public bool AllowSendingOnEndEdit = true;
 
        private Event m_ProcessingEvent = new Event();
 
        private const int k_MaxTextLength = 16382;
 
        private BaseInput input
        {
            get
            {
                if (Object.op_Implicit((Object)(object)EventSystem.current) && Object.op_Implicit((Object)(object)EventSystem.current.currentInputModule))
                {
                    return EventSystem.current.currentInputModule.input;
                }
                return null;
            }
        }
 
        private string compositionString
        {
            get
            {
                if (!((Object)(object)input != (Object)null))
                {
                    return Input.compositionString;
                }
                return input.compositionString;
            }
        }
 
        protected Mesh mesh
        {
            get
            {
                //IL_000f: Unknown result type (might be due to invalid IL or missing references)
                //IL_0019: Expected O, but got Unknown
                if ((Object)(object)m_Mesh == (Object)null)
                {
                    m_Mesh = new Mesh();
                }
                return m_Mesh;
            }
        }
 
        protected TextGenerator cachedInputTextGenerator
        {
            get
            {
                //IL_0009: Unknown result type (might be due to invalid IL or missing references)
                //IL_0013: Expected O, but got Unknown
                if (m_InputTextCache == null)
                {
                    m_InputTextCache = new TextGenerator();
                }
                return m_InputTextCache;
            }
        }
 
        public bool shouldHideMobileInput
        {
            get
            {
                //IL_0000: Unknown result type (might be due to invalid IL or missing references)
                //IL_0005: Unknown result type (might be due to invalid IL or missing references)
                //IL_0006: Unknown result type (might be due to invalid IL or missing references)
                //IL_0008: Invalid comparison between Unknown and I4
                //IL_000a: Unknown result type (might be due to invalid IL or missing references)
                //IL_000d: Invalid comparison between Unknown and I4
                //IL_000f: Unknown result type (might be due to invalid IL or missing references)
                //IL_0012: Invalid comparison between Unknown and I4
                RuntimePlatform platform = Application.platform;
                if ((int)platform == 8 || (int)platform == 11 || (int)platform == 31)
                {
                    return m_HideMobileInput;
                }
                return true;
            }
            set
            {
                SetPropertyUtility.SetStruct<bool>(ref m_HideMobileInput, value);
            }
        }
 
        private bool shouldActivateOnSelect
        {
            get
            {
                //IL_0008: Unknown result type (might be due to invalid IL or missing references)
                //IL_000f: Invalid comparison between Unknown and I4
                if (m_ShouldActivateOnSelect)
                {
                    return (int)Application.platform != 31;
                }
                return false;
            }
            set
            {
                m_ShouldActivateOnSelect = value;
            }
        }
 
        public string text
        {
            get
            {
                return m_Text;
            }
            set
            {
                SetText(value);
            }
        }
 
        public bool isFocused => m_AllowInput;
 
        public float caretBlinkRate
        {
            get
            {
                return m_CaretBlinkRate;
            }
            set
            {
                if (SetPropertyUtility.SetStruct<float>(ref m_CaretBlinkRate, value) && m_AllowInput)
                {
                    SetCaretActive();
                }
            }
        }
 
        public int caretWidth
        {
            get
            {
                return m_CaretWidth;
            }
            set
            {
                if (SetPropertyUtility.SetStruct<int>(ref m_CaretWidth, value))
                {
                    MarkGeometryAsDirty();
                }
            }
        }
 
        public Text textComponent
        {
            get
            {
                return m_TextComponent;
            }
            set
            {
                //IL_001b: Unknown result type (might be due to invalid IL or missing references)
                //IL_0025: Expected O, but got Unknown
                //IL_0032: Unknown result type (might be due to invalid IL or missing references)
                //IL_003c: Expected O, but got Unknown
                //IL_0049: Unknown result type (might be due to invalid IL or missing references)
                //IL_0053: Expected O, but got Unknown
                //IL_0082: Unknown result type (might be due to invalid IL or missing references)
                //IL_008c: Expected O, but got Unknown
                //IL_0099: Unknown result type (might be due to invalid IL or missing references)
                //IL_00a3: Expected O, but got Unknown
                //IL_00b0: Unknown result type (might be due to invalid IL or missing references)
                //IL_00ba: Expected O, but got Unknown
                if ((Object)(object)m_TextComponent != (Object)null)
                {
                    ((Graphic)m_TextComponent).UnregisterDirtyVerticesCallback(new UnityAction(MarkGeometryAsDirty));
                    ((Graphic)m_TextComponent).UnregisterDirtyVerticesCallback(new UnityAction(UpdateLabel));
                    ((Graphic)m_TextComponent).UnregisterDirtyMaterialCallback(new UnityAction(UpdateCaretMaterial));
                }
                if (SetPropertyUtility.SetClass(ref m_TextComponent, value))
                {
                    EnforceTextHOverflow();
                    if ((Object)(object)m_TextComponent != (Object)null)
                    {
                        ((Graphic)m_TextComponent).RegisterDirtyVerticesCallback(new UnityAction(MarkGeometryAsDirty));
                        ((Graphic)m_TextComponent).RegisterDirtyVerticesCallback(new UnityAction(UpdateLabel));
                        ((Graphic)m_TextComponent).RegisterDirtyMaterialCallback(new UnityAction(UpdateCaretMaterial));
                    }
                }
            }
        }
 
        public Graphic placeholder
        {
            get
            {
                return m_Placeholder;
            }
            set
            {
                SetPropertyUtility.SetClass(ref m_Placeholder, value);
            }
        }
 
        public Color caretColor
        {
            get
            {
                //IL_0015: Unknown result type (might be due to invalid IL or missing references)
                //IL_000e: Unknown result type (might be due to invalid IL or missing references)
                if (!customCaretColor)
                {
                    return ((Graphic)textComponent).color;
                }
                return m_CaretColor;
            }
            set
            {
                //IL_0006: Unknown result type (might be due to invalid IL or missing references)
                if (SetPropertyUtility.SetColor(ref m_CaretColor, value))
                {
                    MarkGeometryAsDirty();
                }
            }
        }
 
        public bool customCaretColor
        {
            get
            {
                return m_CustomCaretColor;
            }
            set
            {
                if (m_CustomCaretColor != value)
                {
                    m_CustomCaretColor = value;
                    MarkGeometryAsDirty();
                }
            }
        }
 
        public Color selectionColor
        {
            get
            {
                //IL_0001: Unknown result type (might be due to invalid IL or missing references)
                return m_SelectionColor;
            }
            set
            {
                //IL_0006: Unknown result type (might be due to invalid IL or missing references)
                if (SetPropertyUtility.SetColor(ref m_SelectionColor, value))
                {
                    MarkGeometryAsDirty();
                }
            }
        }
 
        public SubmitEvent onEndEdit
        {
            get
            {
                return m_OnEndEdit;
            }
            set
            {
                SetPropertyUtility.SetClass(ref m_OnEndEdit, value);
            }
        }
 
        [Obsolete("onValueChange has been renamed to onValueChanged")]
        public OnChangeEvent onValueChange
        {
            get
            {
                return onValueChanged;
            }
            set
            {
                onValueChanged = value;
            }
        }
 
        public OnChangeEvent onValueChanged
        {
            get
            {
                return m_OnValueChanged;
            }
            set
            {
                SetPropertyUtility.SetClass(ref m_OnValueChanged, value);
            }
        }
 
        public OnValidateInput onValidateInput
        {
            get
            {
                return m_OnValidateInput;
            }
            set
            {
                SetPropertyUtility.SetClass(ref m_OnValidateInput, value);
            }
        }
 
        public int characterLimit
        {
            get
            {
                return m_CharacterLimit;
            }
            set
            {
                if (SetPropertyUtility.SetStruct<int>(ref m_CharacterLimit, Math.Max(0, value)))
                {
                    UpdateLabel();
                    if (m_Keyboard != null)
                    {
                        m_Keyboard.characterLimit = value;
                    }
                }
            }
        }
 
        public ContentType contentType
        {
            get
            {
                return m_ContentType;
            }
            set
            {
                if (SetPropertyUtility.SetStruct<ContentType>(ref m_ContentType, value))
                {
                    EnforceContentType();
                }
            }
        }
 
        public LineType lineType
        {
            get
            {
                return m_LineType;
            }
            set
            {
                if (SetPropertyUtility.SetStruct<LineType>(ref m_LineType, value))
                {
                    SetToCustomIfContentTypeIsNot(ContentType.Standard, ContentType.Autocorrected);
                    EnforceTextHOverflow();
                }
            }
        }
 
        public InputType inputType
        {
            get
            {
                return m_InputType;
            }
            set
            {
                if (SetPropertyUtility.SetStruct<InputType>(ref m_InputType, value))
                {
                    SetToCustom();
                }
            }
        }
 
        public TouchScreenKeyboard touchScreenKeyboard => m_Keyboard;
 
        public TouchScreenKeyboardType keyboardType
        {
            get
            {
                //IL_0001: Unknown result type (might be due to invalid IL or missing references)
                return m_KeyboardType;
            }
            set
            {
                //IL_0006: Unknown result type (might be due to invalid IL or missing references)
                if (SetPropertyUtility.SetStruct<TouchScreenKeyboardType>(ref m_KeyboardType, value))
                {
                    SetToCustom();
                }
            }
        }
 
        public CharacterValidation characterValidation
        {
            get
            {
                return m_CharacterValidation;
            }
            set
            {
                if (SetPropertyUtility.SetStruct<CharacterValidation>(ref m_CharacterValidation, value))
                {
                    SetToCustom();
                }
            }
        }
 
        public bool readOnly
        {
            get
            {
                return m_ReadOnly;
            }
            set
            {
                m_ReadOnly = value;
            }
        }
 
        public bool multiLine
        {
            get
            {
                if (m_LineType != LineType.MultiLineNewline)
                {
                    return lineType == LineType.MultiLineSubmit;
                }
                return true;
            }
        }
 
        public char asteriskChar
        {
            get
            {
                return m_AsteriskChar;
            }
            set
            {
                if (SetPropertyUtility.SetStruct<char>(ref m_AsteriskChar, value))
                {
                    UpdateLabel();
                }
            }
        }
 
        public bool wasCanceled => m_WasCanceled;
 
        protected int caretPositionInternal
        {
            get
            {
                return m_CaretPosition + compositionString.Length;
            }
            set
            {
                m_CaretPosition = value;
                ClampPos(ref m_CaretPosition);
            }
        }
 
        protected int caretSelectPositionInternal
        {
            get
            {
                return m_CaretSelectPosition + compositionString.Length;
            }
            set
            {
                m_CaretSelectPosition = value;
                ClampPos(ref m_CaretSelectPosition);
            }
        }
 
        private bool hasSelection => caretPositionInternal != caretSelectPositionInternal;
 
        [ExcludeFromUdonWrapper]
        public int caretPosition
        {
            get
            {
                return m_CaretSelectPosition + compositionString.Length;
            }
            set
            {
                selectionAnchorPosition = value;
                selectionFocusPosition = value;
            }
        }
 
        [ExcludeFromUdonWrapper]
        public int selectionAnchorPosition
        {
            get
            {
                return m_CaretPosition + compositionString.Length;
            }
            set
            {
                if (compositionString.Length == 0)
                {
                    m_CaretPosition = value;
                    ClampPos(ref m_CaretPosition);
                }
            }
        }
 
        [ExcludeFromUdonWrapper]
        public int selectionFocusPosition
        {
            get
            {
                return m_CaretSelectPosition + compositionString.Length;
            }
            set
            {
                if (compositionString.Length == 0)
                {
                    m_CaretSelectPosition = value;
                    ClampPos(ref m_CaretSelectPosition);
                }
            }
        }
 
        private static string clipboard
        {
            get
            {
                return GUIUtility.systemCopyBuffer;
            }
            set
            {
                GUIUtility.systemCopyBuffer = value;
            }
        }
 
        public virtual float minWidth => 0f;
 
        public virtual float preferredWidth
        {
            get
            {
                //IL_001a: Unknown result type (might be due to invalid IL or missing references)
                //IL_001f: Unknown result type (might be due to invalid IL or missing references)
                //IL_0024: Unknown result type (might be due to invalid IL or missing references)
                //IL_0036: Unknown result type (might be due to invalid IL or missing references)
                if ((Object)(object)textComponent == (Object)null)
                {
                    return 0f;
                }
                TextGenerationSettings generationSettings = textComponent.GetGenerationSettings(Vector2.zero);
                return textComponent.cachedTextGeneratorForLayout.GetPreferredWidth(m_Text, generationSettings) / textComponent.pixelsPerUnit;
            }
        }
 
        public virtual float flexibleWidth => -1f;
 
        public virtual float minHeight => 0f;
 
        public virtual float preferredHeight
        {
            get
            {
                //IL_0025: Unknown result type (might be due to invalid IL or missing references)
                //IL_002a: Unknown result type (might be due to invalid IL or missing references)
                //IL_002d: Unknown result type (might be due to invalid IL or missing references)
                //IL_003c: Unknown result type (might be due to invalid IL or missing references)
                //IL_0041: Unknown result type (might be due to invalid IL or missing references)
                //IL_0046: Unknown result type (might be due to invalid IL or missing references)
                //IL_0058: Unknown result type (might be due to invalid IL or missing references)
                if ((Object)(object)textComponent == (Object)null)
                {
                    return 0f;
                }
                Text obj = textComponent;
                Rect rect = ((Graphic)textComponent).rectTransform.rect;
                TextGenerationSettings generationSettings = obj.GetGenerationSettings(new Vector2(((Rect)(ref rect)).size.x, 0f));
                return textComponent.cachedTextGeneratorForLayout.GetPreferredHeight(m_Text, generationSettings) / textComponent.pixelsPerUnit;
            }
        }
 
        public virtual float flexibleHeight => -1f;
 
        public virtual int layoutPriority => 1;
 
        public event Action onSelected
        {
            [CompilerGenerated]
            add
            {
                //IL_0010: Unknown result type (might be due to invalid IL or missing references)
                //IL_0016: Expected O, but got Unknown
                Action val = this.m_onSelected;
                Action val2;
                do
                {
                    val2 = val;
                    Action val3 = (Action)Delegate.Combine((Delegate)(object)val2, (Delegate)(object)value);
                    val = Interlocked.CompareExchange<Action>(ref this.m_onSelected, val3, val2);
                }
                while (val != val2);
            }
            [CompilerGenerated]
            remove
            {
                //IL_0010: Unknown result type (might be due to invalid IL or missing references)
                //IL_0016: Expected O, but got Unknown
                Action val = this.m_onSelected;
                Action val2;
                do
                {
                    val2 = val;
                    Action val3 = (Action)Delegate.Remove((Delegate)(object)val2, (Delegate)(object)value);
                    val = Interlocked.CompareExchange<Action>(ref this.m_onSelected, val3, val2);
                }
                while (val != val2);
            }
        }
 
        public VRCUrl GetUrl()
        {
            //IL_0006: Unknown result type (might be due to invalid IL or missing references)
            //IL_0012: Unknown result type (might be due to invalid IL or missing references)
            //IL_0017: Unknown result type (might be due to invalid IL or missing references)
            //IL_0032: Unknown result type (might be due to invalid IL or missing references)
            //IL_0038: Expected O, but got Unknown
            //IL_0026: Unknown result type (might be due to invalid IL or missing references)
            //IL_002c: Expected O, but got Unknown
            _ = ((Component)this).gameObject.scene;
            Scene scene = ((Component)this).gameObject.scene;
            if (((Scene)(ref scene)).IsValid())
            {
                return new VRCUrl(text);
            }
            return new VRCUrl("");
        }
 
        public void SetUrl(VRCUrl url)
        {
            text = url.Get();
        }
 
        protected override void Awake()
        {
            ((Selectable)this).Awake();
            text = "";
            if (!s_AreDevicesEvaluated)
            {
                s_IsQuestDevice = SystemInfo.deviceModel == "Oculus Quest";
                s_IsPicoDevice = SystemInfo.deviceModel.Contains("Pico", (StringComparison)3);
                s_AreDevicesEvaluated = true;
            }
        }
 
        protected VRCUrlInputField()
        {
            //IL_0033: Unknown result type (might be due to invalid IL or missing references)
            //IL_0038: Unknown result type (might be due to invalid IL or missing references)
            //IL_0052: Unknown result type (might be due to invalid IL or missing references)
            //IL_0057: Unknown result type (might be due to invalid IL or missing references)
            //IL_0093: Unknown result type (might be due to invalid IL or missing references)
            //IL_009d: Expected O, but got Unknown
            EnforceTextHOverflow();
        }
 
        private void SetText(string value, bool sendCallback = true)
        {
            //IL_0006: Unknown result type (might be due to invalid IL or missing references)
            //IL_0012: Unknown result type (might be due to invalid IL or missing references)
            //IL_0017: Unknown result type (might be due to invalid IL or missing references)
            _ = ((Component)this).gameObject.scene;
            Scene scene = ((Component)this).gameObject.scene;
            if (!((Scene)(ref scene)).IsValid() || text == value)
            {
                return;
            }
            if (value == null)
            {
                value = "";
            }
            value = value.Replace("\0", String.Empty);
            if (m_LineType == LineType.SingleLine)
            {
                value = value.Replace("\n", "").Replace("\t", "");
            }
            if (this.onValidateInput != null || characterValidation != 0)
            {
                m_Text = "";
                OnValidateInput onValidateInput = this.onValidateInput ?? new OnValidateInput(Validate);
                m_CaretPosition = (m_CaretSelectPosition = value.Length);
                int num = ((characterLimit > 0) ? Math.Min(characterLimit, value.Length) : value.Length);
                for (int i = 0; i < num; i++)
                {
                    char c = onValidateInput(m_Text, m_Text.Length, value[i]);
                    if (c != 0)
                    {
                        m_Text = String.Concat(m_Text, ((Char)(ref c)).ToString());
                    }
                }
            }
            else
            {
                m_Text = ((characterLimit > 0 && value.Length > characterLimit) ? value.Substring(0, characterLimit) : value);
            }
            if (m_Keyboard != null)
            {
                m_Keyboard.text = m_Text;
            }
            if (m_CaretPosition > m_Text.Length)
            {
                m_CaretPosition = (m_CaretSelectPosition = m_Text.Length);
            }
            else if (m_CaretSelectPosition > m_Text.Length)
            {
                m_CaretSelectPosition = m_Text.Length;
            }
            if (sendCallback)
            {
                SendOnValueChanged();
            }
            UpdateLabel();
        }
 
        protected void ClampPos(ref int pos)
        {
            if (pos < 0)
            {
                pos = 0;
            }
            else if (pos > text.Length)
            {
                pos = text.Length;
            }
        }
 
        protected override void OnEnable()
        {
            //IL_007a: Unknown result type (might be due to invalid IL or missing references)
            //IL_0084: Expected O, but got Unknown
            //IL_0091: Unknown result type (might be due to invalid IL or missing references)
            //IL_009b: Expected O, but got Unknown
            //IL_00a8: Unknown result type (might be due to invalid IL or missing references)
            //IL_00b2: Expected O, but got Unknown
            ((Selectable)this).OnEnable();
            if (m_Text == null)
            {
                m_Text = String.Empty;
            }
            m_DrawStart = 0;
            m_DrawEnd = m_Text.Length;
            if ((Object)(object)m_CachedInputRenderer != (Object)null)
            {
                m_CachedInputRenderer.SetMaterial(((MaskableGraphic)m_TextComponent).GetModifiedMaterial(Graphic.defaultGraphicMaterial), (Texture)(object)Texture2D.whiteTexture);
            }
            if ((Object)(object)m_TextComponent != (Object)null)
            {
                ((Graphic)m_TextComponent).RegisterDirtyVerticesCallback(new UnityAction(MarkGeometryAsDirty));
                ((Graphic)m_TextComponent).RegisterDirtyVerticesCallback(new UnityAction(UpdateLabel));
                ((Graphic)m_TextComponent).RegisterDirtyMaterialCallback(new UnityAction(UpdateCaretMaterial));
                UpdateLabel();
            }
        }
 
        protected override void OnDisable()
        {
            //IL_0028: Unknown result type (might be due to invalid IL or missing references)
            //IL_0032: Expected O, but got Unknown
            //IL_003f: Unknown result type (might be due to invalid IL or missing references)
            //IL_0049: Expected O, but got Unknown
            //IL_0056: Unknown result type (might be due to invalid IL or missing references)
            //IL_0060: Expected O, but got Unknown
            m_BlinkCoroutine = null;
            DeactivateInputField();
            if ((Object)(object)m_TextComponent != (Object)null)
            {
                ((Graphic)m_TextComponent).UnregisterDirtyVerticesCallback(new UnityAction(MarkGeometryAsDirty));
                ((Graphic)m_TextComponent).UnregisterDirtyVerticesCallback(new UnityAction(UpdateLabel));
                ((Graphic)m_TextComponent).UnregisterDirtyMaterialCallback(new UnityAction(UpdateCaretMaterial));
            }
            CanvasUpdateRegistry.UnRegisterCanvasElementForRebuild((ICanvasElement)(object)this);
            if ((Object)(object)m_CachedInputRenderer != (Object)null)
            {
                m_CachedInputRenderer.Clear();
            }
            if ((Object)(object)m_Mesh != (Object)null)
            {
                Object.DestroyImmediate((Object)(object)m_Mesh);
            }
            m_Mesh = null;
            ((Selectable)this).OnDisable();
        }
 
        [IteratorStateMachine(/*Could not decode attribute arguments.*/)]
        private IEnumerator CaretBlink()
        {
            m_CaretVisible = true;
            yield return null;
            while (isFocused && m_CaretBlinkRate > 0f)
            {
                float num = 1f / m_CaretBlinkRate;
                bool flag = (Time.unscaledTime - m_BlinkStartTime) % num < num / 2f;
                if (m_CaretVisible != flag)
                {
                    m_CaretVisible = flag;
                    if (!hasSelection)
                    {
                        MarkGeometryAsDirty();
                    }
                }
                yield return null;
            }
            m_BlinkCoroutine = null;
        }
 
        private void SetCaretVisible()
        {
            if (m_AllowInput)
            {
                m_CaretVisible = true;
                m_BlinkStartTime = Time.unscaledTime;
                SetCaretActive();
            }
        }
 
        private void SetCaretActive()
        {
            if (!m_AllowInput)
            {
                return;
            }
            if (m_CaretBlinkRate > 0f)
            {
                if (m_BlinkCoroutine == null)
                {
                    m_BlinkCoroutine = ((MonoBehaviour)this).StartCoroutine(CaretBlink());
                }
            }
            else
            {
                m_CaretVisible = true;
            }
        }
 
        private void UpdateCaretMaterial()
        {
            if ((Object)(object)m_TextComponent != (Object)null && (Object)(object)m_CachedInputRenderer != (Object)null)
            {
                m_CachedInputRenderer.SetMaterial(((MaskableGraphic)m_TextComponent).GetModifiedMaterial(Graphic.defaultGraphicMaterial), (Texture)(object)Texture2D.whiteTexture);
            }
        }
 
        protected void OnFocus()
        {
            SelectAll();
        }
 
        protected void SelectAll()
        {
            caretPositionInternal = text.Length;
            caretSelectPositionInternal = 0;
        }
 
        public void MoveTextEnd(bool shift)
        {
            int length = text.Length;
            if (shift)
            {
                caretSelectPositionInternal = length;
            }
            else
            {
                caretPositionInternal = length;
                caretSelectPositionInternal = caretPositionInternal;
            }
            UpdateLabel();
        }
 
        public void MoveTextStart(bool shift)
        {
            int num = 0;
            if (shift)
            {
                caretSelectPositionInternal = num;
            }
            else
            {
                caretPositionInternal = num;
                caretSelectPositionInternal = caretPositionInternal;
            }
            UpdateLabel();
        }
 
        private bool TouchScreenKeyboardShouldBeUsed()
        {
            //IL_0000: Unknown result type (might be due to invalid IL or missing references)
            //IL_0007: Invalid comparison between Unknown and I4
            if ((int)Application.platform == 11)
            {
                if (s_IsQuestDevice)
                {
                    return TouchScreenKeyboard.isSupported;
                }
                if (s_IsPicoDevice)
                {
                    return false;
                }
                return !TouchScreenKeyboard.isInPlaceEditingAllowed;
            }
            return TouchScreenKeyboard.isSupported;
        }
 
        private bool InPlaceEditing()
        {
            if (TouchScreenKeyboard.isSupported && !m_TouchKeyboardAllowsInPlaceEditing && !s_IsQuestDevice)
            {
                return s_IsPicoDevice;
            }
            return true;
        }
 
        private bool InPlaceEditingChanged()
        {
            if (!s_IsQuestDevice && !s_IsPicoDevice)
            {
                return m_TouchKeyboardAllowsInPlaceEditing != TouchScreenKeyboard.isInPlaceEditingAllowed;
            }
            return false;
        }
 
        private void UpdateCaretFromKeyboard()
        {
            //IL_0006: Unknown result type (might be due to invalid IL or missing references)
            //IL_000b: Unknown result type (might be due to invalid IL or missing references)
            //IL_000c: Unknown result type (might be due to invalid IL or missing references)
            RangeInt selection = m_Keyboard.selection;
            int start = selection.start;
            int end = ((RangeInt)(ref selection)).end;
            bool flag = false;
            if (caretPositionInternal != start)
            {
                flag = true;
                caretPositionInternal = start;
            }
            if (caretSelectPositionInternal != end)
            {
                caretSelectPositionInternal = end;
                flag = true;
            }
            if (flag)
            {
                m_BlinkStartTime = Time.unscaledTime;
                UpdateLabel();
            }
        }
 
        protected virtual void LateUpdate()
        {
            //IL_0049: Unknown result type (might be due to invalid IL or missing references)
            //IL_004f: Expected O, but got Unknown
            //IL_009d: Unknown result type (might be due to invalid IL or missing references)
            //IL_00cb: Unknown result type (might be due to invalid IL or missing references)
            //IL_00d1: Invalid comparison between Unknown and I4
            //IL_02dd: Unknown result type (might be due to invalid IL or missing references)
            //IL_02b0: Unknown result type (might be due to invalid IL or missing references)
            //IL_02ea: Unknown result type (might be due to invalid IL or missing references)
            //IL_02f0: Invalid comparison between Unknown and I4
            if (m_ShouldActivateNextUpdate)
            {
                if (!isFocused)
                {
                    ActivateInputFieldInternal();
                    m_ShouldActivateNextUpdate = false;
                    return;
                }
                m_ShouldActivateNextUpdate = false;
            }
            AssignPositioningIfNeeded();
            if (isFocused && InPlaceEditingChanged())
            {
                if ((Object)(object)m_CachedInputRenderer != (Object)null)
                {
                    VertexHelper val = new VertexHelper();
                    try
                    {
                        val.FillMesh(mesh);
                    }
                    finally
                    {
                        if (val != null)
                        {
                            ((IDisposable)val).Dispose();
                        }
                    }
                    m_CachedInputRenderer.SetMesh(mesh);
                }
                DeactivateInputField();
            }
            if (!isFocused || InPlaceEditing())
            {
                return;
            }
            if (m_Keyboard == null || (int)m_Keyboard.status != 0)
            {
                if (m_Keyboard != null)
                {
                    if (!m_ReadOnly)
                    {
                        this.text = m_Keyboard.text;
                    }
                    if ((int)m_Keyboard.status == 2)
                    {
                        m_WasCanceled = true;
                    }
                }
                ((Selectable)this).OnDeselect((BaseEventData)null);
                return;
            }
            string text = m_Keyboard.text;
            if (m_Text != text)
            {
                if (m_ReadOnly)
                {
                    m_Keyboard.text = m_Text;
                }
                else
                {
                    m_Text = "";
                    for (int i = 0; i < text.Length; i++)
                    {
                        char c = text[i];
                        if (c == '\r' || c == '\u0003')
                        {
                            c = '\n';
                        }
                        if (onValidateInput != null)
                        {
                            c = onValidateInput(m_Text, m_Text.Length, c);
                        }
                        else if (characterValidation != 0)
                        {
                            c = Validate(m_Text, m_Text.Length, c);
                        }
                        if (lineType == LineType.MultiLineSubmit && c == '\n')
                        {
                            m_Keyboard.text = m_Text;
                            ((Selectable)this).OnDeselect((BaseEventData)null);
                            return;
                        }
                        if (c != 0)
                        {
                            m_Text = String.Concat(m_Text, ((Char)(ref c)).ToString());
                        }
                    }
                    if (characterLimit > 0 && m_Text.Length > characterLimit)
                    {
                        m_Text = m_Text.Substring(0, characterLimit);
                    }
                    if (m_Keyboard.canGetSelection)
                    {
                        UpdateCaretFromKeyboard();
                    }
                    else
                    {
                        int num = (caretSelectPositionInternal = m_Text.Length);
                        caretPositionInternal = num;
                    }
                    if (m_Text != text)
                    {
                        m_Keyboard.text = m_Text;
                    }
                    SendOnValueChangedAndUpdateLabel();
                }
            }
            else if (m_HideMobileInput && m_Keyboard.canSetSelection)
            {
                int num2 = Mathf.Min(caretSelectPositionInternal, caretPositionInternal);
                int num3 = Mathf.Abs(caretSelectPositionInternal - caretPositionInternal);
                m_Keyboard.selection = new RangeInt(num2, num3);
            }
            else if (m_Keyboard.canGetSelection && !m_HideMobileInput)
            {
                UpdateCaretFromKeyboard();
            }
            if ((int)m_Keyboard.status != 0)
            {
                if ((int)m_Keyboard.status == 2)
                {
                    m_WasCanceled = true;
                }
                ((Selectable)this).OnDeselect((BaseEventData)null);
            }
        }
 
        [Obsolete("This function is no longer used. Please use RectTransformUtility.ScreenPointToLocalPointInRectangle() instead.")]
        public Vector2 ScreenToLocal(Vector2 screen)
        {
            //IL_0017: Unknown result type (might be due to invalid IL or missing references)
            //IL_001c: Unknown result type (might be due to invalid IL or missing references)
            //IL_001e: Unknown result type (might be due to invalid IL or missing references)
            //IL_0015: Unknown result type (might be due to invalid IL or missing references)
            //IL_0030: Unknown result type (might be due to invalid IL or missing references)
            //IL_0031: Unknown result type (might be due to invalid IL or missing references)
            //IL_0036: Unknown result type (might be due to invalid IL or missing references)
            //IL_003b: Unknown result type (might be due to invalid IL or missing references)
            //IL_00a9: Unknown result type (might be due to invalid IL or missing references)
            //IL_00af: Unknown result type (might be due to invalid IL or missing references)
            //IL_00b5: Unknown result type (might be due to invalid IL or missing references)
            //IL_0052: Unknown result type (might be due to invalid IL or missing references)
            //IL_0053: Unknown result type (might be due to invalid IL or missing references)
            //IL_0058: Unknown result type (might be due to invalid IL or missing references)
            //IL_005d: Unknown result type (might be due to invalid IL or missing references)
            //IL_006b: Unknown result type (might be due to invalid IL or missing references)
            //IL_007b: Unknown result type (might be due to invalid IL or missing references)
            //IL_0087: Unknown result type (might be due to invalid IL or missing references)
            //IL_009e: Unknown result type (might be due to invalid IL or missing references)
            //IL_00a3: Unknown result type (might be due to invalid IL or missing references)
            //IL_00a8: Unknown result type (might be due to invalid IL or missing references)
            Canvas canvas = ((Graphic)m_TextComponent).canvas;
            if ((Object)(object)canvas == (Object)null)
            {
                return screen;
            }
            Vector3 val = Vector3.zero;
            if ((int)canvas.renderMode == 0)
            {
                val = ((Component)m_TextComponent).transform.InverseTransformPoint(Vector2.op_Implicit(screen));
            }
            else if ((Object)(object)canvas.worldCamera != (Object)null)
            {
                Ray val2 = canvas.worldCamera.ScreenPointToRay(Vector2.op_Implicit(screen));
                Plane val3 = default(Plane);
                ((Plane)(ref val3))..ctor(((Component)m_TextComponent).transform.forward, ((Component)m_TextComponent).transform.position);
                float num = default(float);
                ((Plane)(ref val3)).Raycast(val2, ref num);
                val = ((Component)m_TextComponent).transform.InverseTransformPoint(((Ray)(ref val2)).GetPoint(num));
            }
            return new Vector2(val.x, val.y);
        }
 
        private int GetUnclampedCharacterLineFromPosition(Vector2 pos, TextGenerator generator)
        {
            //IL_000a: Unknown result type (might be due to invalid IL or missing references)
            //IL_002e: Unknown result type (might be due to invalid IL or missing references)
            //IL_0041: Unknown result type (might be due to invalid IL or missing references)
            if (!multiLine)
            {
                return 0;
            }
            float num = pos.y * m_TextComponent.pixelsPerUnit;
            float num2 = 0f;
            for (int i = 0; i < generator.lineCount; i++)
            {
                float topY = generator.lines[i].topY;
                float num3 = topY - (float)generator.lines[i].height;
                if (num > topY)
                {
                    float num4 = topY - num2;
                    if (num > topY - 0.5f * num4)
                    {
                        return i - 1;
                    }
                    return i;
                }
                if (num > num3)
                {
                    return i;
                }
                num2 = num3;
            }
            return generator.lineCount;
        }
 
        protected int GetCharacterIndexFromPosition(Vector2 pos)
        {
            //IL_0017: Unknown result type (might be due to invalid IL or missing references)
            //IL_003c: Unknown result type (might be due to invalid IL or missing references)
            //IL_0061: Unknown result type (might be due to invalid IL or missing references)
            //IL_0066: Unknown result type (might be due to invalid IL or missing references)
            //IL_0068: Unknown result type (might be due to invalid IL or missing references)
            //IL_006a: Unknown result type (might be due to invalid IL or missing references)
            //IL_007a: Unknown result type (might be due to invalid IL or missing references)
            //IL_007f: Unknown result type (might be due to invalid IL or missing references)
            //IL_0081: Unknown result type (might be due to invalid IL or missing references)
            //IL_0087: Unknown result type (might be due to invalid IL or missing references)
            //IL_008f: Unknown result type (might be due to invalid IL or missing references)
            //IL_0096: Unknown result type (might be due to invalid IL or missing references)
            //IL_00aa: Unknown result type (might be due to invalid IL or missing references)
            TextGenerator cachedTextGenerator = m_TextComponent.cachedTextGenerator;
            if (cachedTextGenerator.lineCount == 0)
            {
                return 0;
            }
            int unclampedCharacterLineFromPosition = GetUnclampedCharacterLineFromPosition(pos, cachedTextGenerator);
            if (unclampedCharacterLineFromPosition < 0)
            {
                return 0;
            }
            if (unclampedCharacterLineFromPosition >= cachedTextGenerator.lineCount)
            {
                return cachedTextGenerator.characterCountVisible;
            }
            int startCharIdx = cachedTextGenerator.lines[unclampedCharacterLineFromPosition].startCharIdx;
            int lineEndPosition = GetLineEndPosition(cachedTextGenerator, unclampedCharacterLineFromPosition);
            for (int i = startCharIdx; i < lineEndPosition && i < cachedTextGenerator.characterCountVisible; i++)
            {
                UICharInfo val = cachedTextGenerator.characters[i];
                Vector2 val2 = val.cursorPos / m_TextComponent.pixelsPerUnit;
                float num = pos.x - val2.x;
                float num2 = val2.x + val.charWidth / m_TextComponent.pixelsPerUnit - pos.x;
                if (num < num2)
                {
                    return i;
                }
            }
            return lineEndPosition;
        }
 
        private bool MayDrag(PointerEventData eventData)
        {
            //IL_0011: Unknown result type (might be due to invalid IL or missing references)
            if (((UIBehaviour)this).IsActive() && ((Selectable)this).IsInteractable() && (int)eventData.button == 0 && (Object)(object)m_TextComponent != (Object)null)
            {
                if (!InPlaceEditing())
                {
                    return m_HideMobileInput;
                }
                return true;
            }
            return false;
        }
 
        public virtual void OnBeginDrag(PointerEventData eventData)
        {
            if (MayDrag(eventData))
            {
                m_UpdateDrag = true;
            }
        }
 
        public virtual void OnDrag(PointerEventData eventData)
        {
            //IL_000a: Unknown result type (might be due to invalid IL or missing references)
            //IL_000f: Unknown result type (might be due to invalid IL or missing references)
            //IL_0026: Unknown result type (might be due to invalid IL or missing references)
            //IL_0037: Unknown result type (might be due to invalid IL or missing references)
            //IL_005c: Unknown result type (might be due to invalid IL or missing references)
            if (!MayDrag(eventData))
            {
                return;
            }
            Vector2 position = Vector2.zero;
            if (MultipleDisplayUtilities.GetRelativeMousePositionForDrag(eventData, ref position))
            {
                Vector2 pos = default(Vector2);
                RectTransformUtility.ScreenPointToLocalPointInRectangle(((Graphic)textComponent).rectTransform, position, eventData.pressEventCamera, ref pos);
                caretSelectPositionInternal = GetCharacterIndexFromPosition(pos) + m_DrawStart;
                MarkGeometryAsDirty();
                m_DragPositionOutOfBounds = !RectTransformUtility.RectangleContainsScreenPoint(((Graphic)textComponent).rectTransform, eventData.position, eventData.pressEventCamera);
                if (m_DragPositionOutOfBounds && m_DragCoroutine == null)
                {
                    m_DragCoroutine = ((MonoBehaviour)this).StartCoroutine(MouseDragOutsideRect(eventData));
                }
                ((AbstractEventData)eventData).Use();
            }
        }
 
        [IteratorStateMachine(/*Could not decode attribute arguments.*/)]
        private IEnumerator MouseDragOutsideRect(PointerEventData eventData)
        {
            Vector2 val = default(Vector2);
            while (m_UpdateDrag && m_DragPositionOutOfBounds)
            {
                Vector2 position = Vector2.zero;
                if (!MultipleDisplayUtilities.GetRelativeMousePositionForDrag(eventData, ref position))
                {
                    break;
                }
                RectTransformUtility.ScreenPointToLocalPointInRectangle(((Graphic)textComponent).rectTransform, position, eventData.pressEventCamera, ref val);
                Rect rect = ((Graphic)textComponent).rectTransform.rect;
                if (multiLine)
                {
                    if (val.y > ((Rect)(ref rect)).yMax)
                    {
                        MoveUp(shift: true, goToFirstChar: true);
                    }
                    else if (val.y < ((Rect)(ref rect)).yMin)
                    {
                        MoveDown(shift: true, goToLastChar: true);
                    }
                }
                else if (val.x < ((Rect)(ref rect)).xMin)
                {
                    MoveLeft(shift: true, ctrl: false);
                }
                else if (val.x > ((Rect)(ref rect)).xMax)
                {
                    MoveRight(shift: true, ctrl: false);
                }
                UpdateLabel();
                float num = (multiLine ? 0.1f : 0.05f);
                if (m_WaitForSecondsRealtime == null)
                {
                    m_WaitForSecondsRealtime = new WaitForSecondsRealtime(num);
                }
                else
                {
                    m_WaitForSecondsRealtime.waitTime = num;
                }
                yield return m_WaitForSecondsRealtime;
            }
            m_DragCoroutine = null;
        }
 
        public virtual void OnEndDrag(PointerEventData eventData)
        {
            if (MayDrag(eventData))
            {
                m_UpdateDrag = false;
            }
        }
 
        public override void OnPointerDown(PointerEventData eventData)
        {
            //IL_005d: Unknown result type (might be due to invalid IL or missing references)
            //IL_0062: Unknown result type (might be due to invalid IL or missing references)
            //IL_0078: Unknown result type (might be due to invalid IL or missing references)
            if (!MayDrag(eventData))
            {
                return;
            }
            EventSystem.current.SetSelectedGameObject(((Component)this).gameObject, (BaseEventData)(object)eventData);
            bool allowInput = m_AllowInput;
            ((Selectable)this).OnPointerDown(eventData);
            if (!InPlaceEditing() && (m_Keyboard == null || !m_Keyboard.active))
            {
                ((Selectable)this).OnSelect((BaseEventData)(object)eventData);
                return;
            }
            if (allowInput)
            {
                Vector2 pos = default(Vector2);
                RectTransformUtility.ScreenPointToLocalPointInRectangle(((Graphic)textComponent).rectTransform, eventData.pointerPressRaycast.screenPosition, eventData.pressEventCamera, ref pos);
                int num2 = (caretPositionInternal = GetCharacterIndexFromPosition(pos) + m_DrawStart);
                caretSelectPositionInternal = num2;
            }
            UpdateLabel();
            ((AbstractEventData)eventData).Use();
        }
 
        protected EditState KeyPressed(Event evt)
        {
            //IL_0001: Unknown result type (might be due to invalid IL or missing references)
            //IL_0006: Unknown result type (might be due to invalid IL or missing references)
            //IL_0007: Unknown result type (might be due to invalid IL or missing references)
            //IL_000d: Invalid comparison between Unknown and I4
            //IL_0017: Unknown result type (might be due to invalid IL or missing references)
            //IL_0019: Unknown result type (might be due to invalid IL or missing references)
            //IL_001b: Invalid comparison between Unknown and I4
            //IL_000f: Unknown result type (might be due to invalid IL or missing references)
            //IL_0011: Unknown result type (might be due to invalid IL or missing references)
            //IL_0013: Invalid comparison between Unknown and I4
            //IL_001e: Unknown result type (might be due to invalid IL or missing references)
            //IL_0020: Unknown result type (might be due to invalid IL or missing references)
            //IL_0022: Invalid comparison between Unknown and I4
            //IL_0025: Unknown result type (might be due to invalid IL or missing references)
            //IL_0027: Unknown result type (might be due to invalid IL or missing references)
            //IL_0029: Invalid comparison between Unknown and I4
            //IL_003c: Unknown result type (might be due to invalid IL or missing references)
            //IL_0041: Unknown result type (might be due to invalid IL or missing references)
            //IL_0043: Unknown result type (might be due to invalid IL or missing references)
            //IL_0047: Invalid comparison between Unknown and I4
            //IL_007c: Unknown result type (might be due to invalid IL or missing references)
            //IL_0080: Invalid comparison between Unknown and I4
            //IL_0049: Unknown result type (might be due to invalid IL or missing references)
            //IL_004d: Invalid comparison between Unknown and I4
            //IL_0099: Unknown result type (might be due to invalid IL or missing references)
            //IL_009d: Invalid comparison between Unknown and I4
            //IL_0082: Unknown result type (might be due to invalid IL or missing references)
            //IL_0086: Invalid comparison between Unknown and I4
            //IL_0065: Unknown result type (might be due to invalid IL or missing references)
            //IL_0069: Invalid comparison between Unknown and I4
            //IL_004f: Unknown result type (might be due to invalid IL or missing references)
            //IL_0052: Invalid comparison between Unknown and I4
            //IL_00a2: Unknown result type (might be due to invalid IL or missing references)
            //IL_00a6: Invalid comparison between Unknown and I4
            //IL_008b: Unknown result type (might be due to invalid IL or missing references)
            //IL_008f: Invalid comparison between Unknown and I4
            //IL_006e: Unknown result type (might be due to invalid IL or missing references)
            //IL_0072: Invalid comparison between Unknown and I4
            //IL_0057: Unknown result type (might be due to invalid IL or missing references)
            //IL_005b: Invalid comparison between Unknown and I4
            //IL_00a8: Unknown result type (might be due to invalid IL or missing references)
            //IL_00af: Unknown result type (might be due to invalid IL or missing references)
            //IL_00d9: Expected I4, but got Unknown
            EventModifiers modifiers = evt.modifiers;
            bool flag = (((int)SystemInfo.operatingSystemFamily == 1) ? ((modifiers & 8) > 0) : ((modifiers & 2) > 0));
            bool flag2 = (modifiers & 1) > 0;
            bool flag3 = (modifiers & 4) > 0;
            bool flag4 = flag && !flag3 && !flag2;
            KeyCode keyCode = evt.keyCode;
            if ((int)keyCode <= 97)
            {
                if ((int)keyCode <= 13)
                {
                    if ((int)keyCode == 8)
                    {
                        Backspace();
                        return EditState.Continue;
                    }
                    if ((int)keyCode == 13)
                    {
                        goto IL_01b1;
                    }
                }
                else
                {
                    if ((int)keyCode == 27)
                    {
                        m_WasCanceled = true;
                        return EditState.Finish;
                    }
                    if ((int)keyCode == 97 && flag4)
                    {
                        SelectAll();
                        return EditState.Continue;
                    }
                }
            }
            else if ((int)keyCode <= 118)
            {
                if ((int)keyCode != 99)
                {
                    if ((int)keyCode == 118 && flag4)
                    {
                        Append(clipboard);
                        UpdateLabel();
                        return EditState.Continue;
                    }
                }
                else if (flag4)
                {
                    if (inputType != InputType.Password)
                    {
                        clipboard = GetSelectedString();
                    }
                    else
                    {
                        clipboard = "";
                    }
                    return EditState.Continue;
                }
            }
            else
            {
                if ((int)keyCode != 120)
                {
                    if ((int)keyCode != 127)
                    {
                        switch (keyCode - 271)
                        {
                        case 7:
                            MoveTextStart(flag2);
                            return EditState.Continue;
                        case 8:
                            MoveTextEnd(flag2);
                            return EditState.Continue;
                        case 5:
                            MoveLeft(flag2, flag);
                            return EditState.Continue;
                        case 4:
                            MoveRight(flag2, flag);
                            return EditState.Continue;
                        case 2:
                            MoveUp(flag2);
                            return EditState.Continue;
                        case 3:
                            MoveDown(flag2);
                            return EditState.Continue;
                        case 0:
                            break;
                        default:
                            goto IL_01c5;
                        }
                        goto IL_01b1;
                    }
                    ForwardSpace();
                    return EditState.Continue;
                }
                if (flag4)
                {
                    if (inputType != InputType.Password)
                    {
                        clipboard = GetSelectedString();
                    }
                    else
                    {
                        clipboard = "";
                    }
                    Delete();
                    UpdateTouchKeyboardFromEditChanges();
                    SendOnValueChangedAndUpdateLabel();
                    return EditState.Continue;
                }
            }
            goto IL_01c5;
            IL_01b1:
            if (lineType != LineType.MultiLineNewline)
            {
                return EditState.Finish;
            }
            goto IL_01c5;
            IL_01c5:
            char c = evt.character;
            if (!multiLine && (c == '\t' || c == '\r' || c == '\n'))
            {
                return EditState.Continue;
            }
            if (c == '\r' || c == '\u0003')
            {
                c = '\n';
            }
            if (IsValidChar(c))
            {
                Append(c);
            }
            if (c == '\0' && compositionString.Length > 0)
            {
                UpdateLabel();
            }
            return EditState.Continue;
        }
 
        private bool IsValidChar(char c)
        {
            switch (c)
            {
            case '\u007f':
                return false;
            case '\t':
            case '\n':
                return true;
            default:
                return m_TextComponent.font.HasCharacter(c);
            }
        }
 
        public void ProcessEvent(Event e)
        {
            KeyPressed(e);
        }
 
        public virtual void OnUpdateSelected(BaseEventData eventData)
        {
            //IL_0013: Unknown result type (might be due to invalid IL or missing references)
            //IL_0019: Invalid comparison between Unknown and I4
            //IL_003a: Unknown result type (might be due to invalid IL or missing references)
            //IL_003f: Unknown result type (might be due to invalid IL or missing references)
            //IL_0040: Unknown result type (might be due to invalid IL or missing references)
            //IL_0043: Unknown result type (might be due to invalid IL or missing references)
            //IL_0045: Invalid comparison between Unknown and I4
            if (!isFocused)
            {
                return;
            }
            bool flag = false;
            while (Event.PopEvent(m_ProcessingEvent))
            {
                if ((int)m_ProcessingEvent.rawType == 4)
                {
                    flag = true;
                    if (KeyPressed(m_ProcessingEvent) == EditState.Finish)
                    {
                        DeactivateInputField();
                        break;
                    }
                }
                EventType type = m_ProcessingEvent.type;
                if (type - 13 <= 1 && m_ProcessingEvent.commandName == "SelectAll")
                {
                    SelectAll();
                    flag = true;
                }
            }
            if (flag)
            {
                UpdateLabel();
            }
            ((AbstractEventData)eventData).Use();
        }
 
        private string GetSelectedString()
        {
            if (!hasSelection)
            {
                return "";
            }
            int num = caretPositionInternal;
            int num2 = caretSelectPositionInternal;
            if (num > num2)
            {
                int num3 = num;
                num = num2;
                num2 = num3;
            }
            return text.Substring(num, num2 - num);
        }
 
        private int FindtNextWordBegin()
        {
            if (caretSelectPositionInternal + 1 >= text.Length)
            {
                return text.Length;
            }
            int num = text.IndexOfAny(kSeparators, caretSelectPositionInternal + 1);
            if (num == -1)
            {
                return text.Length;
            }
            return num + 1;
        }
 
        private void MoveRight(bool shift, bool ctrl)
        {
            int num2;
            if (hasSelection && !shift)
            {
                num2 = (caretSelectPositionInternal = Mathf.Max(caretPositionInternal, caretSelectPositionInternal));
                caretPositionInternal = num2;
                return;
            }
            int num3 = ((!ctrl) ? (caretSelectPositionInternal + 1) : FindtNextWordBegin());
            if (shift)
            {
                caretSelectPositionInternal = num3;
                return;
            }
            num2 = (caretPositionInternal = num3);
            caretSelectPositionInternal = num2;
        }
 
        private int FindtPrevWordBegin()
        {
            if (caretSelectPositionInternal - 2 < 0)
            {
                return 0;
            }
            int num = text.LastIndexOfAny(kSeparators, caretSelectPositionInternal - 2);
            if (num == -1)
            {
                return 0;
            }
            return num + 1;
        }
 
        private void MoveLeft(bool shift, bool ctrl)
        {
            int num2;
            if (hasSelection && !shift)
            {
                num2 = (caretSelectPositionInternal = Mathf.Min(caretPositionInternal, caretSelectPositionInternal));
                caretPositionInternal = num2;
                return;
            }
            int num3 = ((!ctrl) ? (caretSelectPositionInternal - 1) : FindtPrevWordBegin());
            if (shift)
            {
                caretSelectPositionInternal = num3;
                return;
            }
            num2 = (caretPositionInternal = num3);
            caretSelectPositionInternal = num2;
        }
 
        private int DetermineCharacterLine(int charPos, TextGenerator generator)
        {
            //IL_000d: Unknown result type (might be due to invalid IL or missing references)
            for (int i = 0; i < generator.lineCount - 1; i++)
            {
                if (generator.lines[i + 1].startCharIdx > charPos)
                {
                    return i;
                }
            }
            return generator.lineCount - 1;
        }
 
        private int LineUpCharacterPosition(int originalPos, bool goToFirstChar)
        {
            //IL_0021: Unknown result type (might be due to invalid IL or missing references)
            //IL_0026: Unknown result type (might be due to invalid IL or missing references)
            //IL_004c: Unknown result type (might be due to invalid IL or missing references)
            //IL_0067: Unknown result type (might be due to invalid IL or missing references)
            //IL_0080: Unknown result type (might be due to invalid IL or missing references)
            //IL_0085: Unknown result type (might be due to invalid IL or missing references)
            //IL_008f: Unknown result type (might be due to invalid IL or missing references)
            //IL_0090: Unknown result type (might be due to invalid IL or missing references)
            if (originalPos >= ((ICollection<UICharInfo>)(object)cachedInputTextGenerator.characters).Count)
            {
                return 0;
            }
            UICharInfo val = cachedInputTextGenerator.characters[originalPos];
            int num = DetermineCharacterLine(originalPos, cachedInputTextGenerator);
            if (num <= 0)
            {
                if (!goToFirstChar)
                {
                    return originalPos;
                }
                return 0;
            }
            int num2 = cachedInputTextGenerator.lines[num].startCharIdx - 1;
            for (int i = cachedInputTextGenerator.lines[num - 1].startCharIdx; i < num2; i++)
            {
                if (cachedInputTextGenerator.characters[i].cursorPos.x >= val.cursorPos.x)
                {
                    return i;
                }
            }
            return num2;
        }
 
        private int LineDownCharacterPosition(int originalPos, bool goToLastChar)
        {
            //IL_0026: Unknown result type (might be due to invalid IL or missing references)
            //IL_002b: Unknown result type (might be due to invalid IL or missing references)
            //IL_0078: Unknown result type (might be due to invalid IL or missing references)
            //IL_0091: Unknown result type (might be due to invalid IL or missing references)
            //IL_0096: Unknown result type (might be due to invalid IL or missing references)
            //IL_00a0: Unknown result type (might be due to invalid IL or missing references)
            //IL_00a1: Unknown result type (might be due to invalid IL or missing references)
            if (originalPos >= cachedInputTextGenerator.characterCountVisible)
            {
                return text.Length;
            }
            UICharInfo val = cachedInputTextGenerator.characters[originalPos];
            int num = DetermineCharacterLine(originalPos, cachedInputTextGenerator);
            if (num + 1 >= cachedInputTextGenerator.lineCount)
            {
                if (!goToLastChar)
                {
                    return originalPos;
                }
                return text.Length;
            }
            int lineEndPosition = GetLineEndPosition(cachedInputTextGenerator, num + 1);
            for (int i = cachedInputTextGenerator.lines[num + 1].startCharIdx; i < lineEndPosition; i++)
            {
                if (cachedInputTextGenerator.characters[i].cursorPos.x >= val.cursorPos.x)
                {
                    return i;
                }
            }
            return lineEndPosition;
        }
 
        private void MoveDown(bool shift)
        {
            MoveDown(shift, goToLastChar: true);
        }
 
        private void MoveDown(bool shift, bool goToLastChar)
        {
            int num2;
            if (hasSelection && !shift)
            {
                num2 = (caretSelectPositionInternal = Mathf.Max(caretPositionInternal, caretSelectPositionInternal));
                caretPositionInternal = num2;
            }
            int num3 = (multiLine ? LineDownCharacterPosition(caretSelectPositionInternal, goToLastChar) : text.Length);
            if (shift)
            {
                caretSelectPositionInternal = num3;
                return;
            }
            num2 = (caretSelectPositionInternal = num3);
            caretPositionInternal = num2;
        }
 
        private void MoveUp(bool shift)
        {
            MoveUp(shift, goToFirstChar: true);
        }
 
        private void MoveUp(bool shift, bool goToFirstChar)
        {
            int num2;
            if (hasSelection && !shift)
            {
                num2 = (caretSelectPositionInternal = Mathf.Min(caretPositionInternal, caretSelectPositionInternal));
                caretPositionInternal = num2;
            }
            int num3 = (multiLine ? LineUpCharacterPosition(caretSelectPositionInternal, goToFirstChar) : 0);
            if (shift)
            {
                caretSelectPositionInternal = num3;
                return;
            }
            num2 = (caretPositionInternal = num3);
            caretSelectPositionInternal = num2;
        }
 
        private void Delete()
        {
            if (!m_ReadOnly && caretPositionInternal != caretSelectPositionInternal)
            {
                if (caretPositionInternal < caretSelectPositionInternal)
                {
                    m_Text = String.Concat(text.Substring(0, caretPositionInternal), text.Substring(caretSelectPositionInternal, text.Length - caretSelectPositionInternal));
                    caretSelectPositionInternal = caretPositionInternal;
                }
                else
                {
                    m_Text = String.Concat(text.Substring(0, caretSelectPositionInternal), text.Substring(caretPositionInternal, text.Length - caretPositionInternal));
                    caretPositionInternal = caretSelectPositionInternal;
                }
            }
        }
 
        private void ForwardSpace()
        {
            if (!m_ReadOnly)
            {
                if (hasSelection)
                {
                    Delete();
                    UpdateTouchKeyboardFromEditChanges();
                    SendOnValueChangedAndUpdateLabel();
                }
                else if (caretPositionInternal < text.Length)
                {
                    m_Text = text.Remove(caretPositionInternal, 1);
                    UpdateTouchKeyboardFromEditChanges();
                    SendOnValueChangedAndUpdateLabel();
                }
            }
        }
 
        private void Backspace()
        {
            if (!m_ReadOnly)
            {
                if (hasSelection)
                {
                    Delete();
                    UpdateTouchKeyboardFromEditChanges();
                    SendOnValueChangedAndUpdateLabel();
                }
                else if (caretPositionInternal > 0)
                {
                    m_Text = text.Remove(caretPositionInternal - 1, 1);
                    caretSelectPositionInternal = --caretPositionInternal;
                    UpdateTouchKeyboardFromEditChanges();
                    SendOnValueChangedAndUpdateLabel();
                }
            }
        }
 
        private void Insert(char c)
        {
            if (!m_ReadOnly)
            {
                string text = ((Char)(ref c)).ToString();
                Delete();
                if (characterLimit <= 0 || this.text.Length < characterLimit)
                {
                    m_Text = this.text.Insert(m_CaretPosition, text);
                    caretSelectPositionInternal = (caretPositionInternal += text.Length);
                    UpdateTouchKeyboardFromEditChanges();
                    SendOnValueChanged();
                }
            }
        }
 
        private void UpdateTouchKeyboardFromEditChanges()
        {
            if (m_Keyboard != null && InPlaceEditing())
            {
                m_Keyboard.text = m_Text;
            }
        }
 
        private void SendOnValueChangedAndUpdateLabel()
        {
            SendOnValueChanged();
            UpdateLabel();
        }
 
        private void SendOnValueChanged()
        {
            UISystemProfilerApi.AddMarker("InputField.value", (Object)(object)this);
            if (onValueChanged != null)
            {
                ((UnityEvent<string>)onValueChanged).Invoke(text);
            }
        }
 
        protected void SendOnSubmit()
        {
            UISystemProfilerApi.AddMarker("InputField.onSubmit", (Object)(object)this);
            if (onEndEdit != null)
            {
                ((UnityEvent<string>)onEndEdit).Invoke(m_Text);
            }
        }
 
        private void Append(string input, bool secure = true)
        {
            if (m_ReadOnly || !InPlaceEditing())
            {
                return;
            }
            int i = 0;
            for (int length = input.Length; i < length; i++)
            {
                char c = input[i];
                if (c >= ' ' || c == '\t' || c == '\r' || c == '\n' || c == '\n')
                {
                    Append(c);
                }
            }
        }
 
        protected virtual void Append(char input)
        {
            if (!Char.IsSurrogate(input) && !m_ReadOnly && text.Length < 16382 && InPlaceEditing())
            {
                int num = Math.Min(selectionFocusPosition, selectionAnchorPosition);
                if (onValidateInput != null)
                {
                    input = onValidateInput(text, num, input);
                }
                else if (characterValidation != 0)
                {
                    input = Validate(text, num, input);
                }
                if (input != 0)
                {
                    Insert(input);
                }
            }
        }
 
        protected void UpdateLabel()
        {
            //IL_00b8: Unknown result type (might be due to invalid IL or missing references)
            //IL_00be: Expected O, but got Unknown
            //IL_0111: Unknown result type (might be due to invalid IL or missing references)
            //IL_0116: Unknown result type (might be due to invalid IL or missing references)
            //IL_011a: Unknown result type (might be due to invalid IL or missing references)
            //IL_011f: Unknown result type (might be due to invalid IL or missing references)
            //IL_0126: Unknown result type (might be due to invalid IL or missing references)
            //IL_0127: Unknown result type (might be due to invalid IL or missing references)
            //IL_012c: Unknown result type (might be due to invalid IL or missing references)
            //IL_013d: Unknown result type (might be due to invalid IL or missing references)
            if ((Object)(object)m_TextComponent != (Object)null && (Object)(object)m_TextComponent.font != (Object)null && !m_PreventFontCallback)
            {
                m_PreventFontCallback = true;
                string text = ((!((Object)(object)EventSystem.current != (Object)null) || !((Object)(object)((Component)this).gameObject == (Object)(object)EventSystem.current.currentSelectedGameObject) || compositionString.Length <= 0) ? this.text : String.Concat(this.text.Substring(0, m_CaretPosition), compositionString, this.text.Substring(m_CaretPosition)));
                string text2 = ((inputType != InputType.Password) ? text : ((string)new String(asteriskChar, text.Length)));
                bool flag = String.IsNullOrEmpty(text);
                if ((Object)(object)m_Placeholder != (Object)null)
                {
                    ((Behaviour)m_Placeholder).enabled = flag;
                }
                if (!m_AllowInput)
                {
                    m_DrawStart = 0;
                    m_DrawEnd = m_Text.Length;
                }
                if (!flag)
                {
                    Rect rect = ((Graphic)m_TextComponent).rectTransform.rect;
                    Vector2 size = ((Rect)(ref rect)).size;
                    TextGenerationSettings generationSettings = m_TextComponent.GetGenerationSettings(size);
                    generationSettings.generateOutOfBounds = true;
                    cachedInputTextGenerator.PopulateWithErrors(text2, generationSettings, ((Component)this).gameObject);
                    SetDrawRangeToContainCaretPosition(caretSelectPositionInternal);
                    text2 = text2.Substring(m_DrawStart, Mathf.Min(m_DrawEnd, text2.Length) - m_DrawStart);
                    SetCaretVisible();
                }
                m_TextComponent.text = text2;
                MarkGeometryAsDirty();
                m_PreventFontCallback = false;
            }
        }
 
        private bool IsSelectionVisible()
        {
            if (m_DrawStart > caretPositionInternal || m_DrawStart > caretSelectPositionInternal)
            {
                return false;
            }
            if (m_DrawEnd < caretPositionInternal || m_DrawEnd < caretSelectPositionInternal)
            {
                return false;
            }
            return true;
        }
 
        private static int GetLineStartPosition(TextGenerator gen, int line)
        {
            //IL_001d: Unknown result type (might be due to invalid IL or missing references)
            line = Mathf.Clamp(line, 0, ((ICollection<UILineInfo>)(object)gen.lines).Count - 1);
            return gen.lines[line].startCharIdx;
        }
 
        private static int GetLineEndPosition(TextGenerator gen, int line)
        {
            //IL_0022: Unknown result type (might be due to invalid IL or missing references)
            line = Mathf.Max(line, 0);
            if (line + 1 < ((ICollection<UILineInfo>)(object)gen.lines).Count)
            {
                return gen.lines[line + 1].startCharIdx - 1;
            }
            return gen.characterCountVisible;
        }
 
        private void SetDrawRangeToContainCaretPosition(int caretPos)
        {
            //IL_0015: Unknown result type (might be due to invalid IL or missing references)
            //IL_001a: Unknown result type (might be due to invalid IL or missing references)
            //IL_001d: Unknown result type (might be due to invalid IL or missing references)
            //IL_0022: Unknown result type (might be due to invalid IL or missing references)
            //IL_0068: Unknown result type (might be due to invalid IL or missing references)
            //IL_0074: Unknown result type (might be due to invalid IL or missing references)
            //IL_0112: Unknown result type (might be due to invalid IL or missing references)
            //IL_0121: Unknown result type (might be due to invalid IL or missing references)
            //IL_012e: Unknown result type (might be due to invalid IL or missing references)
            //IL_0091: Unknown result type (might be due to invalid IL or missing references)
            //IL_014d: Unknown result type (might be due to invalid IL or missing references)
            //IL_0285: Unknown result type (might be due to invalid IL or missing references)
            //IL_0290: Unknown result type (might be due to invalid IL or missing references)
            //IL_0161: Unknown result type (might be due to invalid IL or missing references)
            //IL_0170: Unknown result type (might be due to invalid IL or missing references)
            //IL_00a8: Unknown result type (might be due to invalid IL or missing references)
            //IL_00b5: Unknown result type (might be due to invalid IL or missing references)
            //IL_02a2: Unknown result type (might be due to invalid IL or missing references)
            //IL_01a5: Unknown result type (might be due to invalid IL or missing references)
            //IL_0193: Unknown result type (might be due to invalid IL or missing references)
            //IL_02fe: Unknown result type (might be due to invalid IL or missing references)
            //IL_030d: Unknown result type (might be due to invalid IL or missing references)
            //IL_01d9: Unknown result type (might be due to invalid IL or missing references)
            //IL_01ea: Unknown result type (might be due to invalid IL or missing references)
            if (cachedInputTextGenerator.lineCount <= 0)
            {
                return;
            }
            Rect rectExtents = cachedInputTextGenerator.rectExtents;
            Vector2 size = ((Rect)(ref rectExtents)).size;
            if (multiLine)
            {
                IList<UILineInfo> lines = cachedInputTextGenerator.lines;
                int num = DetermineCharacterLine(caretPos, cachedInputTextGenerator);
                if (caretPos > m_DrawEnd)
                {
                    m_DrawEnd = GetLineEndPosition(cachedInputTextGenerator, num);
                    float num2 = lines[num].topY - (float)lines[num].height;
                    if (num == ((ICollection<UILineInfo>)(object)lines).Count - 1)
                    {
                        num2 += lines[num].leading;
                    }
                    int num3 = num;
                    while (num3 > 0 && !(lines[num3 - 1].topY - num2 > size.y))
                    {
                        num3--;
                    }
                    m_DrawStart = GetLineStartPosition(cachedInputTextGenerator, num3);
                    return;
                }
                if (caretPos < m_DrawStart)
                {
                    m_DrawStart = GetLineStartPosition(cachedInputTextGenerator, num);
                }
                int num4 = DetermineCharacterLine(m_DrawStart, cachedInputTextGenerator);
                int i = num4;
                float topY = lines[num4].topY;
                float num5 = lines[i].topY - (float)lines[i].height;
                if (i == ((ICollection<UILineInfo>)(object)lines).Count - 1)
                {
                    num5 += lines[i].leading;
                }
                for (; i < ((ICollection<UILineInfo>)(object)lines).Count - 1; i++)
                {
                    num5 = lines[i + 1].topY - (float)lines[i + 1].height;
                    if (i + 1 == ((ICollection<UILineInfo>)(object)lines).Count - 1)
                    {
                        num5 += lines[i + 1].leading;
                    }
                    if (topY - num5 > size.y)
                    {
                        break;
                    }
                }
                m_DrawEnd = GetLineEndPosition(cachedInputTextGenerator, i);
                while (num4 > 0)
                {
                    topY = lines[num4 - 1].topY;
                    if (topY - num5 > size.y)
                    {
                        break;
                    }
                    num4--;
                }
                m_DrawStart = GetLineStartPosition(cachedInputTextGenerator, num4);
                return;
            }
            IList<UICharInfo> characters = cachedInputTextGenerator.characters;
            if (m_DrawEnd > cachedInputTextGenerator.characterCountVisible)
            {
                m_DrawEnd = cachedInputTextGenerator.characterCountVisible;
            }
            float num6 = 0f;
            if (caretPos > m_DrawEnd || (caretPos == m_DrawEnd && m_DrawStart > 0))
            {
                m_DrawEnd = caretPos;
                m_DrawStart = m_DrawEnd - 1;
                while (m_DrawStart >= 0 && !(num6 + characters[m_DrawStart].charWidth > size.x))
                {
                    num6 += characters[m_DrawStart].charWidth;
                    m_DrawStart--;
                }
                m_DrawStart++;
            }
            else
            {
                if (caretPos < m_DrawStart)
                {
                    m_DrawStart = caretPos;
                }
                m_DrawEnd = m_DrawStart;
            }
            while (m_DrawEnd < cachedInputTextGenerator.characterCountVisible)
            {
                num6 += characters[m_DrawEnd].charWidth;
                if (!(num6 > size.x))
                {
                    m_DrawEnd++;
                    continue;
                }
                break;
            }
        }
 
        public void ForceLabelUpdate()
        {
            UpdateLabel();
        }
 
        private void MarkGeometryAsDirty()
        {
            CanvasUpdateRegistry.RegisterCanvasElementForGraphicRebuild((ICanvasElement)(object)this);
        }
 
        public virtual void Rebuild(CanvasUpdate update)
        {
            //IL_0000: Unknown result type (might be due to invalid IL or missing references)
            //IL_0002: Invalid comparison between Unknown and I4
            if ((int)update == 4)
            {
                UpdateGeometry();
            }
        }
 
        public virtual void LayoutComplete()
        {
        }
 
        public virtual void GraphicUpdateComplete()
        {
        }
 
        private void UpdateGeometry()
        {
            //IL_0060: Unknown result type (might be due to invalid IL or missing references)
            //IL_0066: Expected O, but got Unknown
            if (shouldHideMobileInput)
            {
                if ((Object)(object)m_CachedInputRenderer == (Object)null && (Object)(object)m_TextComponent != (Object)null)
                {
                    GameObject val = new GameObject(String.Concat(((Object)((Component)this).transform).name, " Input Caret"), (Type[])(object)new Type[2]
                    {
                        typeof(RectTransform),
                        typeof(CanvasRenderer)
                    });
                    ((Object)val).hideFlags = (HideFlags)52;
                    val.transform.SetParent(((Component)m_TextComponent).transform.parent);
                    val.transform.SetAsFirstSibling();
                    val.layer = ((Component)this).gameObject.layer;
                    caretRectTrans = val.GetComponent<RectTransform>();
                    m_CachedInputRenderer = val.GetComponent<CanvasRenderer>();
                    m_CachedInputRenderer.SetMaterial(((MaskableGraphic)m_TextComponent).GetModifiedMaterial(Graphic.defaultGraphicMaterial), (Texture)(object)Texture2D.whiteTexture);
                    val.AddComponent<LayoutElement>().ignoreLayout = true;
                    AssignPositioningIfNeeded();
                }
                if (!((Object)(object)m_CachedInputRenderer == (Object)null))
                {
                    OnFillVBO(mesh);
                    m_CachedInputRenderer.SetMesh(mesh);
                }
            }
        }
 
        private void AssignPositioningIfNeeded()
        {
            //IL_0028: Unknown result type (might be due to invalid IL or missing references)
            //IL_0038: Unknown result type (might be due to invalid IL or missing references)
            //IL_0152: Unknown result type (might be due to invalid IL or missing references)
            //IL_016d: Unknown result type (might be due to invalid IL or missing references)
            //IL_0188: Unknown result type (might be due to invalid IL or missing references)
            //IL_01a3: Unknown result type (might be due to invalid IL or missing references)
            //IL_01be: Unknown result type (might be due to invalid IL or missing references)
            //IL_01d9: Unknown result type (might be due to invalid IL or missing references)
            //IL_01f4: Unknown result type (might be due to invalid IL or missing references)
            //IL_020f: Unknown result type (might be due to invalid IL or missing references)
            //IL_004d: Unknown result type (might be due to invalid IL or missing references)
            //IL_005d: Unknown result type (might be due to invalid IL or missing references)
            //IL_0072: Unknown result type (might be due to invalid IL or missing references)
            //IL_0082: Unknown result type (might be due to invalid IL or missing references)
            //IL_0097: Unknown result type (might be due to invalid IL or missing references)
            //IL_00a7: Unknown result type (might be due to invalid IL or missing references)
            //IL_00bc: Unknown result type (might be due to invalid IL or missing references)
            //IL_00cc: Unknown result type (might be due to invalid IL or missing references)
            //IL_00de: Unknown result type (might be due to invalid IL or missing references)
            //IL_00ee: Unknown result type (might be due to invalid IL or missing references)
            //IL_0100: Unknown result type (might be due to invalid IL or missing references)
            //IL_0110: Unknown result type (might be due to invalid IL or missing references)
            //IL_0122: Unknown result type (might be due to invalid IL or missing references)
            //IL_0132: Unknown result type (might be due to invalid IL or missing references)
            if ((Object)(object)m_TextComponent != (Object)null && (Object)(object)caretRectTrans != (Object)null && (((Transform)caretRectTrans).localPosition != ((Transform)((Graphic)m_TextComponent).rectTransform).localPosition || ((Transform)caretRectTrans).localRotation != ((Transform)((Graphic)m_TextComponent).rectTransform).localRotation || ((Transform)caretRectTrans).localScale != ((Transform)((Graphic)m_TextComponent).rectTransform).localScale || caretRectTrans.anchorMin != ((Graphic)m_TextComponent).rectTransform.anchorMin || caretRectTrans.anchorMax != ((Graphic)m_TextComponent).rectTransform.anchorMax || caretRectTrans.anchoredPosition != ((Graphic)m_TextComponent).rectTransform.anchoredPosition || caretRectTrans.sizeDelta != ((Graphic)m_TextComponent).rectTransform.sizeDelta || caretRectTrans.pivot != ((Graphic)m_TextComponent).rectTransform.pivot))
            {
                ((Transform)caretRectTrans).localPosition = ((Transform)((Graphic)m_TextComponent).rectTransform).localPosition;
                ((Transform)caretRectTrans).localRotation = ((Transform)((Graphic)m_TextComponent).rectTransform).localRotation;
                ((Transform)caretRectTrans).localScale = ((Transform)((Graphic)m_TextComponent).rectTransform).localScale;
                caretRectTrans.anchorMin = ((Graphic)m_TextComponent).rectTransform.anchorMin;
                caretRectTrans.anchorMax = ((Graphic)m_TextComponent).rectTransform.anchorMax;
                caretRectTrans.anchoredPosition = ((Graphic)m_TextComponent).rectTransform.anchoredPosition;
                caretRectTrans.sizeDelta = ((Graphic)m_TextComponent).rectTransform.sizeDelta;
                caretRectTrans.pivot = ((Graphic)m_TextComponent).rectTransform.pivot;
            }
        }
 
        private void OnFillVBO(Mesh vbo)
        {
            //IL_0000: Unknown result type (might be due to invalid IL or missing references)
            //IL_0006: Expected O, but got Unknown
            //IL_001d: Unknown result type (might be due to invalid IL or missing references)
            //IL_0022: Unknown result type (might be due to invalid IL or missing references)
            //IL_0027: Unknown result type (might be due to invalid IL or missing references)
            //IL_003c: Unknown result type (might be due to invalid IL or missing references)
            //IL_0032: Unknown result type (might be due to invalid IL or missing references)
            VertexHelper val = new VertexHelper();
            try
            {
                if (!isFocused)
                {
                    val.FillMesh(vbo);
                    return;
                }
                Vector2 roundingOffset = ((Graphic)m_TextComponent).PixelAdjustPoint(Vector2.zero);
                if (!hasSelection)
                {
                    GenerateCaret(val, roundingOffset);
                }
                else
                {
                    GenerateHighlight(val, roundingOffset);
                }
                val.FillMesh(vbo);
            }
            finally
            {
                if (val != null)
                {
                    ((IDisposable)val).Dispose();
                }
            }
        }
 
        private void GenerateCaret(VertexHelper vbo, Vector2 roundingOffset)
        {
            //IL_004c: Unknown result type (might be due to invalid IL or missing references)
            //IL_0051: Unknown result type (might be due to invalid IL or missing references)
            //IL_0097: Unknown result type (might be due to invalid IL or missing references)
            //IL_00a8: Unknown result type (might be due to invalid IL or missing references)
            //IL_00ad: Unknown result type (might be due to invalid IL or missing references)
            //IL_0067: Unknown result type (might be due to invalid IL or missing references)
            //IL_006c: Unknown result type (might be due to invalid IL or missing references)
            //IL_0070: Unknown result type (might be due to invalid IL or missing references)
            //IL_0072: Unknown result type (might be due to invalid IL or missing references)
            //IL_00ec: Unknown result type (might be due to invalid IL or missing references)
            //IL_010f: Unknown result type (might be due to invalid IL or missing references)
            //IL_00c5: Unknown result type (might be due to invalid IL or missing references)
            //IL_00ca: Unknown result type (might be due to invalid IL or missing references)
            //IL_013b: Unknown result type (might be due to invalid IL or missing references)
            //IL_0140: Unknown result type (might be due to invalid IL or missing references)
            //IL_0145: Unknown result type (might be due to invalid IL or missing references)
            //IL_0168: Unknown result type (might be due to invalid IL or missing references)
            //IL_016e: Unknown result type (might be due to invalid IL or missing references)
            //IL_017c: Unknown result type (might be due to invalid IL or missing references)
            //IL_0181: Unknown result type (might be due to invalid IL or missing references)
            //IL_0192: Unknown result type (might be due to invalid IL or missing references)
            //IL_019a: Unknown result type (might be due to invalid IL or missing references)
            //IL_01a8: Unknown result type (might be due to invalid IL or missing references)
            //IL_01ad: Unknown result type (might be due to invalid IL or missing references)
            //IL_01be: Unknown result type (might be due to invalid IL or missing references)
            //IL_01c6: Unknown result type (might be due to invalid IL or missing references)
            //IL_01d1: Unknown result type (might be due to invalid IL or missing references)
            //IL_01d6: Unknown result type (might be due to invalid IL or missing references)
            //IL_01e7: Unknown result type (might be due to invalid IL or missing references)
            //IL_01ed: Unknown result type (might be due to invalid IL or missing references)
            //IL_01f8: Unknown result type (might be due to invalid IL or missing references)
            //IL_01fd: Unknown result type (might be due to invalid IL or missing references)
            //IL_0202: Unknown result type (might be due to invalid IL or missing references)
            //IL_0203: Unknown result type (might be due to invalid IL or missing references)
            //IL_02b0: Unknown result type (might be due to invalid IL or missing references)
            //IL_021c: Unknown result type (might be due to invalid IL or missing references)
            //IL_0221: Unknown result type (might be due to invalid IL or missing references)
            //IL_0231: Unknown result type (might be due to invalid IL or missing references)
            //IL_0247: Unknown result type (might be due to invalid IL or missing references)
            //IL_02ea: Unknown result type (might be due to invalid IL or missing references)
            //IL_02ef: Unknown result type (might be due to invalid IL or missing references)
            //IL_02f4: Unknown result type (might be due to invalid IL or missing references)
            //IL_02f8: Unknown result type (might be due to invalid IL or missing references)
            //IL_02fa: Unknown result type (might be due to invalid IL or missing references)
            //IL_02ff: Unknown result type (might be due to invalid IL or missing references)
            //IL_0306: Unknown result type (might be due to invalid IL or missing references)
            //IL_0327: Unknown result type (might be due to invalid IL or missing references)
            if (!m_CaretVisible)
            {
                return;
            }
            if (m_CursorVerts == null)
            {
                CreateCursorVerts();
            }
            float num = m_CaretWidth;
            int num2 = Mathf.Max(0, caretPositionInternal - m_DrawStart);
            TextGenerator cachedTextGenerator = m_TextComponent.cachedTextGenerator;
            if (cachedTextGenerator == null || cachedTextGenerator.lineCount == 0)
            {
                return;
            }
            Vector2 zero = Vector2.zero;
            if (num2 < ((ICollection<UICharInfo>)(object)cachedTextGenerator.characters).Count)
            {
                UICharInfo val = cachedTextGenerator.characters[num2];
                zero.x = val.cursorPos.x;
            }
            zero.x /= m_TextComponent.pixelsPerUnit;
            float x = zero.x;
            Rect rect = ((Graphic)m_TextComponent).rectTransform.rect;
            if (x > ((Rect)(ref rect)).xMax)
            {
                rect = ((Graphic)m_TextComponent).rectTransform.rect;
                zero.x = ((Rect)(ref rect)).xMax;
            }
            int num3 = DetermineCharacterLine(num2, cachedTextGenerator);
            zero.y = cachedTextGenerator.lines[num3].topY / m_TextComponent.pixelsPerUnit;
            float num4 = (float)cachedTextGenerator.lines[num3].height / m_TextComponent.pixelsPerUnit;
            for (int i = 0; i < m_CursorVerts.Length; i++)
            {
                m_CursorVerts[i].color = Color32.op_Implicit(caretColor);
            }
            m_CursorVerts[0].position = new Vector3(zero.x, zero.y - num4, 0f);
            m_CursorVerts[1].position = new Vector3(zero.x + num, zero.y - num4, 0f);
            m_CursorVerts[2].position = new Vector3(zero.x + num, zero.y, 0f);
            m_CursorVerts[3].position = new Vector3(zero.x, zero.y, 0f);
            if (roundingOffset != Vector2.zero)
            {
                for (int j = 0; j < m_CursorVerts.Length; j++)
                {
                    UIVertex val2 = m_CursorVerts[j];
                    val2.position.x += roundingOffset.x;
                    val2.position.y += roundingOffset.y;
                }
            }
            vbo.AddUIVertexQuad(m_CursorVerts);
            int num5 = Screen.height;
            int targetDisplay = ((Graphic)m_TextComponent).canvas.targetDisplay;
            if (targetDisplay > 0 && targetDisplay < Display.displays.Length)
            {
                num5 = Display.displays[targetDisplay].renderingHeight;
            }
            Camera val3 = (((int)((Graphic)m_TextComponent).canvas.renderMode != 0) ? ((Graphic)m_TextComponent).canvas.worldCamera : null);
            Vector3 val4 = ((Component)m_CachedInputRenderer).gameObject.transform.TransformPoint(m_CursorVerts[0].position);
            Vector2 val5 = RectTransformUtility.WorldToScreenPoint(val3, val4);
            val5.y = (float)num5 - val5.y;
            if ((Object)(object)input != (Object)null)
            {
                input.compositionCursorPos = val5;
            }
        }
 
        private void CreateCursorVerts()
        {
            //IL_0017: Unknown result type (might be due to invalid IL or missing references)
            //IL_001c: Unknown result type (might be due to invalid IL or missing references)
            //IL_002d: Unknown result type (might be due to invalid IL or missing references)
            //IL_0032: Unknown result type (might be due to invalid IL or missing references)
            //IL_0037: Unknown result type (might be due to invalid IL or missing references)
            m_CursorVerts = (UIVertex[])(object)new UIVertex[4];
            for (int i = 0; i < m_CursorVerts.Length; i++)
            {
                m_CursorVerts[i] = UIVertex.simpleVert;
                m_CursorVerts[i].uv0 = Vector4.op_Implicit(Vector2.zero);
            }
        }
 
        private void GenerateHighlight(VertexHelper vbo, Vector2 roundingOffset)
        {
            //IL_005c: Unknown result type (might be due to invalid IL or missing references)
            //IL_0061: Unknown result type (might be due to invalid IL or missing references)
            //IL_0065: Unknown result type (might be due to invalid IL or missing references)
            //IL_006a: Unknown result type (might be due to invalid IL or missing references)
            //IL_006f: Unknown result type (might be due to invalid IL or missing references)
            //IL_0077: Unknown result type (might be due to invalid IL or missing references)
            //IL_007c: Unknown result type (might be due to invalid IL or missing references)
            //IL_0081: Unknown result type (might be due to invalid IL or missing references)
            //IL_00a3: Unknown result type (might be due to invalid IL or missing references)
            //IL_00a8: Unknown result type (might be due to invalid IL or missing references)
            //IL_00b2: Unknown result type (might be due to invalid IL or missing references)
            //IL_00b7: Unknown result type (might be due to invalid IL or missing references)
            //IL_00bb: Unknown result type (might be due to invalid IL or missing references)
            //IL_00bd: Unknown result type (might be due to invalid IL or missing references)
            //IL_00da: Unknown result type (might be due to invalid IL or missing references)
            //IL_00f7: Unknown result type (might be due to invalid IL or missing references)
            //IL_00f9: Unknown result type (might be due to invalid IL or missing references)
            //IL_0103: Unknown result type (might be due to invalid IL or missing references)
            //IL_0117: Unknown result type (might be due to invalid IL or missing references)
            //IL_0125: Unknown result type (might be due to invalid IL or missing references)
            //IL_0142: Unknown result type (might be due to invalid IL or missing references)
            //IL_0154: Unknown result type (might be due to invalid IL or missing references)
            //IL_0159: Unknown result type (might be due to invalid IL or missing references)
            //IL_0193: Unknown result type (might be due to invalid IL or missing references)
            //IL_0198: Unknown result type (might be due to invalid IL or missing references)
            //IL_0164: Unknown result type (might be due to invalid IL or missing references)
            //IL_0176: Unknown result type (might be due to invalid IL or missing references)
            //IL_017b: Unknown result type (might be due to invalid IL or missing references)
            //IL_01b0: Unknown result type (might be due to invalid IL or missing references)
            //IL_01b7: Unknown result type (might be due to invalid IL or missing references)
            //IL_01c3: Unknown result type (might be due to invalid IL or missing references)
            //IL_01c8: Unknown result type (might be due to invalid IL or missing references)
            //IL_01c9: Unknown result type (might be due to invalid IL or missing references)
            //IL_01ce: Unknown result type (might be due to invalid IL or missing references)
            //IL_01d3: Unknown result type (might be due to invalid IL or missing references)
            //IL_01d9: Unknown result type (might be due to invalid IL or missing references)
            //IL_01e2: Unknown result type (might be due to invalid IL or missing references)
            //IL_01e9: Unknown result type (might be due to invalid IL or missing references)
            //IL_01f5: Unknown result type (might be due to invalid IL or missing references)
            //IL_01fa: Unknown result type (might be due to invalid IL or missing references)
            //IL_01fb: Unknown result type (might be due to invalid IL or missing references)
            //IL_0200: Unknown result type (might be due to invalid IL or missing references)
            //IL_0205: Unknown result type (might be due to invalid IL or missing references)
            //IL_020b: Unknown result type (might be due to invalid IL or missing references)
            //IL_0214: Unknown result type (might be due to invalid IL or missing references)
            //IL_021b: Unknown result type (might be due to invalid IL or missing references)
            //IL_0227: Unknown result type (might be due to invalid IL or missing references)
            //IL_022c: Unknown result type (might be due to invalid IL or missing references)
            //IL_022d: Unknown result type (might be due to invalid IL or missing references)
            //IL_0232: Unknown result type (might be due to invalid IL or missing references)
            //IL_0237: Unknown result type (might be due to invalid IL or missing references)
            //IL_023d: Unknown result type (might be due to invalid IL or missing references)
            //IL_0246: Unknown result type (might be due to invalid IL or missing references)
            //IL_024d: Unknown result type (might be due to invalid IL or missing references)
            //IL_0259: Unknown result type (might be due to invalid IL or missing references)
            //IL_025e: Unknown result type (might be due to invalid IL or missing references)
            //IL_025f: Unknown result type (might be due to invalid IL or missing references)
            //IL_0264: Unknown result type (might be due to invalid IL or missing references)
            //IL_0269: Unknown result type (might be due to invalid IL or missing references)
            //IL_026f: Unknown result type (might be due to invalid IL or missing references)
            int num = Mathf.Max(0, caretPositionInternal - m_DrawStart);
            int num2 = Mathf.Max(0, caretSelectPositionInternal - m_DrawStart);
            if (num > num2)
            {
                int num3 = num;
                num = num2;
                num2 = num3;
            }
            num2--;
            TextGenerator cachedTextGenerator = m_TextComponent.cachedTextGenerator;
            if (cachedTextGenerator.lineCount <= 0)
            {
                return;
            }
            int num4 = DetermineCharacterLine(num, cachedTextGenerator);
            int lineEndPosition = GetLineEndPosition(cachedTextGenerator, num4);
            UIVertex simpleVert = UIVertex.simpleVert;
            simpleVert.uv0 = Vector4.op_Implicit(Vector2.zero);
            simpleVert.color = Color32.op_Implicit(selectionColor);
            Vector2 val3 = default(Vector2);
            Vector2 val4 = default(Vector2);
            for (int i = num; i <= num2 && i < cachedTextGenerator.characterCount; i++)
            {
                if (i != lineEndPosition && i != num2)
                {
                    continue;
                }
                UICharInfo val = cachedTextGenerator.characters[num];
                UICharInfo val2 = cachedTextGenerator.characters[i];
                ((Vector2)(ref val3))..ctor(val.cursorPos.x / m_TextComponent.pixelsPerUnit, cachedTextGenerator.lines[num4].topY / m_TextComponent.pixelsPerUnit);
                ((Vector2)(ref val4))..ctor((val2.cursorPos.x + val2.charWidth) / m_TextComponent.pixelsPerUnit, val3.y - (float)cachedTextGenerator.lines[num4].height / m_TextComponent.pixelsPerUnit);
                float x = val4.x;
                Rect rect = ((Graphic)m_TextComponent).rectTransform.rect;
                if (!(x > ((Rect)(ref rect)).xMax))
                {
                    float x2 = val4.x;
                    rect = ((Graphic)m_TextComponent).rectTransform.rect;
                    if (!(x2 < ((Rect)(ref rect)).xMin))
                    {
                        goto IL_01a6;
                    }
                }
                rect = ((Graphic)m_TextComponent).rectTransform.rect;
                val4.x = ((Rect)(ref rect)).xMax;
                goto IL_01a6;
                IL_01a6:
                int currentVertCount = vbo.currentVertCount;
                simpleVert.position = new Vector3(val3.x, val4.y, 0f) + Vector2.op_Implicit(roundingOffset);
                vbo.AddVert(simpleVert);
                simpleVert.position = new Vector3(val4.x, val4.y, 0f) + Vector2.op_Implicit(roundingOffset);
                vbo.AddVert(simpleVert);
                simpleVert.position = new Vector3(val4.x, val3.y, 0f) + Vector2.op_Implicit(roundingOffset);
                vbo.AddVert(simpleVert);
                simpleVert.position = new Vector3(val3.x, val3.y, 0f) + Vector2.op_Implicit(roundingOffset);
                vbo.AddVert(simpleVert);
                vbo.AddTriangle(currentVertCount, currentVertCount + 1, currentVertCount + 2);
                vbo.AddTriangle(currentVertCount + 2, currentVertCount + 3, currentVertCount);
                num = i + 1;
                num4++;
                lineEndPosition = GetLineEndPosition(cachedTextGenerator, num4);
            }
        }
 
        protected char Validate(string text, int pos, char ch)
        {
            if (characterValidation == CharacterValidation.None || !((Behaviour)this).enabled)
            {
                return ch;
            }
            if (characterValidation == CharacterValidation.Integer || characterValidation == CharacterValidation.Decimal)
            {
                bool num = pos == 0 && text.Length > 0 && text[0] == '-';
                bool flag = text.Length > 0 && text[0] == '-' && ((caretPositionInternal == 0 && caretSelectPositionInternal > 0) || (caretSelectPositionInternal == 0 && caretPositionInternal > 0));
                bool flag2 = caretPositionInternal == 0 || caretSelectPositionInternal == 0;
                if (!num || flag)
                {
                    if (ch >= '0' && ch <= '9')
                    {
                        return ch;
                    }
                    if (ch == '-' && (pos == 0 || flag2))
                    {
                        return ch;
                    }
                    if ((ch == '.' || ch == ',') && characterValidation == CharacterValidation.Decimal && text.IndexOfAny((char[])(object)new Char[2]
                    {
                        (Char)46,
                        (Char)44
                    }) == -1)
                    {
                        return ch;
                    }
                }
            }
            else if (characterValidation == CharacterValidation.Alphanumeric)
            {
                if (ch >= 'A' && ch <= 'Z')
                {
                    return ch;
                }
                if (ch >= 'a' && ch <= 'z')
                {
                    return ch;
                }
                if (ch >= '0' && ch <= '9')
                {
                    return ch;
                }
            }
            else if (characterValidation == CharacterValidation.Name)
            {
                if (Char.IsLetter(ch))
                {
                    if (Char.IsLower(ch) && (pos == 0 || text[pos - 1] == ' '))
                    {
                        return Char.ToUpper(ch);
                    }
                    if (Char.IsUpper(ch) && pos > 0 && text[pos - 1] != ' ' && text[pos - 1] != '\'')
                    {
                        return Char.ToLower(ch);
                    }
                    return ch;
                }
                if (ch == '\'' && !text.Contains("'") && (pos <= 0 || (text[pos - 1] != ' ' && text[pos - 1] != '\'')) && (pos >= text.Length || (text[pos] != ' ' && text[pos] != '\'')))
                {
                    return ch;
                }
                if (ch == ' ' && pos != 0 && (pos <= 0 || (text[pos - 1] != ' ' && text[pos - 1] != '\'')) && (pos >= text.Length || (text[pos] != ' ' && text[pos] != '\'')))
                {
                    return ch;
                }
            }
            else if (characterValidation == CharacterValidation.EmailAddress)
            {
                if (ch >= 'A' && ch <= 'Z')
                {
                    return ch;
                }
                if (ch >= 'a' && ch <= 'z')
                {
                    return ch;
                }
                if (ch >= '0' && ch <= '9')
                {
                    return ch;
                }
                if (ch == '@' && text.IndexOf('@') == -1)
                {
                    return ch;
                }
                if ("!#$%&'*+-/=?^_`{|}~".IndexOf(ch) != -1)
                {
                    return ch;
                }
                if (ch == '.')
                {
                    char num2 = ((text.Length > 0) ? text[Mathf.Clamp(pos, 0, text.Length - 1)] : ' ');
                    char c = ((text.Length > 0) ? text[Mathf.Clamp(pos + 1, 0, text.Length - 1)] : '\n');
                    if (num2 != '.' && c != '.')
                    {
                        return ch;
                    }
                }
            }
            return '\0';
        }
 
        public void ActivateInputField()
        {
            if ((Object)(object)m_TextComponent == (Object)null || (Object)(object)m_TextComponent.font == (Object)null || !((UIBehaviour)this).IsActive() || !((Selectable)this).IsInteractable())
            {
                return;
            }
            if (isFocused)
            {
                if (m_Keyboard != null && !m_Keyboard.active)
                {
                    m_Keyboard.active = true;
                    m_Keyboard.text = m_Text;
                }
                Action obj = this.onSelected;
                if (obj != null)
                {
                    obj.Invoke();
                }
            }
            m_ShouldActivateNextUpdate = true;
        }
 
        private void ActivateInputFieldInternal()
        {
            //IL_00c2: Unknown result type (might be due to invalid IL or missing references)
            //IL_0093: Unknown result type (might be due to invalid IL or missing references)
            if ((Object)(object)EventSystem.current == (Object)null)
            {
                return;
            }
            if ((Object)(object)EventSystem.current.currentSelectedGameObject != (Object)(object)((Component)this).gameObject)
            {
                EventSystem.current.SetSelectedGameObject(((Component)this).gameObject);
            }
            m_TouchKeyboardAllowsInPlaceEditing = !s_IsQuestDevice && !s_IsPicoDevice && TouchScreenKeyboard.isInPlaceEditingAllowed;
            if (TouchScreenKeyboardShouldBeUsed())
            {
                if ((Object)(object)input != (Object)null && input.touchSupported)
                {
                    TouchScreenKeyboard.hideInput = shouldHideMobileInput;
                }
                m_Keyboard = ((inputType == InputType.Password) ? TouchScreenKeyboard.Open(m_Text, keyboardType, false, multiLine, true, false, "", characterLimit) : TouchScreenKeyboard.Open(m_Text, keyboardType, inputType == InputType.AutoCorrect, multiLine, false, false, "", characterLimit));
                if (!m_TouchKeyboardAllowsInPlaceEditing)
                {
                    MoveTextEnd(shift: false);
                }
            }
            if (!TouchScreenKeyboard.isSupported || m_TouchKeyboardAllowsInPlaceEditing)
            {
                if ((Object)(object)input != (Object)null)
                {
                    input.imeCompositionMode = (IMECompositionMode)1;
                }
                OnFocus();
            }
            m_AllowInput = true;
            m_OriginalText = text;
            m_WasCanceled = false;
            SetCaretVisible();
            UpdateLabel();
        }
 
        public override void OnSelect(BaseEventData eventData)
        {
            ((Selectable)this).OnSelect(eventData);
            if (shouldActivateOnSelect)
            {
                ActivateInputField();
            }
        }
 
        public virtual void OnPointerClick(PointerEventData eventData)
        {
            //IL_0001: Unknown result type (might be due to invalid IL or missing references)
            if ((int)eventData.button == 0)
            {
                ActivateInputField();
            }
        }
 
        public void DeactivateInputField()
        {
            if (!m_AllowInput)
            {
                return;
            }
            m_HasDoneFocusTransition = false;
            m_AllowInput = false;
            if ((Object)(object)m_Placeholder != (Object)null)
            {
                ((Behaviour)m_Placeholder).enabled = String.IsNullOrEmpty(m_Text);
            }
            if ((Object)(object)m_TextComponent != (Object)null && ((Selectable)this).IsInteractable())
            {
                if (m_WasCanceled)
                {
                    text = m_OriginalText;
                }
                if (AllowSendingOnEndEdit)
                {
                    SendOnSubmit();
                }
                if (m_Keyboard != null)
                {
                    m_Keyboard.active = false;
                    m_Keyboard = null;
                }
                m_CaretPosition = (m_CaretSelectPosition = 0);
                if ((Object)(object)input != (Object)null)
                {
                    input.imeCompositionMode = (IMECompositionMode)0;
                }
            }
            MarkGeometryAsDirty();
        }
 
        public override void OnDeselect(BaseEventData eventData)
        {
            DeactivateInputField();
            ((Selectable)this).OnDeselect(eventData);
        }
 
        public virtual void OnSubmit(BaseEventData eventData)
        {
            if (((UIBehaviour)this).IsActive() && ((Selectable)this).IsInteractable() && !isFocused)
            {
                m_ShouldActivateNextUpdate = true;
            }
        }
 
        private void EnforceContentType()
        {
            //IL_003f: Unknown result type (might be due to invalid IL or missing references)
            //IL_0059: Unknown result type (might be due to invalid IL or missing references)
            //IL_007a: Unknown result type (might be due to invalid IL or missing references)
            //IL_009b: Unknown result type (might be due to invalid IL or missing references)
            //IL_00bc: Unknown result type (might be due to invalid IL or missing references)
            //IL_00da: Unknown result type (might be due to invalid IL or missing references)
            //IL_00f8: Unknown result type (might be due to invalid IL or missing references)
            //IL_0116: Unknown result type (might be due to invalid IL or missing references)
            //IL_0134: Unknown result type (might be due to invalid IL or missing references)
            switch (contentType)
            {
            case ContentType.Standard:
                m_InputType = InputType.Standard;
                m_KeyboardType = (TouchScreenKeyboardType)0;
                m_CharacterValidation = CharacterValidation.None;
                break;
            case ContentType.Autocorrected:
                m_InputType = InputType.AutoCorrect;
                m_KeyboardType = (TouchScreenKeyboardType)0;
                m_CharacterValidation = CharacterValidation.None;
                break;
            case ContentType.IntegerNumber:
                m_LineType = LineType.SingleLine;
                m_InputType = InputType.Standard;
                m_KeyboardType = (TouchScreenKeyboardType)4;
                m_CharacterValidation = CharacterValidation.Integer;
                break;
            case ContentType.DecimalNumber:
                m_LineType = LineType.SingleLine;
                m_InputType = InputType.Standard;
                m_KeyboardType = (TouchScreenKeyboardType)2;
                m_CharacterValidation = CharacterValidation.Decimal;
                break;
            case ContentType.Alphanumeric:
                m_LineType = LineType.SingleLine;
                m_InputType = InputType.Standard;
                m_KeyboardType = (TouchScreenKeyboardType)1;
                m_CharacterValidation = CharacterValidation.Alphanumeric;
                break;
            case ContentType.Name:
                m_LineType = LineType.SingleLine;
                m_InputType = InputType.Standard;
                m_KeyboardType = (TouchScreenKeyboardType)6;
                m_CharacterValidation = CharacterValidation.Name;
                break;
            case ContentType.EmailAddress:
                m_LineType = LineType.SingleLine;
                m_InputType = InputType.Standard;
                m_KeyboardType = (TouchScreenKeyboardType)7;
                m_CharacterValidation = CharacterValidation.EmailAddress;
                break;
            case ContentType.Password:
                m_LineType = LineType.SingleLine;
                m_InputType = InputType.Password;
                m_KeyboardType = (TouchScreenKeyboardType)0;
                m_CharacterValidation = CharacterValidation.None;
                break;
            case ContentType.Pin:
                m_LineType = LineType.SingleLine;
                m_InputType = InputType.Password;
                m_KeyboardType = (TouchScreenKeyboardType)4;
                m_CharacterValidation = CharacterValidation.Integer;
                break;
            }
            EnforceTextHOverflow();
        }
 
        private void EnforceTextHOverflow()
        {
            if ((Object)(object)m_TextComponent != (Object)null)
            {
                if (multiLine)
                {
                    m_TextComponent.horizontalOverflow = (HorizontalWrapMode)0;
                }
                else
                {
                    m_TextComponent.horizontalOverflow = (HorizontalWrapMode)1;
                }
            }
        }
 
        private void SetToCustomIfContentTypeIsNot(params ContentType[] allowedContentTypes)
        {
            if (contentType == ContentType.Custom)
            {
                return;
            }
            for (int i = 0; i < allowedContentTypes.Length; i++)
            {
                if (contentType == allowedContentTypes[i])
                {
                    return;
                }
            }
            contentType = ContentType.Custom;
        }
 
        private void SetToCustom()
        {
            if (contentType != ContentType.Custom)
            {
                contentType = ContentType.Custom;
            }
        }
 
        protected override void DoStateTransition(SelectionState state, bool instant)
        {
            //IL_000d: Unknown result type (might be due to invalid IL or missing references)
            //IL_000f: Invalid comparison between Unknown and I4
            //IL_0009: Unknown result type (might be due to invalid IL or missing references)
            //IL_0019: Unknown result type (might be due to invalid IL or missing references)
            if (m_HasDoneFocusTransition)
            {
                state = (SelectionState)3;
            }
            else if ((int)state == 2)
            {
                m_HasDoneFocusTransition = true;
            }
            ((Selectable)this).DoStateTransition(state, instant);
        }
 
        public virtual void CalculateLayoutInputHorizontal()
        {
        }
 
        public virtual void CalculateLayoutInputVertical()
        {
        }
 
        static VRCUrlInputField()
        {
            Char[] array = new Char[6];
            RuntimeHelpers.InitializeArray((Array)(object)array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
            kSeparators = (char[])(object)array;
            s_AreDevicesEvaluated = false;
            s_IsQuestDevice = false;
            s_IsPicoDevice = false;
        }
 
        Transform ICanvasElement.get_transform()
        {
            return ((Component)this).transform;
        }
    }
}
namespace VRC.SDK3.Components.Video
{
    [PublicAPI]
    public enum VideoError : Enum
    {
        Unknown,
        InvalidURL,
        AccessDenied,
        PlayerError,
        RateLimited
    }
}