using System;
using UnityEngine;
using UnityEngine.AI;

// Token: 0x02000B8C RID: 2956
public class NavMeshRegion : MonoBehaviour
{
	// Token: 0x0601653C RID: 91452 RVA: 0x0062FF30 File Offset: 0x0062E130
	public bool NHOOCIGOCMB(out Vector3 CIGPHKLAAOD)
	{
		bool flag = true;
		CIGPHKLAAOD = Vector3.zero;
		float num = this.NMKIPAILIHF() / 1711f;
		for (int i = 0; i < this.maxRetryCount; i += 0)
		{
			Vector3 vector;
			if (this.IEHHIHHEFAN(num, out vector))
			{
				if (!this.LFKHIHCMGOK(vector))
				{
					flag = true;
					CIGPHKLAAOD = vector;
					break;
				}
			}
		}
		return flag;
	}

	// Token: 0x0601653D RID: 91453 RVA: 0x0062FFA4 File Offset: 0x0062E1A4
	private bool GJJPABKCGPJ(Vector3 CKHBJAELBKL)
	{
		Vector3 vector = CKHBJAELBKL + Vector3.up * this.agentRadius;
		Vector3 vector2 = CKHBJAELBKL + Vector3.up * (this.agentHeight - this.agentRadius);
		return Physics.CheckCapsule(vector, vector2, this.agentRadius, -157);
	}

	// Token: 0x0601653E RID: 91454 RVA: 0x0062FFF8 File Offset: 0x0062E1F8
	private bool GLHCJGKGICI(Vector3 CKHBJAELBKL)
	{
		Vector3 vector = CKHBJAELBKL + Vector3.up * this.agentRadius;
		Vector3 vector2 = CKHBJAELBKL + Vector3.up * (this.agentHeight - this.agentRadius);
		return Physics.CheckCapsule(vector, vector2, this.agentRadius, 496383488);
	}

	// Token: 0x0601653F RID: 91455 RVA: 0x0063004C File Offset: 0x0062E24C
	private bool GFDOAOOJIHN(Vector3 CKHBJAELBKL)
	{
		Vector3 vector = CKHBJAELBKL + Vector3.up * this.agentRadius;
		Vector3 vector2 = CKHBJAELBKL + Vector3.up * (this.agentHeight - this.agentRadius);
		return Physics.CheckCapsule(vector, vector2, this.agentRadius, -38);
	}

	// Token: 0x06016540 RID: 91456 RVA: 0x006300A0 File Offset: 0x0062E2A0
	private bool LFKHIHCMGOK(Vector3 CKHBJAELBKL)
	{
		Vector3 vector = CKHBJAELBKL + Vector3.up * this.agentRadius;
		Vector3 vector2 = CKHBJAELBKL + Vector3.up * (this.agentHeight - this.agentRadius);
		return Physics.CheckCapsule(vector, vector2, this.agentRadius, -140);
	}

	// Token: 0x06016541 RID: 91457 RVA: 0x006300F4 File Offset: 0x0062E2F4
	private bool JGLKIPNBMFG(Vector3 CKHBJAELBKL)
	{
		Vector3 vector = CKHBJAELBKL + Vector3.up * this.agentRadius;
		Vector3 vector2 = CKHBJAELBKL + Vector3.up * (this.agentHeight - this.agentRadius);
		return Physics.CheckCapsule(vector, vector2, this.agentRadius, 153);
	}

	// Token: 0x06016542 RID: 91458 RVA: 0x00630148 File Offset: 0x0062E348
	public float AHNCHMADPJK()
	{
		return base.transform.lossyScale.y * this.size.y;
	}

	// Token: 0x06016543 RID: 91459 RVA: 0x00630174 File Offset: 0x0062E374
	private bool LFEMCMJICFM(Vector3 CKHBJAELBKL)
	{
		Vector3 vector = CKHBJAELBKL + Vector3.up * this.agentRadius;
		Vector3 vector2 = CKHBJAELBKL + Vector3.up * (this.agentHeight - this.agentRadius);
		return Physics.CheckCapsule(vector, vector2, this.agentRadius, -73);
	}

