using System;
using System.Runtime.CompilerServices;
using UnityEngine.Scripting;

namespace UnityEngine.Playables
{
	// Token: 0x020000E0 RID: 224
	[UsedByNativeCode]
	public struct PlayableHandle
	{
		// Token: 0x0600104E RID: 4174 RVA: 0x00015F08 File Offset: 0x00014108
		internal T GetObject<T>() where T : class, IPlayableBehaviour
		{
			T t;
			if (!this.IsValid())
			{
				t = (T)((object)null);
			}
			else
			{
				object scriptInstance = PlayableHandle.GetScriptInstance(ref this);
				if (scriptInstance == null)
				{
					t = (T)((object)null);
				}
				else
				{
					t = (T)((object)scriptInstance);
				}
			}
			return t;
		}

		// Token: 0x0600104F RID: 4175 RVA: 0x00015F54 File Offset: 0x00014154
		private static object GetScriptInstance(ref PlayableHandle playable)
		{
			return PlayableHandle.INTERNAL_CALL_GetScriptInstance(ref playable);
		}

		// Token: 0x06001050 RID: 4176
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern object INTERNAL_CALL_GetScriptInstance(ref PlayableHandle playable);

		// Token: 0x06001051 RID: 4177 RVA: 0x00015F70 File Offset: 0x00014170
		internal void SetScriptInstance(object scriptInstance)
		{
			PlayableHandle.SetScriptInstance(ref this, scriptInstance);
		}

		// Token: 0x06001052 RID: 4178 RVA: 0x00015F7C File Offset: 0x0001417C
		private static void SetScriptInstance(ref PlayableHandle playable, object scriptInstance)
		{
			PlayableHandle.INTERNAL_CALL_SetScriptInstance(ref playable, scriptInstance);
		}

		// Token: 0x06001053 RID: 4179
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_SetScriptInstance(ref PlayableHandle playable, object scriptInstance);

		// Token: 0x06001054 RID: 4180 RVA: 0x00015F88 File Offset: 0x00014188
		internal bool IsValid()
		{
			return PlayableHandle.IsValidInternal(ref this);
		}

		// Token: 0x06001055 RID: 4181 RVA: 0x00015FA4 File Offset: 0x000141A4
		private static bool IsValidInternal(ref PlayableHandle playable)
		{
			return PlayableHandle.INTERNAL_CALL_IsValidInternal(ref playable);
		}

		// Token: 0x06001056 RID: 4182
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern bool INTERNAL_CALL_IsValidInternal(ref PlayableHandle playable);

		// Token: 0x06001057 RID: 4183 RVA: 0x00015FC0 File Offset: 0x000141C0
		private static Type GetPlayableTypeOf(ref PlayableHandle playable)
		{
			return PlayableHandle.INTERNAL_CALL_GetPlayableTypeOf(ref playable);
		}

		// Token: 0x06001058 RID: 4184
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern Type INTERNAL_CALL_GetPlayableTypeOf(ref PlayableHandle playable);

		// Token: 0x06001059 RID: 4185 RVA: 0x00015FDC File Offset: 0x000141DC
		internal Type GetPlayableType()
		{
			return PlayableHandle.GetPlayableTypeOf(ref this);
		}

		// Token: 0x0600105A RID: 4186 RVA: 0x00015FF8 File Offset: 0x000141F8
		internal bool IsPlayableOfType<T>()
		{
			return PlayableHandle.GetPlayableTypeOf(ref this) == typeof(T);
		}

		// Token: 0x1700036C RID: 876
		// (get) Token: 0x0600105B RID: 4187 RVA: 0x00016020 File Offset: 0x00014220
		public static PlayableHandle Null
		{
			get
			{
				return new PlayableHandle
				{
					m_Version = 10
				};
			}
		}

		// Token: 0x0600105C RID: 4188 RVA: 0x00016048 File Offset: 0x00014248
		internal PlayableGraph GetGraph()
		{
			PlayableGraph playableGraph = default(PlayableGraph);
			PlayableHandle.GetGraphInternal(ref this, ref playableGraph);
			return playableGraph;
		}

