using System;
using System.Collections;
using System.Diagnostics;
using System.Threading;
using UnityEngine;

// Token: 0x0200012F RID: 303
public class RetractableRigidbodyPickup : AxisConstrainedRigidbodyPickup
{
	// Token: 0x06003EE7 RID: 16103 RVA: 0x0013E8D0 File Offset: 0x0013CAD0
	private void KAKNDAMENPL()
	{
		this.MLACADCOKJO();
		this.MIOACOEKBFL = base.StartCoroutine(this.MBHEJEJAKMD());
	}

	// Token: 0x06003EE8 RID: 16104 RVA: 0x0013E8EC File Offset: 0x0013CAEC
	public void IPBOBFFKNCN()
	{
		this.BHJPOPJIOKN();
	}

	// Token: 0x1700011F RID: 287
	// (get) Token: 0x06003EE9 RID: 16105 RVA: 0x0013E8F4 File Offset: 0x0013CAF4
	public override Quaternion INMMPMMNFJF
	{
		get
		{
			if (this.MEMOPCOHPLE || this.restTransform == null)
			{
				return base.INMMPMMNFJF;
			}
			return this.restTransform.rotation;
		}
	}

	// Token: 0x06003EEA RID: 16106 RVA: 0x0013E924 File Offset: 0x0013CB24
	public void FFOPOGLPCHP(Action NOBAPCOKFIL)
	{
		Action action = this.LIFJHLPBPOE;
		Action action2;
		do
		{
			action2 = action;
			action = Interlocked.CompareExchange<Action>(ref this.LIFJHLPBPOE, (Action)Delegate.Remove(action2, NOBAPCOKFIL), action);
		}
		while (action != action2);
	}

	// Token: 0x06003EEB RID: 16107 RVA: 0x0013E95C File Offset: 0x0013CB5C
	private void OFPBFFAKPAA()
	{
		this.KAEOKPMPKJA();
		this.MIOACOEKBFL = base.StartCoroutine(this.FMNNMNJLPOK());
	}

	// Token: 0x06003EEC RID: 16108 RVA: 0x0013E978 File Offset: 0x0013CB78
	private void BECIPLLLKCK()
	{
		if (this.MIOACOEKBFL != null)
		{
			base.StopCoroutine(this.MIOACOEKBFL);
		}
	}

	// Token: 0x06003EED RID: 16109 RVA: 0x0013E994 File Offset: 0x0013CB94
	public void MAGNNKCHENP(Action NOBAPCOKFIL)
	{
		Action action = this.LIFJHLPBPOE;
		Action action2;
		do
		{
			action2 = action;
			action = Interlocked.CompareExchange<Action>(ref this.LIFJHLPBPOE, (Action)Delegate.Combine(action2, NOBAPCOKFIL), action);
		}
		while (action != action2);
	}

	// Token: 0x06003EEE RID: 16110 RVA: 0x0013E9CC File Offset: 0x0013CBCC
	protected override void BGJEJHLKNKA()
	{
		base.ACOIMDMPDOM();
		this.ModifyKinematicOnPickupRelease = false;
	}

	// Token: 0x06003EEF RID: 16111 RVA: 0x0013E9DC File Offset: 0x0013CBDC
	private void CCNILLAJIGG()
	{
		if (this.MIOACOEKBFL != null)
		{
			base.StopCoroutine(this.MIOACOEKBFL);
		}
	}

	// Token: 0x06003EF0 RID: 16112 RVA: 0x0013E9F8 File Offset: 0x0013CBF8
	public override void DKMPHIJMFNC(Transform MMEBLCBANIL, Vector3 KOFPGEFEDDH, Quaternion KKKJMGGKNPG)
	{
		base.Pickup(MMEBLCBANIL, KOFPGEFEDDH, KKKJMGGKNPG);
		this.BECIPLLLKCK();
	}

	// Token: 0x06003EF1 RID: 16113 RVA: 0x0013EA0C File Offset: 0x0013CC0C
	public virtual void EJKIKJAFNFB(Transform MMEBLCBANIL, Vector3 KOFPGEFEDDH, Quaternion KKKJMGGKNPG)
	{
		base.DKMPHIJMFNC(MMEBLCBANIL, KOFPGEFEDDH, KKKJMGGKNPG);
		this.NOFKFLLBKIG();
	}

	// Token: 0x06003EF2 RID: 16114 RVA: 0x0013EA20 File Offset: 0x0013CC20
	public void DEGJJLKGLIK(Action NOBAPCOKFIL)
	{
		Action action = this.LIFJHLPBPOE;
		Action action2;
		do
		{
			action2 = action;
			action = Interlocked.CompareExchange<Action>(ref this.LIFJHLPBPOE, (Action)Delegate.Combine(action2, NOBAPCOKFIL), action);
		}
		while (action != action2);
	}

	// Token: 0x06003EF3 RID: 16115 RVA: 0x0013EA58 File Offset: 0x0013CC58
	private IEnumerator GKHFMLAIFHJ()
	{
		float num = 0f;
		while (!base.gameObject.activeSelf && num <= 0.5f)
		{
			yield return null;
			num += Time.deltaTime;
		}
		Vector3 zero = Vector3.zero;
		Vector3 zero2 = Vector3.zero;
		this.GGPILMKBGGN.ClearVelocity();
		num = 0f;
		this.GKMOCFANDOM = true;
		while (this.interpolateToRest && num < this.interpolateToRestDuration)
		{
			Vector3 vector = Vector3.SmoothDamp(this.GGPILMKBGGN.CIGPHKLAAOD, this.KIJCBJAJPID, ref zero, this.interpolateToRestDuration);
			Vector3 eulerAngles = this.INMMPMMNFJF.eulerAngles;
			Vector3 eulerAngles2 = base.transform.rotation.eulerAngles;
			eulerAngles2.x = Mathf.SmoothDampAngle(eulerAngles2.x, eulerAngles.x, ref zero2.x, this.interpolateToRestDuration);
			eulerAngles2.y = Mathf.SmoothDampAngle(eulerAngles2.y, eulerAngles.y, ref zero2.y, this.interpolateToRestDuration);
			eulerAngles2.z = Mathf.SmoothDampAngle(eulerAngles2.z, eulerAngles.z, ref zero2.z, this.interpolateToRestDuration);
			Quaternion quaternion = Quaternion.Euler(eulerAngles2);
			base.JMDOMAJBNEH(vector, quaternion);
			this.GGPILMKBGGN.ClearVelocity();
			yield return new WaitForFixedUpdate();
			num += Time.fixedDeltaTime;
		}
		this.GKMOCFANDOM = false;
		if (this.LIFJHLPBPOE != null)
		{
			this.LIFJHLPBPOE();
		}
		for (;;)
		{
			yield return new WaitForFixedUpdate();
			base.JMDOMAJBNEH(this.KIJCBJAJPID, this.INMMPMMNFJF);
		}
		yield break;
	}

	// Token: 0x06003EF4 RID: 16116 RVA: 0x0013EA74 File Offset: 0x0013CC74
	private void OKFGPOADNIL()
	{
		this.CKDOOABNAON();
		this.MIOACOEKBFL = base.StartCoroutine(this.MBHEJEJAKMD());
	}

	// Token: 0x06003EF5 RID: 16117 RVA: 0x0013EA90 File Offset: 0x0013CC90
	public virtual Vector3 IEHPEJCJKKB()
	{
		if (this.MEOKHJEHNEP() || this.restTransform == null)
		{
			return base.OBFEPECKPGH();
		}
		return this.restTransform.position;
	}