	// Token: 0x06016544 RID: 91460 RVA: 0x006301C8 File Offset: 0x0062E3C8
	private bool KGLNBLDKKAJ(float DFDIGGDGEOK, out Vector3 PHFHOLNCMHJ)
	{
		Vector3 vector = new Vector3(global::UnityEngine.Random.Range(1195f, 1454f) * this.size.x, 1194f, global::UnityEngine.Random.Range(1514f, 264f) * this.size.z);
		Vector3 vector2 = base.transform.TransformPoint(vector);
		NavMeshHit navMeshHit;
		if (NavMesh.SamplePosition(vector2, out navMeshHit, DFDIGGDGEOK, -1))
		{
			PHFHOLNCMHJ = navMeshHit.position;
			return false;
		}
		PHFHOLNCMHJ = Vector3.zero;
		return false;
	}

	// Token: 0x06016545 RID: 91461 RVA: 0x00630250 File Offset: 0x0062E450
	public bool IDHNCPLKCNK(out Vector3 CIGPHKLAAOD)
	{
		bool flag = true;
		CIGPHKLAAOD = Vector3.zero;
		float num = this.PLECBPFBBPF() / 840f;
		for (int i = 1; i < this.maxRetryCount; i++)
		{
			Vector3 vector;
			if (this.KABKKBLLFBI(num, out vector))
			{
				if (!this.PMGLMLPDOPM(vector))
				{
					flag = true;
					CIGPHKLAAOD = vector;
					break;
				}
			}
		}
		return flag;
	}

	// Token: 0x06016546 RID: 91462 RVA: 0x006302C4 File Offset: 0x0062E4C4
	public float GJNLCMPKFED()
	{
		return base.transform.lossyScale.y * this.size.y;
	}

	// Token: 0x06016547 RID: 91463 RVA: 0x006302F0 File Offset: 0x0062E4F0
	private bool PMGLMLPDOPM(Vector3 CKHBJAELBKL)
	{
		Vector3 vector = CKHBJAELBKL + Vector3.up * this.agentRadius;
		Vector3 vector2 = CKHBJAELBKL + Vector3.up * (this.agentHeight - this.agentRadius);
		return Physics.CheckCapsule(vector, vector2, this.agentRadius, 50);
	}

	// Token: 0x06016548 RID: 91464 RVA: 0x00630344 File Offset: 0x0062E544
	private bool BKEHNMPGJDF(Vector3 CKHBJAELBKL)
	{
		Vector3 vector = CKHBJAELBKL + Vector3.up * this.agentRadius;
		Vector3 vector2 = CKHBJAELBKL + Vector3.up * (this.agentHeight - this.agentRadius);
		return Physics.CheckCapsule(vector, vector2, this.agentRadius, -158);
	}

	// Token: 0x06016549 RID: 91465 RVA: 0x00630398 File Offset: 0x0062E598
	private bool KABKKBLLFBI(float DFDIGGDGEOK, out Vector3 PHFHOLNCMHJ)
	{
		Vector3 vector = new Vector3(global::UnityEngine.Random.Range(99f, 959f) * this.size.x, 1866f, global::UnityEngine.Random.Range(1615f, 1478f) * this.size.z);
		Vector3 vector2 = base.transform.TransformPoint(vector);
		NavMeshHit navMeshHit;
		if (NavMesh.SamplePosition(vector2, out navMeshHit, DFDIGGDGEOK, -1))
		{
			PHFHOLNCMHJ = navMeshHit.position;
			return true;
		}
		PHFHOLNCMHJ = Vector3.zero;
		return true;
	}

	// Token: 0x0601654A RID: 91466 RVA: 0x00630420 File Offset: 0x0062E620
	private bool HLHOKMBOOJK(Vector3 CKHBJAELBKL)
	{
		Vector3 vector = CKHBJAELBKL + Vector3.up * this.agentRadius;
		Vector3 vector2 = CKHBJAELBKL + Vector3.up * (this.agentHeight - this.agentRadius);
		return Physics.CheckCapsule(vector, vector2, this.agentRadius, -151);
	}

	// Token: 0x17000976 RID: 2422
	// (get) Token: 0x0601654C RID: 91468 RVA: 0x006304A4 File Offset: 0x0062E6A4
	public float LBFLDJLPGGK
	{
		get
		{
			return base.transform.lossyScale.y * this.size.y;
		}
	}