		// Token: 0x0600105D RID: 4189 RVA: 0x00016070 File Offset: 0x00014270
		internal int GetInputCount()
		{
			return PlayableHandle.GetInputCountInternal(ref this);
		}

		// Token: 0x0600105E RID: 4190 RVA: 0x0001608C File Offset: 0x0001428C
		internal void SetInputCount(int value)
		{
			PlayableHandle.SetInputCountInternal(ref this, value);
		}

		// Token: 0x0600105F RID: 4191 RVA: 0x00016098 File Offset: 0x00014298
		internal int GetOutputCount()
		{
			return PlayableHandle.GetOutputCountInternal(ref this);
		}

		// Token: 0x06001060 RID: 4192 RVA: 0x000160B4 File Offset: 0x000142B4
		internal void SetOutputCount(int value)
		{
			PlayableHandle.SetOutputCountInternal(ref this, value);
		}

		// Token: 0x06001061 RID: 4193 RVA: 0x000160C0 File Offset: 0x000142C0
		internal PlayState GetPlayState()
		{
			return PlayableHandle.GetPlayStateInternal(ref this);
		}

		// Token: 0x06001062 RID: 4194 RVA: 0x000160DC File Offset: 0x000142DC
		internal void SetPlayState(PlayState value)
		{
			PlayableHandle.SetPlayStateInternal(ref this, value);
		}

		// Token: 0x06001063 RID: 4195 RVA: 0x000160E8 File Offset: 0x000142E8
		internal double GetSpeed()
		{
			return PlayableHandle.GetSpeedInternal(ref this);
		}

		// Token: 0x06001064 RID: 4196 RVA: 0x00016104 File Offset: 0x00014304
		internal void SetSpeed(double value)
		{
			PlayableHandle.SetSpeedInternal(ref this, value);
		}

		// Token: 0x06001065 RID: 4197 RVA: 0x00016110 File Offset: 0x00014310
		internal double GetTime()
		{
			return PlayableHandle.GetTimeInternal(ref this);
		}

		// Token: 0x06001066 RID: 4198 RVA: 0x0001612C File Offset: 0x0001432C
		internal void SetTime(double value)
		{
			PlayableHandle.SetTimeInternal(ref this, value);
		}

		// Token: 0x06001067 RID: 4199 RVA: 0x00016138 File Offset: 0x00014338
		internal bool IsDone()
		{
			return PlayableHandle.IsDoneInternal(ref this);
		}

		// Token: 0x06001068 RID: 4200 RVA: 0x00016154 File Offset: 0x00014354
		internal void SetDone(bool value)
		{
			PlayableHandle.SetDoneInternal(ref this, value);
		}

		// Token: 0x06001069 RID: 4201 RVA: 0x00016160 File Offset: 0x00014360
		internal bool GetPropagateSetTime()
		{
			return PlayableHandle.GetPropagateSetTimeInternal(ref this);
		}

		// Token: 0x0600106A RID: 4202 RVA: 0x0001617C File Offset: 0x0001437C
		internal void SetPropagateSetTime(bool value)
		{
			PlayableHandle.SetPropagateSetTimeInternal(ref this, value);
		}

		// Token: 0x0600106B RID: 4203 RVA: 0x00016188 File Offset: 0x00014388
		internal bool CanChangeInputs()
		{
			return PlayableHandle.CanChangeInputsInternal(ref this);
		}

		// Token: 0x0600106C RID: 4204 RVA: 0x000161A4 File Offset: 0x000143A4
		internal bool CanSetWeights()
		{
			return PlayableHandle.CanSetWeightsInternal(ref this);
		}

		// Token: 0x0600106D RID: 4205 RVA: 0x000161C0 File Offset: 0x000143C0
		internal bool CanDestroy()
		{
			return PlayableHandle.CanDestroyInternal(ref this);
		}