	// Token: 0x06003EF6 RID: 16118 RVA: 0x0013EAC0 File Offset: 0x0013CCC0
	public void EJLODMLCKCC(Action NOBAPCOKFIL)
	{
		Action action = this.LIFJHLPBPOE;
		Action action2;
		do
		{
			action2 = action;
			action = Interlocked.CompareExchange<Action>(ref this.LIFJHLPBPOE, (Action)Delegate.Combine(action2, NOBAPCOKFIL), action);
		}
		while (action != action2);
	}

	// Token: 0x06003EF7 RID: 16119 RVA: 0x0013EAF8 File Offset: 0x0013CCF8
	protected virtual void JKFLOMBCKIL()
	{
		base.IOKIFHGPMKI();
		this.ModifyKinematicOnPickupRelease = false;
	}

	// Token: 0x06003EF8 RID: 16120 RVA: 0x0013EB08 File Offset: 0x0013CD08
	public bool IKMILGKMEAO()
	{
		return this.<DCAPNNPGEMN>k__BackingField;
	}

	// Token: 0x06003EF9 RID: 16121 RVA: 0x0013EB10 File Offset: 0x0013CD10
	private void KAEOKPMPKJA()
	{
		if (this.MIOACOEKBFL != null)
		{
			base.StopCoroutine(this.MIOACOEKBFL);
		}
	}

	// Token: 0x06003EFA RID: 16122 RVA: 0x0013EB2C File Offset: 0x0013CD2C
	public bool HAGCKMBNPON()
	{
		return this.<DCAPNNPGEMN>k__BackingField;
	}

	// Token: 0x06003EFB RID: 16123 RVA: 0x0013EB34 File Offset: 0x0013CD34
	private void PABHDKDJIHE()
	{
		if (this.MIOACOEKBFL != null)
		{
			base.StopCoroutine(this.MIOACOEKBFL);
		}
	}

	// Token: 0x06003EFC RID: 16124 RVA: 0x0013EB50 File Offset: 0x0013CD50
	public Transform AFBIKIDBJHM()
	{
		return this.restTransform;
	}

	// Token: 0x06003EFD RID: 16125 RVA: 0x0013EB58 File Offset: 0x0013CD58
	public void AAJPJMDIEFC()
	{
		this.KECMGHONGIB();
	}

	// Token: 0x1700011C RID: 284
	// (get) Token: 0x06003EFE RID: 16126 RVA: 0x0013EB60 File Offset: 0x0013CD60
	// (set) Token: 0x06003F02 RID: 16130 RVA: 0x0013EBE0 File Offset: 0x0013CDE0
	public bool GKMOCFANDOM { get; protected set; }

	// Token: 0x14000009 RID: 9
	// (add) Token: 0x06003EFF RID: 16127 RVA: 0x0013EB68 File Offset: 0x0013CD68
	// (remove) Token: 0x06003F00 RID: 16128 RVA: 0x0013EBA0 File Offset: 0x0013CDA0
	[field: DebuggerBrowsable(DebuggerBrowsableState.Never)]
	public event Action LIFJHLPBPOE;

	// Token: 0x06003F01 RID: 16129 RVA: 0x0013EBD8 File Offset: 0x0013CDD8
	public void DHLIOIJFJNA()
	{
		this.IMKPCHENNLE();
	}

	// Token: 0x06003F03 RID: 16131 RVA: 0x0013EBEC File Offset: 0x0013CDEC
	public void ACBPHOGPMGF()
	{
		this.MLHLCPNHIIL();
	}

	// Token: 0x06003F04 RID: 16132 RVA: 0x0013EBF4 File Offset: 0x0013CDF4
	public Transform MFCAGNJIKMP()
	{
		return this.restTransform;
	}

	// Token: 0x06003F05 RID: 16133 RVA: 0x0013EBFC File Offset: 0x0013CDFC
	private void KECMGHONGIB()
	{
		this.FCKFIIBDNEE();
		this.MIOACOEKBFL = base.StartCoroutine(this.GKHFMLAIFHJ());
	}

	// Token: 0x06003F06 RID: 16134 RVA: 0x0013EC18 File Offset: 0x0013CE18
	protected virtual void PAKPLLPDIOG()
	{
		base.BGJEJHLKNKA();
		this.ModifyKinematicOnPickupRelease = true;
	}

	// Token: 0x06003F07 RID: 16135 RVA: 0x0013EC28 File Offset: 0x0013CE28
	private void IFHBOOJHILC()
	{
		if (this.MIOACOEKBFL != null)
		{
			base.StopCoroutine(this.MIOACOEKBFL);
		}
	}

	// Token: 0x06003F08 RID: 16136 RVA: 0x0013EC44 File Offset: 0x0013CE44
	public void LPMFECKKNIN(Action NOBAPCOKFIL)
	{
		Action action = this.LIFJHLPBPOE;
		Action action2;
		do
		{
			action2 = action;
			action = Interlocked.CompareExchange<Action>(ref this.LIFJHLPBPOE, (Action)Delegate.Remove(action2, NOBAPCOKFIL), action);
		}
		while (action != action2);
	}

	// Token: 0x06003F09 RID: 16137 RVA: 0x0013EC7C File Offset: 0x0013CE7C
	private void LBKAOIAMGDI()
	{
		this.FCKFIIBDNEE();
		this.MIOACOEKBFL = base.StartCoroutine(this.BBFAINDOCGB());
	}

	// Token: 0x06003F0A RID: 16138 RVA: 0x0013EC98 File Offset: 0x0013CE98
	private void LJBIIAPFCPN()
	{
		this.IFHBOOJHILC();
		this.MIOACOEKBFL = base.StartCoroutine(this.FMNNMNJLPOK());
	}

	// Token: 0x06003F0B RID: 16139 RVA: 0x0013ECB4 File Offset: 0x0013CEB4
	public void FNPAEPGOHKP(Action NOBAPCOKFIL)
	{
		Action action = this.LIFJHLPBPOE;
		Action action2;
		do
		{
			action2 = action;
			action = Interlocked.CompareExchange<Action>(ref this.LIFJHLPBPOE, (Action)Delegate.Combine(action2, NOBAPCOKFIL), action);
		}
		while (action != action2);
	}

	// Token: 0x06003F0C RID: 16140 RVA: 0x0013ECEC File Offset: 0x0013CEEC
	public virtual void BKMIECBJMFD(Transform MMEBLCBANIL, Vector3 KOFPGEFEDDH, Quaternion KKKJMGGKNPG)
	{
		base.INNIMLIDAKN(MMEBLCBANIL, KOFPGEFEDDH, KKKJMGGKNPG);
		this.KAEOKPMPKJA();
	}

	// Token: 0x06003F0D RID: 16141 RVA: 0x0013ED00 File Offset: 0x0013CF00
	private void KHBBBPCHHBB()
	{
		this.KAEOKPMPKJA();
		this.MIOACOEKBFL = base.StartCoroutine(this.GKHFMLAIFHJ());
	}

	// Token: 0x06003F0E RID: 16142 RVA: 0x0013ED1C File Offset: 0x0013CF1C
	public void IALIKCOHLBH(Action NOBAPCOKFIL)
	{
		Action action = this.LIFJHLPBPOE;
		Action action2;
		do
		{
			action2 = action;
			action = Interlocked.CompareExchange<Action>(ref this.LIFJHLPBPOE, (Action)Delegate.Combine(action2, NOBAPCOKFIL), action);
		}
		while (action != action2);
	}

	// Token: 0x06003F0F RID: 16143 RVA: 0x0013ED54 File Offset: 0x0013CF54
	private void CIAEHAMEDHB()
	{
		this.OJHBJOHMMBE();
		this.MIOACOEKBFL = base.StartCoroutine(this.MIMKCMKMLII());
	}

