BepInEx/Projects/BanquetForFools/Source/Assembly-CSharp/Cellar.cs

using System;
using System.Collections;
using System.Collections.Generic;
using Pathfinding;
using TMPro;
using UnityEngine;
using UnityEngine.UI;

// Token: 0x0200007A RID: 122
public class Cellar : MonoBehaviour
{
	// Token: 0x06000BD7 RID: 3031 RVA: 0x000E3566 File Offset: 0x000E1766
	public void CreateCellar()
	{
		base.StartCoroutine(this.CellarLoop());
	}

	// Token: 0x06000BD8 RID: 3032 RVA: 0x000E3575 File Offset: 0x000E1775
	private IEnumerator CellarLoop()
	{
		Links.x.hudControl.canvas.enabled = false;
		yield return new WaitForSeconds(0.001f);
		this.tr = base.gameObject.transform;
		for (int i = 0; i < 4; i++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.waypoint, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.waypoints.Add(gameObject);
		}
		for (int j = 0; j < 5; j++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.animatedText, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.animatedTexts.Add(gameObject.GetComponent<Animator>());
		}
		for (int k = 0; k < 5; k++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.animatedTextEmpty, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.animatedTextsEmptys.Add(gameObject.GetComponent<Animator>());
		}
		for (int l = 0; l < 5; l++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.animatedTextsDmg, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.animatedTextsDmgs.Add(gameObject.GetComponent<Animator>());
		}
		for (int m = 0; m < 5; m++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.animatedTextsRallyDmg, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.animatedTextsRallyDmgs.Add(gameObject.GetComponent<Animator>());
		}
		for (int n = 0; n < 5; n++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.animatedTextsFriendlyDmg, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.animatedTextsFriendlyDmgs.Add(gameObject.GetComponent<Animator>());
		}
		for (int num = 0; num < 5; num++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.animatedTextsNpcDmg, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.animatedTextsNpcDmgs.Add(gameObject.GetComponent<Animator>());
		}
		for (int num2 = 0; num2 < 4; num2++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.animatedTextsLevelUp, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.animatedTextsLevelUps.Add(gameObject.GetComponent<Animator>());
		}
		for (int num3 = 0; num3 < 4; num3++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.animatedTextsXp, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.animatedTextsXps.Add(gameObject.GetComponent<Animator>());
		}
		for (int num4 = 0; num4 < 1; num4++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.bagItem, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.bagItems.Add(gameObject.GetComponent<Item>());
		}
		for (int num5 = 0; num5 < 50; num5++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.bagImage, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.bagImages.Add(gameObject.GetComponent<Image>());
			gameObject.SetActive(false);
		}
		yield return new WaitForSeconds(0.001f);
		for (int num6 = 0; num6 < 10; num6++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.quip, new Vector3(10000f, 0f, 0f), Quaternion.identity, Links.x.hudControl.miscFolderQuipsTransform);
			this.quips.Add(gameObject.GetComponent<OverHeadUI>());
			gameObject.SetActive(false);
		}
		for (int num7 = 0; num7 < 4; num7++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.timelineIcon, new Vector3(10000f, 0f, 0f), Quaternion.identity, Links.x.timelineHolder);
			this.timelineIcons.Add(gameObject.GetComponent<TimelineIcon>());
		}
		yield return new WaitForSeconds(0.001f);
		for (int num8 = 0; num8 < 10; num8++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.timelineIconEnemy, new Vector3(10000f, 0f, 0f), Quaternion.identity, Links.x.timelineHolder);
			this.timelineIconsEnemy.Add(gameObject.GetComponent<TimelineIcon>());
		}
		for (int num9 = 0; num9 < 20; num9++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.skillIcon, new Vector3(10000f, 0f, 0f), Quaternion.identity, Links.x.quipHolder);
			this.skillIcons.Add(gameObject);
			gameObject.SetActive(false);
		}
		for (int num10 = 0; num10 < 10; num10++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.spellIcon, new Vector3(10000f, 0f, 0f), Quaternion.identity, Links.x.quipHolder);
			this.spellIcons.Add(gameObject);
			gameObject.SetActive(false);
		}
		for (int num11 = 0; num11 < 1; num11++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.songIcon, new Vector3(10000f, 0f, 0f), Quaternion.identity, Links.x.quipHolder);
			this.songIcons.Add(gameObject);
			gameObject.SetActive(false);
		}
		for (int num12 = 0; num12 < 1; num12++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.bracket, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.brackets.Add(gameObject);
		}
		for (int num13 = 0; num13 < 4; num13++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.grassExplosion, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.grassExplosions.Add(gameObject);
		}
		for (int num14 = 0; num14 < 8; num14++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.seen, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.seens.Add(gameObject);
		}
		for (int num15 = 0; num15 < 8; num15++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.heard, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.heards.Add(gameObject);
		}
		for (int num16 = 0; num16 < 30; num16++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.blood, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.bloods.Add(gameObject.GetComponent<Animator>());
		}
		Transform transform = Links.x.gameplay.transform;
		yield return new WaitForSeconds(0.001f);
		for (int num17 = 0; num17 < 200; num17++)
		{
			GameObject gameObject = new GameObject("-*-");
			this.emptyPoints.Add(gameObject);
			gameObject.transform.parent = this.tr;
		}
		for (int num18 = 0; num18 < 5; num18++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.evading, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.evadings.Add(gameObject);
		}
		for (int num19 = 0; num19 < 15; num19++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.bloodBurstSml, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.bloodBurstSmls.Add(gameObject);
		}
		for (int num20 = 0; num20 < 5; num20++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.bloodBurstShroomerSml, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.bloodBurstShroomerSmls.Add(gameObject);
		}
		for (int num21 = 0; num21 < 15; num21++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.bloodBurstMed, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.bloodBurstMeds.Add(gameObject);
		}
		for (int num22 = 0; num22 < 15; num22++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.bloodBurstLrg, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.bloodBurstLrgs.Add(gameObject);
		}
		yield return new WaitForSeconds(0.001f);
		for (int num23 = 0; num23 < 25; num23++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.intestineOptions[Random.Range(0, this.intestineOptions.Count - 1)], new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.intestines.Add(gameObject);
		}
		for (int num24 = 0; num24 < 20; num24++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.oilOptions[Random.Range(0, this.oilOptions.Count - 1)], new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.oils.Add(gameObject);
		}
		for (int num25 = 0; num25 < 20; num25++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.sapOptions[Random.Range(0, this.sapOptions.Count - 1)], new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.saps.Add(gameObject);
		}
		for (int num26 = 0; num26 < 20; num26++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.beetleOptions[Random.Range(0, this.beetleOptions.Count - 1)], new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.beetles.Add(gameObject);
		}
		for (int num27 = 0; num27 < 10; num27++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.socket, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.sockets.Add(gameObject);
		}
		for (int num28 = 0; num28 < 15; num28++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.socketRepair, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.socketRepairs.Add(gameObject);
		}
		for (int num29 = 0; num29 < 5; num29++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.gauge, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.gauges.Add(gameObject.GetComponent<Gauge>());
		}
		yield return new WaitForSeconds(0.001f);
		for (int num30 = 0; num30 < 15; num30++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.effectVinesJump, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.effectVinesJumps.Add(gameObject);
		}
		for (int num31 = 0; num31 < 6; num31++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.effectVinesHold, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.effectVinesHolds.Add(gameObject);
		}
		for (int num32 = 0; num32 < 40; num32++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.effectsHoverTile, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.effectsHoverTiles.Add(gameObject);
		}
		for (int num33 = 0; num33 < 5; num33++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.effectHealed, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.effectHealeds.Add(gameObject);
		}
		for (int num34 = 0; num34 < 10; num34++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.effectIcon, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.effectIcons.Add(gameObject);
		}
		yield return new WaitForSeconds(0.001f);
		for (int num35 = 0; num35 < 7; num35++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.itemPickup, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.itemPickups.Add(gameObject);
		}
		for (int num36 = 0; num36 < 30; num36++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.itemInRange, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.itemInRanges.Add(gameObject);
		}
		for (int num37 = 0; num37 < 5; num37++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.itemInRangeForSale, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.itemInRangesForSale.Add(gameObject);
		}
		for (int num38 = 0; num38 < 5; num38++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.armorBlock, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.armorBlocks.Add(gameObject);
		}
		yield return new WaitForEndOfFrame();
		for (int num39 = 0; num39 < 10; num39++)
		{
			int num40 = Random.Range(0, this.resourceFrogPrefabs.Count);
			GameObject gameObject = Object.Instantiate<GameObject>(this.resourceFrogPrefabs[num40], new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.resourceFrogs.Add(gameObject);
		}
		for (int num41 = 0; num41 < 10; num41++)
		{
			int num42 = Random.Range(0, this.resourceStickPrefabs.Count);
			GameObject gameObject = Object.Instantiate<GameObject>(this.resourceStickPrefabs[num42], new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.resourceSticks.Add(gameObject);
		}
		for (int num43 = 0; num43 < 10; num43++)
		{
			int num44 = Random.Range(0, this.resourceRockPrefabs.Count);
			GameObject gameObject = Object.Instantiate<GameObject>(this.resourceRockPrefabs[num44], new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.resourceRocks.Add(gameObject);
		}
		for (int num45 = 0; num45 < 10; num45++)
		{
			int num46 = Random.Range(0, this.resourceHollowStickPrefabs.Count);
			GameObject gameObject = Object.Instantiate<GameObject>(this.resourceHollowStickPrefabs[num46], new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.resourceHollowSticks.Add(gameObject);
		}
		for (int num47 = 0; num47 < 10; num47++)
		{
			int num48 = Random.Range(0, this.resourceMushroomPrefabs.Count);
			GameObject gameObject = Object.Instantiate<GameObject>(this.resourceMushroomPrefabs[num48], new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.resourceMushrooms.Add(gameObject);
		}
		for (int num49 = 0; num49 < 10; num49++)
		{
			int num50 = Random.Range(0, this.resourceAcornPrefabs.Count);
			GameObject gameObject = Object.Instantiate<GameObject>(this.resourceAcornPrefabs[num50], new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.resourceAcorns.Add(gameObject);
		}
		for (int num51 = 0; num51 < 10; num51++)
		{
			int num52 = Random.Range(0, this.resourceBerryPrefabs.Count);
			GameObject gameObject = Object.Instantiate<GameObject>(this.resourceBerryPrefabs[num52], new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.resourceBerries.Add(gameObject);
		}
		for (int num53 = 0; num53 < 10; num53++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.leafExplosion, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.leafExplosions.Add(gameObject);
		}
		for (int num54 = 0; num54 < 4; num54++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.effectWaypoint, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.effectWaypoints.Add(gameObject);
		}
		for (int num55 = 0; num55 < 6; num55++)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.spellCasting, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
			this.spellCastings.Add(gameObject);
		}
		foreach (object obj in this.tr)
		{
			Transform transform2 = (Transform)obj;
			if (transform2 != this.tr)
			{
				transform2.gameObject.SetActive(false);
			}
		}
		if (this.incenses.Count == 0)
		{
			for (int num56 = 0; num56 < 2; num56++)
			{
				GameObject gameObject = Object.Instantiate<GameObject>(this.incense, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
				this.incenses.Add(gameObject);
				gameObject.SetActive(false);
			}
		}
		yield break;
	}

	// Token: 0x06000BD9 RID: 3033 RVA: 0x000E3584 File Offset: 0x000E1784
	public void ReturnPooledGameObject(int n, GameObject g)
	{
		if (!g)
		{
			return;
		}
		if (n == 9)
		{
			this.effectStuns.Add(g);
		}
		if (n == 11)
		{
			this.effectsHoverTiles.Add(g);
		}
		if (n == 12)
		{
			this.effectVinesJumps.Add(g);
		}
		if (n == 13)
		{
			this.effectVinesHolds.Add(g);
		}
		if (n == 18)
		{
			this.oils.Add(g);
		}
		if (n == 19)
		{
			this.saps.Add(g);
		}
		if (n == 94)
		{
			this.wines.Add(g);
		}
		if (n == 97)
		{
			this.sporeMagics.Add(g);
		}
		if (n == 19)
		{
			this.beetles.Add(g);
		}
		if (n == 22)
		{
			this.heards.Add(g);
		}
		if (n == 23)
		{
			this.seens.Add(g);
		}
		if (n == 24)
		{
			this.effectSpellCasts.Add(g);
		}
		if (n == 25)
		{
			this.effectSporesPukes.Add(g);
		}
		if (n == 26)
		{
			this.effectSporesPukeHeads.Add(g);
		}
		if (n == 27)
		{
			this.effectSporesHealings.Add(g);
		}
		if (n == 28)
		{
			this.effectSporesHealingHeads.Add(g);
		}
		if (n == 29)
		{
			this.effectRockWalls.Add(g);
		}
		if (n == 30)
		{
			this.effectMosses.Add(g);
		}
		if (n == 31)
		{
			this.summonStarts.Add(g);
		}
		if (n == 33)
		{
			this.itemInRanges.Add(g);
		}
		if (n == 90)
		{
			this.itemInRangesForSale.Add(g);
		}
		if (n == 34)
		{
			this.effectMusics.Add(g);
		}
		if (n == 72)
		{
			this.effectMusicBuffs.Add(g);
		}
		if (n == 73)
		{
			this.effectIcons.Add(g);
		}
		if (n == 38)
		{
			this.elixirExplosions.Add(g);
		}
		if (n == 39)
		{
			this.effectTileNaps.Add(g);
		}
		if (n == 41)
		{
			this.effectTileHealings.Add(g);
		}
		if (n == 45)
		{
			this.effectTileFires.Add(g);
		}
		if (n == 85)
		{
			this.ghostHeads.Add(g);
		}
		if (n == 43)
		{
			this.effectActionTimeUps.Add(g);
		}
		if (n == 47)
		{
			this.effectTileAttractions.Add(g);
		}
		if (n == 40)
		{
			this.effectSleeps.Add(g);
		}
		if (n == 42)
		{
			this.effectHealings.Add(g);
		}
		if (n == 46)
		{
			this.effectMoveSpeedUps.Add(g);
		}
		if (n == 44)
		{
			this.effectConfuseds.Add(g);
		}
		if (n == 48)
		{
			this.effectMoveSpeedDowns.Add(g);
		}
		if (n == 50)
		{
			this.resourceFrogs.Add(g);
		}
		if (n == 51)
		{
			this.resourceSticks.Add(g);
		}
		if (n == 52)
		{
			this.resourceRocks.Add(g);
		}
		if (n == 53)
		{
			this.resourceHollowSticks.Add(g);
		}
		if (n == 54)
		{
			this.resourceMushrooms.Add(g);
		}
		if (n == 59)
		{
			this.resourceAcorns.Add(g);
		}
		if (n == 93)
		{
			this.resourceBerries.Add(g);
		}
		if (n == 55)
		{
			this.effectWaypoints.Add(g);
		}
		if (n == 56)
		{
			this.effectCharmeds.Add(g);
		}
		if (n == 57)
		{
			this.effectCharmedFails.Add(g);
		}
		if (n == 61)
		{
			this.brackets.Add(g);
		}
		if (n == 62)
		{
			this.spiritTiles.Add(g);
		}
		if (n == 63)
		{
			this.spiritLeavings.Add(g);
		}
		if (n == 64)
		{
			this.incenses.Add(g);
		}
		if (n == 65)
		{
			this.healthBars.Add(g);
		}
		if (n == 66)
		{
			this.hearts.Add(g);
		}
		if (n == 68)
		{
			this.effectWordOfPowers.Add(g);
		}
		if (n == 69)
		{
			this.spellCastings.Add(g);
		}
		if (n == 70)
		{
			this.spellCastingTargets.Add(g);
		}
		if (n == 74)
		{
			this.effectSlipSlimes.Add(g);
		}
		if (n == 75)
		{
			this.effectFloats.Add(g);
		}
		if (n == 76)
		{
			this.effectVineCocoons.Add(g);
		}
		if (n == 77)
		{
			this.effectVinePrisons.Add(g);
		}
		if (n == 79)
		{
			this.faunaFrogs.Add(g);
		}
		if (n == 80)
		{
			this.faunaLizards.Add(g);
		}
		if (n == 96)
		{
			this.faunaCarrions.Add(g);
		}
		if (n == 81)
		{
			this.faunaRolys.Add(g);
		}
		if (n == 82)
		{
			this.faunaNests.Add(g);
		}
		if (n == 83)
		{
			this.faunaBees.Add(g);
		}
		if (n == 86)
		{
			this.armorBlocks.Add(g);
		}
		if (n == 87)
		{
			this.synergies.Add(g);
		}
		if (n == 88)
		{
			this.spellWaves.Add(g);
		}
		if (n == 89)
		{
			this.grassInteractions.Add(g);
		}
		if (n == 91)
		{
			this.evadings.Add(g);
		}
		if (n == 92)
		{
			this.effectPotions.Add(g);
		}
		if (n == 98)
		{
			this.rages.Add(g);
		}
		if (n == 100)
		{
			this.dazeds.Add(g);
		}
		if (n == 108)
		{
			this.mushroomWalls.Add(g);
		}
		if (n == 109)
		{
			this.greenChargeUps.Add(g);
		}
		if (n == 110)
		{
			this.poisonSplashes.Add(g);
		}
		if (n == 111)
		{
			this.poisonStays.Add(g);
		}
		if (n == 112)
		{
			this.knockbacks.Add(g);
		}
		if (n == 113)
		{
			this.crowns.Add(g);
		}
		if (n == 114)
		{
			this.whiteChargeUps.Add(g);
		}
		if (n == 115)
		{
			this.webs.Add(g);
		}
		if (n == 116)
		{
			this.webPrisons.Add(g);
		}
		if (n == 117)
		{
			this.boneWalls.Add(g);
		}
		if (n == 118)
		{
			this.incenseHits.Add(g);
		}
		if (n == 120)
		{
			this.knockbackLoops.Add(g);
		}
		if (n == 121)
		{
			this.companionPortraits.Add(g);
		}
		if (n == 122)
		{
			this.staminaBars.Add(g);
		}
		if (n == 123)
		{
			this.revivalGems.Add(g);
		}
		if (n == 124)
		{
			this.pins.Add(g);
		}
		if (n == 130)
		{
			this.orangeChargeUps.Add(g);
		}
		if (n == 131)
		{
			this.staminaRecovers.Add(g);
		}
		if (n == 132)
		{
			this.rains.Add(g);
		}
		if (n == 134)
		{
			this.exitIcons.Add(g);
		}
		if (n == 135)
		{
			this.shroomBombs.Add(g);
		}
		if (n == 136)
		{
			this.boroBoats.Add(g);
		}
		if (n == 137)
		{
			this.oars.Add(g);
		}
		if (n == 138)
		{
			this.boatSplashBacks.Add(g);
		}
		if (n == 139)
		{
			this.boatSplashFronts.Add(g);
		}
		if (n == 140)
		{
			this.boatSplashOars.Add(g);
		}
		if (n == 141)
		{
			this.creatureSplashes.Add(g);
		}
		if (g.transform.parent != this.tr)
		{
			g.transform.SetParent(this.tr, true);
		}
		g.SetActive(false);
	}

	// Token: 0x06000BDA RID: 3034 RVA: 0x000E3C9C File Offset: 0x000E1E9C
	public void ReturnPooledUIObject(int num, GameObject go)
	{
		if (num == 17)
		{
			this.skillIcons.Add(go);
		}
		if (num == 49)
		{
			this.spellIcons.Add(go);
		}
		if (num == 71)
		{
			this.songIcons.Add(go);
		}
		if (go.transform.parent != Links.x.quipHolder)
		{
			go.transform.SetParent(Links.x.quipHolder, true);
		}
		go.SetActive(false);
	}

	// Token: 0x06000BDB RID: 3035 RVA: 0x000E3D18 File Offset: 0x000E1F18
	public GameObject GetPooledGameObject(int num)
	{
		GameObject gameObject = null;
		if (num == 0)
		{
			if (this.waypoints.Count > 0)
			{
				gameObject = this.waypoints[0];
				this.waypoints.RemoveAt(0);
				this.waypoints.Add(gameObject);
				return gameObject;
			}
			return Object.Instantiate<GameObject>(this.waypoint, Vector3.zero, Quaternion.identity, this.tr);
		}
		else if (num == 4)
		{
			if (this.sockets.Count > 0)
			{
				gameObject = this.sockets[0];
				this.sockets.RemoveAt(0);
				return gameObject;
			}
			return Object.Instantiate<GameObject>(this.socket, Vector3.zero, Quaternion.identity, this.tr);
		}
		else if (num == 35)
		{
			if (this.socketRepairs.Count > 0)
			{
				gameObject = this.socketRepairs[0];
				this.socketRepairs.RemoveAt(0);
				return gameObject;
			}
			return Object.Instantiate<GameObject>(this.socketRepair, Vector3.zero, Quaternion.identity, this.tr);
		}
		else if (num == 36)
		{
			if (this.socketSpellRepairs.Count > 0)
			{
				gameObject = this.socketSpellRepairs[0];
				this.socketSpellRepairs.RemoveAt(0);
				return gameObject;
			}
			return Object.Instantiate<GameObject>(this.socketSpellRepair, Vector3.zero, Quaternion.identity, this.tr);
		}
		else if (num == 2)
		{
			if (this.emptyPoints.Count > 0)
			{
				gameObject = this.emptyPoints[0];
				this.emptyPoints.RemoveAt(0);
				return gameObject;
			}
			return new GameObject("-*-")
			{
				transform = 
				{
					parent = this.tr
				}
			};
		}
		else
		{
			if (num == 5 && this.bloodBurstSmls.Count > 0)
			{
				gameObject = this.bloodBurstSmls[0];
				if (!gameObject.activeSelf)
				{
					this.bloodBurstSmls.RemoveAt(0);
					this.bloodBurstSmls.Add(gameObject);
				}
				else
				{
					gameObject = Object.Instantiate<GameObject>(this.bloodBurstSml, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
					this.bloodBurstSmls.Add(gameObject);
				}
				return gameObject;
			}
			if (num == 6 && this.bloodBurstMeds.Count > 0)
			{
				gameObject = this.bloodBurstMeds[0];
				if (!gameObject.activeSelf)
				{
					this.bloodBurstMeds.RemoveAt(0);
					this.bloodBurstMeds.Add(gameObject);
				}
				else
				{
					gameObject = Object.Instantiate<GameObject>(this.bloodBurstMed, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
					this.bloodBurstMeds.Add(gameObject);
				}
				return gameObject;
			}
			if (num == 7 && this.bloodBurstLrgs.Count > 0)
			{
				gameObject = this.bloodBurstLrgs[0];
				if (!gameObject.activeSelf)
				{
					this.bloodBurstLrgs.RemoveAt(0);
					this.bloodBurstLrgs.Add(gameObject);
				}
				else
				{
					gameObject = Object.Instantiate<GameObject>(this.bloodBurstLrg, new Vector3(10000f, 0f, 0f), Quaternion.identity, this.tr);
					this.bloodBurstLrgs.Add(gameObject);
				}
				return gameObject;
			}
			if (num == 67)
			{
				if (this.gorePilesRb.Count > 0)
				{
					gameObject = this.gorePilesRb[0];
					this.gorePilesRb.RemoveAt(0);
					this.removedGorePilesRb.Add(gameObject);
					return gameObject;
				}
				GameObject gameObject2 = Object.Instantiate<GameObject>(this.gorePileOptionsRb[Random.Range(0, this.gorePileOptionsRb.Count)], Vector3.zero, Quaternion.identity, this.tr);
				this.removedGorePilesRb.Add(gameObject2);
				return gameObject2;
			}
			else if (num == 9)
			{
				if (this.effectStuns.Count > 0)
				{
					gameObject = this.effectStuns[0];
					this.effectStuns.RemoveAt(0);
					return gameObject;
				}
				return Object.Instantiate<GameObject>(this.effectStun, Vector3.zero, Quaternion.identity, this.tr);
			}
			else if (num == 10)
			{
				if (this.effectShimmerThrees.Count <= 0)
				{
					return Object.Instantiate<GameObject>(this.effectShimmerThree, Vector3.zero, Quaternion.identity, this.tr);
				}
				gameObject = this.effectShimmerThrees[0];
				if (gameObject.activeSelf)
				{
					this.effectShimmerThrees.RemoveAt(0);
					this.effectShimmerThrees.Add(gameObject);
					return gameObject;
				}
				return Object.Instantiate<GameObject>(this.effectShimmerThree, Vector3.zero, Quaternion.identity, this.tr);
			}
			else if (num == 11)
			{
				if (this.effectsHoverTiles.Count > 0)
				{
					gameObject = this.effectsHoverTiles[0];
					this.effectsHoverTiles.RemoveAt(0);
					return gameObject;
				}
				return Object.Instantiate<GameObject>(this.effectsHoverTile, Vector3.zero, Quaternion.identity, this.tr);
			}
			else if (num == 12)
			{
				if (this.effectVinesJumps.Count > 0)
				{
					gameObject = this.effectVinesJumps[0];
					this.effectVinesJumps.RemoveAt(0);
					return gameObject;
				}
				return Object.Instantiate<GameObject>(this.effectVinesJump, Vector3.zero, Quaternion.identity, this.tr);
			}
			else if (num == 13)
			{
				if (this.effectVinesHolds.Count > 0)
				{
					gameObject = this.effectVinesHolds[0];
					this.effectVinesHolds.RemoveAt(0);
					return gameObject;
				}
				return Object.Instantiate<GameObject>(this.effectVinesHold, Vector3.zero, Quaternion.identity, this.tr);
			}
			else
			{
				if (num == 14 && this.effectHealeds.Count > 0)
				{
					gameObject = this.effectHealeds[0];
					this.effectHealeds.RemoveAt(0);
					this.effectHealeds.Add(gameObject);
					return gameObject;
				}
				if (num == 58)
				{
					if (this.effectFaileds.Count <= 0)
					{
						GameObject gameObject3 = Object.Instantiate<GameObject>(this.effectFailed, Vector3.zero, Quaternion.identity, this.tr);
						this.effectFaileds.Add(gameObject3);
						return gameObject3;
					}
					if (!this.effectFaileds[0].activeSelf)
					{
						gameObject = this.effectFaileds[0];
						this.effectFaileds.RemoveAt(0);
						this.effectFaileds.Add(gameObject);
						return gameObject;
					}
					GameObject gameObject4 = Object.Instantiate<GameObject>(this.effectFailed, Vector3.zero, Quaternion.identity, this.tr);
					this.effectFaileds.Add(gameObject4);
					return gameObject4;
				}
				else
				{
					if (num == 15 && this.buffRemoveds.Count > 0)
					{
						gameObject = this.buffRemoveds[0];
						this.buffRemoveds.RemoveAt(0);
						this.buffRemoveds.Add(gameObject);
						return gameObject;
					}
					if (num == 16)
					{
						if (this.itemPickups.Count > 0)
						{
							gameObject = this.itemPickups[0];
							this.itemPickups.RemoveAt(0);
							this.itemPickups.Add(gameObject);
							return gameObject;
						}
						GameObject gameObject5 = Object.Instantiate<GameObject>(this.itemPickup, Vector3.zero, Quaternion.identity, this.tr);
						this.itemPickups.Add(gameObject5);
						return gameObject5;
					}
					else if (num == 17)
					{
						if (this.skillIcons.Count > 0)
						{
							gameObject = this.skillIcons[0];
							this.skillIcons.RemoveAt(0);
							return gameObject;
						}
						return Object.Instantiate<GameObject>(this.skillIcon, Vector3.zero, Quaternion.identity, this.tr);
					}
					else if (num == 49)
					{
						if (this.spellIcons.Count > 0)
						{
							gameObject = this.spellIcons[0];
							this.spellIcons.RemoveAt(0);
							return gameObject;
						}
						return Object.Instantiate<GameObject>(this.spellIcon, Vector3.zero, Quaternion.identity, this.tr);
					}
					else if (num == 71)
					{
						if (this.songIcons.Count > 0)
						{
							gameObject = this.songIcons[0];
							this.songIcons.RemoveAt(0);
							return gameObject;
						}
						return Object.Instantiate<GameObject>(this.songIcon, Vector3.zero, Quaternion.identity, this.tr);
					}
					else
					{
						if (num == 18)
						{
							if (this.oils.Count > 0)
							{
								gameObject = this.oils[0];
								if (gameObject)
								{
									this.oils.RemoveAt(0);
									return gameObject;
								}
							}
							return Object.Instantiate<GameObject>(this.oilOptions[Random.Range(0, this.oilOptions.Count - 1)], Vector3.zero, Quaternion.identity, this.tr);
						}
						if (num == 19)
						{
							if (this.saps.Count > 0)
							{
								gameObject = this.saps[0];
								if (gameObject)
								{
									this.saps.RemoveAt(0);
									return gameObject;
								}
							}
							return Object.Instantiate<GameObject>(this.sapOptions[Random.Range(0, this.sapOptions.Count - 1)], Vector3.zero, Quaternion.identity, this.tr);
						}
						if (num == 20)
						{
							if (this.beetles.Count > 0)
							{
								gameObject = this.beetles[0];
								this.beetles.RemoveAt(0);
								return gameObject;
							}
							return Object.Instantiate<GameObject>(this.beetleOptions[Random.Range(0, this.beetleOptions.Count - 1)], Vector3.zero, Quaternion.identity, this.tr);
						}
						else if (num == 21 && this.bloodBurstShroomerSmls.Count > 0)
						{
							gameObject = this.bloodBurstShroomerSmls[0];
							if (!gameObject.activeSelf)
							{
								this.bloodBurstShroomerSmls.RemoveAt(0);
								this.bloodBurstShroomerSmls.Add(gameObject);
								return gameObject;
							}
							GameObject gameObject6 = Object.Instantiate<GameObject>(this.bloodBurstShroomerSml, Vector3.zero, Quaternion.identity, this.tr);
							this.bloodBurstShroomerSmls.Add(gameObject6);
							return gameObject6;
						}
						else if (num == 23)
						{
							if (this.seens.Count > 0)
							{
								gameObject = this.seens[0];
								this.seens.RemoveAt(0);
								return gameObject;
							}
							return Object.Instantiate<GameObject>(this.seen, Vector3.zero, Quaternion.identity, this.tr);
						}
						else if (num == 22)
						{
							if (this.heards.Count > 0)
							{
								gameObject = this.heards[0];
								this.heards.RemoveAt(0);
								return gameObject;
							}
							return Object.Instantiate<GameObject>(this.heard, Vector3.zero, Quaternion.identity, this.tr);
						}
						else if (num == 24)
						{
							if (this.effectSpellCasts.Count > 0)
							{
								gameObject = this.effectSpellCasts[0];
								this.effectSpellCasts.RemoveAt(0);
								return gameObject;
							}
							return Object.Instantiate<GameObject>(this.effectSpellCast, Vector3.zero, Quaternion.identity, this.tr);
						}
						else if (num == 25)
						{
							if (this.effectSporesPukes.Count > 0)
							{
								gameObject = this.effectSporesPukes[0];
								this.effectSporesPukes.RemoveAt(0);
								return gameObject;
							}
							return Object.Instantiate<GameObject>(this.effectSporesPuke, Vector3.zero, Quaternion.identity, this.tr);
						}
						else if (num == 26)
						{
							if (this.effectSporesPukeHeads.Count > 0)
							{
								gameObject = this.effectSporesPukeHeads[0];
								this.effectSporesPukeHeads.RemoveAt(0);
								return gameObject;
							}
							return Object.Instantiate<GameObject>(this.effectSporesPukeHead, Vector3.zero, Quaternion.identity, this.tr);
						}
						else if (num == 27)
						{
							if (this.effectSporesHealings.Count > 0)
							{
								gameObject = this.effectSporesHealings[0];
								this.effectSporesHealings.RemoveAt(0);
								return gameObject;
							}
							return Object.Instantiate<GameObject>(this.effectSporesHealing, Vector3.zero, Quaternion.identity, this.tr);
						}
						else if (num == 28)
						{
							if (this.effectSporesHealingHeads.Count > 0)
							{
								gameObject = this.effectSporesHealingHeads[0];
								this.effectSporesHealingHeads.RemoveAt(0);
								return gameObject;
							}
							return Object.Instantiate<GameObject>(this.effectSporesHealingHead, Vector3.zero, Quaternion.identity, this.tr);
						}
						else if (num == 29)
						{
							if (this.effectRockWalls.Count > 0)
							{
								gameObject = this.effectRockWalls[0];
								this.effectRockWalls.RemoveAt(0);
								return gameObject;
							}
							return Object.Instantiate<GameObject>(this.effectRockWall, Vector3.zero, Quaternion.identity, this.tr);
						}
						else if (num == 74)
						{
							if (this.effectSlipSlimes.Count > 0)
							{
								gameObject = this.effectSlipSlimes[0];
								this.effectSlipSlimes.RemoveAt(0);
								return gameObject;
							}
							return Object.Instantiate<GameObject>(this.effectSlipSlime, Vector3.zero, Quaternion.identity, this.tr);
						}
						else if (num == 30)
						{
							if (this.effectMosses.Count > 0)
							{
								gameObject = this.effectMosses[0];
								this.effectMosses.RemoveAt(0);
								return gameObject;
							}
							return Object.Instantiate<GameObject>(this.effectMoss, Vector3.zero, Quaternion.identity, this.tr);
						}
						else if (num == 31)
						{
							if (this.summonStarts.Count > 0)
							{
								gameObject = this.summonStarts[0];
								this.summonStarts.RemoveAt(0);
								return gameObject;
							}
							return Object.Instantiate<GameObject>(this.summonStart, Vector3.zero, Quaternion.identity, this.tr);
						}
						else if (num == 33)
						{
							if (this.itemInRanges.Count > 0)
							{
								gameObject = this.itemInRanges[0];
								this.itemInRanges.RemoveAt(0);
								return gameObject;
							}
							return Object.Instantiate<GameObject>(this.itemInRange, Vector3.zero, Quaternion.identity, this.tr);
						}
						else if (num == 90)
						{
							if (this.itemInRangesForSale.Count > 0)
							{
								gameObject = this.itemInRangesForSale[0];
								this.itemInRangesForSale.RemoveAt(0);
								return gameObject;
							}
							return Object.Instantiate<GameObject>(this.itemInRangeForSale, Vector3.zero, Quaternion.identity, this.tr);
						}
						else
						{
							if (num == 32)
							{
								if (this.summonEnds.Count > 1)
								{
									gameObject = this.summonEnds[0];
									if (!gameObject.activeSelf)
									{
										this.summonEnds.RemoveAt(0);
										this.summonEnds.Add(gameObject);
									}
									else
									{
										gameObject = Object.Instantiate<GameObject>(this.summonEnd, Vector3.zero, Quaternion.identity, this.tr);
										this.summonEnds.Add(gameObject);
									}
								}
								else
								{
									gameObject = Object.Instantiate<GameObject>(this.summonEnd, Vector3.zero, Quaternion.identity, this.tr);
									this.summonEnds.Add(gameObject);
								}
								return gameObject;
							}
							if (num == 34)
							{
								if (this.effectMusics.Count > 0)
								{
									gameObject = this.effectMusics[0];
									if (!gameObject.activeSelf)
									{
										this.effectMusics.RemoveAt(0);
										this.effectMusics.Add(gameObject);
										return gameObject;
									}
								}
								GameObject gameObject7 = Object.Instantiate<GameObject>(this.effectMusic, Vector3.zero, Quaternion.identity, this.tr);
								this.effectMusics.Add(gameObject7);
								return gameObject7;
							}
							if (num == 72)
							{
								if (this.effectMusicBuffs.Count > 0)
								{
									gameObject = this.effectMusicBuffs[0];
									if (!gameObject.activeSelf)
									{
										this.effectMusicBuffs.RemoveAt(0);
										this.effectMusicBuffs.Add(gameObject);
										return gameObject;
									}
								}
								GameObject gameObject8 = Object.Instantiate<GameObject>(this.effectMusicBuff, Vector3.zero, Quaternion.identity, this.tr);
								this.effectMusicBuffs.Add(gameObject8);
								return gameObject8;
							}
							if (num == 73)
							{
								if (this.effectIcons.Count > 0)
								{
									gameObject = this.effectIcons[0];
									this.effectIcons.RemoveAt(0);
									return gameObject;
								}
								return Object.Instantiate<GameObject>(this.effectIcon, Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 38)
							{
								if (this.elixirExplosions.Count <= 0)
								{
									GameObject gameObject9 = Object.Instantiate<GameObject>(this.elixirExplosion, Vector3.zero, Quaternion.identity, this.tr);
									this.elixirExplosions.Add(gameObject);
									return gameObject9;
								}
								gameObject = this.elixirExplosions[0];
								if (!gameObject)
								{
									GameObject gameObject10 = Object.Instantiate<GameObject>(this.elixirExplosion, Vector3.zero, Quaternion.identity, this.tr);
									this.elixirExplosions.Add(gameObject);
									return gameObject10;
								}
								if (gameObject.activeSelf)
								{
									GameObject gameObject11 = Object.Instantiate<GameObject>(this.elixirExplosion, Vector3.zero, Quaternion.identity, this.tr);
									this.elixirExplosions.Add(gameObject);
									return gameObject11;
								}
								this.elixirExplosions.RemoveAt(0);
								this.elixirExplosions.Add(gameObject);
								return gameObject;
							}
							else if (num == 39)
							{
								if (this.effectTileNaps.Count > 0)
								{
									gameObject = this.effectTileNaps[0];
									this.effectTileNaps.RemoveAt(0);
									return gameObject;
								}
								return Object.Instantiate<GameObject>(this.effectTileNap, Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 41)
							{
								if (this.effectTileHealings.Count > 0)
								{
									gameObject = this.effectTileHealings[0];
									this.effectTileHealings.RemoveAt(0);
									return gameObject;
								}
								return Object.Instantiate<GameObject>(this.effectTileHealing, Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 45)
							{
								if (this.effectTileFires.Count > 0)
								{
									gameObject = this.effectTileFires[0];
									this.effectTileFires.RemoveAt(0);
									return gameObject;
								}
								return Object.Instantiate<GameObject>(this.effectTileFire, Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 85)
							{
								if (this.ghostHeads.Count > 0)
								{
									gameObject = this.ghostHeads[0];
									this.ghostHeads.RemoveAt(0);
									return gameObject;
								}
								return Object.Instantiate<GameObject>(this.ghostHead, Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 43)
							{
								if (this.effectActionTimeUps.Count > 0)
								{
									gameObject = this.effectActionTimeUps[0];
									this.effectActionTimeUps.RemoveAt(0);
									return gameObject;
								}
								return Object.Instantiate<GameObject>(this.effectActionTimeUp, Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 47)
							{
								if (this.effectTileAttractions.Count > 0)
								{
									gameObject = this.effectTileAttractions[0];
									this.effectTileAttractions.RemoveAt(0);
									return gameObject;
								}
								return Object.Instantiate<GameObject>(this.effectTileAttraction, Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 40)
							{
								if (this.effectSleeps.Count > 0)
								{
									gameObject = this.effectSleeps[0];
									this.effectSleeps.RemoveAt(0);
									return gameObject;
								}
								return Object.Instantiate<GameObject>(this.effectSleep, Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 42)
							{
								if (this.effectHealings.Count > 0)
								{
									gameObject = this.effectHealings[0];
									this.effectHealings.RemoveAt(0);
									return gameObject;
								}
								return Object.Instantiate<GameObject>(this.effectHealing, Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 46)
							{
								if (this.effectMoveSpeedUps.Count > 0)
								{
									gameObject = this.effectMoveSpeedUps[0];
									this.effectMoveSpeedUps.RemoveAt(0);
									return gameObject;
								}
								return Object.Instantiate<GameObject>(this.effectMoveSpeedUp, Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 44)
							{
								if (this.effectConfuseds.Count > 0)
								{
									gameObject = this.effectConfuseds[0];
									this.effectConfuseds.RemoveAt(0);
									return gameObject;
								}
								return Object.Instantiate<GameObject>(this.effectConfused, Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 48)
							{
								if (this.effectMoveSpeedDowns.Count > 0)
								{
									gameObject = this.effectMoveSpeedDowns[0];
									this.effectMoveSpeedDowns.RemoveAt(0);
									return gameObject;
								}
								return Object.Instantiate<GameObject>(this.effectMoveSpeedDown, Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 50)
							{
								if (this.resourceFrogs.Count > 0)
								{
									gameObject = this.resourceFrogs[0];
									this.resourceFrogs.RemoveAt(0);
									return gameObject;
								}
								int num2 = Random.Range(0, this.resourceFrogPrefabs.Count);
								return Object.Instantiate<GameObject>(this.resourceFrogPrefabs[num2], Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 51)
							{
								if (this.resourceSticks.Count > 0)
								{
									gameObject = this.resourceSticks[0];
									this.resourceSticks.RemoveAt(0);
									return gameObject;
								}
								int num3 = Random.Range(0, this.resourceStickPrefabs.Count);
								return Object.Instantiate<GameObject>(this.resourceStickPrefabs[num3], Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 52)
							{
								if (this.resourceRocks.Count > 0)
								{
									gameObject = this.resourceRocks[0];
									this.resourceRocks.RemoveAt(0);
									return gameObject;
								}
								int num4 = Random.Range(0, this.resourceRockPrefabs.Count);
								return Object.Instantiate<GameObject>(this.resourceRockPrefabs[num4], Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 53)
							{
								if (this.resourceHollowSticks.Count > 0)
								{
									gameObject = this.resourceHollowSticks[0];
									this.resourceHollowSticks.RemoveAt(0);
									return gameObject;
								}
								return Object.Instantiate<GameObject>(this.resourceHollowStickPrefabs[0], Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 54)
							{
								if (this.resourceMushrooms.Count > 0)
								{
									gameObject = this.resourceMushrooms[0];
									this.resourceMushrooms.RemoveAt(0);
									return gameObject;
								}
								int num5 = Random.Range(0, this.resourceMushroomPrefabs.Count);
								return Object.Instantiate<GameObject>(this.resourceMushroomPrefabs[num5], Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 59)
							{
								if (this.resourceAcorns.Count > 0)
								{
									gameObject = this.resourceAcorns[0];
									this.resourceAcorns.RemoveAt(0);
									return gameObject;
								}
								int num6 = Random.Range(0, this.resourceAcornPrefabs.Count);
								return Object.Instantiate<GameObject>(this.resourceAcornPrefabs[num6], Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 93)
							{
								if (this.resourceBerries.Count > 0)
								{
									gameObject = this.resourceBerries[0];
									this.resourceBerries.RemoveAt(0);
									return gameObject;
								}
								int num7 = Random.Range(0, this.resourceBerryPrefabs.Count);
								return Object.Instantiate<GameObject>(this.resourceBerryPrefabs[num7], Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 55)
							{
								if (this.effectWaypoints.Count > 0)
								{
									gameObject = this.effectWaypoints[0];
									this.effectWaypoints.RemoveAt(0);
									return gameObject;
								}
								return Object.Instantiate<GameObject>(this.effectWaypoint, Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 56)
							{
								if (this.effectCharmeds.Count > 0)
								{
									gameObject = this.effectCharmeds[0];
									this.effectCharmeds.RemoveAt(0);
									this.effectCharmeds.Add(gameObject);
									return gameObject;
								}
								GameObject gameObject12 = Object.Instantiate<GameObject>(this.effectCharmed, Vector3.zero, Quaternion.identity, this.tr);
								this.effectCharmeds.Add(gameObject);
								return gameObject12;
							}
							else if (num == 60)
							{
								if (this.leafExplosions.Count <= 0)
								{
									GameObject gameObject13 = Object.Instantiate<GameObject>(this.leafExplosion, Vector3.zero, Quaternion.identity, this.tr);
									this.leafExplosions.Add(gameObject);
									return gameObject13;
								}
								gameObject = this.leafExplosions[0];
								if (!gameObject.activeSelf)
								{
									this.leafExplosions.RemoveAt(0);
									this.leafExplosions.Add(gameObject);
									return gameObject;
								}
								GameObject gameObject14 = Object.Instantiate<GameObject>(this.leafExplosion, Vector3.zero, Quaternion.identity, this.tr);
								this.leafExplosions.Add(gameObject);
								return gameObject14;
							}
							else if (num == 57)
							{
								if (this.effectCharmedFails.Count > 0)
								{
									gameObject = this.effectCharmedFails[0];
									this.effectCharmedFails.RemoveAt(0);
									this.effectCharmedFails.Add(gameObject);
									return gameObject;
								}
								GameObject gameObject15 = Object.Instantiate<GameObject>(this.effectCharmedFail, Vector3.zero, Quaternion.identity, this.tr);
								this.effectCharmedFails.Add(gameObject);
								return gameObject15;
							}
							else if (num == 61)
							{
								if (this.brackets.Count > 0)
								{
									gameObject = this.brackets[0];
									this.brackets.RemoveAt(0);
									return gameObject;
								}
								return Object.Instantiate<GameObject>(this.bracket, Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 63)
							{
								if (this.spiritLeavings.Count > 0)
								{
									gameObject = this.spiritLeavings[0];
									this.spiritLeavings.RemoveAt(0);
									return gameObject;
								}
								return Object.Instantiate<GameObject>(this.spiritLeaving, Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 64)
							{
								if (this.incenses.Count > 0)
								{
									gameObject = this.incenses[0];
									this.incenses.RemoveAt(0);
									return gameObject;
								}
								return Object.Instantiate<GameObject>(this.incense, Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 65)
							{
								if (this.healthBars.Count > 0)
								{
									gameObject = this.healthBars[0];
									this.healthBars.RemoveAt(0);
									return gameObject;
								}
								return Object.Instantiate<GameObject>(this.healthBar, Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 122)
							{
								if (this.staminaBars.Count > 0)
								{
									gameObject = this.staminaBars[0];
									this.staminaBars.RemoveAt(0);
									return gameObject;
								}
								return Object.Instantiate<GameObject>(this.staminaBar, Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 66)
							{
								if (this.hearts.Count > 0)
								{
									gameObject = this.hearts[0];
									this.hearts.RemoveAt(0);
									return gameObject;
								}
								return Object.Instantiate<GameObject>(this.heart, Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 68)
							{
								if (this.effectWordOfPowers.Count > 0)
								{
									gameObject = this.effectWordOfPowers[0];
									this.effectWordOfPowers.RemoveAt(0);
									return gameObject;
								}
								return Object.Instantiate<GameObject>(this.effectWordOfPower, Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 69)
							{
								if (this.spellCastings.Count > 0)
								{
									gameObject = this.spellCastings[0];
									this.spellCastings.RemoveAt(0);
									return gameObject;
								}
								return Object.Instantiate<GameObject>(this.spellCasting, Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 70)
							{
								if (this.spellCastingTargets.Count <= 0)
								{
									GameObject gameObject16 = Object.Instantiate<GameObject>(this.spellCastingTarget, Vector3.zero, Quaternion.identity, this.tr);
									this.spellCastingTargets.Add(gameObject16);
									return gameObject16;
								}
								gameObject = this.spellCastingTargets[0];
								if (!gameObject.activeSelf)
								{
									this.spellCastingTargets.RemoveAt(0);
									this.spellCastingTargets.Add(gameObject);
									return gameObject;
								}
								GameObject gameObject17 = Object.Instantiate<GameObject>(this.spellCastingTarget, Vector3.zero, Quaternion.identity, this.tr);
								this.spellCastingTargets.Add(gameObject17);
								return gameObject17;
							}
							else if (num == 78)
							{
								if (this.spellCastingTargetFails.Count <= 0)
								{
									GameObject gameObject18 = Object.Instantiate<GameObject>(this.spellCastingTargetFail, Vector3.zero, Quaternion.identity, this.tr);
									this.spellCastingTargetFails.Add(gameObject18);
									return gameObject18;
								}
								gameObject = this.spellCastingTargetFails[0];
								if (!gameObject.activeSelf)
								{
									this.spellCastingTargetFails.RemoveAt(0);
									this.spellCastingTargetFails.Add(gameObject);
									return gameObject;
								}
								GameObject gameObject19 = Object.Instantiate<GameObject>(this.spellCastingTargetFail, Vector3.zero, Quaternion.identity, this.tr);
								this.spellCastingTargetFails.Add(gameObject19);
								return gameObject19;
							}
							else if (num == 62)
							{
								if (this.spiritTiles.Count <= 0)
								{
									return Object.Instantiate<GameObject>(this.spiritTile, Vector3.zero, Quaternion.identity, this.tr);
								}
								gameObject = this.spiritTiles[0];
								if (!gameObject.activeSelf)
								{
									this.spiritTiles.RemoveAt(0);
									this.spiritTiles.Add(gameObject);
									return gameObject;
								}
								return Object.Instantiate<GameObject>(this.spiritTile, Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 75)
							{
								if (this.effectFloats.Count > 0)
								{
									gameObject = this.effectFloats[0];
									this.effectFloats.RemoveAt(0);
									return gameObject;
								}
								return Object.Instantiate<GameObject>(this.effectFloat, Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 76)
							{
								if (this.effectVineCocoons.Count > 0)
								{
									gameObject = this.effectVineCocoons[0];
									this.effectVineCocoons.RemoveAt(0);
									return gameObject;
								}
								return Object.Instantiate<GameObject>(this.effectVineCocoon, Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 77)
							{
								if (this.effectVinePrisons.Count > 0)
								{
									gameObject = this.effectVinePrisons[0];
									this.effectVinePrisons.RemoveAt(0);
									return gameObject;
								}
								return Object.Instantiate<GameObject>(this.effectVinePrison, Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 79)
							{
								if (this.faunaFrogs.Count > 0)
								{
									gameObject = this.faunaFrogs[0];
									this.faunaFrogs.RemoveAt(0);
									return gameObject;
								}
								return Object.Instantiate<GameObject>(this.faunaFrog, Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 80)
							{
								if (this.faunaLizards.Count > 0)
								{
									gameObject = this.faunaLizards[0];
									this.faunaLizards.RemoveAt(0);
									return gameObject;
								}
								return Object.Instantiate<GameObject>(this.faunaLizard, Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 96)
							{
								if (this.faunaCarrions.Count > 0)
								{
									gameObject = this.faunaCarrions[0];
									this.faunaCarrions.RemoveAt(0);
									return gameObject;
								}
								return Object.Instantiate<GameObject>(this.faunaCarrion, Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 81)
							{
								if (this.faunaRolys.Count > 0)
								{
									gameObject = this.faunaRolys[0];
									this.faunaRolys.RemoveAt(0);
									return gameObject;
								}
								return Object.Instantiate<GameObject>(this.faunaRoly, Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 82)
							{
								if (this.faunaNests.Count > 0)
								{
									gameObject = this.faunaNests[0];
									this.faunaNests.RemoveAt(0);
									return gameObject;
								}
								return Object.Instantiate<GameObject>(this.faunaNest, Vector3.zero, Quaternion.identity, this.tr);
							}
							else if (num == 83)
							{
								if (this.faunaBees.Count > 0)
								{
									gameObject = this.faunaBees[0];
									this.faunaBees.RemoveAt(0);
									return gameObject;
								}
								return Object.Instantiate<GameObject>(this.faunaBee, Vector3.zero, Quaternion.identity, this.tr);
							}
							else
							{
								if (num == 87)
								{
									if (this.synergies.Count > 0)
									{
										gameObject = this.synergies[0];
										if (!gameObject.activeSelf)
										{
											this.synergies.RemoveAt(0);
											this.synergies.Add(gameObject);
											return gameObject;
										}
									}
									return Object.Instantiate<GameObject>(this.synergy, Vector3.zero, Quaternion.identity, this.tr);
								}
								if (num == 88)
								{
									if (this.spellWaves.Count > 0)
									{
										gameObject = this.spellWaves[0];
										this.spellWaves.RemoveAt(0);
										return gameObject;
									}
									return Object.Instantiate<GameObject>(this.spellWave, Vector3.zero, Quaternion.identity, this.tr);
								}
								else if (num == 91)
								{
									if (this.evadings.Count > 0)
									{
										gameObject = this.evadings[0];
										this.evadings.RemoveAt(0);
										return gameObject;
									}
									return Object.Instantiate<GameObject>(this.evading, Vector3.zero, Quaternion.identity, this.tr);
								}
								else if (num == 98)
								{
									if (this.rages.Count <= 0)
									{
										return Object.Instantiate<GameObject>(this.rage, Vector3.zero, Quaternion.identity, this.tr);
									}
									gameObject = this.rages[0];
									if (!gameObject)
									{
										this.rages.RemoveAt(0);
										return Object.Instantiate<GameObject>(this.rage, Vector3.zero, Quaternion.identity, this.tr);
									}
									this.rages.RemoveAt(0);
									return gameObject;
								}
								else if (num == 92)
								{
									if (this.effectPotions.Count <= 0)
									{
										return Object.Instantiate<GameObject>(this.effectPotion, Vector3.zero, Quaternion.identity, this.tr);
									}
									gameObject = this.effectPotions[0];
									if (gameObject.activeSelf)
									{
										this.effectPotions.RemoveAt(0);
										return gameObject;
									}
									return Object.Instantiate<GameObject>(this.effectPotion, Vector3.zero, Quaternion.identity, this.tr);
								}
								else if (num == 84)
								{
									if (this.grassExplosions.Count <= 0)
									{
										GameObject gameObject20 = Object.Instantiate<GameObject>(this.grassExplosion, Vector3.zero, Quaternion.identity, this.tr);
										this.grassExplosions.Add(gameObject20);
										return gameObject20;
									}
									gameObject = this.grassExplosions[0];
									if (!gameObject.activeSelf)
									{
										this.grassExplosions.RemoveAt(0);
										this.grassExplosions.Add(gameObject);
										return gameObject;
									}
									GameObject gameObject21 = Object.Instantiate<GameObject>(this.grassExplosion, Vector3.zero, Quaternion.identity, this.tr);
									this.grassExplosions.Add(gameObject21);
									return gameObject21;
								}
								else if (num == 86)
								{
									if (this.armorBlocks.Count <= 0)
									{
										GameObject gameObject22 = Object.Instantiate<GameObject>(this.armorBlock, Vector3.zero, Quaternion.identity, this.tr);
										this.armorBlocks.Add(gameObject22);
										return gameObject22;
									}
									gameObject = this.armorBlocks[0];
									if (!gameObject.activeSelf)
									{
										this.armorBlocks.RemoveAt(0);
										this.armorBlocks.Add(gameObject);
										return gameObject;
									}
									GameObject gameObject23 = Object.Instantiate<GameObject>(this.armorBlock, Vector3.zero, Quaternion.identity, this.tr);
									this.armorBlocks.Add(gameObject23);
									return gameObject23;
								}
								else if (num == 89)
								{
									if (this.grassInteractions.Count <= 0)
									{
										GameObject gameObject24 = Object.Instantiate<GameObject>(this.grassInteraction, Vector3.zero, Quaternion.identity, this.tr);
										this.grassInteractions.Add(gameObject24);
										return gameObject24;
									}
									gameObject = this.grassInteractions[0];
									if (!gameObject.activeSelf)
									{
										this.grassInteractions.RemoveAt(0);
										this.grassInteractions.Add(gameObject);
										return gameObject;
									}
									GameObject gameObject25 = Object.Instantiate<GameObject>(this.grassInteraction, Vector3.zero, Quaternion.identity, this.tr);
									this.grassInteractions.Add(gameObject25);
									return gameObject25;
								}
								else
								{
									if (num == 94)
									{
										if (this.wines.Count > 0)
										{
											gameObject = this.wines[0];
											if (gameObject)
											{
												this.wines.RemoveAt(0);
												return gameObject;
											}
										}
										return Object.Instantiate<GameObject>(this.wineOptions[Random.Range(0, this.wineOptions.Count - 1)], Vector3.zero, Quaternion.identity, this.tr);
									}
									if (num == 95)
									{
										if (this.steps.Count <= 0)
										{
											GameObject gameObject26 = Object.Instantiate<GameObject>(this.step, Vector3.zero, Quaternion.identity, this.tr);
											this.steps.Add(gameObject26);
											return gameObject26;
										}
										gameObject = this.steps[0];
										if (!gameObject.activeSelf)
										{
											this.steps.RemoveAt(0);
											this.steps.Add(gameObject);
											return gameObject;
										}
										GameObject gameObject27 = Object.Instantiate<GameObject>(this.step, Vector3.zero, Quaternion.identity, this.tr);
										this.steps.Add(gameObject27);
										return gameObject27;
									}
									else if (num == 97)
									{
										if (this.sporeMagics.Count > 0)
										{
											gameObject = this.sporeMagics[0];
											this.sporeMagics.RemoveAt(0);
											return gameObject;
										}
										return Object.Instantiate<GameObject>(this.sporeMagic, Vector3.zero, Quaternion.identity, this.tr);
									}
									else if (num == 99)
									{
										if (this.emptys.Count > 0)
										{
											return this.emptys[0];
										}
										GameObject gameObject28 = Object.Instantiate<GameObject>(this.empty, Vector3.zero, Quaternion.identity, this.tr);
										this.emptys.Add(gameObject28);
										return gameObject28;
									}
									else if (num == 100)
									{
										if (this.dazeds.Count <= 0)
										{
											return Object.Instantiate<GameObject>(this.dazed, Vector3.zero, Quaternion.identity, this.tr);
										}
										gameObject = this.dazeds[0];
										if (gameObject)
										{
											this.dazeds.RemoveAt(0);
											return gameObject;
										}
										return Object.Instantiate<GameObject>(this.dazed, Vector3.zero, Quaternion.identity, this.tr);
									}
									else if (num == 101)
									{
										if (this.bubbleHits.Count <= 0)
										{
											GameObject gameObject29 = Object.Instantiate<GameObject>(this.bubbleHit, Vector3.zero, Quaternion.identity, this.tr);
											this.bubbleHits.Add(gameObject);
											return gameObject29;
										}
										gameObject = this.bubbleHits[0];
										if (!gameObject)
										{
											gameObject = Object.Instantiate<GameObject>(this.bubbleHit, Vector3.zero, Quaternion.identity, this.tr);
											this.bubbleHits.Add(gameObject);
											return gameObject;
										}
										if (!gameObject.activeSelf)
										{
											this.bubbleHits.RemoveAt(0);
											this.bubbleHits.Add(gameObject);
											return gameObject;
										}
										gameObject = Object.Instantiate<GameObject>(this.bubbleHit, Vector3.zero, Quaternion.identity, this.tr);
										this.bubbleHits.Add(gameObject);
										return gameObject;
									}
									else if (num == 103)
									{
										if (this.spiritBalls.Count <= 0)
										{
											GameObject gameObject30 = Object.Instantiate<GameObject>(this.spiritBall, Vector3.zero, Quaternion.identity, this.tr);
											this.spiritBalls.Add(gameObject);
											return gameObject30;
										}
										gameObject = this.spiritBalls[0];
										if (!gameObject)
										{
											gameObject = Object.Instantiate<GameObject>(this.spiritBall, Vector3.zero, Quaternion.identity, this.tr);
											this.spiritBalls.Add(gameObject);
											return gameObject;
										}
										if (!gameObject.activeSelf)
										{
											this.spiritBalls.RemoveAt(0);
											this.spiritBalls.Add(gameObject);
											return gameObject;
										}
										gameObject = Object.Instantiate<GameObject>(this.spiritBall, Vector3.zero, Quaternion.identity, this.tr);
										this.spiritBalls.Add(gameObject);
										return gameObject;
									}
									else if (num == 102)
									{
										if (this.healthBalls.Count <= 0)
										{
											GameObject gameObject31 = Object.Instantiate<GameObject>(this.healthBall, Vector3.zero, Quaternion.identity, this.tr);
											this.healthBalls.Add(gameObject);
											return gameObject31;
										}
										gameObject = this.healthBalls[0];
										if (!gameObject)
										{
											gameObject = Object.Instantiate<GameObject>(this.healthBall, Vector3.zero, Quaternion.identity, this.tr);
											this.healthBalls.Add(gameObject);
											return gameObject;
										}
										if (!gameObject.activeSelf)
										{
											this.healthBalls.RemoveAt(0);
											this.healthBalls.Add(gameObject);
											return gameObject;
										}
										gameObject = Object.Instantiate<GameObject>(this.healthBall, Vector3.zero, Quaternion.identity, this.tr);
										this.healthBalls.Add(gameObject);
										return gameObject;
									}
									else if (num == 105)
									{
										if (this.healthBallPickups.Count <= 0)
										{
											GameObject gameObject32 = Object.Instantiate<GameObject>(this.healthBallPickup, Vector3.zero, Quaternion.identity, this.tr);
											this.healthBallPickups.Add(gameObject);
											return gameObject32;
										}
										gameObject = this.healthBallPickups[0];
										if (!gameObject)
										{
											gameObject = Object.Instantiate<GameObject>(this.healthBallPickup, Vector3.zero, Quaternion.identity, this.tr);
											this.healthBallPickups.Add(gameObject);
											return gameObject;
										}
										if (!gameObject.activeSelf)
										{
											this.healthBallPickups.RemoveAt(0);
											this.healthBallPickups.Add(gameObject);
											gameObject.transform.localScale = Vector3.one * 5f;
											return gameObject;
										}
										gameObject = Object.Instantiate<GameObject>(this.healthBallPickup, Vector3.zero, Quaternion.identity, this.tr);
										this.healthBallPickups.Add(gameObject);
										return gameObject;
									}
									else
									{
										if (num == 106)
										{
											if (this.poisonExplosions.Count > 0)
											{
												gameObject = this.poisonExplosions[0];
												if (!gameObject.activeSelf)
												{
													this.poisonExplosions.RemoveAt(0);
													this.poisonExplosions.Add(gameObject);
													return gameObject;
												}
											}
											GameObject gameObject33 = Object.Instantiate<GameObject>(this.poisonExplosion, Vector3.zero, Quaternion.identity, this.tr);
											this.poisonExplosions.Add(gameObject33);
											return gameObject33;
										}
										if (num == 119)
										{
											if (this.metalExplosions.Count > 0)
											{
												gameObject = this.metalExplosions[0];
												if (!gameObject.activeSelf)
												{
													this.metalExplosions.RemoveAt(0);
													this.metalExplosions.Add(gameObject);
													return gameObject;
												}
											}
											GameObject gameObject34 = Object.Instantiate<GameObject>(this.metalExplosion, Vector3.zero, Quaternion.identity, this.tr);
											this.metalExplosions.Add(gameObject34);
											return gameObject34;
										}
										if (num == 118)
										{
											if (this.incenseHits.Count > 0)
											{
												gameObject = this.incenseHits[0];
												if (!gameObject.activeSelf)
												{
													this.incenseHits.RemoveAt(0);
													this.poisonExplosions.Add(gameObject);
													return gameObject;
												}
											}
											GameObject gameObject35 = Object.Instantiate<GameObject>(this.incenseHit, Vector3.zero, Quaternion.identity, this.tr);
											this.incenseHits.Add(gameObject35);
											return gameObject35;
										}
										if (num == 107)
										{
											if (this.straightWaves.Count > 0)
											{
												gameObject = this.straightWaves[0];
												if (!gameObject.activeSelf)
												{
													this.straightWaves.RemoveAt(0);
													this.straightWaves.Add(gameObject);
													return gameObject;
												}
											}
											GameObject gameObject36 = Object.Instantiate<GameObject>(this.straightWave, Vector3.zero, Quaternion.identity, this.tr);
											this.straightWaves.Add(gameObject36);
											return gameObject36;
										}
										if (num == 108)
										{
											if (this.mushroomWalls.Count <= 0)
											{
												return Object.Instantiate<GameObject>(this.mushroomWall, Vector3.zero, Quaternion.identity, this.tr);
											}
											gameObject = this.mushroomWalls[0];
											if (!gameObject.activeSelf)
											{
												this.mushroomWalls.RemoveAt(0);
												return gameObject;
											}
											return Object.Instantiate<GameObject>(this.mushroomWall, Vector3.zero, Quaternion.identity, this.tr);
										}
										else if (num == 109)
										{
											if (this.greenChargeUps.Count <= 0)
											{
												return Object.Instantiate<GameObject>(this.greenChargeUp, Vector3.zero, Quaternion.identity, this.tr);
											}
											gameObject = this.greenChargeUps[0];
											if (!gameObject)
											{
												this.greenChargeUps.RemoveAt(0);
												return Object.Instantiate<GameObject>(this.greenChargeUp, Vector3.zero, Quaternion.identity, this.tr);
											}
											this.greenChargeUps.RemoveAt(0);
											return gameObject;
										}
										else if (num == 110)
										{
											if (this.poisonSplashes.Count <= 0)
											{
												return Object.Instantiate<GameObject>(this.poisonSplash, Vector3.zero, Quaternion.identity, this.tr);
											}
											gameObject = this.poisonSplashes[0];
											if (!gameObject.activeSelf)
											{
												this.poisonSplashes.RemoveAt(0);
												return gameObject;
											}
											return Object.Instantiate<GameObject>(this.poisonSplash, Vector3.zero, Quaternion.identity, this.tr);
										}
										else if (num == 111)
										{
											if (this.poisonStays.Count <= 0)
											{
												return Object.Instantiate<GameObject>(this.poisonStay, Vector3.zero, Quaternion.identity, this.tr);
											}
											gameObject = this.poisonStays[0];
											if (!gameObject.activeSelf)
											{
												this.poisonStays.RemoveAt(0);
												return gameObject;
											}
											return Object.Instantiate<GameObject>(this.poisonStay, Vector3.zero, Quaternion.identity, this.tr);
										}
										else if (num == 112)
										{
											if (this.knockbacks.Count <= 0)
											{
												GameObject gameObject37 = Object.Instantiate<GameObject>(this.knockback, Vector3.zero, Quaternion.identity, this.tr);
												this.knockbacks.Add(gameObject37);
												return gameObject37;
											}
											gameObject = this.knockbacks[0];
											if (!gameObject.activeSelf)
											{
												this.knockbacks.RemoveAt(0);
												this.knockbacks.Add(gameObject);
												gameObject.transform.localScale = Vector3.one;
												return gameObject;
											}
											GameObject gameObject38 = Object.Instantiate<GameObject>(this.knockback, Vector3.zero, Quaternion.identity, this.tr);
											this.knockbacks.Add(gameObject38);
											return gameObject38;
										}
										else if (num == 113)
										{
											if (this.crowns.Count <= 0)
											{
												return Object.Instantiate<GameObject>(this.crown, Vector3.zero, Quaternion.identity, this.tr);
											}
											gameObject = this.crowns[0];
											if (!gameObject.activeSelf)
											{
												this.crowns.RemoveAt(0);
												return gameObject;
											}
											return Object.Instantiate<GameObject>(this.crown, Vector3.zero, Quaternion.identity, this.tr);
										}
										else if (num == 114)
										{
											if (this.whiteChargeUps.Count <= 0)
											{
												return Object.Instantiate<GameObject>(this.whiteChargeUp, Vector3.zero, Quaternion.identity, this.tr);
											}
											gameObject = this.whiteChargeUps[0];
											if (!gameObject)
											{
												this.whiteChargeUps.RemoveAt(0);
												return Object.Instantiate<GameObject>(this.whiteChargeUp, Vector3.zero, Quaternion.identity, this.tr);
											}
											this.whiteChargeUps.RemoveAt(0);
											return gameObject;
										}
										else if (num == 115)
										{
											if (this.webs.Count <= 0)
											{
												return Object.Instantiate<GameObject>(this.web, Vector3.zero, Quaternion.identity, this.tr);
											}
											gameObject = this.webs[0];
											if (!gameObject.activeSelf)
											{
												this.webs.RemoveAt(0);
												return gameObject;
											}
											return Object.Instantiate<GameObject>(this.web, Vector3.zero, Quaternion.identity, this.tr);
										}
										else if (num == 116)
										{
											if (this.webPrisons.Count <= 0)
											{
												return Object.Instantiate<GameObject>(this.webPrison, Vector3.zero, Quaternion.identity, this.tr);
											}
											gameObject = this.webPrisons[0];
											if (!gameObject.activeSelf)
											{
												this.webPrisons.RemoveAt(0);
												return gameObject;
											}
											return Object.Instantiate<GameObject>(this.webPrison, Vector3.zero, Quaternion.identity, this.tr);
										}
										else if (num == 117)
										{
											if (this.boneWalls.Count <= 0)
											{
												return Object.Instantiate<GameObject>(this.boneWall, Vector3.zero, Quaternion.identity, this.tr);
											}
											gameObject = this.boneWalls[0];
											if (!gameObject.activeSelf)
											{
												this.boneWalls.RemoveAt(0);
												return gameObject;
											}
											return Object.Instantiate<GameObject>(this.boneWall, Vector3.zero, Quaternion.identity, this.tr);
										}
										else
										{
											if (num == 120)
											{
												if (this.knockbackLoops.Count > 0)
												{
													gameObject = this.knockbackLoops[0];
													if (!gameObject.activeSelf)
													{
														this.knockbackLoops.RemoveAt(0);
														return gameObject;
													}
												}
												GameObject gameObject39 = Object.Instantiate<GameObject>(this.knockbackLoop, Vector3.zero, Quaternion.identity, this.tr);
												this.knockbackLoops.Add(gameObject39);
												return gameObject39;
											}
											if (num == 121)
											{
												if (this.companionPortraits.Count > 0)
												{
													gameObject = this.companionPortraits[0];
													if (!gameObject.activeSelf)
													{
														this.companionPortraits.RemoveAt(0);
														return gameObject;
													}
												}
												GameObject gameObject40 = Object.Instantiate<GameObject>(this.companionPortrait, Vector3.zero, Quaternion.identity, Links.x.hudControl.miscFolderQuipsTransform);
												this.companionPortraits.Add(gameObject40);
												return gameObject40;
											}
											if (num == 123)
											{
												if (this.revivalGems.Count > 0)
												{
													gameObject = this.revivalGems[0];
													if (!gameObject.activeSelf)
													{
														this.revivalGems.RemoveAt(0);
														return gameObject;
													}
												}
												GameObject gameObject41 = Object.Instantiate<GameObject>(this.revivalGem, Vector3.zero, Quaternion.identity, this.tr);
												this.revivalGems.Add(gameObject41);
												return gameObject41;
											}
											if (num == 124)
											{
												if (this.pins.Count > 0)
												{
													gameObject = this.pins[0];
													if (!gameObject.activeSelf)
													{
														this.pins.RemoveAt(0);
														return gameObject;
													}
												}
												GameObject gameObject42 = Object.Instantiate<GameObject>(this.pin, Vector3.zero, Quaternion.identity, this.tr);
												this.pins.Add(gameObject42);
												return gameObject42;
											}
											if (num == 129)
											{
												if (this.knockbacksSml.Count <= 0)
												{
													GameObject gameObject43 = Object.Instantiate<GameObject>(this.knockbackSml, Vector3.zero, Quaternion.identity, this.tr);
													this.knockbacksSml.Add(gameObject43);
													return gameObject43;
												}
												gameObject = this.knockbacksSml[0];
												if (!gameObject.activeSelf)
												{
													this.knockbacksSml.RemoveAt(0);
													this.knockbacksSml.Add(gameObject);
													return gameObject;
												}
												GameObject gameObject44 = Object.Instantiate<GameObject>(this.knockbackSml, Vector3.zero, Quaternion.identity, this.tr);
												this.knockbacksSml.Add(gameObject44);
												return gameObject44;
											}
											else if (num == 130)
											{
												if (this.orangeChargeUps.Count <= 0)
												{
													return Object.Instantiate<GameObject>(this.orangeChargeUp, Vector3.zero, Quaternion.identity, this.tr);
												}
												gameObject = this.orangeChargeUps[0];
												if (!gameObject)
												{
													this.orangeChargeUps.RemoveAt(0);
													return Object.Instantiate<GameObject>(this.orangeChargeUp, Vector3.zero, Quaternion.identity, this.tr);
												}
												this.orangeChargeUps.RemoveAt(0);
												return gameObject;
											}
											else if (num == 131)
											{
												if (this.staminaRecovers.Count <= 0)
												{
													return Object.Instantiate<GameObject>(this.staminaRecover, Vector3.zero, Quaternion.identity, this.tr);
												}
												gameObject = this.staminaRecovers[0];
												if (!gameObject)
												{
													this.staminaRecovers.RemoveAt(0);
													return Object.Instantiate<GameObject>(this.staminaRecover, Vector3.zero, Quaternion.identity, this.tr);
												}
												this.staminaRecovers.RemoveAt(0);
												return gameObject;
											}
											else if (num == 132)
											{
												if (this.rains.Count <= 0)
												{
													return Object.Instantiate<GameObject>(this.rain, Vector3.zero, Quaternion.identity, this.tr);
												}
												gameObject = this.rains[0];
												if (!gameObject)
												{
													this.rains.RemoveAt(0);
													return Object.Instantiate<GameObject>(this.rain, Vector3.zero, Quaternion.identity, this.tr);
												}
												this.rains.RemoveAt(0);
												return gameObject;
											}
											else if (num == 133)
											{
												if (this.barrelsBreakings.Count > 0)
												{
													gameObject = this.barrelsBreakings[0];
													this.barrelsBreakings.RemoveAt(0);
													return gameObject;
												}
												return Object.Instantiate<GameObject>(this.barrelsBreaking, Vector3.zero, Quaternion.identity, this.tr);
											}
											else if (num == 134)
											{
												if (this.exitIcons.Count > 0)
												{
													gameObject = this.exitIcons[0];
													this.exitIcons.RemoveAt(0);
													return gameObject;
												}
												return Object.Instantiate<GameObject>(this.exitIcon, Vector3.zero, Quaternion.identity, this.tr);
											}
											else if (num == 135)
											{
												if (this.shroomBombs.Count <= 0)
												{
													GameObject gameObject45 = Object.Instantiate<GameObject>(this.shroomBomb, Vector3.zero, Quaternion.identity, this.tr);
													this.shroomBombs.Add(gameObject45);
													return gameObject45;
												}
												gameObject = this.shroomBombs[0];
												if (!gameObject.activeSelf)
												{
													this.shroomBombs.RemoveAt(0);
													this.shroomBombs.Add(gameObject);
													return gameObject;
												}
												GameObject gameObject46 = Object.Instantiate<GameObject>(this.shroomBomb, Vector3.zero, Quaternion.identity, this.tr);
												this.shroomBombs.Add(gameObject46);
												return gameObject46;
											}
											else if (num == 136)
											{
												if (this.boroBoats.Count <= 0)
												{
													return Object.Instantiate<GameObject>(this.boroBoat, Vector3.zero, Quaternion.identity, this.tr);
												}
												gameObject = this.boroBoats[0];
												if (!gameObject.activeSelf)
												{
													this.boroBoats.RemoveAt(0);
													return gameObject;
												}
												return Object.Instantiate<GameObject>(this.boroBoat, Vector3.zero, Quaternion.identity, this.tr);
											}
											else if (num == 137)
											{
												if (this.oars.Count <= 0)
												{
													return Object.Instantiate<GameObject>(this.oar, Vector3.zero, Quaternion.identity, this.tr);
												}
												gameObject = this.oars[0];
												if (!gameObject.activeSelf)
												{
													this.oars.RemoveAt(0);
													return gameObject;
												}
												return Object.Instantiate<GameObject>(this.oar, Vector3.zero, Quaternion.identity, this.tr);
											}
											else if (num == 138)
											{
												if (this.boatSplashBacks.Count <= 0)
												{
													return Object.Instantiate<GameObject>(this.boatSplashBack, Vector3.zero, Quaternion.identity, this.tr);
												}
												gameObject = this.boatSplashBacks[0];
												if (!gameObject.activeSelf)
												{
													this.boatSplashBacks.RemoveAt(0);
													return gameObject;
												}
												return Object.Instantiate<GameObject>(this.boatSplashBack, Vector3.zero, Quaternion.identity, this.tr);
											}
											else if (num == 139)
											{
												if (this.boatSplashFronts.Count <= 0)
												{
													return Object.Instantiate<GameObject>(this.boatSplashFront, Vector3.zero, Quaternion.identity, this.tr);
												}
												gameObject = this.boatSplashFronts[0];
												if (!gameObject.activeSelf)
												{
													this.boatSplashFronts.RemoveAt(0);
													return gameObject;
												}
												return Object.Instantiate<GameObject>(this.boatSplashFront, Vector3.zero, Quaternion.identity, this.tr);
											}
											else if (num == 140)
											{
												if (this.boatSplashOars.Count <= 0)
												{
													return Object.Instantiate<GameObject>(this.boatSplashOar, Vector3.zero, Quaternion.identity, this.tr);
												}
												gameObject = this.boatSplashOars[0];
												if (!gameObject.activeSelf)
												{
													this.boatSplashOars.RemoveAt(0);
													return gameObject;
												}
												return Object.Instantiate<GameObject>(this.boatSplashOar, Vector3.zero, Quaternion.identity, this.tr);
											}
											else
											{
												if (num != 141)
												{
													return null;
												}
												if (this.creatureSplashes.Count <= 0)
												{
													return Object.Instantiate<GameObject>(this.creatureSplash, Vector3.zero, Quaternion.identity, this.tr);
												}
												gameObject = this.creatureSplashes[0];
												if (!gameObject.activeSelf)
												{
													this.creatureSplashes.RemoveAt(0);
													return gameObject;
												}
												return Object.Instantiate<GameObject>(this.creatureSplash, Vector3.zero, Quaternion.identity, this.tr);
											}
										}
									}
								}
							}
						}
					}
				}
			}
		}
	}

	// Token: 0x06000BDC RID: 3036 RVA: 0x000E7198 File Offset: 0x000E5398
	public void CheckIfTooMany()
	{
		if (this.bloodBurstSmls.Count > 20)
		{
			for (int i = 20; i < this.bloodBurstSmls.Count; i++)
			{
				if (this.bloodBurstSmls[i])
				{
					Object.Destroy(this.bloodBurstSmls[i]);
					this.bloodBurstSmls[i] = null;
				}
			}
			this.bloodBurstSmls.RemoveAll((GameObject item) => item == null);
		}
		if (this.bloodBurstMeds.Count > 20)
		{
			for (int j = 20; j < this.bloodBurstMeds.Count; j++)
			{
				if (this.bloodBurstMeds[j])
				{
					Object.Destroy(this.bloodBurstMeds[j]);
					this.bloodBurstMeds[j] = null;
				}
			}
			this.bloodBurstMeds.RemoveAll((GameObject item) => item == null);
		}
		if (this.bloodBurstLrgs.Count > 20)
		{
			for (int k = 20; k < this.bloodBurstLrgs.Count; k++)
			{
				if (this.bloodBurstLrgs[k])
				{
					Object.Destroy(this.bloodBurstLrgs[k]);
					this.bloodBurstLrgs[k] = null;
				}
			}
			this.bloodBurstLrgs.RemoveAll((GameObject item) => item == null);
		}
		if (this.gorePilesRb.Count > 20)
		{
			for (int l = 20; l < this.gorePilesRb.Count; l++)
			{
				if (this.gorePilesRb[l])
				{
					Object.Destroy(this.gorePilesRb[l]);
					this.gorePilesRb[l] = null;
				}
			}
			this.gorePilesRb.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectStuns.Count > 5)
		{
			for (int m = 5; m < this.effectStuns.Count; m++)
			{
				if (this.effectStuns[m])
				{
					Object.Destroy(this.effectStuns[m]);
					this.effectStuns[m] = null;
				}
			}
			this.effectStuns.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectShimmerThrees.Count > 5)
		{
			for (int n = 5; n < this.effectShimmerThrees.Count; n++)
			{
				if (this.effectShimmerThrees[n])
				{
					Object.Destroy(this.effectShimmerThrees[n]);
					this.effectShimmerThrees[n] = null;
				}
			}
			this.effectShimmerThrees.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectVinesJumps.Count > 10)
		{
			for (int num = 10; num < this.effectVinesJumps.Count; num++)
			{
				if (this.effectVinesJumps[num])
				{
					Object.Destroy(this.effectVinesJumps[num]);
					this.effectVinesJumps[num] = null;
				}
			}
			this.effectVinesJumps.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectVinesHolds.Count > 5)
		{
			for (int num2 = 5; num2 < this.effectVinesHolds.Count; num2++)
			{
				if (this.effectVinesHolds[num2])
				{
					Object.Destroy(this.effectVinesHolds[num2]);
					this.effectVinesHolds[num2] = null;
				}
			}
			this.effectVinesHolds.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectHealeds.Count > 10)
		{
			for (int num3 = 10; num3 < this.effectHealeds.Count; num3++)
			{
				if (this.effectHealeds[num3])
				{
					Object.Destroy(this.effectHealeds[num3]);
					this.effectHealeds[num3] = null;
				}
			}
			this.effectHealeds.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectFaileds.Count > 5)
		{
			for (int num4 = 5; num4 < this.effectFaileds.Count; num4++)
			{
				if (this.effectFaileds[num4])
				{
					Object.Destroy(this.effectFaileds[num4]);
					this.effectFaileds[num4] = null;
				}
			}
			this.effectFaileds.RemoveAll((GameObject item) => item == null);
		}
		if (this.buffRemoveds.Count > 5)
		{
			for (int num5 = 5; num5 < this.buffRemoveds.Count; num5++)
			{
				if (this.buffRemoveds[num5])
				{
					Object.Destroy(this.buffRemoveds[num5]);
					this.buffRemoveds[num5] = null;
				}
			}
			this.buffRemoveds.RemoveAll((GameObject item) => item == null);
		}
		if (this.itemPickups.Count > 10)
		{
			for (int num6 = 10; num6 < this.itemPickups.Count; num6++)
			{
				if (this.itemPickups[num6])
				{
					Object.Destroy(this.itemPickups[num6]);
					this.itemPickups[num6] = null;
				}
			}
			this.itemPickups.RemoveAll((GameObject item) => item == null);
		}
		if (this.oils.Count > 20)
		{
			for (int num7 = 20; num7 < this.oils.Count; num7++)
			{
				if (this.oils[num7])
				{
					Object.Destroy(this.oils[num7]);
					this.oils[num7] = null;
				}
			}
			this.oils.RemoveAll((GameObject item) => item == null);
		}
		if (this.saps.Count > 20)
		{
			for (int num8 = 20; num8 < this.saps.Count; num8++)
			{
				if (this.saps[num8])
				{
					Object.Destroy(this.saps[num8]);
					this.saps[num8] = null;
				}
			}
			this.saps.RemoveAll((GameObject item) => item == null);
		}
		if (this.bloodBurstShroomerSmls.Count > 0)
		{
			for (int num9 = 0; num9 < this.bloodBurstShroomerSmls.Count; num9++)
			{
				if (this.bloodBurstShroomerSmls[num9])
				{
					Object.Destroy(this.bloodBurstShroomerSmls[num9]);
					this.bloodBurstShroomerSmls[num9] = null;
				}
			}
			this.bloodBurstShroomerSmls.RemoveAll((GameObject item) => item == null);
		}
		if (this.seens.Count > 20)
		{
			for (int num10 = 20; num10 < this.seens.Count; num10++)
			{
				if (this.seens[num10])
				{
					Object.Destroy(this.seens[num10]);
					this.seens[num10] = null;
				}
			}
			this.seens.RemoveAll((GameObject item) => item == null);
		}
		if (this.heards.Count > 20)
		{
			for (int num11 = 20; num11 < this.heards.Count; num11++)
			{
				if (this.heards[num11])
				{
					Object.Destroy(this.heards[num11]);
					this.heards[num11] = null;
				}
			}
			this.heards.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectSpellCasts.Count > 5)
		{
			for (int num12 = 5; num12 < this.effectSpellCasts.Count; num12++)
			{
				if (this.effectSpellCasts[num12])
				{
					Object.Destroy(this.effectSpellCasts[num12]);
					this.effectSpellCasts[num12] = null;
				}
			}
			this.effectSpellCasts.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectSporesPukes.Count > 20)
		{
			for (int num13 = 20; num13 < this.effectSporesPukes.Count; num13++)
			{
				if (this.effectSporesPukes[num13])
				{
					Object.Destroy(this.effectSporesPukes[num13]);
					this.effectSporesPukes[num13] = null;
				}
			}
			this.effectSporesPukes.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectSporesPukeHeads.Count > 10)
		{
			for (int num14 = 10; num14 < this.effectSporesPukeHeads.Count; num14++)
			{
				if (this.effectSporesPukeHeads[num14])
				{
					Object.Destroy(this.effectSporesPukeHeads[num14]);
					this.effectSporesPukeHeads[num14] = null;
				}
			}
			this.effectSporesPukeHeads.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectSporesHealings.Count > 10)
		{
			for (int num15 = 10; num15 < this.effectSporesHealings.Count; num15++)
			{
				if (this.effectSporesHealings[num15])
				{
					Object.Destroy(this.effectSporesHealings[num15]);
					this.effectSporesHealings[num15] = null;
				}
			}
			this.effectSporesHealings.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectSporesHealingHeads.Count > 10)
		{
			for (int num16 = 10; num16 < this.effectSporesHealingHeads.Count; num16++)
			{
				if (this.effectSporesHealingHeads[num16])
				{
					Object.Destroy(this.effectSporesHealingHeads[num16]);
					this.effectSporesHealingHeads[num16] = null;
				}
			}
			this.effectSporesHealingHeads.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectRockWalls.Count > 30)
		{
			for (int num17 = 30; num17 < this.effectRockWalls.Count; num17++)
			{
				if (this.effectRockWalls[num17])
				{
					Object.Destroy(this.effectRockWalls[num17]);
					this.effectRockWalls[num17] = null;
				}
			}
			this.effectRockWalls.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectSlipSlimes.Count > 30)
		{
			for (int num18 = 30; num18 < this.effectSlipSlimes.Count; num18++)
			{
				if (this.effectSlipSlimes[num18])
				{
					Object.Destroy(this.effectSlipSlimes[num18]);
					this.effectSlipSlimes[num18] = null;
				}
			}
			this.effectSlipSlimes.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectMosses.Count > 40)
		{
			for (int num19 = 40; num19 < this.effectMosses.Count; num19++)
			{
				if (this.effectMosses[num19])
				{
					Object.Destroy(this.effectMosses[num19]);
					this.effectMosses[num19] = null;
				}
			}
			this.effectMosses.RemoveAll((GameObject item) => item == null);
		}
		if (this.summonStarts.Count > 5)
		{
			for (int num20 = 5; num20 < this.summonStarts.Count; num20++)
			{
				if (this.summonStarts[num20])
				{
					Object.Destroy(this.summonStarts[num20]);
					this.summonStarts[num20] = null;
				}
			}
			this.summonStarts.RemoveAll((GameObject item) => item == null);
		}
		if (this.itemInRanges.Count > 20)
		{
			for (int num21 = 20; num21 < this.itemInRanges.Count; num21++)
			{
				if (this.itemInRanges[num21])
				{
					Object.Destroy(this.itemInRanges[num21]);
					this.itemInRanges[num21] = null;
				}
			}
			this.itemInRanges.RemoveAll((GameObject item) => item == null);
		}
		if (this.itemInRangesForSale.Count > 30)
		{
			for (int num22 = 30; num22 < this.itemInRangesForSale.Count; num22++)
			{
				if (this.itemInRangesForSale[num22])
				{
					Object.Destroy(this.itemInRangesForSale[num22]);
					this.itemInRangesForSale[num22] = null;
				}
			}
			this.itemInRangesForSale.RemoveAll((GameObject item) => item == null);
		}
		if (this.summonEnds.Count > 10)
		{
			for (int num23 = 10; num23 < this.summonEnds.Count; num23++)
			{
				if (this.summonEnds[num23])
				{
					Object.Destroy(this.summonEnds[num23]);
					this.summonEnds[num23] = null;
				}
			}
			this.summonEnds.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectMusics.Count > 10)
		{
			for (int num24 = 10; num24 < this.effectMusics.Count; num24++)
			{
				if (this.effectMusics[num24])
				{
					Object.Destroy(this.effectMusics[num24]);
					this.effectMusics[num24] = null;
				}
			}
			this.effectMusics.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectMusicBuffs.Count > 10)
		{
			for (int num25 = 10; num25 < this.effectMusicBuffs.Count; num25++)
			{
				if (this.effectMusicBuffs[num25])
				{
					Object.Destroy(this.effectMusicBuffs[num25]);
					this.effectMusicBuffs[num25] = null;
				}
			}
			this.effectMusicBuffs.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectIcons.Count > 30)
		{
			for (int num26 = 30; num26 < this.effectIcons.Count; num26++)
			{
				if (this.effectIcons[num26])
				{
					Object.Destroy(this.effectIcons[num26]);
					this.effectIcons[num26] = null;
				}
			}
			this.effectIcons.RemoveAll((GameObject item) => item == null);
		}
		if (this.elixirExplosions.Count > 10)
		{
			for (int num27 = 10; num27 < this.elixirExplosions.Count; num27++)
			{
				if (this.elixirExplosions[num27])
				{
					Object.Destroy(this.elixirExplosions[num27]);
					this.elixirExplosions[num27] = null;
				}
			}
			this.elixirExplosions.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectTileNaps.Count > 0)
		{
			for (int num28 = 0; num28 < this.effectTileNaps.Count; num28++)
			{
				if (this.effectTileNaps[num28])
				{
					Object.Destroy(this.effectTileNaps[num28]);
					this.effectTileNaps[num28] = null;
				}
			}
			this.effectTileNaps.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectTileHealings.Count > 3)
		{
			for (int num29 = 3; num29 < this.effectTileHealings.Count; num29++)
			{
				if (this.effectTileHealings[num29])
				{
					Object.Destroy(this.effectTileHealings[num29]);
					this.effectTileHealings[num29] = null;
				}
			}
			this.effectTileHealings.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectTileFires.Count > 0)
		{
			for (int num30 = 0; num30 < this.effectTileFires.Count; num30++)
			{
				if (this.effectTileFires[num30])
				{
					Object.Destroy(this.effectTileFires[num30]);
					this.effectTileFires[num30] = null;
				}
			}
			this.effectTileFires.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectMoveSpeedDowns.Count > 0)
		{
			for (int num31 = 0; num31 < this.effectMoveSpeedDowns.Count; num31++)
			{
				if (this.effectMoveSpeedDowns[num31])
				{
					Object.Destroy(this.effectMoveSpeedDowns[num31]);
					this.effectMoveSpeedDowns[num31] = null;
				}
			}
			this.effectMoveSpeedDowns.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectMoveSpeedUps.Count > 0)
		{
			for (int num32 = 0; num32 < this.effectMoveSpeedUps.Count; num32++)
			{
				if (this.effectMoveSpeedUps[num32])
				{
					Object.Destroy(this.effectMoveSpeedUps[num32]);
					this.effectMoveSpeedUps[num32] = null;
				}
			}
			this.effectMoveSpeedUps.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectTileAttractions.Count > 0)
		{
			for (int num33 = 0; num33 < this.effectTileAttractions.Count; num33++)
			{
				if (this.effectTileAttractions[num33])
				{
					Object.Destroy(this.effectTileAttractions[num33]);
					this.effectTileAttractions[num33] = null;
				}
			}
			this.effectTileAttractions.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectSleeps.Count > 0)
		{
			for (int num34 = 0; num34 < this.effectSleeps.Count; num34++)
			{
				if (this.effectSleeps[num34])
				{
					Object.Destroy(this.effectSleeps[num34]);
					this.effectSleeps[num34] = null;
				}
			}
			this.effectSleeps.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectHealings.Count > 0)
		{
			for (int num35 = 0; num35 < this.effectHealings.Count; num35++)
			{
				if (this.effectHealings[num35])
				{
					Object.Destroy(this.effectHealings[num35]);
					this.effectHealings[num35] = null;
				}
			}
			this.effectHealings.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectActionTimeUps.Count > 0)
		{
			for (int num36 = 0; num36 < this.effectActionTimeUps.Count; num36++)
			{
				if (this.effectActionTimeUps[num36])
				{
					Object.Destroy(this.effectActionTimeUps[num36]);
					this.effectActionTimeUps[num36] = null;
				}
			}
			this.effectActionTimeUps.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectConfuseds.Count > 0)
		{
			for (int num37 = 0; num37 < this.effectConfuseds.Count; num37++)
			{
				if (this.effectConfuseds[num37])
				{
					Object.Destroy(this.effectConfuseds[num37]);
					this.effectConfuseds[num37] = null;
				}
			}
			this.effectConfuseds.RemoveAll((GameObject item) => item == null);
		}
		if (this.ghostHeads.Count > 0)
		{
			for (int num38 = 0; num38 < this.ghostHeads.Count; num38++)
			{
				if (this.ghostHeads[num38])
				{
					Object.Destroy(this.ghostHeads[num38]);
					this.ghostHeads[num38] = null;
				}
			}
			this.ghostHeads.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectWaypoints.Count > 10)
		{
			for (int num39 = 10; num39 < this.effectWaypoints.Count; num39++)
			{
				if (this.effectWaypoints[num39])
				{
					Object.Destroy(this.effectWaypoints[num39]);
					this.effectWaypoints[num39] = null;
				}
			}
			this.effectWaypoints.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectCharmeds.Count > 10)
		{
			for (int num40 = 10; num40 < this.effectCharmeds.Count; num40++)
			{
				if (this.effectCharmeds[num40])
				{
					Object.Destroy(this.effectCharmeds[num40]);
					this.effectCharmeds[num40] = null;
				}
			}
			this.effectCharmeds.RemoveAll((GameObject item) => item == null);
		}
		if (this.leafExplosions.Count > 10)
		{
			for (int num41 = 10; num41 < this.leafExplosions.Count; num41++)
			{
				if (this.leafExplosions[num41])
				{
					Object.Destroy(this.leafExplosions[num41]);
					this.leafExplosions[num41] = null;
				}
			}
			this.leafExplosions.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectCharmedFails.Count > 10)
		{
			for (int num42 = 10; num42 < this.effectCharmedFails.Count; num42++)
			{
				if (this.effectCharmedFails[num42])
				{
					Object.Destroy(this.effectCharmedFails[num42]);
					this.effectCharmedFails[num42] = null;
				}
			}
			this.effectCharmedFails.RemoveAll((GameObject item) => item == null);
		}
		if (this.brackets.Count > 10)
		{
			for (int num43 = 10; num43 < this.brackets.Count; num43++)
			{
				if (this.brackets[num43])
				{
					Object.Destroy(this.brackets[num43]);
					this.brackets[num43] = null;
				}
			}
			this.brackets.RemoveAll((GameObject item) => item == null);
		}
		if (this.spiritLeavings.Count > 10)
		{
			for (int num44 = 10; num44 < this.spiritLeavings.Count; num44++)
			{
				if (this.spiritLeavings[num44])
				{
					Object.Destroy(this.spiritLeavings[num44]);
					this.spiritLeavings[num44] = null;
				}
			}
			this.spiritLeavings.RemoveAll((GameObject item) => item == null);
		}
		if (this.incenses.Count > 0)
		{
			for (int num45 = 0; num45 < this.incenses.Count; num45++)
			{
				if (this.incenses[num45])
				{
					Object.Destroy(this.incenses[num45]);
					this.incenses[num45] = null;
				}
			}
			this.incenses.RemoveAll((GameObject item) => item == null);
		}
		if (this.healthBars.Count > 0)
		{
			for (int num46 = 0; num46 < this.healthBars.Count; num46++)
			{
				if (this.healthBars[num46])
				{
					Object.Destroy(this.healthBars[num46]);
					this.healthBars[num46] = null;
				}
			}
			this.healthBars.RemoveAll((GameObject item) => item == null);
		}
		if (this.staminaBars.Count > 20)
		{
			for (int num47 = 0; num47 < this.staminaBars.Count; num47++)
			{
				if (this.staminaBars[num47])
				{
					Object.Destroy(this.staminaBars[num47]);
					this.staminaBars[num47] = null;
				}
			}
			this.staminaBars.RemoveAll((GameObject item) => item == null);
		}
		if (this.hearts.Count > 5)
		{
			for (int num48 = 5; num48 < this.hearts.Count; num48++)
			{
				if (this.hearts[num48])
				{
					Object.Destroy(this.hearts[num48]);
					this.hearts[num48] = null;
				}
			}
			this.hearts.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectWordOfPowers.Count > 0)
		{
			for (int num49 = 0; num49 < this.effectWordOfPowers.Count; num49++)
			{
				if (this.effectWordOfPowers[num49])
				{
					Object.Destroy(this.effectWordOfPowers[num49]);
					this.effectWordOfPowers[num49] = null;
				}
			}
			this.effectWordOfPowers.RemoveAll((GameObject item) => item == null);
		}
		if (this.spellCastings.Count > 3)
		{
			for (int num50 = 3; num50 < this.spellCastings.Count; num50++)
			{
				if (this.spellCastings[num50])
				{
					Object.Destroy(this.spellCastings[num50]);
					this.spellCastings[num50] = null;
				}
			}
			this.spellCastings.RemoveAll((GameObject item) => item == null);
		}
		if (this.spellCastingTargets.Count > 3)
		{
			for (int num51 = 3; num51 < this.spellCastingTargets.Count; num51++)
			{
				if (this.spellCastingTargets[num51])
				{
					Object.Destroy(this.spellCastingTargets[num51]);
					this.spellCastingTargets[num51] = null;
				}
			}
			this.spellCastingTargets.RemoveAll((GameObject item) => item == null);
		}
		if (this.spellCastingTargetFails.Count > 0)
		{
			for (int num52 = 0; num52 < this.spellCastingTargetFails.Count; num52++)
			{
				if (this.spellCastingTargetFails[num52])
				{
					Object.Destroy(this.spellCastingTargetFails[num52]);
					this.spellCastingTargetFails[num52] = null;
				}
			}
			this.spellCastingTargetFails.RemoveAll((GameObject item) => item == null);
		}
		if (this.spiritTiles.Count > 5)
		{
			for (int num53 = 5; num53 < this.spiritTiles.Count; num53++)
			{
				if (this.spiritTiles[num53])
				{
					Object.Destroy(this.spiritTiles[num53]);
					this.spiritTiles[num53] = null;
				}
			}
			this.spiritTiles.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectFloats.Count > 4)
		{
			for (int num54 = 4; num54 < this.effectFloats.Count; num54++)
			{
				if (this.effectFloats[num54])
				{
					Object.Destroy(this.effectFloats[num54]);
					this.effectFloats[num54] = null;
				}
			}
			this.effectFloats.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectVineCocoons.Count > 5)
		{
			for (int num55 = 5; num55 < this.effectVineCocoons.Count; num55++)
			{
				if (this.effectVineCocoons[num55])
				{
					Object.Destroy(this.effectVineCocoons[num55]);
					this.effectVineCocoons[num55] = null;
				}
			}
			this.effectVineCocoons.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectVinePrisons.Count > 4)
		{
			for (int num56 = 4; num56 < this.effectVinePrisons.Count; num56++)
			{
				if (this.effectVinePrisons[num56])
				{
					Object.Destroy(this.effectVinePrisons[num56]);
					this.effectVinePrisons[num56] = null;
				}
			}
			this.effectVinePrisons.RemoveAll((GameObject item) => item == null);
		}
		if (this.faunaFrogs.Count > 5)
		{
			for (int num57 = 5; num57 < this.faunaFrogs.Count; num57++)
			{
				if (this.faunaFrogs[num57])
				{
					Object.Destroy(this.faunaFrogs[num57]);
					this.faunaFrogs[num57] = null;
				}
			}
			this.faunaFrogs.RemoveAll((GameObject item) => item == null);
		}
		if (this.faunaLizards.Count > 5)
		{
			for (int num58 = 5; num58 < this.faunaLizards.Count; num58++)
			{
				if (this.faunaLizards[num58])
				{
					Object.Destroy(this.faunaLizards[num58]);
					this.faunaLizards[num58] = null;
				}
			}
			this.faunaLizards.RemoveAll((GameObject item) => item == null);
		}
		if (this.faunaCarrions.Count > 0)
		{
			for (int num59 = 0; num59 < this.faunaCarrions.Count; num59++)
			{
				if (this.faunaCarrions[num59])
				{
					Object.Destroy(this.faunaCarrions[num59]);
					this.faunaCarrions[num59] = null;
				}
			}
			this.faunaCarrions.RemoveAll((GameObject item) => item == null);
		}
		if (this.faunaRolys.Count > 5)
		{
			for (int num60 = 5; num60 < this.faunaRolys.Count; num60++)
			{
				if (this.faunaRolys[num60])
				{
					Object.Destroy(this.faunaRolys[num60]);
					this.faunaRolys[num60] = null;
				}
			}
			this.faunaRolys.RemoveAll((GameObject item) => item == null);
		}
		if (this.faunaNests.Count > 5)
		{
			for (int num61 = 5; num61 < this.faunaNests.Count; num61++)
			{
				if (this.faunaNests[num61])
				{
					Object.Destroy(this.faunaNests[num61]);
					this.faunaNests[num61] = null;
				}
			}
			this.faunaNests.RemoveAll((GameObject item) => item == null);
		}
		if (this.faunaBees.Count > 10)
		{
			for (int num62 = 10; num62 < this.faunaBees.Count; num62++)
			{
				if (this.faunaBees[num62])
				{
					Object.Destroy(this.faunaBees[num62]);
					this.faunaBees[num62] = null;
				}
			}
			this.faunaBees.RemoveAll((GameObject item) => item == null);
		}
		if (this.synergies.Count > 4)
		{
			for (int num63 = 4; num63 < this.synergies.Count; num63++)
			{
				if (this.synergies[num63])
				{
					Object.Destroy(this.synergies[num63]);
					this.synergies[num63] = null;
				}
			}
			this.synergies.RemoveAll((GameObject item) => item == null);
		}
		if (this.spellWaves.Count > 4)
		{
			for (int num64 = 4; num64 < this.spellWaves.Count; num64++)
			{
				if (this.spellWaves[num64])
				{
					Object.Destroy(this.spellWaves[num64]);
					this.spellWaves[num64] = null;
				}
			}
			this.spellWaves.RemoveAll((GameObject item) => item == null);
		}
		if (this.evadings.Count > 3)
		{
			for (int num65 = 3; num65 < this.evadings.Count; num65++)
			{
				if (this.evadings[num65])
				{
					Object.Destroy(this.evadings[num65]);
					this.evadings[num65] = null;
				}
			}
			this.evadings.RemoveAll((GameObject item) => item == null);
		}
		if (this.rages.Count > 3)
		{
			for (int num66 = 3; num66 < this.rages.Count; num66++)
			{
				if (this.rages[num66])
				{
					Object.Destroy(this.rages[num66]);
					this.rages[num66] = null;
				}
			}
			this.rages.RemoveAll((GameObject item) => item == null);
		}
		if (this.effectPotions.Count > 4)
		{
			for (int num67 = 4; num67 < this.effectPotions.Count; num67++)
			{
				if (this.effectPotions[num67])
				{
					Object.Destroy(this.effectPotions[num67]);
					this.effectPotions[num67] = null;
				}
			}
			this.effectPotions.RemoveAll((GameObject item) => item == null);
		}
		if (this.grassExplosions.Count > 10)
		{
			for (int num68 = 10; num68 < this.grassExplosions.Count; num68++)
			{
				if (this.grassExplosions[num68])
				{
					Object.Destroy(this.grassExplosions[num68]);
					this.grassExplosions[num68] = null;
				}
			}
			this.grassExplosions.RemoveAll((GameObject item) => item == null);
		}
		if (this.armorBlocks.Count > 10)
		{
			for (int num69 = 10; num69 < this.armorBlocks.Count; num69++)
			{
				if (this.armorBlocks[num69])
				{
					Object.Destroy(this.armorBlocks[num69]);
					this.armorBlocks[num69] = null;
				}
			}
			this.armorBlocks.RemoveAll((GameObject item) => item == null);
		}
		if (this.wines.Count > 0)
		{
			for (int num70 = 0; num70 < this.grassInteractions.Count; num70++)
			{
				if (this.grassInteractions[num70])
				{
					Object.Destroy(this.grassInteractions[num70]);
					this.grassInteractions[num70] = null;
				}
			}
			this.grassInteractions.RemoveAll((GameObject item) => item == null);
		}
		if (this.steps.Count > 10)
		{
			for (int num71 = 10; num71 < this.steps.Count; num71++)
			{
				if (this.steps[num71])
				{
					Object.Destroy(this.steps[num71]);
					this.steps[num71] = null;
				}
			}
			this.steps.RemoveAll((GameObject item) => item == null);
		}
		if (this.sporeMagics.Count > 10)
		{
			for (int num72 = 10; num72 < this.sporeMagics.Count; num72++)
			{
				if (this.sporeMagics[num72])
				{
					Object.Destroy(this.emptyPoints[num72]);
					this.sporeMagics[num72] = null;
				}
			}
			this.sporeMagics.RemoveAll((GameObject item) => item == null);
		}
		if (this.emptys.Count > 20)
		{
			for (int num73 = 20; num73 < this.emptys.Count; num73++)
			{
				if (this.emptys[num73])
				{
					Object.Destroy(this.emptys[num73]);
					this.emptys[num73] = null;
				}
			}
			this.emptys.RemoveAll((GameObject item) => item == null);
		}
		if (this.dazeds.Count > 4)
		{
			for (int num74 = 4; num74 < this.dazeds.Count; num74++)
			{
				if (this.dazeds[num74])
				{
					Object.Destroy(this.dazeds[num74]);
					this.dazeds[num74] = null;
				}
			}
			this.dazeds.RemoveAll((GameObject item) => item == null);
		}
		if (this.bubbleHits.Count > 1)
		{
			for (int num75 = 1; num75 < this.bubbleHits.Count; num75++)
			{
				if (this.bubbleHits[num75])
				{
					Object.Destroy(this.bubbleHits[num75]);
					this.bubbleHits[num75] = null;
				}
			}
			this.bubbleHits.RemoveAll((GameObject item) => item == null);
		}
		if (this.spiritBalls.Count > 5)
		{
			for (int num76 = 5; num76 < this.spiritBalls.Count; num76++)
			{
				if (this.spiritBalls[num76])
				{
					Object.Destroy(this.spiritBalls[num76]);
					this.spiritBalls[num76] = null;
				}
			}
			this.spiritBalls.RemoveAll((GameObject item) => item == null);
		}
		if (this.healthBalls.Count > 10)
		{
			for (int num77 = 10; num77 < this.healthBalls.Count; num77++)
			{
				if (this.healthBalls[num77])
				{
					Object.Destroy(this.healthBalls[num77]);
					this.healthBalls[num77] = null;
				}
			}
			this.healthBalls.RemoveAll((GameObject item) => item == null);
		}
		if (this.healthBallPickups.Count > 10)
		{
			for (int num78 = 10; num78 < this.healthBallPickups.Count; num78++)
			{
				if (this.healthBallPickups[num78])
				{
					Object.Destroy(this.healthBallPickups[num78]);
					this.healthBallPickups[num78] = null;
				}
			}
			this.healthBallPickups.RemoveAll((GameObject item) => item == null);
		}
		if (this.poisonExplosions.Count > 5)
		{
			for (int num79 = 5; num79 < this.poisonExplosions.Count; num79++)
			{
				if (this.poisonExplosions[num79])
				{
					Object.Destroy(this.poisonExplosions[num79]);
					this.poisonExplosions[num79] = null;
				}
			}
			this.poisonExplosions.RemoveAll((GameObject item) => item == null);
		}
		if (this.metalExplosions.Count > 3)
		{
			for (int num80 = 3; num80 < this.metalExplosions.Count; num80++)
			{
				if (this.metalExplosions[num80])
				{
					Object.Destroy(this.metalExplosions[num80]);
					this.metalExplosions[num80] = null;
				}
			}
			this.metalExplosions.RemoveAll((GameObject item) => item == null);
		}
		if (this.incenseHits.Count > 1)
		{
			for (int num81 = 1; num81 < this.incenseHits.Count; num81++)
			{
				if (this.incenseHits[num81])
				{
					Object.Destroy(this.incenseHits[num81]);
					this.incenseHits[num81] = null;
				}
			}
			this.incenseHits.RemoveAll((GameObject item) => item == null);
		}
		if (this.straightWaves.Count > 5)
		{
			for (int num82 = 5; num82 < this.straightWaves.Count; num82++)
			{
				if (this.straightWaves[num82])
				{
					Object.Destroy(this.straightWaves[num82]);
					this.straightWaves[num82] = null;
				}
			}
			this.straightWaves.RemoveAll((GameObject item) => item == null);
		}
		if (this.mushroomWalls.Count > 1)
		{
			for (int num83 = 1; num83 < this.mushroomWalls.Count; num83++)
			{
				if (this.mushroomWalls[num83])
				{
					Object.Destroy(this.mushroomWalls[num83]);
					this.mushroomWalls[num83] = null;
				}
			}
			this.mushroomWalls.RemoveAll((GameObject item) => item == null);
		}
		if (this.greenChargeUps.Count > 2)
		{
			for (int num84 = 2; num84 < this.greenChargeUps.Count; num84++)
			{
				if (this.greenChargeUps[num84])
				{
					Object.Destroy(this.greenChargeUps[num84]);
					this.greenChargeUps[num84] = null;
				}
			}
			this.greenChargeUps.RemoveAll((GameObject item) => item == null);
		}
		if (this.poisonSplashes.Count > 2)
		{
			for (int num85 = 2; num85 < this.poisonSplashes.Count; num85++)
			{
				if (this.poisonSplashes[num85])
				{
					Object.Destroy(this.poisonSplashes[num85]);
					this.poisonSplashes[num85] = null;
				}
			}
			this.poisonSplashes.RemoveAll((GameObject item) => item == null);
		}
		if (this.poisonStays.Count > 3)
		{
			for (int num86 = 3; num86 < this.poisonStays.Count; num86++)
			{
				if (this.poisonStays[num86])
				{
					Object.Destroy(this.poisonStays[num86]);
					this.poisonStays[num86] = null;
				}
			}
			this.poisonStays.RemoveAll((GameObject item) => item == null);
		}
		if (this.knockbacks.Count > 5)
		{
			for (int num87 = 5; num87 < this.knockbacks.Count; num87++)
			{
				if (this.knockbacks[num87])
				{
					Object.Destroy(this.knockbacks[num87]);
					this.knockbacks[num87] = null;
				}
			}
			this.knockbacks.RemoveAll((GameObject item) => item == null);
		}
		if (this.crowns.Count > 3)
		{
			for (int num88 = 3; num88 < this.crowns.Count; num88++)
			{
				if (this.crowns[num88])
				{
					Object.Destroy(this.crowns[num88]);
					this.crowns[num88] = null;
				}
			}
			this.crowns.RemoveAll((GameObject item) => item == null);
		}
		if (this.whiteChargeUps.Count > 15)
		{
			for (int num89 = 15; num89 < this.whiteChargeUps.Count; num89++)
			{
				if (this.whiteChargeUps[num89])
				{
					Object.Destroy(this.whiteChargeUps[num89]);
					this.whiteChargeUps[num89] = null;
				}
			}
			this.whiteChargeUps.RemoveAll((GameObject item) => item == null);
		}
		if (this.webs.Count > 1)
		{
			for (int num90 = 1; num90 < this.webs.Count; num90++)
			{
				if (this.webs[num90])
				{
					Object.Destroy(this.webs[num90]);
					this.webs[num90] = null;
				}
			}
			this.webs.RemoveAll((GameObject item) => item == null);
		}
		if (this.webPrisons.Count > 1)
		{
			for (int num91 = 1; num91 < this.webPrisons.Count; num91++)
			{
				if (this.webPrisons[num91])
				{
					Object.Destroy(this.webPrisons[num91]);
					this.webPrisons[num91] = null;
				}
			}
			this.webPrisons.RemoveAll((GameObject item) => item == null);
		}
		if (this.boneWalls.Count > 0)
		{
			for (int num92 = 0; num92 < this.boneWalls.Count; num92++)
			{
				if (this.boneWalls[num92])
				{
					Object.Destroy(this.boneWalls[num92]);
					this.boneWalls[num92] = null;
				}
			}
			this.boneWalls.RemoveAll((GameObject item) => item == null);
		}
		if (this.knockbackLoops.Count > 5)
		{
			for (int num93 = 5; num93 < this.knockbackLoops.Count; num93++)
			{
				if (this.knockbackLoops[num93])
				{
					Object.Destroy(this.knockbackLoops[num93]);
					this.knockbackLoops[num93] = null;
				}
			}
			this.knockbackLoops.RemoveAll((GameObject item) => item == null);
		}
	}

	// Token: 0x06000BDD RID: 3037 RVA: 0x000EA610 File Offset: 0x000E8810
	public GameObject GetBracket(int type, Bounds bounds)
	{
		GameObject pooledGameObject = this.GetPooledGameObject(61);
		pooledGameObject.SetActive(true);
		pooledGameObject.transform.LookAt(bounds.center + Links.x.worldCamera.gameObject.transform.rotation * Links.x.worldCamera.gameObject.transform.forward, Links.x.worldCamera.gameObject.transform.rotation * Vector3.up);
		this.SetBracketSize(bounds, pooledGameObject);
		this.SetBracketMaterial(type, pooledGameObject);
		return pooledGameObject;
	}

	// Token: 0x06000BDE RID: 3038 RVA: 0x000EA6B0 File Offset: 0x000E88B0
	public void SetBracketMaterial(int type, GameObject b)
	{
		Material material = Links.x.bracketColor1;
		if (type == 1)
		{
			material = Links.x.bracketColor2;
		}
		if (type == 2)
		{
			material = Links.x.bracketColor3;
		}
		b.transform.GetChild(0).transform.gameObject.GetComponent<HannahAnimatorSimple>().UpdateMaterials(material);
		b.transform.GetChild(1).transform.gameObject.GetComponent<HannahAnimatorSimple>().UpdateMaterials(material);
		b.transform.GetChild(2).transform.gameObject.GetComponent<HannahAnimatorSimple>().UpdateMaterials(material);
		b.transform.GetChild(3).transform.gameObject.GetComponent<HannahAnimatorSimple>().UpdateMaterials(material);
	}

	// Token: 0x06000BDF RID: 3039 RVA: 0x000EA76C File Offset: 0x000E896C
	public void SetBracketSize(Bounds bounds, GameObject b)
	{
		if (!b)
		{
			return;
		}
		float num = bounds.size.x / 2f * 0.75f;
		float num2 = bounds.size.y / 2f * 0.9f;
		b.transform.GetChild(0).transform.localPosition = new Vector3(num * -1f, num2 * 1f);
		b.transform.GetChild(1).transform.localPosition = new Vector3(num * 1f, num2 * 1f);
		b.transform.GetChild(2).transform.localPosition = new Vector3(num * -1f, num2 * -1f);
		b.transform.GetChild(3).transform.localPosition = new Vector3(num * 1f, num2 * -1f);
		b.transform.position = bounds.center;
	}

	// Token: 0x06000BE0 RID: 3040 RVA: 0x000EA86A File Offset: 0x000E8A6A
	public void ReturnGorePile(GameObject go)
	{
		this.gorePiles.Add(go);
		go.SetActive(false);
	}

	// Token: 0x06000BE1 RID: 3041 RVA: 0x000EA87F File Offset: 0x000E8A7F
	public void ReturnGorePileRb(GameObject go)
	{
		this.gorePilesRb.Add(go);
		go.SetActive(false);
	}

	// Token: 0x06000BE2 RID: 3042 RVA: 0x000EA894 File Offset: 0x000E8A94
	public MeshRenderer GetEdgeMesh(int size)
	{
		MeshRenderer meshRenderer = null;
		if (size != 0)
		{
			if (this.radiusGemsLrg.Count > 0)
			{
				meshRenderer = this.radiusGemsLrg[0];
				this.radiusGemsLrg.RemoveAt(0);
			}
			else
			{
				meshRenderer = Object.Instantiate<GameObject>(this.radiusGemLrg, Vector3.zero, Quaternion.identity, this.tr).GetComponent<MeshRenderer>();
			}
		}
		meshRenderer.enabled = true;
		return meshRenderer;
	}

	// Token: 0x06000BE3 RID: 3043 RVA: 0x000EA8F8 File Offset: 0x000E8AF8
	public void ReturnEdgeMesh(MeshRenderer r, int size)
	{
		r.enabled = false;
		this.radiusGemsLrg.Add(r);
	}

	// Token: 0x06000BE4 RID: 3044 RVA: 0x000EA910 File Offset: 0x000E8B10
	public MeshRenderer GetGridLine(int type)
	{
		MeshRenderer meshRenderer = null;
		if (type == 0)
		{
			if (this.gridLines.Count > 0)
			{
				meshRenderer = this.gridLines[0];
				this.gridLines.RemoveAt(0);
			}
			else
			{
				meshRenderer = Object.Instantiate<GameObject>(this.gridLine, Vector3.zero, Quaternion.identity, this.tr).transform.GetChild(0).gameObject.GetComponent<MeshRenderer>();
			}
		}
		else if (type == 1)
		{
			if (this.gridLines2.Count > 0)
			{
				meshRenderer = this.gridLines2[0];
				this.gridLines2.RemoveAt(0);
			}
			else
			{
				meshRenderer = Object.Instantiate<GameObject>(this.gridLine2, Vector3.zero, Quaternion.identity, this.tr).transform.GetChild(0).gameObject.GetComponent<MeshRenderer>();
			}
		}
		else if (type == 2)
		{
			if (this.squares.Count > 0)
			{
				meshRenderer = this.squares[0];
				this.squares.RemoveAt(0);
			}
			else
			{
				meshRenderer = Object.Instantiate<GameObject>(this.square, Vector3.zero, Quaternion.identity, this.tr).transform.GetChild(0).gameObject.GetComponent<MeshRenderer>();
			}
		}
		meshRenderer.enabled = true;
		return meshRenderer;
	}

	// Token: 0x06000BE5 RID: 3045 RVA: 0x000EAA4D File Offset: 0x000E8C4D
	public void ReturnGridLine(MeshRenderer r, int type)
	{
		if (type == 0)
		{
			this.gridLines.Add(r);
		}
		else if (type == 1)
		{
			this.gridLines2.Add(r);
		}
		else if (type == 2)
		{
			this.squares.Add(r);
		}
		r.enabled = false;
	}

	// Token: 0x06000BE6 RID: 3046 RVA: 0x000EAA8C File Offset: 0x000E8C8C
	public void ReturnSocket(GameObject go, string type)
	{
		if (type == "")
		{
			this.sockets.Add(go);
			return;
		}
		if (type == "Spell")
		{
			this.socketSpellRepairs.Add(go);
			return;
		}
		this.socketRepairs.Add(go);
	}

	// Token: 0x06000BE7 RID: 3047 RVA: 0x000EAAD9 File Offset: 0x000E8CD9
	public void ReturnEmptyPoint(GameObject go)
	{
		go.SetActive(false);
		if (Records.x.editor)
		{
			go.name = "-";
		}
		this.emptyPoints.Add(go);
	}

	// Token: 0x06000BE8 RID: 3048 RVA: 0x000EAB08 File Offset: 0x000E8D08
	public void ReturnCombatPools()
	{
		for (int i = 0; i < this.bloods.Count; i++)
		{
			if (this.bloods[i])
			{
				this.bloods[i].gameObject.SetActive(false);
			}
		}
	}

	// Token: 0x06000BE9 RID: 3049 RVA: 0x000EAB58 File Offset: 0x000E8D58
	public Portrait GetPortrait()
	{
		if (this.portraits.Count > 0)
		{
			Portrait portrait = this.portraits[0];
			this.portraits.RemoveAt(0);
			return portrait;
		}
		return Object.Instantiate<GameObject>(this.portrait, Vector3.zero, Quaternion.identity, this.tr).GetComponent<Portrait>();
	}

	// Token: 0x06000BEA RID: 3050 RVA: 0x000EABAC File Offset: 0x000E8DAC
	public void ReturnPortrait(Portrait go)
	{
		go.gameObject.SetActive(false);
		this.portraits.Add(go);
	}

	// Token: 0x06000BEB RID: 3051 RVA: 0x000EABC8 File Offset: 0x000E8DC8
	public SkillButton GetSkillButton()
	{
		if (this.skillButtons.Count > 0)
		{
			SkillButton skillButton = this.skillButtons[0];
			this.skillButtons.RemoveAt(0);
			return skillButton;
		}
		return Object.Instantiate<GameObject>(this.skillButton, Vector3.zero, Quaternion.identity, this.tr).GetComponent<SkillButton>();
	}

	// Token: 0x06000BEC RID: 3052 RVA: 0x000EAC1C File Offset: 0x000E8E1C
	public void ReturnSkillButton(SkillButton go)
	{
		go.gameObject.SetActive(false);
		go.transform.SetParent(Links.x.quipHolder.transform, true);
		this.skillButtons.Add(go);
	}

	// Token: 0x06000BED RID: 3053 RVA: 0x000EAC54 File Offset: 0x000E8E54
	public GameObject GetVine()
	{
		if (this.vines.Count > 0)
		{
			GameObject gameObject = this.vines[0];
			this.vines.RemoveAt(0);
			return gameObject;
		}
		return Object.Instantiate<GameObject>(this.vine, Vector3.zero, Quaternion.identity, this.tr);
	}

	// Token: 0x06000BEE RID: 3054 RVA: 0x000EACA3 File Offset: 0x000E8EA3
	public void ReturnVine(GameObject go)
	{
		go.gameObject.SetActive(false);
		this.vines.Add(go);
	}

	// Token: 0x06000BEF RID: 3055 RVA: 0x000EACC0 File Offset: 0x000E8EC0
	public Animator GetBlood()
	{
		Animator animator = this.bloods[0];
		this.bloods.RemoveAt(0);
		this.bloods.Add(animator);
		animator.transform.LookAt(animator.transform.position + Links.x.worldCamera.gameObject.transform.rotation * Vector3.forward, Links.x.worldCamera.gameObject.transform.rotation * Vector3.up);
		return animator;
	}

	// Token: 0x06000BF0 RID: 3056 RVA: 0x000EAD58 File Offset: 0x000E8F58
	public Animator GetAnimatedText(string type, string txt, bool left)
	{
		Animator animator = null;
		GameObject gameObject = null;
		if (type == "XP")
		{
			if (this.animatedTextsXps.Count > 0)
			{
				animator = this.animatedTextsXps[0];
				if (animator)
				{
					gameObject = animator.gameObject;
					if (animator.GetCurrentAnimatorStateInfo(0).normalizedTime > 0.95f || !animator.gameObject.activeSelf)
					{
						this.animatedTextsXps.RemoveAt(0);
					}
					else
					{
						animator = null;
					}
				}
			}
			if (!animator)
			{
				gameObject = Object.Instantiate<GameObject>(this.animatedTextsXp, Vector3.zero, Quaternion.identity, this.tr);
				animator = gameObject.GetComponent<Animator>();
			}
			this.texts = gameObject.GetComponentsInChildren<TextMeshPro>(true);
			for (int i = 0; i < this.texts.Length; i++)
			{
				if (!this.texts[i].gameObject.name.Contains("XP"))
				{
					this.texts[i].text = txt;
				}
			}
			gameObject.transform.LookAt(gameObject.transform.position + Links.x.worldCamera.gameObject.transform.rotation * Vector3.forward, Links.x.worldCamera.gameObject.transform.rotation * Vector3.up);
			this.animatedTextsXps.Add(animator);
			animator.gameObject.SetActive(true);
			animator.Play("XP", -1, 0f);
			return animator;
		}
		if (type == "LevelUp")
		{
			if (this.animatedTextsLevelUps.Count > 0)
			{
				animator = this.animatedTextsLevelUps[0];
				if (animator)
				{
					gameObject = animator.gameObject;
					if (animator.GetCurrentAnimatorStateInfo(0).normalizedTime > 0.95f || !animator.gameObject.activeSelf)
					{
						this.animatedTextsLevelUps.RemoveAt(0);
					}
					else
					{
						animator = null;
					}
				}
				else
				{
					this.animatedTextsLevelUps.RemoveAt(0);
				}
			}
			if (!animator)
			{
				gameObject = Object.Instantiate<GameObject>(this.animatedTextsLevelUp, Vector3.zero, Quaternion.identity, this.tr);
				animator = gameObject.GetComponent<Animator>();
			}
			gameObject.transform.LookAt(gameObject.transform.position + Links.x.worldCamera.gameObject.transform.rotation * Vector3.forward, Links.x.worldCamera.gameObject.transform.rotation * Vector3.up);
			if (animator)
			{
				this.animatedTextsLevelUps.Add(animator);
				animator.gameObject.SetActive(true);
				animator.Play("LevelUp", -1, 0f);
			}
			return animator;
		}
		if (type == "NPCDmg")
		{
			if (this.animatedTextsNpcDmgs.Count > 0)
			{
				animator = this.animatedTextsNpcDmgs[0];
				gameObject = animator.gameObject;
				if (animator)
				{
					if (animator.GetCurrentAnimatorStateInfo(0).normalizedTime > 0.95f || !animator.gameObject.activeSelf)
					{
						this.animatedTextsNpcDmgs.RemoveAt(0);
					}
					else
					{
						animator = null;
					}
				}
			}
			if (!animator)
			{
				gameObject = Object.Instantiate<GameObject>(this.animatedTextsNpcDmg, Vector3.zero, Quaternion.identity, this.tr);
				animator = gameObject.GetComponent<Animator>();
			}
			this.texts = gameObject.GetComponentsInChildren<TextMeshPro>(true);
			for (int j = 0; j < this.texts.Length; j++)
			{
				this.texts[j].text = txt;
			}
			gameObject.transform.LookAt(gameObject.transform.position + Links.x.worldCamera.gameObject.transform.rotation * Vector3.forward, Links.x.worldCamera.gameObject.transform.rotation * Vector3.up);
			this.animatedTextsNpcDmgs.Add(animator);
			animator.gameObject.SetActive(true);
			animator.Play("NPC_Dmg", -1, 0f);
			return animator;
		}
		if (type == "SmallDmg")
		{
			if (this.animatedTextsSmallNpcDmgs.Count > 0)
			{
				animator = this.animatedTextsSmallNpcDmgs[0];
				gameObject = animator.gameObject;
				if (animator)
				{
					if (animator.GetCurrentAnimatorStateInfo(0).normalizedTime > 0.95f || !animator.gameObject.activeSelf)
					{
						this.animatedTextsSmallNpcDmgs.RemoveAt(0);
					}
					else
					{
						animator = null;
					}
				}
			}
			if (!animator)
			{
				gameObject = Object.Instantiate<GameObject>(this.animatedTextsSmallNpcDmg, Vector3.zero, Quaternion.identity, this.tr);
				animator = gameObject.GetComponent<Animator>();
			}
			this.texts = gameObject.GetComponentsInChildren<TextMeshPro>(true);
			for (int k = 0; k < this.texts.Length; k++)
			{
				this.texts[k].text = txt;
			}
			gameObject.transform.LookAt(gameObject.transform.position + Links.x.worldCamera.gameObject.transform.rotation * Vector3.forward, Links.x.worldCamera.gameObject.transform.rotation * Vector3.up);
			this.animatedTextsSmallNpcDmgs.Add(animator);
			animator.gameObject.SetActive(true);
			animator.Play("NPC_Dmg", -1, 0f);
			return animator;
		}
		if (type == "PocketDmg")
		{
			if (this.animatedTextsDmgs.Count > 0)
			{
				animator = this.animatedTextsDmgs[0];
				gameObject = animator.gameObject;
				if (animator)
				{
					if (animator.GetCurrentAnimatorStateInfo(0).normalizedTime > 0.95f || !animator.gameObject.activeSelf)
					{
						this.animatedTextsDmgs.RemoveAt(0);
					}
					else
					{
						animator = null;
					}
				}
			}
			if (!animator)
			{
				gameObject = Object.Instantiate<GameObject>(this.animatedTextsDmg, Vector3.zero, Quaternion.identity, this.tr);
				animator = gameObject.GetComponent<Animator>();
			}
			this.texts = gameObject.GetComponentsInChildren<TextMeshPro>(true);
			for (int l = 0; l < this.texts.Length; l++)
			{
				this.texts[l].text = txt;
			}
			gameObject.transform.LookAt(gameObject.transform.position + Links.x.worldCamera.gameObject.transform.rotation * Vector3.forward, Links.x.worldCamera.gameObject.transform.rotation * Vector3.up);
			this.animatedTextsDmgs.Add(animator);
			animator.gameObject.SetActive(true);
			if (left)
			{
				animator.Play("DmgLeft", -1, 0f);
			}
			else
			{
				animator.Play("Dmg", -1, 0f);
			}
			return animator;
		}
		if (type == "RallyDmg")
		{
			if (this.animatedTextsRallyDmgs.Count > 1)
			{
				animator = this.animatedTextsRallyDmgs[0];
				gameObject = animator.gameObject;
				if (animator)
				{
					if (animator.GetCurrentAnimatorStateInfo(0).normalizedTime > 0.95f || !animator.gameObject.activeSelf)
					{
						this.animatedTextsRallyDmgs.RemoveAt(0);
					}
					else
					{
						animator = null;
					}
				}
			}
			if (!animator)
			{
				gameObject = Object.Instantiate<GameObject>(this.animatedTextsRallyDmg, Vector3.zero, Quaternion.identity, this.tr);
				animator = gameObject.GetComponent<Animator>();
			}
			this.texts = gameObject.GetComponentsInChildren<TextMeshPro>(true);
			for (int m = 0; m < this.texts.Length; m++)
			{
				this.texts[m].text = txt;
			}
			gameObject.transform.LookAt(gameObject.transform.position + Links.x.worldCamera.gameObject.transform.rotation * Vector3.forward, Links.x.worldCamera.gameObject.transform.rotation * Vector3.up);
			this.animatedTextsRallyDmgs.Add(animator);
			animator.gameObject.SetActive(true);
			if (left)
			{
				animator.Play("DmgLeft", -1, 0f);
			}
			else
			{
				animator.Play("Dmg", -1, 0f);
			}
			return animator;
		}
		if (type == "PartyDmg")
		{
			if (this.animatedTextsFriendlyDmgs.Count > 0)
			{
				animator = this.animatedTextsFriendlyDmgs[0];
				gameObject = animator.gameObject;
				if (animator)
				{
					if (animator.GetCurrentAnimatorStateInfo(0).normalizedTime > 0.95f || !animator.gameObject.activeSelf)
					{
						this.animatedTextsFriendlyDmgs.RemoveAt(0);
					}
					else
					{
						animator = null;
					}
				}
			}
			if (!animator)
			{
				gameObject = Object.Instantiate<GameObject>(this.animatedTextsFriendlyDmg, Vector3.zero, Quaternion.identity, this.tr);
				animator = gameObject.GetComponent<Animator>();
			}
			this.texts = gameObject.GetComponentsInChildren<TextMeshPro>(true);
			for (int n = 0; n < this.texts.Length; n++)
			{
				this.texts[n].text = txt;
			}
			gameObject.transform.LookAt(gameObject.transform.position + Links.x.worldCamera.gameObject.transform.rotation * Vector3.forward, Links.x.worldCamera.gameObject.transform.rotation * Vector3.up);
			this.animatedTextsFriendlyDmgs.Add(animator);
			animator.gameObject.SetActive(true);
			animator.Play("NPC_Dmg", -1, 0f);
			return animator;
		}
		if (type == "Evaded")
		{
			gameObject = this.animatedTextEvaded.gameObject;
			gameObject.transform.LookAt(gameObject.transform.position + Links.x.worldCamera.gameObject.transform.rotation * Vector3.forward, Links.x.worldCamera.gameObject.transform.rotation * Vector3.up);
			animator = gameObject.GetComponent<Animator>();
			animator.gameObject.SetActive(true);
			if (left)
			{
				animator.Play("Blocked_left");
			}
			else
			{
				animator.Play("Blocked_right", -1, 0f);
			}
			return animator;
		}
		if (type == "Blocked")
		{
			gameObject = this.animatedTextBlocked.gameObject;
			gameObject.transform.LookAt(gameObject.transform.position + Links.x.worldCamera.gameObject.transform.rotation * Vector3.forward, Links.x.worldCamera.gameObject.transform.rotation * Vector3.up);
			animator = gameObject.GetComponent<Animator>();
			animator.gameObject.SetActive(true);
			if (left)
			{
				animator.Play("Blocked_left");
			}
			else
			{
				animator.Play("Blocked_right", -1, 0f);
			}
			return animator;
		}
		if (type == "Defend")
		{
			gameObject = this.animatedTextDefended.gameObject;
			gameObject.transform.LookAt(gameObject.transform.position + Links.x.worldCamera.gameObject.transform.rotation * Vector3.forward, Links.x.worldCamera.gameObject.transform.rotation * Vector3.up);
			animator = gameObject.GetComponent<Animator>();
			animator.gameObject.SetActive(true);
			return animator;
		}
		if (type == "SkillCheckPass")
		{
			gameObject = this.animatedTextSkillCheckPass.gameObject;
			gameObject.transform.LookAt(gameObject.transform.position + Links.x.worldCamera.gameObject.transform.rotation * Vector3.forward, Links.x.worldCamera.gameObject.transform.rotation * Vector3.up);
			animator = gameObject.GetComponent<Animator>();
			this.texts = gameObject.GetComponentsInChildren<TextMeshPro>(true);
			for (int num = 0; num < this.texts.Length; num++)
			{
				this.texts[num].text = txt;
			}
			animator.gameObject.SetActive(true);
			animator.Play("SkillCheckPass", -1, 0f);
			return animator;
		}
		if (type == "Absorbed")
		{
			gameObject = this.animatedTextsAbsorbed.gameObject;
			gameObject.transform.LookAt(gameObject.transform.position + Links.x.worldCamera.gameObject.transform.rotation * Vector3.forward, Links.x.worldCamera.gameObject.transform.rotation * Vector3.up);
			animator = gameObject.GetComponent<Animator>();
			animator.gameObject.SetActive(true);
			if (left)
			{
				animator.Play("Blocked_left");
			}
			else
			{
				animator.Play("Blocked_right", -1, 0f);
			}
			return animator;
		}
		if (type == "Rally")
		{
			gameObject = this.animatedTextRally.gameObject;
			gameObject.transform.LookAt(gameObject.transform.position + Links.x.worldCamera.gameObject.transform.rotation * Vector3.forward, Links.x.worldCamera.gameObject.transform.rotation * Vector3.up);
			animator = gameObject.GetComponent<Animator>();
			animator.gameObject.SetActive(true);
			animator.Play("Rally", -1, 0f);
			return animator;
		}
		if (type == "RallyDmgTotal")
		{
			gameObject = this.animatedTextRallyBigNumber.gameObject;
			gameObject.transform.LookAt(gameObject.transform.position + Links.x.worldCamera.gameObject.transform.rotation * Vector3.forward, Links.x.worldCamera.gameObject.transform.rotation * Vector3.up);
			animator = gameObject.GetComponent<Animator>();
			animator.gameObject.SetActive(true);
			this.texts = gameObject.GetComponentsInChildren<TextMeshPro>(true);
			for (int num2 = 0; num2 < this.texts.Length; num2++)
			{
				this.texts[num2].text = txt;
			}
			animator.Play("RallyBigNumber", -1, 0f);
			return animator;
		}
		if (type == "Text")
		{
			if (this.animatedTextsEmptys.Count > 0)
			{
				animator = this.animatedTextsEmptys[0];
				if (animator)
				{
					gameObject = animator.gameObject;
					if (animator)
					{
						if (animator.GetCurrentAnimatorStateInfo(0).normalizedTime > 0.95f || !animator.gameObject.activeSelf)
						{
							this.animatedTextsEmptys.RemoveAt(0);
						}
						else
						{
							animator = null;
						}
					}
				}
				else
				{
					this.animatedTextsEmptys.RemoveAt(0);
				}
			}
			if (!animator)
			{
				gameObject = Object.Instantiate<GameObject>(this.animatedTextEmpty, Vector3.zero, Quaternion.identity, this.tr);
				animator = gameObject.GetComponent<Animator>();
			}
			this.texts = gameObject.GetComponentsInChildren<TextMeshPro>(true);
			for (int num3 = 0; num3 < this.texts.Length; num3++)
			{
				this.texts[num3].text = txt;
			}
			gameObject.transform.LookAt(gameObject.transform.position + Links.x.worldCamera.gameObject.transform.rotation * Vector3.forward, Links.x.worldCamera.gameObject.transform.rotation * Vector3.up);
			this.animatedTextsEmptys.Add(animator);
			animator.gameObject.SetActive(true);
			animator.Play("NPC_Dmg", -1, 0f);
			return animator;
		}
		if (this.animatedTexts.Count > 0)
		{
			animator = this.animatedTexts[0];
			gameObject = animator.gameObject;
			if (animator)
			{
				if (animator.GetCurrentAnimatorStateInfo(0).normalizedTime > 0.95f || !animator.gameObject.activeSelf)
				{
					this.animatedTexts.RemoveAt(0);
				}
				else
				{
					animator = null;
				}
			}
		}
		if (!animator)
		{
			gameObject = Object.Instantiate<GameObject>(this.animatedText, Vector3.zero, Quaternion.identity, this.tr);
			animator = gameObject.GetComponent<Animator>();
		}
		this.texts = gameObject.GetComponentsInChildren<TextMeshPro>(true);
		for (int num4 = 0; num4 < this.texts.Length; num4++)
		{
			this.texts[num4].text = txt;
		}
		gameObject.transform.LookAt(gameObject.transform.position + Links.x.worldCamera.gameObject.transform.rotation * Vector3.forward, Links.x.worldCamera.gameObject.transform.rotation * Vector3.up);
		this.animatedTexts.Add(animator);
		animator.gameObject.SetActive(true);
		if (left)
		{
			animator.Play("Blocked_left");
		}
		else
		{
			animator.Play("Blocked_right", -1, 0f);
		}
		return animator;
	}

	// Token: 0x06000BF1 RID: 3057 RVA: 0x000EBEAF File Offset: 0x000EA0AF
	public void ReturnanimatedText(Animator go)
	{
		if (go)
		{
			go.gameObject.transform.parent = this.tr;
			go.gameObject.SetActive(false);
		}
	}

	// Token: 0x06000BF2 RID: 3058 RVA: 0x000EBEDC File Offset: 0x000EA0DC
	public OverHeadUI GetQuip()
	{
		if (this.quips.Count <= 0)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.quip, Vector3.zero, Quaternion.identity, Links.x.hudControl.miscFolderQuipsTransform);
			this.quips.Add(gameObject.GetComponent<OverHeadUI>());
			return gameObject.GetComponent<OverHeadUI>();
		}
		if (!this.quips[0].gameObject.activeSelf)
		{
			OverHeadUI overHeadUI = this.quips[0];
			this.quips.RemoveAt(0);
			this.quips.Add(overHeadUI);
			return overHeadUI;
		}
		GameObject gameObject2 = Object.Instantiate<GameObject>(this.quip, Vector3.zero, Quaternion.identity, Links.x.hudControl.miscFolderQuipsTransform);
		this.quips.Add(gameObject2.GetComponent<OverHeadUI>());
		return gameObject2.GetComponent<OverHeadUI>();
	}

	// Token: 0x06000BF3 RID: 3059 RVA: 0x000EBFB4 File Offset: 0x000EA1B4
	public OverHeadUI GetSelectionArrow()
	{
		if (this.selectionArrows.Count > 0)
		{
			OverHeadUI overHeadUI = this.selectionArrows[0];
			this.selectionArrows.RemoveAt(0);
			return overHeadUI;
		}
		return Object.Instantiate<GameObject>(this.selectionArrow, Vector3.zero, Quaternion.identity, Links.x.quipHolder).GetComponent<OverHeadUI>();
	}

	// Token: 0x06000BF4 RID: 3060 RVA: 0x000EC00C File Offset: 0x000EA20C
	public void ReturnArrow(OverHeadUI go)
	{
		this.selectionArrows.Add(go);
	}

	// Token: 0x06000BF5 RID: 3061 RVA: 0x000EC01C File Offset: 0x000EA21C
	public TimelineIcon GetTimelineIcon()
	{
		if (this.timelineIcons.Count > 0)
		{
			TimelineIcon timelineIcon = this.timelineIcons[0];
			if (!timelineIcon.character)
			{
				this.timelineIcons.RemoveAt(0);
				return timelineIcon;
			}
		}
		return Object.Instantiate<GameObject>(this.timelineIcon, Vector3.zero, Quaternion.identity, Links.x.timelineHolder).GetComponent<TimelineIcon>();
	}

	// Token: 0x06000BF6 RID: 3062 RVA: 0x000EC085 File Offset: 0x000EA285
	public void ReturnTimelineIcon(TimelineIcon go)
	{
		this.timelineIcons.Add(go);
	}

	// Token: 0x06000BF7 RID: 3063 RVA: 0x000EC094 File Offset: 0x000EA294
	public TimelineIcon GetTimelineIconEnemy()
	{
		if (this.timelineIconsEnemy.Count > 0)
		{
			TimelineIcon timelineIcon = this.timelineIconsEnemy[0];
			this.timelineIconsEnemy.RemoveAt(0);
			return timelineIcon;
		}
		return Object.Instantiate<GameObject>(this.timelineIconEnemy, Vector3.zero, Quaternion.identity, Links.x.timelineHolder).GetComponent<TimelineIcon>();
	}

	// Token: 0x06000BF8 RID: 3064 RVA: 0x000EC0EC File Offset: 0x000EA2EC
	public void ReturnTimelineIconEnemy(TimelineIcon go)
	{
		this.timelineIconsEnemy.Add(go);
	}

	// Token: 0x06000BF9 RID: 3065 RVA: 0x000EC0FC File Offset: 0x000EA2FC
	public void DropPickup(bool isHealth, Vector3 torsoPosition, Character actionTarget)
	{
		if (Records.x.miniGame)
		{
			return;
		}
		int num = 0;
		for (int i = 0; i < this.pickups.Count; i++)
		{
			if (isHealth && this.pickups[i].isHealth)
			{
				num++;
			}
			if (!isHealth && this.pickups[i].isSpirit)
			{
				num++;
			}
		}
		int num2 = 0;
		if (isHealth)
		{
			if (Links.x.gameplay.seconds < Links.x.combat.combatStartTime + 230f)
			{
				num2 = Random.Range(0, 80);
			}
			else
			{
				num2 = Random.Range(0, 50);
			}
		}
		else
		{
			int num3 = Links.x.PartyNeedsSpiritPickup();
			if (num3 == 0)
			{
				num2 = Random.Range(0, 22);
			}
			if (num3 == 1)
			{
				num2 = Random.Range(0, 15);
			}
			if (num3 == 2)
			{
				num2 = Random.Range(0, 12);
			}
			if (num3 >= 3)
			{
				num2 = Random.Range(0, 8);
			}
		}
		if (num2 == 0 && ((num < 1 && isHealth) || (num < 2 && !isHealth && !Records.x.banquetIsle)))
		{
			int num4 = 102;
			if (!isHealth)
			{
				num4 = 103;
			}
			GameObject pooledGameObject = Links.x.cellar.GetPooledGameObject(num4);
			if (pooledGameObject)
			{
				pooledGameObject.GetComponent<Pickups>().Setup(torsoPosition, actionTarget.torsoPosition, actionTarget.node);
			}
		}
	}

	// Token: 0x06000BFA RID: 3066 RVA: 0x000EC23C File Offset: 0x000EA43C
	public Pickups NodeHasPickup(GraphNode node)
	{
		for (int i = 0; i < this.pickups.Count; i++)
		{
			if (this.pickups[i].node == node)
			{
				return this.pickups[i];
			}
		}
		return null;
	}

	// Token: 0x06000BFB RID: 3067 RVA: 0x000EC281 File Offset: 0x000EA481
	public void AddPickups(Pickups pickup)
	{
		if (this.pickups.IndexOf(pickup) == -1)
		{
			this.pickups.Add(pickup);
		}
	}

	// Token: 0x06000BFC RID: 3068 RVA: 0x000EC2A0 File Offset: 0x000EA4A0
	public void ReturnPickups(Pickups pickup)
	{
		int num = this.pickups.IndexOf(pickup);
		if (num > -1)
		{
			this.pickups.RemoveAt(num);
		}
	}

	// Token: 0x06000BFD RID: 3069 RVA: 0x000EC2CA File Offset: 0x000EA4CA
	public void AddEffects(Effects effect)
	{
		if (this.currentEffects.IndexOf(effect) == -1)
		{
			this.currentEffects.Add(effect);
		}
	}

	// Token: 0x06000BFE RID: 3070 RVA: 0x000EC2E8 File Offset: 0x000EA4E8
	public void ReturnEffects(Effects effect)
	{
		int num = this.currentEffects.IndexOf(effect);
		if (num > -1)
		{
			this.currentEffects.RemoveAt(num);
		}
	}

	// Token: 0x06000BFF RID: 3071 RVA: 0x000EC312 File Offset: 0x000EA512
	public void AddTileEffect(TileEffects effect)
	{
		if (this.currentTileEffects.IndexOf(effect) == -1)
		{
			this.currentTileEffects.Add(effect);
		}
	}

	// Token: 0x06000C00 RID: 3072 RVA: 0x000EC330 File Offset: 0x000EA530
	public void RemoveTileEffect(TileEffects effect)
	{
		int num = this.currentTileEffects.IndexOf(effect);
		if (num > -1)
		{
			this.currentTileEffects.RemoveAt(num);
		}
	}

	// Token: 0x06000C01 RID: 3073 RVA: 0x000EC35C File Offset: 0x000EA55C
	public bool CharacterHasCastTileEffect(Character c, string n)
	{
		foreach (TileEffects tileEffects in this.currentTileEffects)
		{
			if (tileEffects && tileEffects.source == c && tileEffects.effect._Name == n)
			{
				return true;
			}
		}
		return false;
	}

	// Token: 0x06000C02 RID: 3074 RVA: 0x000EC3D8 File Offset: 0x000EA5D8
	public void SaveEnemySummons()
	{
		foreach (TileEffects tileEffects in this.currentTileEffects)
		{
			if (tileEffects && tileEffects.needsCreatureSave)
			{
				tileEffects.SaveCreatures();
			}
		}
	}

	// Token: 0x06000C03 RID: 3075 RVA: 0x000EC43C File Offset: 0x000EA63C
	public int NonSavingTileEffects()
	{
		int num = 0;
		for (int i = 0; i < this.currentTileEffects.Count; i++)
		{
			if (this.currentTileEffects[i] && !this.currentTileEffects[i].effect._IsSong && this.currentTileEffects[i].source && !this.currentTileEffects[i].ShouldBeDone())
			{
				num++;
			}
		}
		return num;
	}

	// Token: 0x06000C04 RID: 3076 RVA: 0x000EC4BC File Offset: 0x000EA6BC
	public void SaveTileEffects(string filename)
	{
	}

	// Token: 0x06000C05 RID: 3077 RVA: 0x000EC4BE File Offset: 0x000EA6BE
	public void LoadTileEffects(string filename)
	{
	}

	// Token: 0x06000C06 RID: 3078 RVA: 0x000EC4C0 File Offset: 0x000EA6C0
	public bool OtherListHasTile(TileEffects effect, GraphNode n, string effectName)
	{
		for (int i = 0; i < this.currentTileEffects.Count; i++)
		{
			TileEffects tileEffects = this.currentTileEffects[i];
			if (tileEffects && tileEffects.setPenalty && tileEffects != effect)
			{
				if (effectName == "")
				{
					if (tileEffects.HasTile(n))
					{
						return true;
					}
				}
				else if (tileEffects.effect._Name.Contains(effectName) && tileEffects.HasTile(n))
				{
					return true;
				}
			}
		}
		return false;
	}

	// Token: 0x06000C07 RID: 3079 RVA: 0x000EC540 File Offset: 0x000EA740
	public Item GetItem()
	{
		if (this.bagItems.Count > 0)
		{
			Item item = this.bagItems[0];
			this.bagItems.RemoveAt(0);
			return item;
		}
		return Object.Instantiate<GameObject>(this.bagItem, Vector3.zero, Quaternion.identity, this.tr).GetComponent<Item>();
	}

	// Token: 0x06000C08 RID: 3080 RVA: 0x000EC594 File Offset: 0x000EA794
	public void ReturnItem(Item bagItem)
	{
		bagItem.transform.SetParent(this.tr);
		this.bagItems.Add(bagItem);
	}

	// Token: 0x06000C09 RID: 3081 RVA: 0x000EC5B4 File Offset: 0x000EA7B4
	public Image GetImage(int num)
	{
		if (num != 0)
		{
			return null;
		}
		if (this.bagImages.Count > 0)
		{
			Image image = this.bagImages[0];
			this.bagImages.RemoveAt(0);
			return image;
		}
		return Object.Instantiate<GameObject>(this.bagImage, Vector3.zero, Quaternion.identity, this.tr).GetComponent<Image>();
	}

	// Token: 0x06000C0A RID: 3082 RVA: 0x000EC60D File Offset: 0x000EA80D
	public void ReturnImage(Image img, int num)
	{
		if (num == 0)
		{
			img.gameObject.transform.SetParent(Links.x.quipHolder);
			img.gameObject.SetActive(false);
			this.bagImages.Add(img);
		}
	}

	// Token: 0x06000C0B RID: 3083 RVA: 0x000EC644 File Offset: 0x000EA844
	public RectTransform GetHannahAnimator(int type)
	{
		RectTransform rectTransform = null;
		if (type == 0)
		{
			if (this.highlightFXs.Count > 2)
			{
				rectTransform = this.highlightFXs[0];
				if (rectTransform.gameObject.activeSelf)
				{
					rectTransform = null;
				}
				else
				{
					this.highlightFXs.RemoveAt(0);
					this.highlightFXs.Add(rectTransform);
				}
			}
			if (!rectTransform)
			{
				rectTransform = Object.Instantiate<RectTransform>(this.highlightFX, Vector3.zero, Quaternion.identity, Links.x.hudControl.miscFolderQuipsTransform).GetComponent<RectTransform>();
				this.highlightFXs.Add(rectTransform);
			}
		}
		if (type == 1)
		{
			if (this.removeFXs.Count > 2)
			{
				rectTransform = this.removeFXs[0];
				if (rectTransform.gameObject.activeSelf)
				{
					rectTransform = null;
				}
				else
				{
					this.removeFXs.RemoveAt(0);
					this.removeFXs.Add(rectTransform);
				}
			}
			if (!rectTransform)
			{
				rectTransform = Object.Instantiate<RectTransform>(this.removeFX, Vector3.zero, Quaternion.identity, Links.x.hudControl.miscFolderQuipsTransform).GetComponent<RectTransform>();
				this.removeFXs.Add(rectTransform);
			}
		}
		return rectTransform;
	}

	// Token: 0x06000C0C RID: 3084 RVA: 0x000EC765 File Offset: 0x000EA965
	public int CombatBreakableCount()
	{
		return this.combatBreakables.Count;
	}

	// Token: 0x06000C0D RID: 3085 RVA: 0x000EC772 File Offset: 0x000EA972
	public void AddCombatBreakable(TimedBreakable b)
	{
		this.combatBreakables.Add(b);
	}

	// Token: 0x06000C0E RID: 3086 RVA: 0x000EC780 File Offset: 0x000EA980
	public void RemoveCombatBreakable(TimedBreakable b)
	{
		int num = this.combatBreakables.IndexOf(b);
		if (num > -1)
		{
			this.combatBreakables.RemoveAt(num);
		}
	}

	// Token: 0x06000C0F RID: 3087 RVA: 0x000EC7AC File Offset: 0x000EA9AC
	public Gauge GetGauge()
	{
		if (this.gauges.Count <= 0)
		{
			return Object.Instantiate<GameObject>(this.gauge, Vector3.zero, Quaternion.identity, Links.x.quipHolder).GetComponent<Gauge>();
		}
		Gauge gauge = this.gauges[0];
		if (!gauge)
		{
			return Object.Instantiate<GameObject>(this.gauge, Vector3.zero, Quaternion.identity, Links.x.quipHolder).GetComponent<Gauge>();
		}
		this.gauges.RemoveAt(0);
		return gauge;
	}

	// Token: 0x06000C10 RID: 3088 RVA: 0x000EC835 File Offset: 0x000EAA35
	public void ReturnGauge(Gauge go)
	{
		if (go)
		{
			go.gameObject.SetActive(false);
			this.gauges.Add(go);
		}
	}

	// Token: 0x06000C11 RID: 3089 RVA: 0x000EC858 File Offset: 0x000EAA58
	public GameObject GetGorePile()
	{
		if (this.gorePiles.Count > 0)
		{
			GameObject gameObject = this.gorePiles[0];
			this.gorePiles.RemoveAt(0);
			this.removedGorePiles.Add(gameObject);
			this.removeGoreHours.Add(Links.x.gameplay.gameDays);
			return gameObject;
		}
		GameObject gameObject2 = Object.Instantiate<GameObject>(this.gorePileOptions[Random.Range(0, this.gorePileOptions.Count)], Vector3.zero, Quaternion.identity, this.tr);
		this.removedGorePiles.Add(gameObject2);
		this.removeGoreHours.Add(Links.x.gameplay.gameDays);
		return gameObject2;
	}

	// Token: 0x06000C12 RID: 3090 RVA: 0x000EC90D File Offset: 0x000EAB0D
	public void SaveGorePiles(string filename)
	{
	}

	// Token: 0x06000C13 RID: 3091 RVA: 0x000EC90F File Offset: 0x000EAB0F
	public void LoadGorePiles(string filename)
	{
	}

	// Token: 0x06000C14 RID: 3092 RVA: 0x000EC914 File Offset: 0x000EAB14
	public void ReturnGorePiles()
	{
		for (int i = 0; i < this.removedGorePiles.Count; i++)
		{
			this.gorePiles.Add(this.removedGorePiles[i]);
			this.removedGorePiles[i].SetActive(false);
		}
		this.removedGorePiles.Clear();
		for (int j = 0; j < this.removedGorePilesRb.Count; j++)
		{
			if (this.removedGorePilesRb[j])
			{
				if (!this.gorePilesRb.Contains(this.removedGorePilesRb[j]))
				{
					this.gorePilesRb.Add(this.removedGorePilesRb[j]);
				}
				this.removedGorePilesRb[j].SetActive(false);
			}
		}
		this.removedGorePilesRb.Clear();
	}

	// Token: 0x04001239 RID: 4665
	public List<Effects> currentEffects = new List<Effects>();

	// Token: 0x0400123A RID: 4666
	public List<TileEffects> currentTileEffects = new List<TileEffects>();

	// Token: 0x0400123B RID: 4667
	private List<string> currentTileEffectNames = new List<string>();

	// Token: 0x0400123C RID: 4668
	private List<int> currentTileEffectTimes = new List<int>();

	// Token: 0x0400123D RID: 4669
	public List<Pickups> pickups = new List<Pickups>();

	// Token: 0x0400123E RID: 4670
	public List<GameObject> revivalGems = new List<GameObject>();

	// Token: 0x0400123F RID: 4671
	public GameObject revivalGem;

	// Token: 0x04001240 RID: 4672
	public List<GameObject> grassInteractions = new List<GameObject>();

	// Token: 0x04001241 RID: 4673
	public GameObject grassInteraction;

	// Token: 0x04001242 RID: 4674
	public List<GameObject> exitIcons = new List<GameObject>();

	// Token: 0x04001243 RID: 4675
	public GameObject exitIcon;

	// Token: 0x04001244 RID: 4676
	public List<GameObject> healthBars = new List<GameObject>();

	// Token: 0x04001245 RID: 4677
	public GameObject healthBar;

	// Token: 0x04001246 RID: 4678
	public List<GameObject> staminaBars = new List<GameObject>();

	// Token: 0x04001247 RID: 4679
	public GameObject staminaBar;

	// Token: 0x04001248 RID: 4680
	public List<GameObject> steps = new List<GameObject>();

	// Token: 0x04001249 RID: 4681
	public GameObject step;

	// Token: 0x0400124A RID: 4682
	public List<GameObject> pins = new List<GameObject>();

	// Token: 0x0400124B RID: 4683
	public GameObject pin;

	// Token: 0x0400124C RID: 4684
	public List<GameObject> hearts = new List<GameObject>();

	// Token: 0x0400124D RID: 4685
	public GameObject heart;

	// Token: 0x0400124E RID: 4686
	public List<GameObject> dazeds = new List<GameObject>();

	// Token: 0x0400124F RID: 4687
	public GameObject dazed;

	// Token: 0x04001250 RID: 4688
	public List<OverHeadUI> quips = new List<OverHeadUI>();

	// Token: 0x04001251 RID: 4689
	public GameObject quip;

	// Token: 0x04001252 RID: 4690
	public List<OverHeadUI> selectionArrows = new List<OverHeadUI>();

	// Token: 0x04001253 RID: 4691
	public GameObject selectionArrow;

	// Token: 0x04001254 RID: 4692
	public List<TimelineIcon> timelineIcons = new List<TimelineIcon>();

	// Token: 0x04001255 RID: 4693
	public GameObject timelineIcon;

	// Token: 0x04001256 RID: 4694
	public List<TimelineIcon> timelineIconsEnemy = new List<TimelineIcon>();

	// Token: 0x04001257 RID: 4695
	public GameObject timelineIconEnemy;

	// Token: 0x04001258 RID: 4696
	public List<SkillButton> skillButtons = new List<SkillButton>();

	// Token: 0x04001259 RID: 4697
	public GameObject skillButton;

	// Token: 0x0400125A RID: 4698
	public List<Portrait> portraits = new List<Portrait>();

	// Token: 0x0400125B RID: 4699
	public GameObject portrait;

	// Token: 0x0400125C RID: 4700
	public List<Gauge> gauges = new List<Gauge>();

	// Token: 0x0400125D RID: 4701
	public GameObject gauge;

	// Token: 0x0400125E RID: 4702
	public List<Item> bagItems = new List<Item>();

	// Token: 0x0400125F RID: 4703
	public GameObject bagItem;

	// Token: 0x04001260 RID: 4704
	public List<Image> bagImages = new List<Image>();

	// Token: 0x04001261 RID: 4705
	public GameObject bagImage;

	// Token: 0x04001262 RID: 4706
	public List<GameObject> skillIcons = new List<GameObject>();

	// Token: 0x04001263 RID: 4707
	public GameObject skillIcon;

	// Token: 0x04001264 RID: 4708
	public List<GameObject> spellIcons = new List<GameObject>();

	// Token: 0x04001265 RID: 4709
	public GameObject spellIcon;

	// Token: 0x04001266 RID: 4710
	public List<GameObject> songIcons = new List<GameObject>();

	// Token: 0x04001267 RID: 4711
	public GameObject songIcon;

	// Token: 0x04001268 RID: 4712
	public List<GameObject> vines = new List<GameObject>();

	// Token: 0x04001269 RID: 4713
	public GameObject vine;

	// Token: 0x0400126A RID: 4714
	public List<GameObject> sockets = new List<GameObject>();

	// Token: 0x0400126B RID: 4715
	public GameObject socket;

	// Token: 0x0400126C RID: 4716
	public List<GameObject> socketRepairs = new List<GameObject>();

	// Token: 0x0400126D RID: 4717
	public GameObject socketRepair;

	// Token: 0x0400126E RID: 4718
	public List<GameObject> socketSpellRepairs = new List<GameObject>();

	// Token: 0x0400126F RID: 4719
	public GameObject socketSpellRepair;

	// Token: 0x04001270 RID: 4720
	public List<GameObject> waypoints = new List<GameObject>();

	// Token: 0x04001271 RID: 4721
	public GameObject waypoint;

	// Token: 0x04001272 RID: 4722
	public List<GameObject> seens = new List<GameObject>();

	// Token: 0x04001273 RID: 4723
	public GameObject seen;

	// Token: 0x04001274 RID: 4724
	public List<GameObject> heards = new List<GameObject>();

	// Token: 0x04001275 RID: 4725
	public GameObject heard;

	// Token: 0x04001276 RID: 4726
	public List<GameObject> emptyPoints = new List<GameObject>();

	// Token: 0x04001277 RID: 4727
	public List<Animator> animatedTexts = new List<Animator>();

	// Token: 0x04001278 RID: 4728
	public GameObject animatedText;

	// Token: 0x04001279 RID: 4729
	public List<Animator> animatedTextsEmptys = new List<Animator>();

	// Token: 0x0400127A RID: 4730
	public GameObject animatedTextEmpty;

	// Token: 0x0400127B RID: 4731
	public List<Animator> animatedTextsDmgs = new List<Animator>();

	// Token: 0x0400127C RID: 4732
	public GameObject animatedTextsDmg;

	// Token: 0x0400127D RID: 4733
	public List<Animator> animatedTextsRallyDmgs = new List<Animator>();

	// Token: 0x0400127E RID: 4734
	public GameObject animatedTextsRallyDmg;

	// Token: 0x0400127F RID: 4735
	public List<Animator> animatedTextsFriendlyDmgs = new List<Animator>();

	// Token: 0x04001280 RID: 4736
	public GameObject animatedTextsFriendlyDmg;

	// Token: 0x04001281 RID: 4737
	public List<Animator> animatedTextsNpcDmgs = new List<Animator>();

	// Token: 0x04001282 RID: 4738
	public GameObject animatedTextsNpcDmg;

	// Token: 0x04001283 RID: 4739
	public List<Animator> animatedTextsLevelUps = new List<Animator>();

	// Token: 0x04001284 RID: 4740
	public GameObject animatedTextsLevelUp;

	// Token: 0x04001285 RID: 4741
	public List<Animator> animatedTextsXps = new List<Animator>();

	// Token: 0x04001286 RID: 4742
	public GameObject animatedTextsXp;

	// Token: 0x04001287 RID: 4743
	public List<Animator> animatedTextsSmallNpcDmgs = new List<Animator>();

	// Token: 0x04001288 RID: 4744
	public GameObject animatedTextsSmallNpcDmg;

	// Token: 0x04001289 RID: 4745
	public GameObject animatedTextsAbsorbed;

	// Token: 0x0400128A RID: 4746
	public GameObject animatedTextBlocked;

	// Token: 0x0400128B RID: 4747
	public GameObject animatedTextDefended;

	// Token: 0x0400128C RID: 4748
	public GameObject animatedTextRally;

	// Token: 0x0400128D RID: 4749
	public GameObject animatedTextEvaded;

	// Token: 0x0400128E RID: 4750
	public GameObject animatedTextRallyBigNumber;

	// Token: 0x0400128F RID: 4751
	public GameObject animatedTextSkillCheckPass;

	// Token: 0x04001290 RID: 4752
	public List<Animator> bloods = new List<Animator>();

	// Token: 0x04001291 RID: 4753
	public GameObject blood;

	// Token: 0x04001292 RID: 4754
	public List<GameObject> bubbleHits = new List<GameObject>();

	// Token: 0x04001293 RID: 4755
	public GameObject bubbleHit;

	// Token: 0x04001294 RID: 4756
	public List<MeshRenderer> radiusGemsLrg = new List<MeshRenderer>();

	// Token: 0x04001295 RID: 4757
	public GameObject radiusGemLrg;

	// Token: 0x04001296 RID: 4758
	public List<GameObject> brackets = new List<GameObject>();

	// Token: 0x04001297 RID: 4759
	public GameObject bracket;

	// Token: 0x04001298 RID: 4760
	public List<MeshRenderer> gridLines = new List<MeshRenderer>();

	// Token: 0x04001299 RID: 4761
	public GameObject gridLine;

	// Token: 0x0400129A RID: 4762
	public List<MeshRenderer> gridLines2 = new List<MeshRenderer>();

	// Token: 0x0400129B RID: 4763
	public GameObject gridLine2;

	// Token: 0x0400129C RID: 4764
	public List<MeshRenderer> squares = new List<MeshRenderer>();

	// Token: 0x0400129D RID: 4765
	public GameObject square;

	// Token: 0x0400129E RID: 4766
	public List<GameObject> gorePiles = new List<GameObject>();

	// Token: 0x0400129F RID: 4767
	public List<GameObject> gorePileOptions = new List<GameObject>();

	// Token: 0x040012A0 RID: 4768
	public List<GameObject> removedGorePiles = new List<GameObject>();

	// Token: 0x040012A1 RID: 4769
	private List<int> removeGoreHours = new List<int>();

	// Token: 0x040012A2 RID: 4770
	private List<Vector3> gorePileLocations = new List<Vector3>();

	// Token: 0x040012A3 RID: 4771
	private List<Quaternion> gorePileRotations = new List<Quaternion>();

	// Token: 0x040012A4 RID: 4772
	private List<int> gorePileDays = new List<int>();

	// Token: 0x040012A5 RID: 4773
	public List<GameObject> gorePilesRb = new List<GameObject>();

	// Token: 0x040012A6 RID: 4774
	public List<GameObject> gorePileOptionsRb = new List<GameObject>();

	// Token: 0x040012A7 RID: 4775
	public List<GameObject> removedGorePilesRb = new List<GameObject>();

	// Token: 0x040012A8 RID: 4776
	public List<GameObject> intestines = new List<GameObject>();

	// Token: 0x040012A9 RID: 4777
	public List<GameObject> intestineOptions = new List<GameObject>();

	// Token: 0x040012AA RID: 4778
	public List<GameObject> oils = new List<GameObject>();

	// Token: 0x040012AB RID: 4779
	public List<GameObject> oilOptions = new List<GameObject>();

	// Token: 0x040012AC RID: 4780
	public List<GameObject> wines = new List<GameObject>();

	// Token: 0x040012AD RID: 4781
	public List<GameObject> wineOptions = new List<GameObject>();

	// Token: 0x040012AE RID: 4782
	public List<GameObject> sporeMagics = new List<GameObject>();

	// Token: 0x040012AF RID: 4783
	public GameObject sporeMagic;

	// Token: 0x040012B0 RID: 4784
	public List<GameObject> saps = new List<GameObject>();

	// Token: 0x040012B1 RID: 4785
	public List<GameObject> sapOptions = new List<GameObject>();

	// Token: 0x040012B2 RID: 4786
	public List<GameObject> beetles = new List<GameObject>();

	// Token: 0x040012B3 RID: 4787
	public List<GameObject> beetleOptions = new List<GameObject>();

	// Token: 0x040012B4 RID: 4788
	public List<GameObject> bloodBurstSmls = new List<GameObject>();

	// Token: 0x040012B5 RID: 4789
	public GameObject bloodBurstSml;

	// Token: 0x040012B6 RID: 4790
	public List<GameObject> bloodBurstShroomerSmls = new List<GameObject>();

	// Token: 0x040012B7 RID: 4791
	public GameObject bloodBurstShroomerSml;

	// Token: 0x040012B8 RID: 4792
	public List<GameObject> bloodBurstMeds = new List<GameObject>();

	// Token: 0x040012B9 RID: 4793
	public GameObject bloodBurstMed;

	// Token: 0x040012BA RID: 4794
	public List<GameObject> bloodBurstLrgs = new List<GameObject>();

	// Token: 0x040012BB RID: 4795
	public GameObject bloodBurstLrg;

	// Token: 0x040012BC RID: 4796
	public List<GameObject> effectPotions = new List<GameObject>();

	// Token: 0x040012BD RID: 4797
	public GameObject effectPotion;

	// Token: 0x040012BE RID: 4798
	public List<GameObject> effectShimmerThrees = new List<GameObject>();

	// Token: 0x040012BF RID: 4799
	public GameObject effectShimmerThree;

	// Token: 0x040012C0 RID: 4800
	public List<GameObject> effectSlipSlimes = new List<GameObject>();

	// Token: 0x040012C1 RID: 4801
	public GameObject effectSlipSlime;

	// Token: 0x040012C2 RID: 4802
	public List<GameObject> effectRockWalls = new List<GameObject>();

	// Token: 0x040012C3 RID: 4803
	public GameObject effectRockWall;

	// Token: 0x040012C4 RID: 4804
	public List<GameObject> effectStuns = new List<GameObject>();

	// Token: 0x040012C5 RID: 4805
	public GameObject effectStun;

	// Token: 0x040012C6 RID: 4806
	public List<GameObject> summonStarts = new List<GameObject>();

	// Token: 0x040012C7 RID: 4807
	public GameObject summonStart;

	// Token: 0x040012C8 RID: 4808
	public List<GameObject> summonEnds = new List<GameObject>();

	// Token: 0x040012C9 RID: 4809
	public GameObject summonEnd;

	// Token: 0x040012CA RID: 4810
	public List<GameObject> effectWaypoints = new List<GameObject>();

	// Token: 0x040012CB RID: 4811
	public GameObject effectWaypoint;

	// Token: 0x040012CC RID: 4812
	public List<GameObject> effectsHoverTiles = new List<GameObject>();

	// Token: 0x040012CD RID: 4813
	public GameObject effectsHoverTile;

	// Token: 0x040012CE RID: 4814
	public List<GameObject> effectSpellCasts = new List<GameObject>();

	// Token: 0x040012CF RID: 4815
	public GameObject effectSpellCast;

	// Token: 0x040012D0 RID: 4816
	public List<GameObject> effectVinesJumps = new List<GameObject>();

	// Token: 0x040012D1 RID: 4817
	public GameObject effectVinesJump;

	// Token: 0x040012D2 RID: 4818
	public List<GameObject> effectVinesHolds = new List<GameObject>();

	// Token: 0x040012D3 RID: 4819
	public GameObject effectVinesHold;

	// Token: 0x040012D4 RID: 4820
	public List<GameObject> effectSporesPukes = new List<GameObject>();

	// Token: 0x040012D5 RID: 4821
	public GameObject effectSporesPuke;

	// Token: 0x040012D6 RID: 4822
	public List<GameObject> effectMosses = new List<GameObject>();

	// Token: 0x040012D7 RID: 4823
	public GameObject effectMoss;

	// Token: 0x040012D8 RID: 4824
	public List<GameObject> effectSporesPukeHeads = new List<GameObject>();

	// Token: 0x040012D9 RID: 4825
	public GameObject effectSporesPukeHead;

	// Token: 0x040012DA RID: 4826
	public List<GameObject> effectSporesHealings = new List<GameObject>();

	// Token: 0x040012DB RID: 4827
	public GameObject effectSporesHealing;

	// Token: 0x040012DC RID: 4828
	public List<GameObject> effectSporesHealingHeads = new List<GameObject>();

	// Token: 0x040012DD RID: 4829
	public GameObject effectSporesHealingHead;

	// Token: 0x040012DE RID: 4830
	public List<GameObject> effectHealeds = new List<GameObject>();

	// Token: 0x040012DF RID: 4831
	public GameObject effectHealed;

	// Token: 0x040012E0 RID: 4832
	public List<GameObject> effectFaileds = new List<GameObject>();

	// Token: 0x040012E1 RID: 4833
	public GameObject effectFailed;

	// Token: 0x040012E2 RID: 4834
	public List<GameObject> effectMusics = new List<GameObject>();

	// Token: 0x040012E3 RID: 4835
	public GameObject effectMusic;

	// Token: 0x040012E4 RID: 4836
	public List<GameObject> effectMusicBuffs = new List<GameObject>();

	// Token: 0x040012E5 RID: 4837
	public GameObject effectMusicBuff;

	// Token: 0x040012E6 RID: 4838
	public List<GameObject> effectIcons = new List<GameObject>();

	// Token: 0x040012E7 RID: 4839
	public GameObject effectIcon;

	// Token: 0x040012E8 RID: 4840
	public List<GameObject> buffRemoveds = new List<GameObject>();

	// Token: 0x040012E9 RID: 4841
	public GameObject buffRemoved;

	// Token: 0x040012EA RID: 4842
	public List<GameObject> effectCharmeds = new List<GameObject>();

	// Token: 0x040012EB RID: 4843
	public GameObject effectCharmed;

	// Token: 0x040012EC RID: 4844
	public List<GameObject> effectCharmedFails = new List<GameObject>();

	// Token: 0x040012ED RID: 4845
	public GameObject effectCharmedFail;

	// Token: 0x040012EE RID: 4846
	public List<GameObject> elixirExplosions = new List<GameObject>();

	// Token: 0x040012EF RID: 4847
	public GameObject elixirExplosion;

	// Token: 0x040012F0 RID: 4848
	public List<GameObject> effectTileNaps = new List<GameObject>();

	// Token: 0x040012F1 RID: 4849
	public GameObject effectTileNap;

	// Token: 0x040012F2 RID: 4850
	public List<GameObject> effectTileHealings = new List<GameObject>();

	// Token: 0x040012F3 RID: 4851
	public GameObject effectTileHealing;

	// Token: 0x040012F4 RID: 4852
	public List<GameObject> effectTileFires = new List<GameObject>();

	// Token: 0x040012F5 RID: 4853
	public GameObject effectTileFire;

	// Token: 0x040012F6 RID: 4854
	public List<GameObject> ghostHeads = new List<GameObject>();

	// Token: 0x040012F7 RID: 4855
	public GameObject ghostHead;

	// Token: 0x040012F8 RID: 4856
	public List<GameObject> effectActionTimeUps = new List<GameObject>();

	// Token: 0x040012F9 RID: 4857
	public GameObject effectActionTimeUp;

	// Token: 0x040012FA RID: 4858
	public List<GameObject> effectTileAttractions = new List<GameObject>();

	// Token: 0x040012FB RID: 4859
	public GameObject effectTileAttraction;

	// Token: 0x040012FC RID: 4860
	public List<GameObject> effectSleeps = new List<GameObject>();

	// Token: 0x040012FD RID: 4861
	public GameObject effectSleep;

	// Token: 0x040012FE RID: 4862
	public List<GameObject> effectHealings = new List<GameObject>();

	// Token: 0x040012FF RID: 4863
	public GameObject effectHealing;

	// Token: 0x04001300 RID: 4864
	public List<GameObject> effectMoveSpeedUps = new List<GameObject>();

	// Token: 0x04001301 RID: 4865
	public GameObject effectMoveSpeedUp;

	// Token: 0x04001302 RID: 4866
	public List<GameObject> effectConfuseds = new List<GameObject>();

	// Token: 0x04001303 RID: 4867
	public GameObject effectConfused;

	// Token: 0x04001304 RID: 4868
	public List<GameObject> effectMoveSpeedDowns = new List<GameObject>();

	// Token: 0x04001305 RID: 4869
	public GameObject effectMoveSpeedDown;

	// Token: 0x04001306 RID: 4870
	public List<GameObject> effectWordOfPowers = new List<GameObject>();

	// Token: 0x04001307 RID: 4871
	public GameObject effectWordOfPower;

	// Token: 0x04001308 RID: 4872
	public List<GameObject> spiritTiles = new List<GameObject>();

	// Token: 0x04001309 RID: 4873
	public GameObject spiritTile;

	// Token: 0x0400130A RID: 4874
	public List<GameObject> spiritLeavings = new List<GameObject>();

	// Token: 0x0400130B RID: 4875
	public GameObject spiritLeaving;

	// Token: 0x0400130C RID: 4876
	public List<GameObject> incenses = new List<GameObject>();

	// Token: 0x0400130D RID: 4877
	public GameObject incense;

	// Token: 0x0400130E RID: 4878
	public List<GameObject> resourceFrogPrefabs = new List<GameObject>();

	// Token: 0x0400130F RID: 4879
	public List<GameObject> resourceFrogs = new List<GameObject>();

	// Token: 0x04001310 RID: 4880
	public List<GameObject> resourceStickPrefabs = new List<GameObject>();

	// Token: 0x04001311 RID: 4881
	public List<GameObject> resourceSticks = new List<GameObject>();

	// Token: 0x04001312 RID: 4882
	public List<GameObject> resourceRockPrefabs = new List<GameObject>();

	// Token: 0x04001313 RID: 4883
	public List<GameObject> resourceRocks = new List<GameObject>();

	// Token: 0x04001314 RID: 4884
	public List<GameObject> resourceHollowStickPrefabs = new List<GameObject>();

	// Token: 0x04001315 RID: 4885
	public List<GameObject> resourceHollowSticks = new List<GameObject>();

	// Token: 0x04001316 RID: 4886
	public List<GameObject> resourceMushroomPrefabs = new List<GameObject>();

	// Token: 0x04001317 RID: 4887
	public List<GameObject> resourceMushrooms = new List<GameObject>();

	// Token: 0x04001318 RID: 4888
	public List<GameObject> resourceAcornPrefabs = new List<GameObject>();

	// Token: 0x04001319 RID: 4889
	public List<GameObject> resourceAcorns = new List<GameObject>();

	// Token: 0x0400131A RID: 4890
	public List<GameObject> resourceBerryPrefabs = new List<GameObject>();

	// Token: 0x0400131B RID: 4891
	public List<GameObject> resourceBerries = new List<GameObject>();

	// Token: 0x0400131C RID: 4892
	public List<GameObject> leafExplosions = new List<GameObject>();

	// Token: 0x0400131D RID: 4893
	public GameObject leafExplosion;

	// Token: 0x0400131E RID: 4894
	public List<GameObject> itemPickups = new List<GameObject>();

	// Token: 0x0400131F RID: 4895
	public GameObject itemPickup;

	// Token: 0x04001320 RID: 4896
	public List<GameObject> itemInRanges = new List<GameObject>();

	// Token: 0x04001321 RID: 4897
	public GameObject itemInRange;

	// Token: 0x04001322 RID: 4898
	public List<GameObject> itemInRangesForSale = new List<GameObject>();

	// Token: 0x04001323 RID: 4899
	public GameObject itemInRangeForSale;

	// Token: 0x04001324 RID: 4900
	public List<GameObject> spellCastings = new List<GameObject>();

	// Token: 0x04001325 RID: 4901
	public GameObject spellCasting;

	// Token: 0x04001326 RID: 4902
	public List<GameObject> spellCastingTargets = new List<GameObject>();

	// Token: 0x04001327 RID: 4903
	public GameObject spellCastingTarget;

	// Token: 0x04001328 RID: 4904
	public List<GameObject> spellCastingTargetFails = new List<GameObject>();

	// Token: 0x04001329 RID: 4905
	public GameObject spellCastingTargetFail;

	// Token: 0x0400132A RID: 4906
	public List<GameObject> effectFloats = new List<GameObject>();

	// Token: 0x0400132B RID: 4907
	public GameObject effectFloat;

	// Token: 0x0400132C RID: 4908
	public List<GameObject> effectVineCocoons = new List<GameObject>();

	// Token: 0x0400132D RID: 4909
	public GameObject effectVineCocoon;

	// Token: 0x0400132E RID: 4910
	public List<GameObject> effectVinePrisons = new List<GameObject>();

	// Token: 0x0400132F RID: 4911
	public GameObject effectVinePrison;

	// Token: 0x04001330 RID: 4912
	public List<GameObject> faunaFrogs = new List<GameObject>();

	// Token: 0x04001331 RID: 4913
	public GameObject faunaFrog;

	// Token: 0x04001332 RID: 4914
	public List<GameObject> faunaLizards = new List<GameObject>();

	// Token: 0x04001333 RID: 4915
	public GameObject faunaLizard;

	// Token: 0x04001334 RID: 4916
	public List<GameObject> faunaRolys = new List<GameObject>();

	// Token: 0x04001335 RID: 4917
	public GameObject faunaRoly;

	// Token: 0x04001336 RID: 4918
	public List<GameObject> faunaNests = new List<GameObject>();

	// Token: 0x04001337 RID: 4919
	public GameObject faunaNest;

	// Token: 0x04001338 RID: 4920
	public List<GameObject> faunaBees = new List<GameObject>();

	// Token: 0x04001339 RID: 4921
	public GameObject faunaBee;

	// Token: 0x0400133A RID: 4922
	public List<GameObject> faunaCarrions = new List<GameObject>();

	// Token: 0x0400133B RID: 4923
	public GameObject faunaCarrion;

	// Token: 0x0400133C RID: 4924
	public List<GameObject> grassExplosions = new List<GameObject>();

	// Token: 0x0400133D RID: 4925
	public GameObject grassExplosion;

	// Token: 0x0400133E RID: 4926
	public List<GameObject> armorBlocks = new List<GameObject>();

	// Token: 0x0400133F RID: 4927
	public GameObject armorBlock;

	// Token: 0x04001340 RID: 4928
	public List<GameObject> synergies = new List<GameObject>();

	// Token: 0x04001341 RID: 4929
	public GameObject synergy;

	// Token: 0x04001342 RID: 4930
	public List<GameObject> spellWaves = new List<GameObject>();

	// Token: 0x04001343 RID: 4931
	public GameObject spellWave;

	// Token: 0x04001344 RID: 4932
	public List<GameObject> evadings = new List<GameObject>();

	// Token: 0x04001345 RID: 4933
	public GameObject evading;

	// Token: 0x04001346 RID: 4934
	public List<GameObject> rages = new List<GameObject>();

	// Token: 0x04001347 RID: 4935
	public GameObject rage;

	// Token: 0x04001348 RID: 4936
	public List<GameObject> emptys = new List<GameObject>();

	// Token: 0x04001349 RID: 4937
	public GameObject empty;

	// Token: 0x0400134A RID: 4938
	public List<RectTransform> highlightFXs = new List<RectTransform>();

	// Token: 0x0400134B RID: 4939
	public RectTransform highlightFX;

	// Token: 0x0400134C RID: 4940
	public List<RectTransform> removeFXs = new List<RectTransform>();

	// Token: 0x0400134D RID: 4941
	public RectTransform removeFX;

	// Token: 0x0400134E RID: 4942
	public List<GameObject> healthBalls = new List<GameObject>();

	// Token: 0x0400134F RID: 4943
	public GameObject healthBall;

	// Token: 0x04001350 RID: 4944
	public List<GameObject> spiritBalls = new List<GameObject>();

	// Token: 0x04001351 RID: 4945
	public GameObject spiritBall;

	// Token: 0x04001352 RID: 4946
	public List<GameObject> healthBallPickups = new List<GameObject>();

	// Token: 0x04001353 RID: 4947
	public GameObject healthBallPickup;

	// Token: 0x04001354 RID: 4948
	public List<GameObject> poisonExplosions = new List<GameObject>();

	// Token: 0x04001355 RID: 4949
	public GameObject poisonExplosion;

	// Token: 0x04001356 RID: 4950
	public List<GameObject> straightWaves = new List<GameObject>();

	// Token: 0x04001357 RID: 4951
	public GameObject straightWave;

	// Token: 0x04001358 RID: 4952
	public List<GameObject> mushroomWalls = new List<GameObject>();

	// Token: 0x04001359 RID: 4953
	public GameObject mushroomWall;

	// Token: 0x0400135A RID: 4954
	public List<GameObject> boneWalls = new List<GameObject>();

	// Token: 0x0400135B RID: 4955
	public GameObject boneWall;

	// Token: 0x0400135C RID: 4956
	public List<GameObject> greenChargeUps = new List<GameObject>();

	// Token: 0x0400135D RID: 4957
	public GameObject greenChargeUp;

	// Token: 0x0400135E RID: 4958
	public List<GameObject> whiteChargeUps = new List<GameObject>();

	// Token: 0x0400135F RID: 4959
	public GameObject whiteChargeUp;

	// Token: 0x04001360 RID: 4960
	public List<GameObject> orangeChargeUps = new List<GameObject>();

	// Token: 0x04001361 RID: 4961
	public GameObject orangeChargeUp;

	// Token: 0x04001362 RID: 4962
	public List<GameObject> poisonSplashes = new List<GameObject>();

	// Token: 0x04001363 RID: 4963
	public GameObject poisonSplash;

	// Token: 0x04001364 RID: 4964
	public List<GameObject> poisonStays = new List<GameObject>();

	// Token: 0x04001365 RID: 4965
	public GameObject poisonStay;

	// Token: 0x04001366 RID: 4966
	public List<GameObject> webPrisons = new List<GameObject>();

	// Token: 0x04001367 RID: 4967
	public GameObject webPrison;

	// Token: 0x04001368 RID: 4968
	public List<GameObject> webs = new List<GameObject>();

	// Token: 0x04001369 RID: 4969
	public GameObject web;

	// Token: 0x0400136A RID: 4970
	public List<GameObject> knockbacks = new List<GameObject>();

	// Token: 0x0400136B RID: 4971
	public GameObject knockback;

	// Token: 0x0400136C RID: 4972
	public List<GameObject> knockbacksSml = new List<GameObject>();

	// Token: 0x0400136D RID: 4973
	public GameObject knockbackSml;

	// Token: 0x0400136E RID: 4974
	public List<GameObject> knockbackLoops = new List<GameObject>();

	// Token: 0x0400136F RID: 4975
	public GameObject knockbackLoop;

	// Token: 0x04001370 RID: 4976
	public List<GameObject> crowns = new List<GameObject>();

	// Token: 0x04001371 RID: 4977
	public GameObject crown;

	// Token: 0x04001372 RID: 4978
	public List<GameObject> incenseHits = new List<GameObject>();

	// Token: 0x04001373 RID: 4979
	public GameObject incenseHit;

	// Token: 0x04001374 RID: 4980
	public List<GameObject> metalExplosions = new List<GameObject>();

	// Token: 0x04001375 RID: 4981
	public GameObject metalExplosion;

	// Token: 0x04001376 RID: 4982
	public List<GameObject> companionPortraits = new List<GameObject>();

	// Token: 0x04001377 RID: 4983
	public GameObject companionPortrait;

	// Token: 0x04001378 RID: 4984
	public List<GameObject> staminaRecovers = new List<GameObject>();

	// Token: 0x04001379 RID: 4985
	public GameObject staminaRecover;

	// Token: 0x0400137A RID: 4986
	public List<GameObject> rains = new List<GameObject>();

	// Token: 0x0400137B RID: 4987
	public GameObject rain;

	// Token: 0x0400137C RID: 4988
	public List<GameObject> barrelsBreakings = new List<GameObject>();

	// Token: 0x0400137D RID: 4989
	public GameObject barrelsBreaking;

	// Token: 0x0400137E RID: 4990
	public List<GameObject> shroomBombs = new List<GameObject>();

	// Token: 0x0400137F RID: 4991
	public GameObject shroomBomb;

	// Token: 0x04001380 RID: 4992
	public List<GameObject> boroBoats = new List<GameObject>();

	// Token: 0x04001381 RID: 4993
	public GameObject boroBoat;

	// Token: 0x04001382 RID: 4994
	public List<GameObject> oars = new List<GameObject>();

	// Token: 0x04001383 RID: 4995
	public GameObject oar;

	// Token: 0x04001384 RID: 4996
	public List<GameObject> boatSplashBacks = new List<GameObject>();

	// Token: 0x04001385 RID: 4997
	public GameObject boatSplashBack;

	// Token: 0x04001386 RID: 4998
	public List<GameObject> boatSplashFronts = new List<GameObject>();

	// Token: 0x04001387 RID: 4999
	public GameObject boatSplashFront;

	// Token: 0x04001388 RID: 5000
	public List<GameObject> boatSplashOars = new List<GameObject>();

	// Token: 0x04001389 RID: 5001
	public GameObject boatSplashOar;

	// Token: 0x0400138A RID: 5002
	public List<GameObject> creatureSplashes = new List<GameObject>();

	// Token: 0x0400138B RID: 5003
	public GameObject creatureSplash;

	// Token: 0x0400138C RID: 5004
	public List<TimedBreakable> combatBreakables = new List<TimedBreakable>();

	// Token: 0x0400138D RID: 5005
	public GameObject egg;

	// Token: 0x0400138E RID: 5006
	public GameObject miniGameUI;

	// Token: 0x0400138F RID: 5007
	public GameObject armor;

	// Token: 0x04001390 RID: 5008
	public Transform tr;

	// Token: 0x04001391 RID: 5009
	private TextMeshPro[] texts = new TextMeshPro[0];

	// Token: 0x04001392 RID: 5010
	public Material[] cocoonMaterials;
}