		// Token: 0x0600106E RID: 4206 RVA: 0x000161DC File Offset: 0x000143DC
		private static bool CanChangeInputsInternal(ref PlayableHandle playable)
		{
			return PlayableHandle.INTERNAL_CALL_CanChangeInputsInternal(ref playable);
		}

		// Token: 0x0600106F RID: 4207
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern bool INTERNAL_CALL_CanChangeInputsInternal(ref PlayableHandle playable);

		// Token: 0x06001070 RID: 4208 RVA: 0x000161F8 File Offset: 0x000143F8
		private static bool CanSetWeightsInternal(ref PlayableHandle playable)
		{
			return PlayableHandle.INTERNAL_CALL_CanSetWeightsInternal(ref playable);
		}

		// Token: 0x06001071 RID: 4209
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern bool INTERNAL_CALL_CanSetWeightsInternal(ref PlayableHandle playable);

		// Token: 0x06001072 RID: 4210 RVA: 0x00016214 File Offset: 0x00014414
		private static bool CanDestroyInternal(ref PlayableHandle playable)
		{
			return PlayableHandle.INTERNAL_CALL_CanDestroyInternal(ref playable);
		}

		// Token: 0x06001073 RID: 4211
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern bool INTERNAL_CALL_CanDestroyInternal(ref PlayableHandle playable);

		// Token: 0x06001074 RID: 4212 RVA: 0x00016230 File Offset: 0x00014430
		private static PlayState GetPlayStateInternal(ref PlayableHandle playable)
		{
			return PlayableHandle.INTERNAL_CALL_GetPlayStateInternal(ref playable);
		}

		// Token: 0x06001075 RID: 4213
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern PlayState INTERNAL_CALL_GetPlayStateInternal(ref PlayableHandle playable);

		// Token: 0x06001076 RID: 4214 RVA: 0x0001624C File Offset: 0x0001444C
		private static void SetPlayStateInternal(ref PlayableHandle playable, PlayState playState)
		{
			PlayableHandle.INTERNAL_CALL_SetPlayStateInternal(ref playable, playState);
		}

		// Token: 0x06001077 RID: 4215
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_SetPlayStateInternal(ref PlayableHandle playable, PlayState playState);

		// Token: 0x06001078 RID: 4216 RVA: 0x00016258 File Offset: 0x00014458
		private static double GetSpeedInternal(ref PlayableHandle playable)
		{
			return PlayableHandle.INTERNAL_CALL_GetSpeedInternal(ref playable);
		}

		// Token: 0x06001079 RID: 4217
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern double INTERNAL_CALL_GetSpeedInternal(ref PlayableHandle playable);

		// Token: 0x0600107A RID: 4218 RVA: 0x00016274 File Offset: 0x00014474
		private static void SetSpeedInternal(ref PlayableHandle playable, double speed)
		{
			PlayableHandle.INTERNAL_CALL_SetSpeedInternal(ref playable, speed);
		}

		// Token: 0x0600107B RID: 4219
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_SetSpeedInternal(ref PlayableHandle playable, double speed);

		// Token: 0x0600107C RID: 4220 RVA: 0x00016280 File Offset: 0x00014480
		private static double GetTimeInternal(ref PlayableHandle playable)
		{
			return PlayableHandle.INTERNAL_CALL_GetTimeInternal(ref playable);
		}

		// Token: 0x0600107D RID: 4221
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern double INTERNAL_CALL_GetTimeInternal(ref PlayableHandle playable);

		// Token: 0x0600107E RID: 4222 RVA: 0x0001629C File Offset: 0x0001449C
		private static void SetTimeInternal(ref PlayableHandle playable, double time)
		{
			PlayableHandle.INTERNAL_CALL_SetTimeInternal(ref playable, time);
		}

		// Token: 0x0600107F RID: 4223
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_SetTimeInternal(ref PlayableHandle playable, double time);