	// Token: 0x06003F10 RID: 16144 RVA: 0x0013ED70 File Offset: 0x0013CF70
	public override Vector3 KDKOBKDCHHD()
	{
		if (this.MEMOPCOHPLE || this.restTransform == null)
		{
			return base.KIJCBJAJPID;
		}
		return this.restTransform.position;
	}

	// Token: 0x06003F11 RID: 16145 RVA: 0x0013EDA0 File Offset: 0x0013CFA0
	public virtual Quaternion LEEODCKKGOI()
	{
		if (this.MEOKHJEHNEP() || this.restTransform == null)
		{
			return base.NMNJGHKFNGM();
		}
		return this.restTransform.rotation;
	}

	// Token: 0x1700011D RID: 285
	// (get) Token: 0x06003F12 RID: 16146 RVA: 0x0013EDD0 File Offset: 0x0013CFD0
	public Transform PLCCOELEBIJ
	{
		get
		{
			return this.restTransform;
		}
	}

	// Token: 0x06003F13 RID: 16147 RVA: 0x0013EDD8 File Offset: 0x0013CFD8
	public virtual void JIHFCFBNOHL(Transform MMEBLCBANIL, Vector3 KOFPGEFEDDH, Quaternion KKKJMGGKNPG)
	{
		base.Pickup(MMEBLCBANIL, KOFPGEFEDDH, KKKJMGGKNPG);
		this.KAEOKPMPKJA();
	}

	// Token: 0x06003F14 RID: 16148 RVA: 0x0013EDEC File Offset: 0x0013CFEC
	protected void EPJAONGHGKI(bool NOBAPCOKFIL)
	{
		this.<DCAPNNPGEMN>k__BackingField = NOBAPCOKFIL;
	}

	// Token: 0x1700011E RID: 286
	// (get) Token: 0x06003F15 RID: 16149 RVA: 0x0013EDF8 File Offset: 0x0013CFF8
	public override Vector3 KIJCBJAJPID
	{
		get
		{
			if (this.MEMOPCOHPLE || this.restTransform == null)
			{
				return base.KIJCBJAJPID;
			}
			return this.restTransform.position;
		}
	}

	// Token: 0x06003F16 RID: 16150 RVA: 0x0013EE28 File Offset: 0x0013D028
	public virtual Quaternion EIJCNLNGKBL()
	{
		if (this.MEOKHJEHNEP() || this.restTransform == null)
		{
			return base.PFNKPANCNBN();
		}
		return this.restTransform.rotation;
	}

	// Token: 0x06003F17 RID: 16151 RVA: 0x0013EE58 File Offset: 0x0013D058
	public virtual Quaternion FIPIKFGLHIN()
	{
		if (this.DIGCFIAANFF() || this.restTransform == null)
		{
			return base.INMMPMMNFJF;
		}
		return this.restTransform.rotation;
	}

	// Token: 0x06003F18 RID: 16152 RVA: 0x0013EE88 File Offset: 0x0013D088
	public void DEADFGJIIKE(Action NOBAPCOKFIL)
	{
		Action action = this.LIFJHLPBPOE;
		Action action2;
		do
		{
			action2 = action;
			action = Interlocked.CompareExchange<Action>(ref this.LIFJHLPBPOE, (Action)Delegate.Combine(action2, NOBAPCOKFIL), action);
		}
		while (action != action2);
	}

	// Token: 0x06003F19 RID: 16153 RVA: 0x0013EEC0 File Offset: 0x0013D0C0
	public virtual void KLNNBDJKLFP(Transform MMEBLCBANIL, Vector3 KOFPGEFEDDH, Quaternion KKKJMGGKNPG)
	{
		base.JKJPCLEILPC(MMEBLCBANIL, KOFPGEFEDDH, KKKJMGGKNPG);
		this.BJLOIBIHACK();
	}

	// Token: 0x06003F1A RID: 16154 RVA: 0x0013EED4 File Offset: 0x0013D0D4
	private IEnumerator ECPNOAKECBD()
	{
		num = 0f;
		while (!base.gameObject.activeSelf && num <= 0.5f)
		{
			yield return null;
			num += Time.deltaTime;
		}
		zero = Vector3.zero;
		zero2 = Vector3.zero;
		this.GGPILMKBGGN.ClearVelocity();
		num = 0f;
		this.GKMOCFANDOM = true;
		while (this.interpolateToRest && num < this.interpolateToRestDuration)
		{
			vector = Vector3.SmoothDamp(this.GGPILMKBGGN.CIGPHKLAAOD, this.KIJCBJAJPID, ref zero, this.interpolateToRestDuration);
			eulerAngles = this.INMMPMMNFJF.eulerAngles;
			eulerAngles2 = base.transform.rotation.eulerAngles;
			eulerAngles2.x = Mathf.SmoothDampAngle(eulerAngles2.x, eulerAngles.x, ref zero2.x, this.interpolateToRestDuration);
			eulerAngles2.y = Mathf.SmoothDampAngle(eulerAngles2.y, eulerAngles.y, ref zero2.y, this.interpolateToRestDuration);
			eulerAngles2.z = Mathf.SmoothDampAngle(eulerAngles2.z, eulerAngles.z, ref zero2.z, this.interpolateToRestDuration);
			quaternion = Quaternion.Euler(eulerAngles2);
			base.JMDOMAJBNEH(vector, quaternion);
			this.GGPILMKBGGN.ClearVelocity();
			yield return new WaitForFixedUpdate();
			num += Time.fixedDeltaTime;
		}
		this.GKMOCFANDOM = false;
		if (this.LIFJHLPBPOE != null)
		{
			this.LIFJHLPBPOE();
		}
		for (;;)
		{
			yield return new WaitForFixedUpdate();
			base.JMDOMAJBNEH(this.KIJCBJAJPID, this.INMMPMMNFJF);
		}
		yield break;
	}

	// Token: 0x06003F1B RID: 16155 RVA: 0x0013EEF0 File Offset: 0x0013D0F0
	public void JMGCAFNBHGJ(Action NOBAPCOKFIL)
	{
		Action action = this.LIFJHLPBPOE;
		Action action2;
		do
		{
			action2 = action;
			action = Interlocked.CompareExchange<Action>(ref this.LIFJHLPBPOE, (Action)Delegate.Combine(action2, NOBAPCOKFIL), action);
		}
		while (action != action2);
	}

	// Token: 0x06003F1C RID: 16156 RVA: 0x0013EF28 File Offset: 0x0013D128
	protected void PJNGFJPGLJE(bool NOBAPCOKFIL)
	{
		this.<DCAPNNPGEMN>k__BackingField = NOBAPCOKFIL;
	}

	// Token: 0x06003F1D RID: 16157 RVA: 0x0013EF34 File Offset: 0x0013D134
	private void MKDMMIHOOBK()
	{
		this.BECIPLLLKCK();
		this.MIOACOEKBFL = base.StartCoroutine(this.ECPNOAKECBD());
	}

	// Token: 0x06003F1E RID: 16158 RVA: 0x0013EF50 File Offset: 0x0013D150
	private void DHFJNNAHOJC()
	{
		this.CCNILLAJIGG();
		this.MIOACOEKBFL = base.StartCoroutine(this.MBHEJEJAKMD());
	}

	// Token: 0x06003F1F RID: 16159 RVA: 0x0013EF6C File Offset: 0x0013D16C
	public bool KIFHKLOANNP()
	{
		return this.<DCAPNNPGEMN>k__BackingField;
	}

	// Token: 0x06003F20 RID: 16160 RVA: 0x0013EF74 File Offset: 0x0013D174
	public virtual Quaternion IDMOEPFEDGG()
	{
		if (this.MEOKHJEHNEP() || this.restTransform == null)
		{
			return base.NMNJGHKFNGM();
		}
		return this.restTransform.rotation;
	}