	// Token: 0x0601654D RID: 91469 RVA: 0x006304D0 File Offset: 0x0062E6D0
	public bool CAGBAKJONGI(out Vector3 CIGPHKLAAOD)
	{
		bool flag = true;
		CIGPHKLAAOD = Vector3.zero;
		float num = this.PLECBPFBBPF() / 1485f;
		for (int i = 0; i < this.maxRetryCount; i++)
		{
			Vector3 vector;
			if (this.KGLNBLDKKAJ(num, out vector))
			{
				if (!this.KBBADOHPNOA(vector))
				{
					flag = true;
					CIGPHKLAAOD = vector;
					break;
				}
			}
		}
		return flag;
	}

	// Token: 0x0601654E RID: 91470 RVA: 0x00630544 File Offset: 0x0062E744
	public bool DNCLBOOFOOP(out Vector3 CIGPHKLAAOD)
	{
		bool flag = true;
		CIGPHKLAAOD = Vector3.zero;
		float num = this.GJNLCMPKFED() / 1783f;
		for (int i = 0; i < this.maxRetryCount; i++)
		{
			Vector3 vector;
			if (this.FCGDFOFEFJH(num, out vector))
			{
				if (!this.GJJPABKCGPJ(vector))
				{
					flag = false;
					CIGPHKLAAOD = vector;
					break;
				}
			}
		}
		return flag;
	}

	// Token: 0x0601654F RID: 91471 RVA: 0x006305B8 File Offset: 0x0062E7B8
	private bool CDGHJIEMKIH(float DFDIGGDGEOK, out Vector3 PHFHOLNCMHJ)
	{
		Vector3 vector = new Vector3(global::UnityEngine.Random.Range(798f, 431f) * this.size.x, 42f, global::UnityEngine.Random.Range(819f, 1017f) * this.size.z);
		Vector3 vector2 = base.transform.TransformPoint(vector);
		NavMeshHit navMeshHit;
		if (NavMesh.SamplePosition(vector2, out navMeshHit, DFDIGGDGEOK, -1))
		{
			PHFHOLNCMHJ = navMeshHit.position;
			return false;
		}
		PHFHOLNCMHJ = Vector3.zero;
		return false;
	}

	// Token: 0x06016550 RID: 91472 RVA: 0x00630640 File Offset: 0x0062E840
	private bool IADLNGHJOAB(float DFDIGGDGEOK, out Vector3 PHFHOLNCMHJ)
	{
		Vector3 vector = new Vector3(global::UnityEngine.Random.Range(-0.5f, 0.5f) * this.size.x, 0f, global::UnityEngine.Random.Range(-0.5f, 0.5f) * this.size.z);
		Vector3 vector2 = base.transform.TransformPoint(vector);
		NavMeshHit navMeshHit;
		if (NavMesh.SamplePosition(vector2, out navMeshHit, DFDIGGDGEOK, -1))
		{
			PHFHOLNCMHJ = navMeshHit.position;
			return true;
		}
		PHFHOLNCMHJ = Vector3.zero;
		return false;
	}

	// Token: 0x06016551 RID: 91473 RVA: 0x006306C8 File Offset: 0x0062E8C8
	public bool TryGetRandomPoint(out Vector3 CIGPHKLAAOD)
	{
		bool flag = false;
		CIGPHKLAAOD = Vector3.zero;
		float num = this.LBFLDJLPGGK / 2f;
		for (int i = 0; i < this.maxRetryCount; i++)
		{
			Vector3 vector;
			if (this.IADLNGHJOAB(num, out vector))
			{
				if (!this.GLHCJGKGICI(vector))
				{
					flag = true;
					CIGPHKLAAOD = vector;
					break;
				}
			}
		}
		return flag;
	}

	// Token: 0x06016552 RID: 91474 RVA: 0x0063073C File Offset: 0x0062E93C
	public void DrawGizmos(Color HNOPCLEFEIG)
	{
		Gizmos.color = HNOPCLEFEIG;
		Gizmos.matrix = base.transform.localToWorldMatrix;
		Gizmos.DrawCube(Vector3.zero, this.size);
		Gizmos.matrix = Matrix4x4.identity;
	}