		// Token: 0x06001080 RID: 4224 RVA: 0x000162A8 File Offset: 0x000144A8
		private static bool IsDoneInternal(ref PlayableHandle playable)
		{
			return PlayableHandle.INTERNAL_CALL_IsDoneInternal(ref playable);
		}

		// Token: 0x06001081 RID: 4225
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern bool INTERNAL_CALL_IsDoneInternal(ref PlayableHandle playable);

		// Token: 0x06001082 RID: 4226 RVA: 0x000162C4 File Offset: 0x000144C4
		private static void SetDoneInternal(ref PlayableHandle playable, bool isDone)
		{
			PlayableHandle.INTERNAL_CALL_SetDoneInternal(ref playable, isDone);
		}

		// Token: 0x06001083 RID: 4227
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_SetDoneInternal(ref PlayableHandle playable, bool isDone);

		// Token: 0x06001084 RID: 4228 RVA: 0x000162D0 File Offset: 0x000144D0
		internal double GetDuration()
		{
			return PlayableHandle.GetDurationInternal(ref this);
		}

		// Token: 0x06001085 RID: 4229 RVA: 0x000162EC File Offset: 0x000144EC
		internal void SetDuration(double value)
		{
			PlayableHandle.SetDurationInternal(ref this, value);
		}

		// Token: 0x06001086 RID: 4230 RVA: 0x000162F8 File Offset: 0x000144F8
		private static double GetDurationInternal(ref PlayableHandle playable)
		{
			return PlayableHandle.INTERNAL_CALL_GetDurationInternal(ref playable);
		}

		// Token: 0x06001087 RID: 4231
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern double INTERNAL_CALL_GetDurationInternal(ref PlayableHandle playable);

		// Token: 0x06001088 RID: 4232 RVA: 0x00016314 File Offset: 0x00014514
		private static void SetDurationInternal(ref PlayableHandle playable, double duration)
		{
			PlayableHandle.INTERNAL_CALL_SetDurationInternal(ref playable, duration);
		}

		// Token: 0x06001089 RID: 4233
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_SetDurationInternal(ref PlayableHandle playable, double duration);

		// Token: 0x0600108A RID: 4234 RVA: 0x00016320 File Offset: 0x00014520
		private static bool GetPropagateSetTimeInternal(ref PlayableHandle playable)
		{
			return PlayableHandle.INTERNAL_CALL_GetPropagateSetTimeInternal(ref playable);
		}

		// Token: 0x0600108B RID: 4235
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern bool INTERNAL_CALL_GetPropagateSetTimeInternal(ref PlayableHandle playable);

		// Token: 0x0600108C RID: 4236 RVA: 0x0001633C File Offset: 0x0001453C
		private static void SetPropagateSetTimeInternal(ref PlayableHandle playable, bool value)
		{
			PlayableHandle.INTERNAL_CALL_SetPropagateSetTimeInternal(ref playable, value);
		}

		// Token: 0x0600108D RID: 4237
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_SetPropagateSetTimeInternal(ref PlayableHandle playable, bool value);

		// Token: 0x0600108E RID: 4238 RVA: 0x00016348 File Offset: 0x00014548
		private static void GetGraphInternal(ref PlayableHandle playable, ref PlayableGraph graph)
		{
			PlayableHandle.INTERNAL_CALL_GetGraphInternal(ref playable, ref graph);
		}

		// Token: 0x0600108F RID: 4239
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_GetGraphInternal(ref PlayableHandle playable, ref PlayableGraph graph);

		// Token: 0x06001090 RID: 4240 RVA: 0x00016354 File Offset: 0x00014554
		private static int GetInputCountInternal(ref PlayableHandle playable)
		{
			return PlayableHandle.INTERNAL_CALL_GetInputCountInternal(ref playable);
		}

		// Token: 0x06001091 RID: 4241
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern int INTERNAL_CALL_GetInputCountInternal(ref PlayableHandle playable);

		// Token: 0x06001092 RID: 4242 RVA: 0x00016370 File Offset: 0x00014570
		private static void SetInputCountInternal(ref PlayableHandle playable, int count)
		{
			PlayableHandle.INTERNAL_CALL_SetInputCountInternal(ref playable, count);
		}