	// Token: 0x06003F21 RID: 16161 RVA: 0x0013EFA4 File Offset: 0x0013D1A4
	private IEnumerator BBFAINDOCGB()
	{
		num = 0f;
		while (!base.gameObject.activeSelf && num <= 0.5f)
		{
			yield return null;
			num += Time.deltaTime;
		}
		zero = Vector3.zero;
		zero2 = Vector3.zero;
		this.GGPILMKBGGN.ClearVelocity();
		num = 0f;
		this.GKMOCFANDOM = true;
		while (this.interpolateToRest && num < this.interpolateToRestDuration)
		{
			vector = Vector3.SmoothDamp(this.GGPILMKBGGN.CIGPHKLAAOD, this.KIJCBJAJPID, ref zero, this.interpolateToRestDuration);
			eulerAngles = this.INMMPMMNFJF.eulerAngles;
			eulerAngles2 = base.transform.rotation.eulerAngles;
			eulerAngles2.x = Mathf.SmoothDampAngle(eulerAngles2.x, eulerAngles.x, ref zero2.x, this.interpolateToRestDuration);
			eulerAngles2.y = Mathf.SmoothDampAngle(eulerAngles2.y, eulerAngles.y, ref zero2.y, this.interpolateToRestDuration);
			eulerAngles2.z = Mathf.SmoothDampAngle(eulerAngles2.z, eulerAngles.z, ref zero2.z, this.interpolateToRestDuration);
			quaternion = Quaternion.Euler(eulerAngles2);
			base.JMDOMAJBNEH(vector, quaternion);
			this.GGPILMKBGGN.ClearVelocity();
			yield return new WaitForFixedUpdate();
			num += Time.fixedDeltaTime;
		}
		this.GKMOCFANDOM = false;
		if (this.LIFJHLPBPOE != null)
		{
			this.LIFJHLPBPOE();
		}
		for (;;)
		{
			yield return new WaitForFixedUpdate();
			base.JMDOMAJBNEH(this.KIJCBJAJPID, this.INMMPMMNFJF);
		}
		yield break;
	}

	// Token: 0x06003F22 RID: 16162 RVA: 0x0013EFC0 File Offset: 0x0013D1C0
	private void BCABDNIFPBA()
	{
		if (this.MIOACOEKBFL != null)
		{
			base.StopCoroutine(this.MIOACOEKBFL);
		}
	}

	// Token: 0x06003F23 RID: 16163 RVA: 0x0013EFDC File Offset: 0x0013D1DC
	private void HHEDHCCMPDK()
	{
		if (this.MIOACOEKBFL != null)
		{
			base.StopCoroutine(this.MIOACOEKBFL);
		}
	}

	// Token: 0x06003F24 RID: 16164 RVA: 0x0013EFF8 File Offset: 0x0013D1F8
	protected virtual void JJEKHMENJFE()
	{
		base.FIDMEJHMGJI();
		this.ModifyKinematicOnPickupRelease = true;
	}

	// Token: 0x06003F25 RID: 16165 RVA: 0x0013F008 File Offset: 0x0013D208
	public void CNBEHBJACKK()
	{
		this.OFPBFFAKPAA();
	}

	// Token: 0x06003F26 RID: 16166 RVA: 0x0013F010 File Offset: 0x0013D210
	protected virtual void IDFGKJHJBLA()
	{
		base.NGHJFABFAOA();
		this.ModifyKinematicOnPickupRelease = false;
	}

	// Token: 0x06003F27 RID: 16167 RVA: 0x0013F020 File Offset: 0x0013D220
	public void FPNBBNPFHPP()
	{
		this.OFPBFFAKPAA();
	}

	// Token: 0x06003F28 RID: 16168 RVA: 0x0013F028 File Offset: 0x0013D228
	public bool KAGCLJFJHAP()
	{
		return this.<DCAPNNPGEMN>k__BackingField;
	}

	// Token: 0x06003F29 RID: 16169 RVA: 0x0013F030 File Offset: 0x0013D230
	public Transform FCMEMJIBBIB()
	{
		return this.restTransform;
	}

	// Token: 0x06003F2A RID: 16170 RVA: 0x0013F038 File Offset: 0x0013D238
	public Transform GPJNOFHNCFL()
	{
		return this.restTransform;
	}

	// Token: 0x06003F2B RID: 16171 RVA: 0x0013F040 File Offset: 0x0013D240
	protected void KIFBKDJCCKN(bool NOBAPCOKFIL)
	{
		this.<DCAPNNPGEMN>k__BackingField = NOBAPCOKFIL;
	}

	// Token: 0x06003F2C RID: 16172 RVA: 0x0013F04C File Offset: 0x0013D24C
	private IEnumerator PBHEKFEDACM()
	{
		num = 0f;
		while (!base.gameObject.activeSelf && num <= 0.5f)
		{
			yield return null;
			num += Time.deltaTime;
		}
		zero = Vector3.zero;
		zero2 = Vector3.zero;
		this.GGPILMKBGGN.ClearVelocity();
		num = 0f;
		this.GKMOCFANDOM = true;
		while (this.interpolateToRest && num < this.interpolateToRestDuration)
		{
			vector = Vector3.SmoothDamp(this.GGPILMKBGGN.CIGPHKLAAOD, this.KIJCBJAJPID, ref zero, this.interpolateToRestDuration);
			eulerAngles = this.INMMPMMNFJF.eulerAngles;
			eulerAngles2 = base.transform.rotation.eulerAngles;
			eulerAngles2.x = Mathf.SmoothDampAngle(eulerAngles2.x, eulerAngles.x, ref zero2.x, this.interpolateToRestDuration);
			eulerAngles2.y = Mathf.SmoothDampAngle(eulerAngles2.y, eulerAngles.y, ref zero2.y, this.interpolateToRestDuration);
			eulerAngles2.z = Mathf.SmoothDampAngle(eulerAngles2.z, eulerAngles.z, ref zero2.z, this.interpolateToRestDuration);
			quaternion = Quaternion.Euler(eulerAngles2);
			base.JMDOMAJBNEH(vector, quaternion);
			this.GGPILMKBGGN.ClearVelocity();
			yield return new WaitForFixedUpdate();
			num += Time.fixedDeltaTime;
		}
		this.GKMOCFANDOM = false;
		if (this.LIFJHLPBPOE != null)
		{
			this.LIFJHLPBPOE();
		}
		for (;;)
		{
			yield return new WaitForFixedUpdate();
			base.JMDOMAJBNEH(this.KIJCBJAJPID, this.INMMPMMNFJF);
		}
		yield break;
	}

	// Token: 0x06003F2D RID: 16173 RVA: 0x0013F068 File Offset: 0x0013D268
	public virtual Vector3 KMPANEOCMNM()
	{
		if (this.MEOKHJEHNEP() || this.restTransform == null)
		{
			return base.HIHHOENBMEF();
		}
		return this.restTransform.position;
	}

	// Token: 0x06003F2E RID: 16174 RVA: 0x0013F098 File Offset: 0x0013D298
	public Transform CPPABIHPEMA()
	{
		return this.restTransform;
	}

	// Token: 0x06003F2F RID: 16175 RVA: 0x0013F0A0 File Offset: 0x0013D2A0
	private void OIGECOECCBD()
	{
		if (this.MIOACOEKBFL != null)
		{
			base.StopCoroutine(this.MIOACOEKBFL);
		}
	}