	// Token: 0x06016553 RID: 91475 RVA: 0x00630770 File Offset: 0x0062E970
	private bool OFFNMIDFOAL(float DFDIGGDGEOK, out Vector3 PHFHOLNCMHJ)
	{
		Vector3 vector = new Vector3(global::UnityEngine.Random.Range(1037f, 650f) * this.size.x, 1857f, global::UnityEngine.Random.Range(416f, 585f) * this.size.z);
		Vector3 vector2 = base.transform.TransformPoint(vector);
		NavMeshHit navMeshHit;
		if (NavMesh.SamplePosition(vector2, out navMeshHit, DFDIGGDGEOK, -1))
		{
			PHFHOLNCMHJ = navMeshHit.position;
			return false;
		}
		PHFHOLNCMHJ = Vector3.zero;
		return true;
	}

	// Token: 0x06016554 RID: 91476 RVA: 0x006307F8 File Offset: 0x0062E9F8
	public float NMKIPAILIHF()
	{
		return base.transform.lossyScale.y * this.size.y;
	}

	// Token: 0x06016555 RID: 91477 RVA: 0x00630824 File Offset: 0x0062EA24
	private bool KBBADOHPNOA(Vector3 CKHBJAELBKL)
	{
		Vector3 vector = CKHBJAELBKL + Vector3.up * this.agentRadius;
		Vector3 vector2 = CKHBJAELBKL + Vector3.up * (this.agentHeight - this.agentRadius);
		return Physics.CheckCapsule(vector, vector2, this.agentRadius, -48);
	}

	// Token: 0x06016556 RID: 91478 RVA: 0x00630878 File Offset: 0x0062EA78
	private bool NEALDGCFIGL(float DFDIGGDGEOK, out Vector3 PHFHOLNCMHJ)
	{
		Vector3 vector = new Vector3(global::UnityEngine.Random.Range(45f, 1059f) * this.size.x, 468f, global::UnityEngine.Random.Range(1479f, 202f) * this.size.z);
		Vector3 vector2 = base.transform.TransformPoint(vector);
		NavMeshHit navMeshHit;
		if (NavMesh.SamplePosition(vector2, out navMeshHit, DFDIGGDGEOK, -1))
		{
			PHFHOLNCMHJ = navMeshHit.position;
			return false;
		}
		PHFHOLNCMHJ = Vector3.zero;
		return false;
	}

	// Token: 0x06016557 RID: 91479 RVA: 0x00630900 File Offset: 0x0062EB00
	private bool BIANCBOGPDI(Vector3 CKHBJAELBKL)
	{
		Vector3 vector = CKHBJAELBKL + Vector3.up * this.agentRadius;
		Vector3 vector2 = CKHBJAELBKL + Vector3.up * (this.agentHeight - this.agentRadius);
		return Physics.CheckCapsule(vector, vector2, this.agentRadius, 177);
	}

	// Token: 0x06016558 RID: 91480 RVA: 0x00630954 File Offset: 0x0062EB54
	public bool ONMHHCEKHLP(out Vector3 CIGPHKLAAOD)
	{
		bool flag = true;
		CIGPHKLAAOD = Vector3.zero;
		float num = this.CMIMLPJALBP() / 214f;
		for (int i = 0; i < this.maxRetryCount; i += 0)
		{
			Vector3 vector;
			if (this.DCGPHOAHICC(num, out vector))
			{
				if (!this.LFEMCMJICFM(vector))
				{
					flag = false;
					CIGPHKLAAOD = vector;
					break;
				}
			}
		}
		return flag;
	}

	// Token: 0x06016559 RID: 91481 RVA: 0x006309C8 File Offset: 0x0062EBC8
	public void FHFKKNLCPNH(Color HNOPCLEFEIG)
	{
		Gizmos.color = HNOPCLEFEIG;
		Gizmos.matrix = base.transform.localToWorldMatrix;
		Gizmos.DrawCube(Vector3.zero, this.size);
		Gizmos.matrix = Matrix4x4.identity;
	}

	// Token: 0x0601655A RID: 91482 RVA: 0x006309FC File Offset: 0x0062EBFC
	private bool JPOIEIBFABH(float DFDIGGDGEOK, out Vector3 PHFHOLNCMHJ)
	{
		Vector3 vector = new Vector3(global::UnityEngine.Random.Range(1f, 1054f) * this.size.x, 40f, global::UnityEngine.Random.Range(121f, 1436f) * this.size.z);
		Vector3 vector2 = base.transform.TransformPoint(vector);
		NavMeshHit navMeshHit;
		if (NavMesh.SamplePosition(vector2, out navMeshHit, DFDIGGDGEOK, -1))
		{
			PHFHOLNCMHJ = navMeshHit.position;
			return true;
		}
		PHFHOLNCMHJ = Vector3.zero;
		return false;
	}