		// Token: 0x06001093 RID: 4243
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_SetInputCountInternal(ref PlayableHandle playable, int count);

		// Token: 0x06001094 RID: 4244 RVA: 0x0001637C File Offset: 0x0001457C
		private static int GetOutputCountInternal(ref PlayableHandle playable)
		{
			return PlayableHandle.INTERNAL_CALL_GetOutputCountInternal(ref playable);
		}

		// Token: 0x06001095 RID: 4245
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern int INTERNAL_CALL_GetOutputCountInternal(ref PlayableHandle playable);

		// Token: 0x06001096 RID: 4246 RVA: 0x00016398 File Offset: 0x00014598
		private static void SetOutputCountInternal(ref PlayableHandle playable, int count)
		{
			PlayableHandle.INTERNAL_CALL_SetOutputCountInternal(ref playable, count);
		}

		// Token: 0x06001097 RID: 4247
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_SetOutputCountInternal(ref PlayableHandle playable, int count);

		// Token: 0x06001098 RID: 4248 RVA: 0x000163A4 File Offset: 0x000145A4
		internal Playable GetInput(int inputPort)
		{
			return new Playable(PlayableHandle.GetInputInternal(ref this, inputPort));
		}

		// Token: 0x06001099 RID: 4249 RVA: 0x000163C8 File Offset: 0x000145C8
		private static PlayableHandle GetInputInternal(ref PlayableHandle playable, int index)
		{
			PlayableHandle playableHandle;
			PlayableHandle.INTERNAL_CALL_GetInputInternal(ref playable, index, out playableHandle);
			return playableHandle;
		}

		// Token: 0x0600109A RID: 4250
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_GetInputInternal(ref PlayableHandle playable, int index, out PlayableHandle value);

		// Token: 0x0600109B RID: 4251 RVA: 0x000163E8 File Offset: 0x000145E8
		internal Playable GetOutput(int outputPort)
		{
			return new Playable(PlayableHandle.GetOutputInternal(ref this, outputPort));
		}

		// Token: 0x0600109C RID: 4252 RVA: 0x0001640C File Offset: 0x0001460C
		private static PlayableHandle GetOutputInternal(ref PlayableHandle playable, int index)
		{
			PlayableHandle playableHandle;
			PlayableHandle.INTERNAL_CALL_GetOutputInternal(ref playable, index, out playableHandle);
			return playableHandle;
		}

		// Token: 0x0600109D RID: 4253
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_GetOutputInternal(ref PlayableHandle playable, int index, out PlayableHandle value);

		// Token: 0x0600109E RID: 4254 RVA: 0x0001642C File Offset: 0x0001462C
		private static void SetInputWeightFromIndexInternal(ref PlayableHandle playable, int index, float weight)
		{
			PlayableHandle.INTERNAL_CALL_SetInputWeightFromIndexInternal(ref playable, index, weight);
		}

		// Token: 0x0600109F RID: 4255
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_SetInputWeightFromIndexInternal(ref PlayableHandle playable, int index, float weight);

		// Token: 0x060010A0 RID: 4256 RVA: 0x00016438 File Offset: 0x00014638
		internal bool SetInputWeight(int inputIndex, float weight)
		{
			bool flag;
			if (this.CheckInputBounds(inputIndex))
			{
				PlayableHandle.SetInputWeightFromIndexInternal(ref this, inputIndex, weight);
				flag = true;
			}
			else
			{
				flag = false;
			}
			return flag;
		}

		// Token: 0x060010A1 RID: 4257 RVA: 0x0001646C File Offset: 0x0001466C
		private static float GetInputWeightFromIndexInternal(ref PlayableHandle playable, int index)
		{
			return PlayableHandle.INTERNAL_CALL_GetInputWeightFromIndexInternal(ref playable, index);
		}