	// Token: 0x06003F30 RID: 16176 RVA: 0x0013F0BC File Offset: 0x0013D2BC
	public void HCLABIBGBCL(Action NOBAPCOKFIL)
	{
		Action action = this.LIFJHLPBPOE;
		Action action2;
		do
		{
			action2 = action;
			action = Interlocked.CompareExchange<Action>(ref this.LIFJHLPBPOE, (Action)Delegate.Combine(action2, NOBAPCOKFIL), action);
		}
		while (action != action2);
	}

	// Token: 0x06003F31 RID: 16177 RVA: 0x0013F0F4 File Offset: 0x0013D2F4
	private IEnumerator MBHEJEJAKMD()
	{
		num = 0f;
		while (!base.gameObject.activeSelf && num <= 0.5f)
		{
			yield return null;
			num += Time.deltaTime;
		}
		zero = Vector3.zero;
		zero2 = Vector3.zero;
		this.GGPILMKBGGN.ClearVelocity();
		num = 0f;
		this.GKMOCFANDOM = true;
		while (this.interpolateToRest && num < this.interpolateToRestDuration)
		{
			vector = Vector3.SmoothDamp(this.GGPILMKBGGN.CIGPHKLAAOD, this.KIJCBJAJPID, ref zero, this.interpolateToRestDuration);
			eulerAngles = this.INMMPMMNFJF.eulerAngles;
			eulerAngles2 = base.transform.rotation.eulerAngles;
			eulerAngles2.x = Mathf.SmoothDampAngle(eulerAngles2.x, eulerAngles.x, ref zero2.x, this.interpolateToRestDuration);
			eulerAngles2.y = Mathf.SmoothDampAngle(eulerAngles2.y, eulerAngles.y, ref zero2.y, this.interpolateToRestDuration);
			eulerAngles2.z = Mathf.SmoothDampAngle(eulerAngles2.z, eulerAngles.z, ref zero2.z, this.interpolateToRestDuration);
			quaternion = Quaternion.Euler(eulerAngles2);
			base.JMDOMAJBNEH(vector, quaternion);
			this.GGPILMKBGGN.ClearVelocity();
			yield return new WaitForFixedUpdate();
			num += Time.fixedDeltaTime;
		}
		this.GKMOCFANDOM = false;
		if (this.LIFJHLPBPOE != null)
		{
			this.LIFJHLPBPOE();
		}
		for (;;)
		{
			yield return new WaitForFixedUpdate();
			base.JMDOMAJBNEH(this.KIJCBJAJPID, this.INMMPMMNFJF);
		}
		yield break;
	}

	// Token: 0x06003F32 RID: 16178 RVA: 0x0013F110 File Offset: 0x0013D310
	public void NPPOBLJOAEC(Action NOBAPCOKFIL)
	{
		Action action = this.LIFJHLPBPOE;
		Action action2;
		do
		{
			action2 = action;
			action = Interlocked.CompareExchange<Action>(ref this.LIFJHLPBPOE, (Action)Delegate.Remove(action2, NOBAPCOKFIL), action);
		}
		while (action != action2);
	}

	// Token: 0x06003F33 RID: 16179 RVA: 0x0013F148 File Offset: 0x0013D348
	public virtual void FFMENJFIKEO(Transform MMEBLCBANIL, Vector3 KOFPGEFEDDH, Quaternion KKKJMGGKNPG)
	{
		base.FILMFKIEBCJ(MMEBLCBANIL, KOFPGEFEDDH, KKKJMGGKNPG);
		this.KAEOKPMPKJA();
	}

	// Token: 0x06003F34 RID: 16180 RVA: 0x0013F15C File Offset: 0x0013D35C
	private void DLBEAAPEFJE()
	{
		if (this.MIOACOEKBFL != null)
		{
			base.StopCoroutine(this.MIOACOEKBFL);
		}
	}

	// Token: 0x06003F35 RID: 16181 RVA: 0x0013F178 File Offset: 0x0013D378
	private void ENNGONOILMC()
	{
		if (this.MIOACOEKBFL != null)
		{
			base.StopCoroutine(this.MIOACOEKBFL);
		}
	}

	// Token: 0x06003F36 RID: 16182 RVA: 0x0013F194 File Offset: 0x0013D394
	private IEnumerator MGOLIDDPKJP()
	{
		num = 0f;
		while (!base.gameObject.activeSelf && num <= 0.5f)
		{
			yield return null;
			num += Time.deltaTime;
		}
		zero = Vector3.zero;
		zero2 = Vector3.zero;
		this.GGPILMKBGGN.ClearVelocity();
		num = 0f;
		this.GKMOCFANDOM = true;
		while (this.interpolateToRest && num < this.interpolateToRestDuration)
		{
			vector = Vector3.SmoothDamp(this.GGPILMKBGGN.CIGPHKLAAOD, this.KIJCBJAJPID, ref zero, this.interpolateToRestDuration);
			eulerAngles = this.INMMPMMNFJF.eulerAngles;
			eulerAngles2 = base.transform.rotation.eulerAngles;
			eulerAngles2.x = Mathf.SmoothDampAngle(eulerAngles2.x, eulerAngles.x, ref zero2.x, this.interpolateToRestDuration);
			eulerAngles2.y = Mathf.SmoothDampAngle(eulerAngles2.y, eulerAngles.y, ref zero2.y, this.interpolateToRestDuration);
			eulerAngles2.z = Mathf.SmoothDampAngle(eulerAngles2.z, eulerAngles.z, ref zero2.z, this.interpolateToRestDuration);
			quaternion = Quaternion.Euler(eulerAngles2);
			base.JMDOMAJBNEH(vector, quaternion);
			this.GGPILMKBGGN.ClearVelocity();
			yield return new WaitForFixedUpdate();
			num += Time.fixedDeltaTime;
		}
		this.GKMOCFANDOM = false;
		if (this.LIFJHLPBPOE != null)
		{
			this.LIFJHLPBPOE();
		}
		for (;;)
		{
			yield return new WaitForFixedUpdate();
			base.JMDOMAJBNEH(this.KIJCBJAJPID, this.INMMPMMNFJF);
		}
		yield break;
	}

	// Token: 0x06003F37 RID: 16183 RVA: 0x0013F1B0 File Offset: 0x0013D3B0
	public bool GOCMAPHLDOP()
	{
		return this.<DCAPNNPGEMN>k__BackingField;
	}

	// Token: 0x06003F38 RID: 16184 RVA: 0x0013F1B8 File Offset: 0x0013D3B8
	private void GECKGFGGNBM()
	{
		this.CCNILLAJIGG();
		this.MIOACOEKBFL = base.StartCoroutine(this.MBHEJEJAKMD());
	}

	// Token: 0x06003F39 RID: 16185 RVA: 0x0013F1D4 File Offset: 0x0013D3D4
	public void GAKAJKGEMEH()
	{
		this.BHCIFOGHHHP();
	}

	// Token: 0x06003F3A RID: 16186 RVA: 0x0013F1DC File Offset: 0x0013D3DC
	protected void DPHHOGFHHDP(bool NOBAPCOKFIL)
	{
		this.<DCAPNNPGEMN>k__BackingField = NOBAPCOKFIL;
	}

	// Token: 0x06003F3B RID: 16187 RVA: 0x0013F1E8 File Offset: 0x0013D3E8
	public void FIJFHDLHGEN(Action NOBAPCOKFIL)
	{
		Action action = this.LIFJHLPBPOE;
		Action action2;
		do
		{
			action2 = action;
			action = Interlocked.CompareExchange<Action>(ref this.LIFJHLPBPOE, (Action)Delegate.Remove(action2, NOBAPCOKFIL), action);
		}
		while (action != action2);
	}