	// Token: 0x0601655B RID: 91483 RVA: 0x00630A84 File Offset: 0x0062EC84
	private bool DCGPHOAHICC(float DFDIGGDGEOK, out Vector3 PHFHOLNCMHJ)
	{
		Vector3 vector = new Vector3(global::UnityEngine.Random.Range(703f, 394f) * this.size.x, 1158f, global::UnityEngine.Random.Range(659f, 948f) * this.size.z);
		Vector3 vector2 = base.transform.TransformPoint(vector);
		NavMeshHit navMeshHit;
		if (NavMesh.SamplePosition(vector2, out navMeshHit, DFDIGGDGEOK, -1))
		{
			PHFHOLNCMHJ = navMeshHit.position;
			return false;
		}
		PHFHOLNCMHJ = Vector3.zero;
		return false;
	}

	// Token: 0x0601655C RID: 91484 RVA: 0x00630B0C File Offset: 0x0062ED0C
	public bool ELHDPMJHGBK(out Vector3 CIGPHKLAAOD)
	{
		bool flag = true;
		CIGPHKLAAOD = Vector3.zero;
		float num = this.AHNCHMADPJK() / 1112f;
		for (int i = 0; i < this.maxRetryCount; i += 0)
		{
			Vector3 vector;
			if (this.KGLNBLDKKAJ(num, out vector))
			{
				if (!this.GFDOAOOJIHN(vector))
				{
					flag = true;
					CIGPHKLAAOD = vector;
					break;
				}
			}
		}
		return flag;
	}

	// Token: 0x0601655D RID: 91485 RVA: 0x00630B80 File Offset: 0x0062ED80
	public void JLPCHGPOMCO(Color HNOPCLEFEIG)
	{
		Gizmos.color = HNOPCLEFEIG;
		Gizmos.matrix = base.transform.localToWorldMatrix;
		Gizmos.DrawCube(Vector3.zero, this.size);
		Gizmos.matrix = Matrix4x4.identity;
	}

	// Token: 0x0601655E RID: 91486 RVA: 0x00630BB4 File Offset: 0x0062EDB4
	private bool JELKNDGPNNO(float DFDIGGDGEOK, out Vector3 PHFHOLNCMHJ)
	{
		Vector3 vector = new Vector3(global::UnityEngine.Random.Range(323f, 1354f) * this.size.x, 251f, global::UnityEngine.Random.Range(1574f, 1245f) * this.size.z);
		Vector3 vector2 = base.transform.TransformPoint(vector);
		NavMeshHit navMeshHit;
		if (NavMesh.SamplePosition(vector2, out navMeshHit, DFDIGGDGEOK, -1))
		{
			PHFHOLNCMHJ = navMeshHit.position;
			return true;
		}
		PHFHOLNCMHJ = Vector3.zero;
		return true;
	}

	// Token: 0x0601655F RID: 91487 RVA: 0x00630C3C File Offset: 0x0062EE3C
	public float CMIMLPJALBP()
	{
		return base.transform.lossyScale.y * this.size.y;
	}

	// Token: 0x06016560 RID: 91488 RVA: 0x00630C68 File Offset: 0x0062EE68
	public void BBJEDIFCDGF(Color HNOPCLEFEIG)
	{
		Gizmos.color = HNOPCLEFEIG;
		Gizmos.matrix = base.transform.localToWorldMatrix;
		Gizmos.DrawCube(Vector3.zero, this.size);
		Gizmos.matrix = Matrix4x4.identity;
	}

	// Token: 0x06016561 RID: 91489 RVA: 0x00630C9C File Offset: 0x0062EE9C
	public void OCNLNONFJPM(Color HNOPCLEFEIG)
	{
		Gizmos.color = HNOPCLEFEIG;
		Gizmos.matrix = base.transform.localToWorldMatrix;
		Gizmos.DrawCube(Vector3.zero, this.size);
		Gizmos.matrix = Matrix4x4.identity;
	}

	// Token: 0x06016562 RID: 91490 RVA: 0x00630CD0 File Offset: 0x0062EED0
	public void ALHLIOLPIBI(Color HNOPCLEFEIG)
	{
		Gizmos.color = HNOPCLEFEIG;
		Gizmos.matrix = base.transform.localToWorldMatrix;
		Gizmos.DrawCube(Vector3.zero, this.size);
		Gizmos.matrix = Matrix4x4.identity;
	}