		// Token: 0x060010A2 RID: 4258
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern float INTERNAL_CALL_GetInputWeightFromIndexInternal(ref PlayableHandle playable, int index);

		// Token: 0x060010A3 RID: 4259 RVA: 0x00016488 File Offset: 0x00014688
		internal void SetInputWeight(PlayableHandle input, float weight)
		{
			PlayableHandle.SetInputWeightInternal(ref this, ref input, weight);
		}

		// Token: 0x060010A4 RID: 4260 RVA: 0x00016494 File Offset: 0x00014694
		private static void SetInputWeightInternal(ref PlayableHandle playable, ref PlayableHandle input, float weight)
		{
			PlayableHandle.INTERNAL_CALL_SetInputWeightInternal(ref playable, ref input, weight);
		}

		// Token: 0x060010A5 RID: 4261
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_SetInputWeightInternal(ref PlayableHandle playable, ref PlayableHandle input, float weight);

		// Token: 0x060010A6 RID: 4262 RVA: 0x000164A0 File Offset: 0x000146A0
		internal float GetInputWeight(int inputIndex)
		{
			float num;
			if (this.CheckInputBounds(inputIndex))
			{
				num = PlayableHandle.GetInputWeightFromIndexInternal(ref this, inputIndex);
			}
			else
			{
				num = 0f;
			}
			return num;
		}

		// Token: 0x060010A7 RID: 4263 RVA: 0x000164D4 File Offset: 0x000146D4
		internal void Destroy()
		{
			this.GetGraph().DestroyPlayable<Playable>(new Playable(this));
		}

		// Token: 0x060010A8 RID: 4264 RVA: 0x000164FC File Offset: 0x000146FC
		public static bool operator ==(PlayableHandle x, PlayableHandle y)
		{
			return PlayableHandle.CompareVersion(x, y);
		}

		// Token: 0x060010A9 RID: 4265 RVA: 0x00016518 File Offset: 0x00014718
		public static bool operator !=(PlayableHandle x, PlayableHandle y)
		{
			return !PlayableHandle.CompareVersion(x, y);
		}

		// Token: 0x060010AA RID: 4266 RVA: 0x00016538 File Offset: 0x00014738
		public override bool Equals(object p)
		{
			return p is PlayableHandle && PlayableHandle.CompareVersion(this, (PlayableHandle)p);
		}

		// Token: 0x060010AB RID: 4267 RVA: 0x00016570 File Offset: 0x00014770
		public override int GetHashCode()
		{
			return this.m_Handle.GetHashCode() ^ this.m_Version.GetHashCode();
		}

		// Token: 0x060010AC RID: 4268 RVA: 0x000165A8 File Offset: 0x000147A8
		internal static bool CompareVersion(PlayableHandle lhs, PlayableHandle rhs)
		{
			return lhs.m_Handle == rhs.m_Handle && lhs.m_Version == rhs.m_Version;
		}

		// Token: 0x060010AD RID: 4269 RVA: 0x000165E8 File Offset: 0x000147E8
		internal bool CheckInputBounds(int inputIndex)
		{
			return this.CheckInputBounds(inputIndex, false);
		}

		// Token: 0x060010AE RID: 4270 RVA: 0x00016608 File Offset: 0x00014808
		internal bool CheckInputBounds(int inputIndex, bool acceptAny)
		{
			bool flag;
			if (inputIndex == -1 && acceptAny)
			{
				flag = true;
			}
			else
			{
				if (inputIndex < 0)
				{
					throw new IndexOutOfRangeException("Index must be greater than 0");
				}
				if (this.GetInputCount() <= inputIndex)
				{
					throw new IndexOutOfRangeException(string.Concat(new object[]
					{
						"inputIndex ",
						inputIndex,
						" is greater than the number of available inputs (",
						this.GetInputCount(),
						")."
					}));
				}
				flag = true;
			}
			return flag;
		}

		// Token: 0x0400020A RID: 522
		internal IntPtr m_Handle;

		// Token: 0x0400020B RID: 523
		internal int m_Version;
	}
}