	// Token: 0x06003F3C RID: 16188 RVA: 0x0013F220 File Offset: 0x0013D420
	public void MLAPFJFODGN(Action NOBAPCOKFIL)
	{
		Action action = this.LIFJHLPBPOE;
		Action action2;
		do
		{
			action2 = action;
			action = Interlocked.CompareExchange<Action>(ref this.LIFJHLPBPOE, (Action)Delegate.Remove(action2, NOBAPCOKFIL), action);
		}
		while (action != action2);
	}

	// Token: 0x06003F3D RID: 16189 RVA: 0x0013F258 File Offset: 0x0013D458
	public virtual Quaternion EMPEJHCLIHF()
	{
		if (this.MEMOPCOHPLE || this.restTransform == null)
		{
			return base.INMMPMMNFJF;
		}
		return this.restTransform.rotation;
	}

	// Token: 0x06003F3E RID: 16190 RVA: 0x0013F288 File Offset: 0x0013D488
	private void OFMNNAOAONJ()
	{
		this.DLBEAAPEFJE();
		this.MIOACOEKBFL = base.StartCoroutine(this.HAGEFOJOPOH());
	}

	// Token: 0x06003F3F RID: 16191 RVA: 0x0013F2A4 File Offset: 0x0013D4A4
	private void MLHLCPNHIIL()
	{
		this.DLBEAAPEFJE();
		this.MIOACOEKBFL = base.StartCoroutine(this.HAGEFOJOPOH());
	}

	// Token: 0x06003F40 RID: 16192 RVA: 0x0013F2C0 File Offset: 0x0013D4C0
	public override void Pickup(Transform MMEBLCBANIL, Vector3 KOFPGEFEDDH, Quaternion KKKJMGGKNPG)
	{
		base.Pickup(MMEBLCBANIL, KOFPGEFEDDH, KKKJMGGKNPG);
		this.DLBEAAPEFJE();
	}

	// Token: 0x06003F41 RID: 16193 RVA: 0x0013F2D4 File Offset: 0x0013D4D4
	protected override void Awake()
	{
		base.Awake();
		this.ModifyKinematicOnPickupRelease = false;
	}

	// Token: 0x06003F42 RID: 16194 RVA: 0x0013F2E4 File Offset: 0x0013D4E4
	public void ODHIMCOMOHN()
	{
		this.OFMNNAOAONJ();
	}

	// Token: 0x06003F43 RID: 16195 RVA: 0x0013F2EC File Offset: 0x0013D4EC
	public virtual Quaternion AJNNPBPIFML()
	{
		if (this.DIGCFIAANFF() || this.restTransform == null)
		{
			return base.IHKIDKCPIHL();
		}
		return this.restTransform.rotation;
	}

	// Token: 0x06003F44 RID: 16196 RVA: 0x0013F31C File Offset: 0x0013D51C
	private void COLLNOIPMJF()
	{
		this.ILOMOCJPNLA();
		this.MIOACOEKBFL = base.StartCoroutine(this.MGOLIDDPKJP());
	}

	// Token: 0x06003F45 RID: 16197 RVA: 0x0013F338 File Offset: 0x0013D538
	public virtual Quaternion KACELJAPLEN()
	{
		if (this.DIGCFIAANFF() || this.restTransform == null)
		{
			return base.NMNJGHKFNGM();
		}
		return this.restTransform.rotation;
	}

	// Token: 0x06003F46 RID: 16198 RVA: 0x0013F368 File Offset: 0x0013D568
	public Transform AFLIKFMPGKK()
	{
		return this.restTransform;
	}

	// Token: 0x06003F47 RID: 16199 RVA: 0x0013F370 File Offset: 0x0013D570
	private void BJLOIBIHACK()
	{
		if (this.MIOACOEKBFL != null)
		{
			base.StopCoroutine(this.MIOACOEKBFL);
		}
	}

	// Token: 0x06003F48 RID: 16200 RVA: 0x0013F38C File Offset: 0x0013D58C
	public Transform HBAOKHGCFMC()
	{
		return this.restTransform;
	}

	// Token: 0x06003F49 RID: 16201 RVA: 0x0013F394 File Offset: 0x0013D594
	public Transform OLGLGOLPOLG()
	{
		return this.restTransform;
	}

	// Token: 0x06003F4A RID: 16202 RVA: 0x0013F39C File Offset: 0x0013D59C
	private IEnumerator FMNNMNJLPOK()
	{
		num = 0f;
		while (!base.gameObject.activeSelf && num <= 0.5f)
		{
			yield return null;
			num += Time.deltaTime;
		}
		zero = Vector3.zero;
		zero2 = Vector3.zero;
		this.GGPILMKBGGN.ClearVelocity();
		num = 0f;
		this.GKMOCFANDOM = true;
		while (this.interpolateToRest && num < this.interpolateToRestDuration)
		{
			vector = Vector3.SmoothDamp(this.GGPILMKBGGN.CIGPHKLAAOD, this.KIJCBJAJPID, ref zero, this.interpolateToRestDuration);
			eulerAngles = this.INMMPMMNFJF.eulerAngles;
			eulerAngles2 = base.transform.rotation.eulerAngles;
			eulerAngles2.x = Mathf.SmoothDampAngle(eulerAngles2.x, eulerAngles.x, ref zero2.x, this.interpolateToRestDuration);
			eulerAngles2.y = Mathf.SmoothDampAngle(eulerAngles2.y, eulerAngles.y, ref zero2.y, this.interpolateToRestDuration);
			eulerAngles2.z = Mathf.SmoothDampAngle(eulerAngles2.z, eulerAngles.z, ref zero2.z, this.interpolateToRestDuration);
			quaternion = Quaternion.Euler(eulerAngles2);
			base.JMDOMAJBNEH(vector, quaternion);
			this.GGPILMKBGGN.ClearVelocity();
			yield return new WaitForFixedUpdate();
			num += Time.fixedDeltaTime;
		}
		this.GKMOCFANDOM = false;
		if (this.LIFJHLPBPOE != null)
		{
			this.LIFJHLPBPOE();
		}
		for (;;)
		{
			yield return new WaitForFixedUpdate();
			base.JMDOMAJBNEH(this.KIJCBJAJPID, this.INMMPMMNFJF);
		}
		yield break;
	}

	// Token: 0x06003F4B RID: 16203 RVA: 0x0013F3B8 File Offset: 0x0013D5B8
	private void IMFOKGMJHIO()
	{
		this.DLBEAAPEFJE();
		this.MIOACOEKBFL = base.StartCoroutine(this.MIMKCMKMLII());
	}

	// Token: 0x06003F4C RID: 16204 RVA: 0x0013F3D4 File Offset: 0x0013D5D4
	protected virtual void OEHDEPBJFAB()
	{
		base.BGJEJHLKNKA();
		this.ModifyKinematicOnPickupRelease = true;
	}

	// Token: 0x06003F4D RID: 16205 RVA: 0x0013F3E4 File Offset: 0x0013D5E4
	protected virtual void EGPCNMCCHNL()
	{
		base.Awake();
		this.ModifyKinematicOnPickupRelease = true;
	}