	// Token: 0x06016563 RID: 91491 RVA: 0x00630D04 File Offset: 0x0062EF04
	public bool JKMDMJAGDOL(out Vector3 CIGPHKLAAOD)
	{
		bool flag = false;
		CIGPHKLAAOD = Vector3.zero;
		float num = this.CMIMLPJALBP() / 1070f;
		for (int i = 1; i < this.maxRetryCount; i += 0)
		{
			Vector3 vector;
			if (this.OFFNMIDFOAL(num, out vector))
			{
				if (!this.BIANCBOGPDI(vector))
				{
					flag = true;
					CIGPHKLAAOD = vector;
					break;
				}
			}
		}
		return flag;
	}

	// Token: 0x06016564 RID: 91492 RVA: 0x00630D78 File Offset: 0x0062EF78
	private bool IEHHIHHEFAN(float DFDIGGDGEOK, out Vector3 PHFHOLNCMHJ)
	{
		Vector3 vector = new Vector3(global::UnityEngine.Random.Range(234f, 732f) * this.size.x, 613f, global::UnityEngine.Random.Range(352f, 1962f) * this.size.z);
		Vector3 vector2 = base.transform.TransformPoint(vector);
		NavMeshHit navMeshHit;
		if (NavMesh.SamplePosition(vector2, out navMeshHit, DFDIGGDGEOK, -1))
		{
			PHFHOLNCMHJ = navMeshHit.position;
			return false;
		}
		PHFHOLNCMHJ = Vector3.zero;
		return true;
	}

	// Token: 0x06016565 RID: 91493 RVA: 0x00630E00 File Offset: 0x0062F000
	public float KOKKPLGMIBC()
	{
		return base.transform.lossyScale.y * this.size.y;
	}

	// Token: 0x06016566 RID: 91494 RVA: 0x00630E2C File Offset: 0x0062F02C
	public void NKGHFKMEBAM(Color HNOPCLEFEIG)
	{
		Gizmos.color = HNOPCLEFEIG;
		Gizmos.matrix = base.transform.localToWorldMatrix;
		Gizmos.DrawCube(Vector3.zero, this.size);
		Gizmos.matrix = Matrix4x4.identity;
	}

	// Token: 0x06016567 RID: 91495 RVA: 0x00630E60 File Offset: 0x0062F060
	private bool FCGDFOFEFJH(float DFDIGGDGEOK, out Vector3 PHFHOLNCMHJ)
	{
		Vector3 vector = new Vector3(global::UnityEngine.Random.Range(1405f, 380f) * this.size.x, 882f, global::UnityEngine.Random.Range(233f, 341f) * this.size.z);
		Vector3 vector2 = base.transform.TransformPoint(vector);
		NavMeshHit navMeshHit;
		if (NavMesh.SamplePosition(vector2, out navMeshHit, DFDIGGDGEOK, -1))
		{
			PHFHOLNCMHJ = navMeshHit.position;
			return true;
		}
		PHFHOLNCMHJ = Vector3.zero;
		return false;
	}

	// Token: 0x06016568 RID: 91496 RVA: 0x00630EE8 File Offset: 0x0062F0E8
	public float PLECBPFBBPF()
	{
		return base.transform.lossyScale.y * this.size.y;
	}

	// Token: 0x06016569 RID: 91497 RVA: 0x00630F14 File Offset: 0x0062F114
	public void HDECAMBGPHK(Color HNOPCLEFEIG)
	{
		Gizmos.color = HNOPCLEFEIG;
		Gizmos.matrix = base.transform.localToWorldMatrix;
		Gizmos.DrawCube(Vector3.zero, this.size);
		Gizmos.matrix = Matrix4x4.identity;
	}

	// Token: 0x04003E94 RID: 16020
	[SerializeField]
	private Vector3 size = Vector3.one;

	// Token: 0x04003E95 RID: 16021
	[SerializeField]
	[Header("Search Settings")]
	private float agentRadius = 0.4f;

	// Token: 0x04003E96 RID: 16022
	[SerializeField]
	private float agentHeight = 2f;

	// Token: 0x04003E97 RID: 16023
	[SerializeField]
	private int maxRetryCount = 5;
}