	// Token: 0x06003F4E RID: 16206 RVA: 0x0013F3F4 File Offset: 0x0013D5F4
	private IEnumerator HAGEFOJOPOH()
	{
		num = 0f;
		while (!base.gameObject.activeSelf && num <= 0.5f)
		{
			yield return null;
			num += Time.deltaTime;
		}
		zero = Vector3.zero;
		zero2 = Vector3.zero;
		this.GGPILMKBGGN.ClearVelocity();
		num = 0f;
		this.GKMOCFANDOM = true;
		while (this.interpolateToRest && num < this.interpolateToRestDuration)
		{
			vector = Vector3.SmoothDamp(this.GGPILMKBGGN.CIGPHKLAAOD, this.KIJCBJAJPID, ref zero, this.interpolateToRestDuration);
			eulerAngles = this.INMMPMMNFJF.eulerAngles;
			eulerAngles2 = base.transform.rotation.eulerAngles;
			eulerAngles2.x = Mathf.SmoothDampAngle(eulerAngles2.x, eulerAngles.x, ref zero2.x, this.interpolateToRestDuration);
			eulerAngles2.y = Mathf.SmoothDampAngle(eulerAngles2.y, eulerAngles.y, ref zero2.y, this.interpolateToRestDuration);
			eulerAngles2.z = Mathf.SmoothDampAngle(eulerAngles2.z, eulerAngles.z, ref zero2.z, this.interpolateToRestDuration);
			quaternion = Quaternion.Euler(eulerAngles2);
			base.JMDOMAJBNEH(vector, quaternion);
			this.GGPILMKBGGN.ClearVelocity();
			yield return new WaitForFixedUpdate();
			num += Time.fixedDeltaTime;
		}
		this.GKMOCFANDOM = false;
		if (this.LIFJHLPBPOE != null)
		{
			this.LIFJHLPBPOE();
		}
		for (;;)
		{
			yield return new WaitForFixedUpdate();
			base.JMDOMAJBNEH(this.KIJCBJAJPID, this.INMMPMMNFJF);
		}
		yield break;
	}

	// Token: 0x06003F4F RID: 16207 RVA: 0x0013F410 File Offset: 0x0013D610
	public bool JKOPBJCCCKG()
	{
		return this.<DCAPNNPGEMN>k__BackingField;
	}

	// Token: 0x06003F50 RID: 16208 RVA: 0x0013F418 File Offset: 0x0013D618
	private void FCKFIIBDNEE()
	{
		if (this.MIOACOEKBFL != null)
		{
			base.StopCoroutine(this.MIOACOEKBFL);
		}
	}

	// Token: 0x06003F51 RID: 16209 RVA: 0x0013F434 File Offset: 0x0013D634
	public void HBKCNIEPEFF(Action NOBAPCOKFIL)
	{
		Action action = this.LIFJHLPBPOE;
		Action action2;
		do
		{
			action2 = action;
			action = Interlocked.CompareExchange<Action>(ref this.LIFJHLPBPOE, (Action)Delegate.Combine(action2, NOBAPCOKFIL), action);
		}
		while (action != action2);
	}

	// Token: 0x06003F52 RID: 16210 RVA: 0x0013F46C File Offset: 0x0013D66C
	public void KELBMDKFBBG()
	{
		this.KHBBBPCHHBB();
	}

	// Token: 0x06003F53 RID: 16211 RVA: 0x0013F474 File Offset: 0x0013D674
	private IEnumerator MIMKCMKMLII()
	{
		num = 0f;
		while (!base.gameObject.activeSelf && num <= 0.5f)
		{
			yield return null;
			num += Time.deltaTime;
		}
		zero = Vector3.zero;
		zero2 = Vector3.zero;
		this.GGPILMKBGGN.ClearVelocity();
		num = 0f;
		this.GKMOCFANDOM = true;
		while (this.interpolateToRest && num < this.interpolateToRestDuration)
		{
			vector = Vector3.SmoothDamp(this.GGPILMKBGGN.CIGPHKLAAOD, this.KIJCBJAJPID, ref zero, this.interpolateToRestDuration);
			eulerAngles = this.INMMPMMNFJF.eulerAngles;
			eulerAngles2 = base.transform.rotation.eulerAngles;
			eulerAngles2.x = Mathf.SmoothDampAngle(eulerAngles2.x, eulerAngles.x, ref zero2.x, this.interpolateToRestDuration);
			eulerAngles2.y = Mathf.SmoothDampAngle(eulerAngles2.y, eulerAngles.y, ref zero2.y, this.interpolateToRestDuration);
			eulerAngles2.z = Mathf.SmoothDampAngle(eulerAngles2.z, eulerAngles.z, ref zero2.z, this.interpolateToRestDuration);
			quaternion = Quaternion.Euler(eulerAngles2);
			base.JMDOMAJBNEH(vector, quaternion);
			this.GGPILMKBGGN.ClearVelocity();
			yield return new WaitForFixedUpdate();
			num += Time.fixedDeltaTime;
		}
		this.GKMOCFANDOM = false;
		if (this.LIFJHLPBPOE != null)
		{
			this.LIFJHLPBPOE();
		}
		for (;;)
		{
			yield return new WaitForFixedUpdate();
			base.JMDOMAJBNEH(this.KIJCBJAJPID, this.INMMPMMNFJF);
		}
		yield break;
	}

	// Token: 0x06003F54 RID: 16212 RVA: 0x0013F490 File Offset: 0x0013D690
	public virtual Vector3 AAJCCKPMOPB()
	{
		if (this.DIGCFIAANFF() || this.restTransform == null)
		{
			return base.JAAGAOBMHGM();
		}
		return this.restTransform.position;
	}

	// Token: 0x06003F55 RID: 16213 RVA: 0x0013F4C0 File Offset: 0x0013D6C0
	protected void CBHHHFDIBDO(bool NOBAPCOKFIL)
	{
		this.<DCAPNNPGEMN>k__BackingField = NOBAPCOKFIL;
	}

	// Token: 0x06003F56 RID: 16214 RVA: 0x0013F4CC File Offset: 0x0013D6CC
	public Transform MHIIMKJPPHO()
	{
		return this.restTransform;
	}

	// Token: 0x06003F57 RID: 16215 RVA: 0x0013F4D4 File Offset: 0x0013D6D4
	public virtual void IHMHAAJNJDI(Transform MMEBLCBANIL, Vector3 KOFPGEFEDDH, Quaternion KKKJMGGKNPG)
	{
		base.INNIMLIDAKN(MMEBLCBANIL, KOFPGEFEDDH, KKKJMGGKNPG);
		this.DLBEAAPEFJE();
	}

	// Token: 0x06003F58 RID: 16216 RVA: 0x0013F4E8 File Offset: 0x0013D6E8
	public bool LJOOAAOGDNF()
	{
		return this.<DCAPNNPGEMN>k__BackingField;
	}

	// Token: 0x06003F59 RID: 16217 RVA: 0x0013F4F0 File Offset: 0x0013D6F0
	private void ILOMOCJPNLA()
	{
		if (this.MIOACOEKBFL != null)
		{
			base.StopCoroutine(this.MIOACOEKBFL);
		}
	}

	// Token: 0x06003F5A RID: 16218 RVA: 0x0013F50C File Offset: 0x0013D70C
	private void CKDOOABNAON()
	{
		if (this.MIOACOEKBFL != null)
		{
			base.StopCoroutine(this.MIOACOEKBFL);
		}
	}

	// Token: 0x06003F5B RID: 16219 RVA: 0x0013F528 File Offset: 0x0013D728
	private void OJHBJOHMMBE()
	{
		if (this.MIOACOEKBFL != null)
		{
			base.StopCoroutine(this.MIOACOEKBFL);
		}
	}

	// Token: 0x06003F5C RID: 16220 RVA: 0x0013F544 File Offset: 0x0013D744
	public virtual Vector3 BKCNKDGBOCD()
	{
		if (this.DIGCFIAANFF() || this.restTransform == null)
		{
			return base.KDKOBKDCHHD();
		}
		return this.restTransform.position;
	}

	// Token: 0x06003F5D RID: 16221 RVA: 0x0013F574 File Offset: 0x0013D774
	public Transform EODPEGJOKLH()
	{
		return this.restTransform;
	}

	// Token: 0x06003F5E RID: 16222 RVA: 0x0013F57C File Offset: 0x0013D77C
	public void Retract()
	{
		this.MLHLCPNHIIL();
	}

	// Token: 0x06003F5F RID: 16223 RVA: 0x0013F584 File Offset: 0x0013D784
	private void NOFKFLLBKIG()
	{
		if (this.MIOACOEKBFL != null)
		{
			base.StopCoroutine(this.MIOACOEKBFL);
		}
	}

	// Token: 0x06003F60 RID: 16224 RVA: 0x0013F5A0 File Offset: 0x0013D7A0
	private void BHJPOPJIOKN()
	{
		this.HHEDHCCMPDK();
		this.MIOACOEKBFL = base.StartCoroutine(this.MGOLIDDPKJP());
	}

	// Token: 0x06003F61 RID: 16225 RVA: 0x0013F5BC File Offset: 0x0013D7BC
	private void BHCIFOGHHHP()
	{
		this.OJHBJOHMMBE();
		this.MIOACOEKBFL = base.StartCoroutine(this.OPDPPIBOKBH());
	}

	// Token: 0x06003F62 RID: 16226 RVA: 0x0013F5D8 File Offset: 0x0013D7D8
	public virtual Vector3 EMOMGBODBNE()
	{
		if (this.MEMOPCOHPLE || this.restTransform == null)
		{
			return base.KDKOBKDCHHD();
		}
		return this.restTransform.position;
	}

	// Token: 0x06003F63 RID: 16227 RVA: 0x0013F608 File Offset: 0x0013D808
	public void IPHMEKNHJFM(Action NOBAPCOKFIL)
	{
		Action action = this.LIFJHLPBPOE;
		Action action2;
		do
		{
			action2 = action;
			action = Interlocked.CompareExchange<Action>(ref this.LIFJHLPBPOE, (Action)Delegate.Remove(action2, NOBAPCOKFIL), action);
		}
		while (action != action2);
	}

	// Token: 0x06003F64 RID: 16228 RVA: 0x0013F640 File Offset: 0x0013D840
	protected virtual void DDDJHGJFIJL()
	{
		base.NGHJFABFAOA();
		this.ModifyKinematicOnPickupRelease = true;
	}

	// Token: 0x06003F65 RID: 16229 RVA: 0x0013F650 File Offset: 0x0013D850
	private void IMKPCHENNLE()
	{
		this.FCKFIIBDNEE();
		this.MIOACOEKBFL = base.StartCoroutine(this.GKHFMLAIFHJ());
	}

	// Token: 0x06003F66 RID: 16230 RVA: 0x0013F66C File Offset: 0x0013D86C
	protected void JJHKGJHHLPK(bool NOBAPCOKFIL)
	{
		this.<DCAPNNPGEMN>k__BackingField = NOBAPCOKFIL;
	}

	// Token: 0x06003F67 RID: 16231 RVA: 0x0013F678 File Offset: 0x0013D878
	public virtual Vector3 NBBCOBJMJOP()
	{
		if (this.DIGCFIAANFF() || this.restTransform == null)
		{
			return base.OBFEPECKPGH();
		}
		return this.restTransform.position;
	}

	// Token: 0x06003F68 RID: 16232 RVA: 0x0013F6A8 File Offset: 0x0013D8A8
	private IEnumerator OPDPPIBOKBH()
	{
		num = 0f;
		while (!base.gameObject.activeSelf && num <= 0.5f)
		{
			yield return null;
			num += Time.deltaTime;
		}
		zero = Vector3.zero;
		zero2 = Vector3.zero;
		this.GGPILMKBGGN.ClearVelocity();
		num = 0f;
		this.GKMOCFANDOM = true;
		while (this.interpolateToRest && num < this.interpolateToRestDuration)
		{
			vector = Vector3.SmoothDamp(this.GGPILMKBGGN.CIGPHKLAAOD, this.KIJCBJAJPID, ref zero, this.interpolateToRestDuration);
			eulerAngles = this.INMMPMMNFJF.eulerAngles;
			eulerAngles2 = base.transform.rotation.eulerAngles;
			eulerAngles2.x = Mathf.SmoothDampAngle(eulerAngles2.x, eulerAngles.x, ref zero2.x, this.interpolateToRestDuration);
			eulerAngles2.y = Mathf.SmoothDampAngle(eulerAngles2.y, eulerAngles.y, ref zero2.y, this.interpolateToRestDuration);
			eulerAngles2.z = Mathf.SmoothDampAngle(eulerAngles2.z, eulerAngles.z, ref zero2.z, this.interpolateToRestDuration);
			quaternion = Quaternion.Euler(eulerAngles2);
			base.JMDOMAJBNEH(vector, quaternion);
			this.GGPILMKBGGN.ClearVelocity();
			yield return new WaitForFixedUpdate();
			num += Time.fixedDeltaTime;
		}
		this.GKMOCFANDOM = false;
		if (this.LIFJHLPBPOE != null)
		{
			this.LIFJHLPBPOE();
		}
		for (;;)
		{
			yield return new WaitForFixedUpdate();
			base.JMDOMAJBNEH(this.KIJCBJAJPID, this.INMMPMMNFJF);
		}
		yield break;
	}

	// Token: 0x06003F6A RID: 16234 RVA: 0x0013F6E0 File Offset: 0x0013D8E0
	protected virtual void BKHPHJMIDFO()
	{
		base.ACOIMDMPDOM();
		this.ModifyKinematicOnPickupRelease = true;
	}

	// Token: 0x06003F6B RID: 16235 RVA: 0x0013F6F0 File Offset: 0x0013D8F0
	public void BOOHNEHOMEJ(Action NOBAPCOKFIL)
	{
		Action action = this.LIFJHLPBPOE;
		Action action2;
		do
		{
			action2 = action;
			action = Interlocked.CompareExchange<Action>(ref this.LIFJHLPBPOE, (Action)Delegate.Combine(action2, NOBAPCOKFIL), action);
		}
		while (action != action2);
	}

	// Token: 0x06003F6C RID: 16236 RVA: 0x0013F728 File Offset: 0x0013D928
	public bool EMKBDJPPCJF()
	{
		return this.<DCAPNNPGEMN>k__BackingField;
	}

	// Token: 0x06003F6D RID: 16237 RVA: 0x0013F730 File Offset: 0x0013D930
	private void MLACADCOKJO()
	{
		if (this.MIOACOEKBFL != null)
		{
			base.StopCoroutine(this.MIOACOEKBFL);
		}
	}

	// Token: 0x06003F6E RID: 16238 RVA: 0x0013F74C File Offset: 0x0013D94C
	protected virtual void KMEHAACNJAG()
	{
		base.ACOIMDMPDOM();
		this.ModifyKinematicOnPickupRelease = true;
	}

	// Token: 0x06003F6F RID: 16239 RVA: 0x0013F75C File Offset: 0x0013D95C
	public Transform LMHKDHNCCCF()
	{
		return this.restTransform;
	}

	// Token: 0x06003F70 RID: 16240 RVA: 0x0013F764 File Offset: 0x0013D964
	protected virtual void JLHHADIPOED()
	{
		base.ACOIMDMPDOM();
		this.ModifyKinematicOnPickupRelease = true;
	}

	// Token: 0x040007F2 RID: 2034
	[SerializeField]
	[Header("Retractable")]
	private bool interpolateToRest = true;

	// Token: 0x040007F3 RID: 2035
	[SerializeField]
	private float interpolateToRestDuration = 0.25f;

	// Token: 0x040007F4 RID: 2036
	[SerializeField]
	private Transform restTransform;

	// Token: 0x040007F5 RID: 2037
	private Coroutine MIOACOEKBFL;
}