Decompiled source of ScorchedVoxels v0.20.69

Get the Thunderstore App

Easily install and manage your mods with the Thunderstore App!
Get App
Decompiled source of ScorchedVoxels v0.20.69

ScorchedVoxels.dll

Decompiled 3 hours ago
Download (616.9 KB)
The result has been truncated due to the large size, download it to view full contents!
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using R2API.Networking;
using R2API.Networking.Interfaces;
using RiskOfOptions;
using RiskOfOptions.OptionConfigs;
using RiskOfOptions.Options;
using RoR2;
using RoR2.Navigation;
using RoR2.Stats;
using RoR2.UI;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.Profiling;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ScorchedVoxels")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.20.69.0")]
[assembly: AssemblyInformationalVersion("0.20.69")]
[assembly: AssemblyProduct("ScorchedVoxels")]
[assembly: AssemblyTitle("ScorchedVoxels")]
[assembly: AssemblyVersion("0.20.69.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ScorchedVoxels
{
	internal enum BgCat : byte
	{
		Plain,
		Pattern,
		Pride,
		Flag
	}
	internal static class BackgroundSystem
	{
		internal struct Def
		{
			public string name;

			public BgCat cat;

			public Action<Color32[], int, int> paint;
		}

		private const int TexW = 128;

		private const int TexH = 192;

		private const float AR = 1.5f;

		private static readonly Dictionary<int, Texture2D> cache = new Dictionary<int, Texture2D>();

		public static readonly Def[] Table = BuildTable();

		public static bool IsFree(int idx)
		{
			if (idx >= 0 && idx < Table.Length)
			{
				return Table[idx].cat != BgCat.Pattern;
			}
			return false;
		}

		public static bool IsOwned(string profileKey, int idx)
		{
			if (idx < 0 || idx >= Table.Length)
			{
				return false;
			}
			if (IsFree(idx))
			{
				return true;
			}
			IReadOnlyList<int> readOnlyList = UserLifetimeStats.UnlockedBackgrounds(profileKey);
			for (int i = 0; i < readOnlyList.Count; i++)
			{
				if (readOnlyList[i] == idx)
				{
					return true;
				}
			}
			return false;
		}

		public static int CurrentBackground(NetworkUser nu)
		{
			return CurrentForProfile(UserLifetimeStats.ProfileKey(nu));
		}

		public static int CurrentForProfile(string key)
		{
			if (key == null)
			{
				return 0;
			}
			int chosenBackground = UserLifetimeStats.GetChosenBackground(key);
			if (chosenBackground >= 0 && IsOwned(key, chosenBackground))
			{
				return chosenBackground;
			}
			IReadOnlyList<int> readOnlyList = UserLifetimeStats.UnlockedBackgrounds(key);
			if (readOnlyList.Count <= 0)
			{
				return 0;
			}
			return readOnlyList[readOnlyList.Count - 1];
		}

		public static int UnlockRandomPattern(NetworkUser nu, Random rng)
		{
			string text = UserLifetimeStats.ProfileKey(nu);
			if (text == null)
			{
				return -1;
			}
			List<int> list = new List<int>();
			for (int i = 0; i < Table.Length; i++)
			{
				if (Table[i].cat == BgCat.Pattern && !IsOwned(text, i))
				{
					list.Add(i);
				}
			}
			if (list.Count == 0)
			{
				return -1;
			}
			int num = list[rng.Next(list.Count)];
			UserLifetimeStats.AddBackground(text, num);
			return num;
		}

		public static int PatternCount()
		{
			int num = 0;
			Def[] table = Table;
			for (int i = 0; i < table.Length; i++)
			{
				if (table[i].cat == BgCat.Pattern)
				{
					num++;
				}
			}
			return num;
		}

		public static Texture2D GetTexture(int idx)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			if (idx <= 0 || idx >= Table.Length)
			{
				return null;
			}
			if (cache.TryGetValue(idx, out var value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			Color32[] array = (Color32[])(object)new Color32[24576];
			Table[idx].paint(array, 128, 192);
			value = new Texture2D(128, 192, (TextureFormat)4, false);
			((Texture)value).wrapMode = (TextureWrapMode)1;
			((Texture)value).filterMode = (FilterMode)1;
			value.SetPixels32(array);
			value.Apply(false, true);
			cache[idx] = value;
			return value;
		}

		private static Color32 C(uint rgb)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			return new Color32((byte)(rgb >> 16), (byte)(rgb >> 8), (byte)rgb, byte.MaxValue);
		}

		private static void Set(Color32[] px, int W, int H, int x, int yTop, Color32 c)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			px[(H - 1 - yTop) * W + x] = c;
		}

		private static void Fill(Color32[] px, int W, int H, Color32 c)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < px.Length; i++)
			{
				px[i] = c;
			}
		}

		private static void HStripesW(Color32[] px, int W, int H, uint[] cols, float[] w)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			float num = 0f;
			foreach (float num2 in w)
			{
				num += num2;
			}
			Color32[] array = (Color32[])(object)new Color32[cols.Length];
			for (int j = 0; j < cols.Length; j++)
			{
				array[j] = C(cols[j]);
			}
			for (int k = 0; k < H; k++)
			{
				float num3 = ((float)k + 0.5f) / (float)H * num;
				int num4 = 0;
				for (float num5 = w[0]; num3 > num5; num5 += w[++num4])
				{
					if (num4 >= cols.Length - 1)
					{
						break;
					}
				}
				for (int l = 0; l < W; l++)
				{
					Set(px, W, H, l, k, array[num4]);
				}
			}
		}

		private static void HStripes(Color32[] px, int W, int H, params uint[] cols)
		{
			float[] array = new float[cols.Length];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = 1f;
			}
			HStripesW(px, W, H, cols, array);
		}

		private static void VStripesW(Color32[] px, int W, int H, uint[] cols, float[] w)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			float num = 0f;
			foreach (float num2 in w)
			{
				num += num2;
			}
			Color32[] array = (Color32[])(object)new Color32[cols.Length];
			for (int j = 0; j < cols.Length; j++)
			{
				array[j] = C(cols[j]);
			}
			for (int k = 0; k < W; k++)
			{
				float num3 = ((float)k + 0.5f) / (float)W * num;
				int num4 = 0;
				for (float num5 = w[0]; num3 > num5; num5 += w[++num4])
				{
					if (num4 >= cols.Length - 1)
					{
						break;
					}
				}
				for (int l = 0; l < H; l++)
				{
					Set(px, W, H, k, l, array[num4]);
				}
			}
		}

		private static void VStripes(Color32[] px, int W, int H, params uint[] cols)
		{
			float[] array = new float[cols.Length];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = 1f;
			}
			VStripesW(px, W, H, cols, array);
		}

		private static void Band(Color32[] px, int W, int H, float u0, float v0, float u1, float v1, Color32 c)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.Max(0, Mathf.FloorToInt(u0 * (float)W));
			int num2 = Mathf.Min(W, Mathf.CeilToInt(u1 * (float)W));
			int num3 = Mathf.Max(0, Mathf.FloorToInt(v0 * (float)H));
			int num4 = Mathf.Min(H, Mathf.CeilToInt(v1 * (float)H));
			for (int i = num3; i < num4; i++)
			{
				for (int j = num; j < num2; j++)
				{
					Set(px, W, H, j, i, c);
				}
			}
		}

		private static void Disc(Color32[] px, int W, int H, float cu, float cv, float r, Color32 c)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			float num = cv * 1.5f;
			for (int i = 0; i < H; i++)
			{
				for (int j = 0; j < W; j++)
				{
					float num2 = ((float)j + 0.5f) / (float)W;
					float num3 = ((float)i + 0.5f) / (float)H * 1.5f;
					if ((num2 - cu) * (num2 - cu) + (num3 - num) * (num3 - num) <= r * r)
					{
						Set(px, W, H, j, i, c);
					}
				}
			}
		}

		private static void Ring(Color32[] px, int W, int H, float cu, float cv, float r, float t, Color32 c)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			float num = cv * 1.5f;
			for (int i = 0; i < H; i++)
			{
				for (int j = 0; j < W; j++)
				{
					float num2 = ((float)j + 0.5f) / (float)W;
					float num3 = ((float)i + 0.5f) / (float)H * 1.5f;
					float num4 = Mathf.Sqrt((num2 - cu) * (num2 - cu) + (num3 - num) * (num3 - num));
					if (num4 <= r && num4 >= r - t)
					{
						Set(px, W, H, j, i, c);
					}
				}
			}
		}

		private static void Crescent(Color32[] px, int W, int H, float cu, float cv, float r, float cutDu, float cutR, Color32 c)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			float num = cv * 1.5f;
			for (int i = 0; i < H; i++)
			{
				for (int j = 0; j < W; j++)
				{
					float num2 = ((float)j + 0.5f) / (float)W;
					float num3 = ((float)i + 0.5f) / (float)H * 1.5f;
					bool num4 = (num2 - cu) * (num2 - cu) + (num3 - num) * (num3 - num) <= r * r;
					float num5 = num2 - (cu + cutDu);
					bool flag = num5 * num5 + (num3 - num) * (num3 - num) <= cutR * cutR;
					if (num4 && !flag)
					{
						Set(px, W, H, j, i, c);
					}
				}
			}
		}

		private static void Star(Color32[] px, int W, int H, float cu, float cv, float r, float rot, Color32 c)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			float num = cv * 1.5f;
			Vector2[] array = (Vector2[])(object)new Vector2[10];
			for (int i = 0; i < 10; i++)
			{
				float num2 = ((i % 2 == 0) ? r : (r * 0.42f));
				float num3 = (-90f + rot + (float)i * 36f) * (MathF.PI / 180f);
				array[i] = new Vector2(cu + num2 * Mathf.Cos(num3), num + num2 * Mathf.Sin(num3));
			}
			int num4 = Mathf.Max(0, Mathf.FloorToInt((cu - r) * (float)W));
			int num5 = Mathf.Min(W, Mathf.CeilToInt((cu + r) * (float)W));
			int num6 = Mathf.Max(0, Mathf.FloorToInt((num - r) / 1.5f * (float)H));
			int num7 = Mathf.Min(H, Mathf.CeilToInt((num + r) / 1.5f * (float)H));
			Vector2 p = default(Vector2);
			for (int j = num6; j < num7; j++)
			{
				for (int k = num4; k < num5; k++)
				{
					((Vector2)(ref p))..ctor(((float)k + 0.5f) / (float)W, ((float)j + 0.5f) / (float)H * 1.5f);
					if (InPoly(array, p))
					{
						Set(px, W, H, k, j, c);
					}
				}
			}
		}

		private static bool InPoly(Vector2[] poly, Vector2 p)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			int num = 0;
			int num2 = poly.Length - 1;
			while (num < poly.Length)
			{
				if (poly[num].y > p.y != poly[num2].y > p.y && p.x < (poly[num2].x - poly[num].x) * (p.y - poly[num].y) / (poly[num2].y - poly[num].y) + poly[num].x)
				{
					flag = !flag;
				}
				num2 = num++;
			}
			return flag;
		}

		private static void Tri(Color32[] px, int W, int H, Vector2 a, Vector2 b, Vector2 c3, Color32 c)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < H; i++)
			{
				for (int j = 0; j < W; j++)
				{
					Vector2 p = new Vector2(((float)j + 0.5f) / (float)W, ((float)i + 0.5f) / (float)H);
					float num = Sign(p, a, b);
					float num2 = Sign(p, b, c3);
					float num3 = Sign(p, c3, a);
					bool flag = num < 0f || num2 < 0f || num3 < 0f;
					bool flag2 = num > 0f || num2 > 0f || num3 > 0f;
					if (!(flag && flag2))
					{
						Set(px, W, H, j, i, c);
					}
				}
			}
			static float Sign(Vector2 val, Vector2 q, Vector2 s)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				return (val.x - s.x) * (q.y - s.y) - (q.x - s.x) * (val.y - s.y);
			}
		}

		private static void NordicCross(Color32[] px, int W, int H, float t, Color32 c)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			Band(px, W, H, 0.38f - t * 0.5f, 0f, 0.38f + t * 0.5f, 1f, c);
			Band(px, W, H, 0f, 0.5f - t * 0.5f / 1.5f, 1f, 0.5f + t * 0.5f / 1.5f, c);
		}

		private static void DiagStripes(Color32[] px, int W, int H, int periodPx, Color32 a, Color32 b)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < H; i++)
			{
				for (int j = 0; j < W; j++)
				{
					Set(px, W, H, j, i, ((j + i) / periodPx % 2 == 0) ? a : b);
				}
			}
		}

		private static void Checker(Color32[] px, int W, int H, int cols, Color32 a, Color32 b)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			int num = W / cols;
			for (int i = 0; i < H; i++)
			{
				for (int j = 0; j < W; j++)
				{
					Set(px, W, H, j, i, ((j / num + i / num) % 2 == 0) ? a : b);
				}
			}
		}

		private static void BlockNoise(Color32[] px, int W, int H, int seed, int cols, uint[] palette)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			Random random = new Random(seed);
			int num = W / cols;
			int num2 = H / num + 1;
			Color32[] array = (Color32[])(object)new Color32[palette.Length];
			for (int i = 0; i < palette.Length; i++)
			{
				array[i] = C(palette[i]);
			}
			Color32[,] array2 = new Color32[cols + 1, num2 + 1];
			for (int j = 0; j <= num2; j++)
			{
				for (int k = 0; k <= cols; k++)
				{
					array2[k, j] = array[random.Next(array.Length)];
				}
			}
			for (int l = 0; l < H; l++)
			{
				for (int m = 0; m < W; m++)
				{
					Set(px, W, H, m, l, array2[Mathf.Min(m / num, cols), Mathf.Min(l / num, num2)]);
				}
			}
		}

		private static void SpeckleDiscs(Color32[] px, int W, int H, int seed, int count, float rMin, float rMax, uint[] palette)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			Random random = new Random(seed);
			for (int i = 0; i < count; i++)
			{
				float cu = (float)random.NextDouble();
				float cv = (float)random.NextDouble();
				float r = Mathf.Lerp(rMin, rMax, (float)random.NextDouble());
				Disc(px, W, H, cu, cv, r, C(palette[random.Next(palette.Length)]));
			}
		}

		private static void VGrad(Color32[] px, int W, int H, uint top, uint bottom)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			Color val = Color32.op_Implicit(C(top));
			Color val2 = Color32.op_Implicit(C(bottom));
			for (int i = 0; i < H; i++)
			{
				Color32 c = Color32.op_Implicit(Color.Lerp(val, val2, ((float)i + 0.5f) / (float)H));
				for (int j = 0; j < W; j++)
				{
					Set(px, W, H, j, i, c);
				}
			}
		}

		private static void DotGrid(Color32[] px, int W, int H, int nx, float r, Color32 c)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			float num = 1f / (float)nx;
			int num2 = Mathf.RoundToInt(1.5f / num);
			for (int i = 0; i <= num2; i++)
			{
				for (int j = 0; j <= nx; j++)
				{
					float num3 = ((i % 2 == 0) ? 0f : (num * 0.5f));
					Disc(px, W, H, (float)j * num + num3, (float)i * num / 1.5f, r, c);
				}
			}
		}

		private static void UnionJack(Color32[] px, int W, int H)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			Fill(px, W, H, C(74089u));
			float num = Mathf.Sqrt(3.25f);
			for (int i = 0; i < H; i++)
			{
				for (int j = 0; j < W; j++)
				{
					float num2 = ((float)j + 0.5f) / (float)W;
					float num3 = ((float)i + 0.5f) / (float)H * 1.5f;
					float num4 = Mathf.Abs(num2 * 1.5f - num3) / num;
					float num5 = Mathf.Abs(1.5f - num2 * 1.5f - num3) / num;
					if (num4 < 0.1f || num5 < 0.1f)
					{
						Set(px, W, H, j, i, Color32.op_Implicit(Color.white));
					}
					if (num4 < 0.045f || num5 < 0.045f)
					{
						Set(px, W, H, j, i, C(13111342u));
					}
				}
			}
			Band(px, W, H, 0.345f, 0f, 0.655f, 1f, Color32.op_Implicit(Color.white));
			Band(px, W, H, 0f, 0.39666668f, 1f, 0.60333335f, Color32.op_Implicit(Color.white));
			Band(px, W, H, 0.41f, 0f, 0.59000003f, 1f, C(13111342u));
			Band(px, W, H, 0f, 0.44f, 1f, 0.56f, C(13111342u));
		}

		private static Def[] BuildTable()
		{
			List<Def> t = new List<Def>();
			P("Plain", BgCat.Plain, delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(1250072u));
			});
			P("Hazard Stripes", BgCat.Pattern, delegate(Color32[] px, int W, int H)
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				DiagStripes(px, W, H, 22, C(15235584u), C(1710618u));
			});
			P("Voxel Grid", BgCat.Pattern, delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(1316380u));
				for (int i = 0; i < H; i++)
				{
					for (int j = 0; j < W; j++)
					{
						if (j % 16 == 0 || i % 16 == 0)
						{
							Set(px, W, H, j, i, C(2764346u));
						}
					}
				}
				Random random = new Random(4242);
				for (int k = 0; k < 9; k++)
				{
					int num = random.Next(W / 16);
					int num2 = random.Next(H / 16);
					Band(px, W, H, (float)num * 16f / (float)W, (float)num2 * 16f / (float)H, ((float)num * 16f + 15f) / (float)W, ((float)num2 * 16f + 15f) / (float)H, (k % 3 == 0) ? C(11754258u) : C(4008472u));
				}
			});
			P("Forest Camo", BgCat.Pattern, delegate(Color32[] px, int W, int H)
			{
				BlockNoise(px, W, H, 1337, 10, new uint[4] { 3885615u, 5727805u, 2765603u, 7240530u });
			});
			P("Desert Camo", BgCat.Pattern, delegate(Color32[] px, int W, int H)
			{
				BlockNoise(px, W, H, 7331, 10, new uint[4] { 12759680u, 10914404u, 9074001u, 14076323u });
			});
			P("Ember Field", BgCat.Pattern, delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(1511951u));
				SpeckleDiscs(px, W, H, 99, 90, 0.004f, 0.016f, new uint[4] { 16738816u, 16756736u, 12729122u, 5579281u });
			});
			P("Gold Vein", BgCat.Pattern, delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(2365970u));
				SpeckleDiscs(px, W, H, 512, 120, 0.003f, 0.01f, new uint[3] { 16763187u, 12092939u, 3812380u });
				SpeckleDiscs(px, W, H, 513, 8, 0.014f, 0.024f, new uint[1] { 16763187u });
			});
			P("Starfield", BgCat.Pattern, delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(658452u));
				SpeckleDiscs(px, W, H, 2001, 110, 0.002f, 0.007f, new uint[3] { 16777215u, 12571903u, 8952251u });
				SpeckleDiscs(px, W, H, 2002, 6, 0.01f, 0.015f, new uint[1] { 16777215u });
			});
			P("Boiler Plate", BgCat.Pattern, delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(3817284u));
				DotGrid(px, W, H, 6, 0.018f, C(2303530u));
			});
			P("Banana Peel", BgCat.Pattern, delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(16768830u));
				SpeckleDiscs(px, W, H, 777, 26, 0.008f, 0.03f, new uint[3] { 8016416u, 10251046u, 6044950u });
			});
			P("Bubblegum", BgCat.Pattern, delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(16751297u));
				DotGrid(px, W, H, 5, 0.035f, C(16769518u));
			});
			P("Sunset", BgCat.Pattern, delegate(Color32[] px, int W, int H)
			{
				VGrad(px, W, H, 16747586u, 6106764u);
			});
			P("The Abyss", BgCat.Pattern, delegate(Color32[] px, int W, int H)
			{
				VGrad(px, W, H, 1347995u, 399936u);
			});
			P("Checkerboard", BgCat.Pattern, delegate(Color32[] px, int W, int H)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				Checker(px, W, H, 6, C(2303275u), C(3816774u));
			});
			P("Moonscape", BgCat.Pattern, delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(7238008u));
				Random random = new Random(31415);
				for (int i = 0; i < 14; i++)
				{
					float num = (float)random.NextDouble();
					float num2 = (float)random.NextDouble();
					float num3 = Mathf.Lerp(0.02f, 0.09f, (float)random.NextDouble());
					Disc(px, W, H, num, num2, num3, C(5593183u));
					Disc(px, W, H, num - num3 * 0.15f, num2 - num3 * 0.1f, num3 * 0.72f, C(4737874u));
				}
			});
			P("Rainbow Pride", BgCat.Pride, delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 14942979u, 16747520u, 16772352u, 32806u, 2375822u, 7547266u);
			});
			P("Progress Pride", BgCat.Pride, delegate(Color32[] px, int W, int H)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0101: Unknown result type (might be due to invalid IL or missing references)
				//IL_010b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0122: Unknown result type (might be due to invalid IL or missing references)
				//IL_0131: Unknown result type (might be due to invalid IL or missing references)
				//IL_0140: Unknown result type (might be due to invalid IL or missing references)
				//IL_014a: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 14942979u, 16747520u, 16772352u, 32806u, 2375822u, 7547266u);
				Tri(px, W, H, new Vector2(0f, -0.1f), new Vector2(0.62f, 0.5f), new Vector2(0f, 1.1f), Color32.op_Implicit(Color.white));
				Tri(px, W, H, new Vector2(0f, 0.02f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0.98f), C(16230584u));
				Tri(px, W, H, new Vector2(0f, 0.14f), new Vector2(0.38f, 0.5f), new Vector2(0f, 0.86f), C(5623292u));
				Tri(px, W, H, new Vector2(0f, 0.26f), new Vector2(0.26f, 0.5f), new Vector2(0f, 0.74f), C(9721110u));
				Tri(px, W, H, new Vector2(0f, 0.38f), new Vector2(0.14f, 0.5f), new Vector2(0f, 0.62f), C(1052688u));
			});
			P("Trans Pride", BgCat.Pride, delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 5623292u, 16230584u, 16777215u, 16230584u, 5623292u);
			});
			P("Bi Pride", BgCat.Pride, delegate(Color32[] px, int W, int H)
			{
				HStripesW(px, W, H, new uint[3] { 14025328u, 10178454u, 14504u }, new float[3] { 2f, 1f, 2f });
			});
			P("Pan Pride", BgCat.Pride, delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 16720268u, 16766976u, 2208255u);
			});
			P("Nonbinary Pride", BgCat.Pride, delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 16577588u, 16777215u, 10246609u, 2894892u);
			});
			P("Lesbian Pride", BgCat.Pride, delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 13970688u, 16751190u, 16777215u, 13853348u, 10682978u);
			});
			P("Gay Men Pride", BgCat.Pride, delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 494960u, 2543274u, 16777215u, 8105442u, 4004472u);
			});
			P("Ace Pride", BgCat.Pride, delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 1052688u, 10724259u, 16777215u, 8388736u);
			});
			P("Aro Pride", BgCat.Pride, delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 4040002u, 10998649u, 16777215u, 11119017u, 1052688u);
			});
			P("Genderfluid Pride", BgCat.Pride, delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 16741794u, 16777215u, 12458198u, 1052688u, 3358397u);
			});
			P("Genderqueer Pride", BgCat.Pride, delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 11894492u, 16777215u, 4882723u);
			});
			P("Agender Pride", BgCat.Pride, delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 1052688u, 12171705u, 16777215u, 12121219u, 16777215u, 12171705u, 1052688u);
			});
			P("Intersex Pride", BgCat.Pride, delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(16766976u));
				Ring(px, W, H, 0.5f, 0.5f, 0.2f, 0.055f, C(7930538u));
			});
			AddFlags(t);
			return t.ToArray();
			void P(string name, BgCat cat, Action<Color32[], int, int> paint)
			{
				t.Add(new Def
				{
					name = name,
					cat = cat,
					paint = paint
				});
			}
		}

		private static void PaintUnionJackCanton(Color32[] px, int W, int H)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.RoundToInt(0.5f * (float)W);
			int num2 = Mathf.RoundToInt(0.34f * (float)H);
			for (int i = 0; i < num2; i++)
			{
				for (int j = 0; j < num; j++)
				{
					float num3 = ((float)j + 0.5f) / (float)num;
					float num4 = ((float)i + 0.5f) / (float)num2;
					Color32 c = C(74089u);
					float num5 = Mathf.Abs(num3 - num4);
					float num6 = Mathf.Abs(1f - num3 - num4);
					if (num5 < 0.16f || num6 < 0.16f)
					{
						c = Color32.op_Implicit(Color.white);
					}
					if (num5 < 0.07f || num6 < 0.07f)
					{
						c = C(13111342u);
					}
					if (Mathf.Abs(num3 - 0.5f) < 0.17f || Mathf.Abs(num4 - 0.5f) < 0.17f)
					{
						c = Color32.op_Implicit(Color.white);
					}
					if (Mathf.Abs(num3 - 0.5f) < 0.1f || Mathf.Abs(num4 - 0.5f) < 0.1f)
					{
						c = C(13111342u);
					}
					Set(px, W, H, j, i, c);
				}
			}
		}

		private static void DiagBand(Color32[] px, int W, int H, bool rising, float off, float halfW, Color32 c)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Sqrt(3.25f);
			for (int i = 0; i < H; i++)
			{
				for (int j = 0; j < W; j++)
				{
					float num2 = ((float)j + 0.5f) / (float)W;
					float num3 = ((float)i + 0.5f) / (float)H * 1.5f;
					float num4 = (rising ? (num3 - 1.5f * (1f - num2)) : (num3 - 1.5f * num2)) / num;
					if (num4 >= off - halfW && num4 <= off + halfW)
					{
						Set(px, W, H, j, i, c);
					}
				}
			}
		}

		private static void Sun(Color32[] px, int W, int H, float cu, float cv, float rDisc, float rRay, int n, Color32 c, float rot = 0f)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			float cq = cv * 1.5f;
			float num = MathF.PI * 11f / 20f / (float)n;
			for (int i = 0; i < n; i++)
			{
				float num2 = rot * (MathF.PI / 180f) + (float)i * 2f * MathF.PI / (float)n;
				Tri(px, W, H, P(num2, rDisc + rRay), P(num2 - num, rDisc * 0.85f), P(num2 + num, rDisc * 0.85f), c);
			}
			Disc(px, W, H, cu, cv, rDisc, c);
			Vector2 P(float ang, float r)
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				return new Vector2(cu + r * Mathf.Cos(ang), (cq + r * Mathf.Sin(ang)) / 1.5f);
			}
		}

		private static void Quad(Color32[] px, int W, int H, Vector2 a, Vector2 b, Vector2 c4, Vector2 d, Color32 c)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			Tri(px, W, H, a, b, c4, c);
			Tri(px, W, H, a, c4, d, c);
		}

		private static void Rhomb(Color32[] px, int W, int H, float cu, float cv, float ru, float rv, Color32 c)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			Tri(px, W, H, new Vector2(cu - ru, cv), new Vector2(cu, cv - rv), new Vector2(cu + ru, cv), c);
			Tri(px, W, H, new Vector2(cu - ru, cv), new Vector2(cu, cv + rv), new Vector2(cu + ru, cv), c);
		}

		private static void ZigzagHoist(Color32[] px, int W, int H, float bandW, int teeth, float amp, Color32 c)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < H; i++)
			{
				float num = Mathf.PingPong(((float)i + 0.5f) / (float)H * (float)teeth * 2f, 1f);
				int num2 = Mathf.Min(W, Mathf.RoundToInt((bandW + amp * (num * 2f - 1f)) * (float)W));
				for (int j = 0; j < num2; j++)
				{
					Set(px, W, H, j, i, c);
				}
			}
		}

		private static void CrossAt(Color32[] px, int W, int H, float cu, float cv, float arm, float thick, Color32 c)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			Band(px, W, H, cu - arm, cv - thick / 1.5f, cu + arm, cv + thick / 1.5f, c);
			Band(px, W, H, cu - thick, cv - arm / 1.5f, cu + thick, cv + arm / 1.5f, c);
		}

		private static void AddFlags(List<Def> t)
		{
			P("Afghanistan", delegate(Color32[] px, int W, int H)
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				VStripes(px, W, H, 1052688u, 13836305u, 31286u);
				Disc(px, W, H, 0.5f, 0.5f, 0.07f, Color32.op_Implicit(Color.white));
			});
			P("Albania", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(14949920u));
				Tri(px, W, H, V(0.18f, 0.34f), V(0.48f, 0.48f), V(0.18f, 0.62f), C(1052688u));
				Tri(px, W, H, V(0.82f, 0.34f), V(0.52f, 0.48f), V(0.82f, 0.62f), C(1052688u));
				Band(px, W, H, 0.46f, 0.3f, 0.54f, 0.66f, C(1052688u));
				Disc(px, W, H, 0.5f, 0.285f, 0.035f, C(1052688u));
			});
			P("Algeria", delegate(Color32[] px, int W, int H)
			{
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				VStripes(px, W, H, 25139u, 16777215u);
				Crescent(px, W, H, 0.49f, 0.5f, 0.13f, 0.05f, 0.11f, C(13766708u));
				Star(px, W, H, 0.575f, 0.5f, 0.05f, 90f, C(13766708u));
			});
			P("Andorra", delegate(Color32[] px, int W, int H)
			{
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				VStripesW(px, W, H, new uint[3] { 1050271u, 16702720u, 13959218u }, new float[3] { 1f, 1.2f, 1f });
				Disc(px, W, H, 0.5f, 0.5f, 0.05f, C(13087615u));
			});
			P("Angola", delegate(Color32[] px, int W, int H)
			{
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 13371695u, 1052688u);
				Ring(px, W, H, 0.5f, 0.47f, 0.1f, 0.028f, C(16763648u));
				Star(px, W, H, 0.5f, 0.53f, 0.05f, 0f, C(16763648u));
			});
			P("Antigua & Barbuda", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(13504806u));
				Tri(px, W, H, V(0f, 0f), V(1f, 0f), V(0.5f, 1f), C(1052688u));
				Sun(px, W, H, 0.5f, 0.22f, 0.055f, 0.045f, 9, C(16568598u));
				Tri(px, W, H, V(0.15f, 0.3f), V(0.85f, 0.3f), V(0.5f, 1f), C(29382u));
				Tri(px, W, H, V(0.24f, 0.48f), V(0.76f, 0.48f), V(0.5f, 1f), Color32.op_Implicit(Color.white));
			});
			P("Argentina", delegate(Color32[] px, int W, int H)
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 7122148u, 16777215u, 7122148u);
				Disc(px, W, H, 0.5f, 0.5f, 0.085f, C(16758812u));
			});
			P("Armenia", delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 14221330u, 13216u, 15902720u);
			});
			P("Australia", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(74089u));
				Star(px, W, H, 0.28f, 0.72f, 0.1f, 0f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.72f, 0.32f, 0.055f, 0f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.8f, 0.55f, 0.055f, 0f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.63f, 0.6f, 0.045f, 0f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.74f, 0.8f, 0.055f, 0f, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0f, 0f, 0.5f, 0.34f, C(74089u));
				PaintUnionJackCanton(px, W, H);
			});
			P("Austria", delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 15676224u, 16777215u, 15676224u);
			});
			P("Azerbaijan", delegate(Color32[] px, int W, int H)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 37564u, 14942251u, 44902u);
				Crescent(px, W, H, 0.46f, 0.5f, 0.1f, 0.035f, 0.085f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.575f, 0.5f, 0.045f, 90f, Color32.op_Implicit(Color.white));
			});
			P("Bahamas", delegate(Color32[] px, int W, int H)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 30603u, 16762668u, 30603u);
				Tri(px, W, H, V(0f, 0f), V(0.42f, 0.5f), V(0f, 1f), C(1052688u));
			});
			P("Bahrain", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(13504806u));
				ZigzagHoist(px, W, H, 0.32f, 5, 0.06f, Color32.op_Implicit(Color.white));
			});
			P("Bangladesh", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(27214u));
				Disc(px, W, H, 0.45f, 0.5f, 0.16f, C(16001601u));
			});
			P("Barbados", delegate(Color32[] px, int W, int H)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_0098: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0116: Unknown result type (might be due to invalid IL or missing references)
				//IL_0125: Unknown result type (might be due to invalid IL or missing references)
				//IL_0134: Unknown result type (might be due to invalid IL or missing references)
				//IL_013e: Unknown result type (might be due to invalid IL or missing references)
				VStripes(px, W, H, 9855u, 16762662u, 9855u);
				Band(px, W, H, 0.475f, 0.4f, 0.525f, 0.62f, C(1052688u));
				Band(px, W, H, 0.405f, 0.44f, 0.44f, 0.54f, C(1052688u));
				Band(px, W, H, 0.56f, 0.44f, 0.595f, 0.54f, C(1052688u));
				Tri(px, W, H, V(0.405f, 0.44f), V(0.44f, 0.44f), V(0.4225f, 0.38f), C(1052688u));
				Tri(px, W, H, V(0.56f, 0.44f), V(0.595f, 0.44f), V(0.5775f, 0.38f), C(1052688u));
				Tri(px, W, H, V(0.475f, 0.4f), V(0.525f, 0.4f), V(0.5f, 0.34f), C(1052688u));
			});
			P("Belarus", delegate(Color32[] px, int W, int H)
			{
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				HStripesW(px, W, H, new uint[2] { 13506336u, 31792u }, new float[2] { 2f, 1f });
				Band(px, W, H, 0f, 0f, 0.12f, 1f, Color32.op_Implicit(Color.white));
				for (int i = 0; i < 9; i++)
				{
					Rhomb(px, W, H, 0.06f, 0.055f + (float)i * 0.111f, 0.045f, 0.04f, C(13506336u));
				}
			});
			P("Belgium", delegate(Color32[] px, int W, int H)
			{
				VStripes(px, W, H, 1052688u, 16636452u, 15676224u);
			});
			P("Belize", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(16263u));
				Band(px, W, H, 0f, 0f, 1f, 0.08f, C(13504806u));
				Band(px, W, H, 0f, 0.92f, 1f, 1f, C(13504806u));
				Disc(px, W, H, 0.5f, 0.5f, 0.165f, Color32.op_Implicit(Color.white));
				Ring(px, W, H, 0.5f, 0.5f, 0.165f, 0.025f, C(2659328u));
				Disc(px, W, H, 0.5f, 0.5f, 0.045f, C(2659328u));
			});
			P("Benin", delegate(Color32[] px, int W, int H)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				Band(px, W, H, 0f, 0f, 1f, 0.5f, C(16568598u));
				Band(px, W, H, 0f, 0.5f, 1f, 1f, C(15208749u));
				Band(px, W, H, 0f, 0f, 0.4f, 1f, C(34641u));
			});
			P("Bhutan", delegate(Color32[] px, int W, int H)
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_0090: Unknown result type (might be due to invalid IL or missing references)
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0114: Unknown result type (might be due to invalid IL or missing references)
				//IL_0119: Unknown result type (might be due to invalid IL or missing references)
				Tri(px, W, H, V(0f, 0f), V(1f, 0f), V(0f, 1f), C(16766240u));
				Tri(px, W, H, V(1f, 0f), V(1f, 1f), V(0f, 1f), C(16731666u));
				Disc(px, W, H, 0.34f, 0.64f, 0.045f, Color32.op_Implicit(Color.white));
				Disc(px, W, H, 0.45f, 0.55f, 0.055f, Color32.op_Implicit(Color.white));
				Disc(px, W, H, 0.56f, 0.46f, 0.045f, Color32.op_Implicit(Color.white));
				Disc(px, W, H, 0.66f, 0.38f, 0.055f, Color32.op_Implicit(Color.white));
				Disc(px, W, H, 0.76f, 0.3f, 0.04f, Color32.op_Implicit(Color.white));
			});
			P("Bolivia", delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 13970206u, 16376576u, 31028u);
			});
			P("Bosnia & Herzegovina", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(5257u));
				Tri(px, W, H, V(0.3f, 0.08f), V(0.88f, 0.08f), V(0.88f, 0.72f), C(16698112u));
				for (int i = 0; i < 5; i++)
				{
					Star(px, W, H, 0.24f + (float)i * 0.13f, 0.11f + (float)i * 0.145f, 0.045f, 0f, Color32.op_Implicit(Color.white));
				}
			});
			P("Botswana", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(7711451u));
				Band(px, W, H, 0f, 0.41f, 1f, 0.59f, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0f, 0.445f, 1f, 0.555f, C(1052688u));
			});
			P("Brazil", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0097: Unknown result type (might be due to invalid IL or missing references)
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(38713u));
				for (int i = 0; i < H; i++)
				{
					for (int j = 0; j < W; j++)
					{
						float num = ((float)j + 0.5f) / (float)W;
						float num2 = ((float)i + 0.5f) / (float)H;
						if (Mathf.Abs(num - 0.5f) / 0.44f + Mathf.Abs(num2 - 0.5f) / 0.36f <= 1f)
						{
							Set(px, W, H, j, i, C(16702720u));
						}
					}
				}
				Disc(px, W, H, 0.5f, 0.5f, 0.185f, C(74089u));
			});
			P("Brunei", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(16244759u));
				DiagBand(px, W, H, rising: false, -0.06f, 0.1f, Color32.op_Implicit(Color.white));
				DiagBand(px, W, H, rising: false, 0.075f, 0.045f, C(1052688u));
				Disc(px, W, H, 0.5f, 0.5f, 0.075f, C(13570342u));
				Band(px, W, H, 0.48f, 0.36f, 0.52f, 0.64f, C(13570342u));
			});
			P("Bulgaria", delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 16777215u, 38510u, 14034450u);
			});
			P("Burkina Faso", delegate(Color32[] px, int W, int H)
			{
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 15674157u, 40521u);
				Star(px, W, H, 0.5f, 0.5f, 0.09f, 0f, C(16568598u));
			});
			P("Burundi", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_009e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0107: Unknown result type (might be due to invalid IL or missing references)
				//IL_012d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0153: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(2012474u));
				Tri(px, W, H, V(0f, 0f), V(1f, 0f), V(0.5f, 0.5f), C(13504806u));
				Tri(px, W, H, V(0f, 1f), V(1f, 1f), V(0.5f, 0.5f), C(13504806u));
				DiagBand(px, W, H, rising: true, 0f, 0.045f, Color32.op_Implicit(Color.white));
				DiagBand(px, W, H, rising: false, 0f, 0.045f, Color32.op_Implicit(Color.white));
				Disc(px, W, H, 0.5f, 0.5f, 0.14f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.5f, 0.42f, 0.035f, 0f, C(13504806u));
				Star(px, W, H, 0.44f, 0.55f, 0.035f, 0f, C(13504806u));
				Star(px, W, H, 0.56f, 0.55f, 0.035f, 0f, C(13504806u));
			});
			P("Cabo Verde", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(14483u));
				Band(px, W, H, 0f, 0.55f, 1f, 0.61f, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0f, 0.61f, 1f, 0.67f, C(13574183u));
				Band(px, W, H, 0f, 0.67f, 1f, 0.73f, Color32.op_Implicit(Color.white));
				for (int i = 0; i < 10; i++)
				{
					float num = (float)i * MathF.PI * 2f / 10f;
					Star(px, W, H, 0.42f + 0.1f * Mathf.Cos(num), 0.64f + 1f / 15f * Mathf.Sin(num), 0.022f, 0f, C(16240918u));
				}
			});
			P("Cambodia", delegate(Color32[] px, int W, int H)
			{
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_0092: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_0101: Unknown result type (might be due to invalid IL or missing references)
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0124: Unknown result type (might be due to invalid IL or missing references)
				//IL_0129: Unknown result type (might be due to invalid IL or missing references)
				HStripesW(px, W, H, new uint[3] { 208545u, 14680101u, 208545u }, new float[3] { 1f, 2f, 1f });
				Band(px, W, H, 0.36f, 0.52f, 0.64f, 0.56f, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0.4f, 0.44f, 0.6f, 0.52f, Color32.op_Implicit(Color.white));
				Tri(px, W, H, V(0.38f, 0.44f), V(0.46f, 0.44f), V(0.42f, 0.35f), Color32.op_Implicit(Color.white));
				Tri(px, W, H, V(0.45f, 0.42f), V(0.55f, 0.42f), V(0.5f, 0.31f), Color32.op_Implicit(Color.white));
				Tri(px, W, H, V(0.54f, 0.44f), V(0.62f, 0.44f), V(0.58f, 0.35f), Color32.op_Implicit(Color.white));
			});
			P("Cameroon", delegate(Color32[] px, int W, int H)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				VStripes(px, W, H, 31326u, 13504806u, 16568598u);
				Star(px, W, H, 0.5f, 0.5f, 0.07f, 0f, C(16568598u));
			});
			P("Canada", delegate(Color32[] px, int W, int H)
			{
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				VStripesW(px, W, H, new uint[3] { 14157345u, 16777215u, 14157345u }, new float[3] { 1f, 2f, 1f });
				Star(px, W, H, 0.5f, 0.47f, 0.16f, 0f, C(14157345u));
				Band(px, W, H, 0.485f, 0.56f, 0.515f, 0.66f, C(14157345u));
			});
			P("Central African Republic", delegate(Color32[] px, int W, int H)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 12418u, 16777215u, 2660136u, 16764416u);
				Band(px, W, H, 0.42f, 0f, 0.58f, 1f, C(13766708u));
				Star(px, W, H, 0.13f, 0.11f, 0.05f, 0f, C(16764416u));
			});
			P("Chad", delegate(Color32[] px, int W, int H)
			{
				VStripes(px, W, H, 9828u, 16698112u, 12979248u);
			});
			P("Chile", delegate(Color32[] px, int W, int H)
			{
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 16777215u, 14297372u);
				Band(px, W, H, 0f, 0f, 0.36f, 0.5f, C(12960u));
				Star(px, W, H, 0.18f, 0.25f, 0.09f, 0f, Color32.op_Implicit(Color.white));
			});
			P("China", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(15604773u));
				Star(px, W, H, 0.22f, 0.2f, 0.13f, 0f, C(16776960u));
				Star(px, W, H, 0.42f, 0.08f, 0.045f, 20f, C(16776960u));
				Star(px, W, H, 0.48f, 0.17f, 0.045f, 45f, C(16776960u));
				Star(px, W, H, 0.48f, 0.28f, 0.045f, 0f, C(16776960u));
				Star(px, W, H, 0.42f, 0.36f, 0.045f, -20f, C(16776960u));
			});
			P("Colombia", delegate(Color32[] px, int W, int H)
			{
				HStripesW(px, W, H, new uint[3] { 16568598u, 14483u, 13504806u }, new float[3] { 2f, 1f, 1f });
			});
			P("Comoros", delegate(Color32[] px, int W, int H)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 16762398u, 16777215u, 13504806u, 3831236u);
				Tri(px, W, H, V(0f, 0f), V(0.5f, 0.5f), V(0f, 1f), C(2334278u));
				Crescent(px, W, H, 0.14f, 0.5f, 0.09f, 0.03f, 0.075f, Color32.op_Implicit(Color.white));
				for (int i = 0; i < 4; i++)
				{
					Disc(px, W, H, 0.24f, 0.35f + (float)i * 0.1f, 0.014f, Color32.op_Implicit(Color.white));
				}
			});
			P("Congo", delegate(Color32[] px, int W, int H)
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				Tri(px, W, H, V(0f, 0f), V(1f, 0f), V(0f, 1f), C(38211u));
				Tri(px, W, H, V(1f, 0f), V(1f, 1f), V(0f, 1f), C(14427167u));
				DiagBand(px, W, H, rising: true, 0f, 0.1f, C(16506442u));
			});
			P("Cook Islands", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(8283u));
				for (int i = 0; i < 15; i++)
				{
					float num = (float)i * MathF.PI * 2f / 15f;
					Star(px, W, H, 0.62f + 0.16f * Mathf.Cos(num), 0.6f + 0.10666666f * Mathf.Sin(num), 0.022f, 0f, Color32.op_Implicit(Color.white));
				}
				PaintUnionJackCanton(px, W, H);
			});
			P("Costa Rica", delegate(Color32[] px, int W, int H)
			{
				HStripesW(px, W, H, new uint[5] { 11135u, 16777215u, 13504806u, 16777215u, 11135u }, new float[5] { 1f, 1f, 2f, 1f, 1f });
			});
			P("Côte d'Ivoire", delegate(Color32[] px, int W, int H)
			{
				VStripes(px, W, H, 16744960u, 16777215u, 39492u);
			});
			P("Croatia", delegate(Color32[] px, int W, int H)
			{
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 16711680u, 16777215u, 1513366u);
				for (int i = 0; i < 4; i++)
				{
					for (int j = 0; j < 5; j++)
					{
						Band(px, W, H, 0.375f + (float)j * 0.05f, 0.38f + (float)i * 0.06f, 0.375f + (float)(j + 1) * 0.05f, 0.38f + (float)(i + 1) * 0.06f, ((j + i) % 2 == 0) ? C(16711680u) : Color32.op_Implicit(Color.white));
					}
				}
			});
			P("Cuba", delegate(Color32[] px, int W, int H)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 10895u, 16777215u, 10895u, 16777215u, 10895u);
				Tri(px, W, H, V(0f, 0f), V(0.55f, 0.5f), V(0f, 1f), C(13571115u));
				Star(px, W, H, 0.18f, 0.5f, 0.07f, 0f, Color32.op_Implicit(Color.white));
			});
			P("Cyprus", delegate(Color32[] px, int W, int H)
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, Color32.op_Implicit(Color.white));
				Disc(px, W, H, 0.42f, 0.42f, 0.055f, C(13989888u));
				Disc(px, W, H, 0.52f, 0.4f, 0.05f, C(13989888u));
				Disc(px, W, H, 0.6f, 0.44f, 0.032f, C(13989888u));
				Disc(px, W, H, 0.44f, 0.57f, 0.02f, C(5135153u));
				Disc(px, W, H, 0.5f, 0.59f, 0.02f, C(5135153u));
				Disc(px, W, H, 0.56f, 0.57f, 0.02f, C(5135153u));
			});
			P("Czechia", delegate(Color32[] px, int W, int H)
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 16777215u, 14095386u);
				Tri(px, W, H, V(0f, 0f), V(0.5f, 0.5f), V(0f, 1f), C(1131902u));
			});
			P("DR Congo", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(32767u));
				DiagBand(px, W, H, rising: true, 0f, 0.11f, C(16242200u));
				DiagBand(px, W, H, rising: true, 0f, 0.075f, C(13504545u));
				Star(px, W, H, 0.16f, 0.13f, 0.08f, 0f, C(16242200u));
			});
			P("Denmark", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(13111342u));
				NordicCross(px, W, H, 0.14f, Color32.op_Implicit(Color.white));
			});
			P("Djibouti", delegate(Color32[] px, int W, int H)
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 6992615u, 1223979u);
				Tri(px, W, H, V(0f, 0f), V(0.55f, 0.5f), V(0f, 1f), Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.18f, 0.5f, 0.06f, 0f, C(14095386u));
			});
			P("Dominica", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_010d: Unknown result type (might be due to invalid IL or missing references)
				//IL_012e: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(27455u));
				Band(px, W, H, 0f, 0.44f, 1f, 0.48f, C(16568598u));
				Band(px, W, H, 0f, 0.48f, 1f, 0.52f, C(1052688u));
				Band(px, W, H, 0f, 0.52f, 1f, 0.56f, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0.44f, 0f, 0.48f, 1f, C(16568598u));
				Band(px, W, H, 0.48f, 0f, 0.52f, 1f, C(1052688u));
				Band(px, W, H, 0.52f, 0f, 0.56f, 1f, Color32.op_Implicit(Color.white));
				Disc(px, W, H, 0.5f, 0.5f, 0.1f, C(13900848u));
				Disc(px, W, H, 0.5f, 0.5f, 0.035f, C(27455u));
			});
			P("Dominican Republic", delegate(Color32[] px, int W, int H)
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0f, 0f, 0.44f, 0.44f, C(11618u));
				Band(px, W, H, 0.56f, 0f, 1f, 0.44f, C(13504806u));
				Band(px, W, H, 0f, 0.56f, 0.44f, 1f, C(13504806u));
				Band(px, W, H, 0.56f, 0.56f, 1f, 1f, C(11618u));
				Disc(px, W, H, 0.5f, 0.5f, 0.035f, C(27455u));
			});
			P("Ecuador", delegate(Color32[] px, int W, int H)
			{
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				HStripesW(px, W, H, new uint[3] { 16768256u, 216738u, 15539236u }, new float[3] { 2f, 1f, 1f });
				Disc(px, W, H, 0.5f, 0.5f, 0.06f, C(9202239u));
			});
			P("Egypt", delegate(Color32[] px, int W, int H)
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 13504806u, 16777215u, 1052688u);
				Disc(px, W, H, 0.5f, 0.47f, 0.045f, C(12620544u));
				Tri(px, W, H, V(0.46f, 0.5f), V(0.54f, 0.5f), V(0.5f, 0.58f), C(12620544u));
			});
			P("El Salvador", delegate(Color32[] px, int W, int H)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 1001391u, 16777215u, 1001391u);
				Tri(px, W, H, V(0.43f, 0.44f), V(0.57f, 0.44f), V(0.5f, 0.57f), C(13149184u));
				Tri(px, W, H, V(0.455f, 0.46f), V(0.545f, 0.46f), V(0.5f, 0.545f), Color32.op_Implicit(Color.white));
			});
			P("Equatorial Guinea", delegate(Color32[] px, int W, int H)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 4102656u, 16777215u, 14885144u);
				Tri(px, W, H, V(0f, 0f), V(0.4f, 0.5f), V(0f, 1f), C(29646u));
				Disc(px, W, H, 0.62f, 0.5f, 0.035f, C(10266268u));
			});
			P("Eritrea", delegate(Color32[] px, int W, int H)
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 1223979u, 4295133u);
				Tri(px, W, H, V(0f, 0f), V(1f, 0.5f), V(0f, 1f), C(15336503u));
				Ring(px, W, H, 0.24f, 0.5f, 0.07f, 0.02f, C(16762662u));
				Disc(px, W, H, 0.24f, 0.5f, 0.02f, C(16762662u));
			});
			P("Estonia", delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 29390u, 1052688u, 16777215u);
			});
			P("Eswatini", delegate(Color32[] px, int W, int H)
			{
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				HStripesW(px, W, H, new uint[5] { 4087481u, 16767232u, 11602956u, 16767232u, 4087481u }, new float[5] { 3f, 1f, 5f, 1f, 3f });
				Band(px, W, H, 0.2f, 0.49f, 0.8f, 0.51f, C(10709803u));
				Disc(px, W, H, 0.42f, 0.5f, 0.075f, C(1052688u));
				Disc(px, W, H, 0.58f, 0.5f, 0.075f, C(1052688u));
				Disc(px, W, H, 0.5f, 0.5f, 0.085f, C(1052688u));
				Disc(px, W, H, 0.44f, 0.5f, 0.055f, Color32.op_Implicit(Color.white));
				Disc(px, W, H, 0.53f, 0.5f, 0.04f, Color32.op_Implicit(Color.white));
			});
			P("Ethiopia", delegate(Color32[] px, int W, int H)
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 493872u, 16571657u, 14291482u);
				Disc(px, W, H, 0.5f, 0.5f, 0.13f, C(1001391u));
				Star(px, W, H, 0.5f, 0.5f, 0.1f, 0f, C(16571657u));
				Star(px, W, H, 0.5f, 0.5f, 0.055f, 0f, C(1001391u));
			});
			P("Fiji", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(6864869u));
				Band(px, W, H, 0.6f, 0.52f, 0.82f, 0.78f, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0.6f, 0.52f, 0.82f, 0.58f, C(13766708u));
				Band(px, W, H, 0.695f, 0.58f, 0.725f, 0.78f, C(13766708u));
				Band(px, W, H, 0.6f, 0.655f, 0.82f, 0.685f, C(13766708u));
				PaintUnionJackCanton(px, W, H);
			});
			P("Finland", delegate(Color32[] px, int W, int H)
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, Color32.op_Implicit(Color.white));
				NordicCross(px, W, H, 0.16f, C(12140u));
			});
			P("France", delegate(Color32[] px, int W, int H)
			{
				VStripes(px, W, H, 21924u, 16777215u, 15679797u);
			});
			P("Gabon", delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 40544u, 16568598u, 3831236u);
			});
			P("Gambia", delegate(Color32[] px, int W, int H)
			{
				HStripesW(px, W, H, new uint[5] { 13504806u, 16777215u, 793740u, 16777215u, 3831592u }, new float[5] { 6f, 1f, 4f, 1f, 6f });
			});
			P("Georgia", delegate(Color32[] px, int W, int H)
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0.44f, 0f, 0.56f, 1f, C(16711680u));
				Band(px, W, H, 0f, 0.46f, 1f, 0.54f, C(16711680u));
				CrossAt(px, W, H, 0.22f, 0.22f, 0.05f, 0.018f, C(16711680u));
				CrossAt(px, W, H, 0.78f, 0.22f, 0.05f, 0.018f, C(16711680u));
				CrossAt(px, W, H, 0.22f, 0.78f, 0.05f, 0.018f, C(16711680u));
				CrossAt(px, W, H, 0.78f, 0.78f, 0.05f, 0.018f, C(16711680u));
			});
			P("Germany", delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 1052688u, 14483456u, 16764416u);
			});
			P("Ghana", delegate(Color32[] px, int W, int H)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 15676224u, 16765184u, 38713u);
				Star(px, W, H, 0.5f, 0.5f, 0.1f, 0f, C(1052688u));
			});
			P("Greece", delegate(Color32[] px, int W, int H)
			{
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 876207u, 16777215u, 876207u, 16777215u, 876207u, 16777215u, 876207u, 16777215u, 876207u);
				Band(px, W, H, 0f, 0f, 0.37f, 0.37f, C(876207u));
				Band(px, W, H, 0.145f, 0f, 0.225f, 0.37f, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0f, 0.145f, 0.37f, 0.225f, Color32.op_Implicit(Color.white));
			});
			P("Grenada", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
				//IL_0104: Unknown result type (might be due to invalid IL or missing references)
				//IL_0125: Unknown result type (might be due to invalid IL or missing references)
				//IL_014b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0171: Unknown result type (might be due to invalid IL or missing references)
				//IL_0197: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0209: Unknown result type (might be due to invalid IL or missing references)
				//IL_022f: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(13504806u));
				Tri(px, W, H, V(0.09f, 0.09f), V(0.91f, 0.09f), V(0.5f, 0.5f), C(16568598u));
				Tri(px, W, H, V(0.09f, 0.91f), V(0.91f, 0.91f), V(0.5f, 0.5f), C(16568598u));
				Tri(px, W, H, V(0.09f, 0.09f), V(0.5f, 0.5f), V(0.09f, 0.91f), C(31326u));
				Tri(px, W, H, V(0.91f, 0.09f), V(0.5f, 0.5f), V(0.91f, 0.91f), C(31326u));
				Disc(px, W, H, 0.5f, 0.5f, 0.075f, C(13504806u));
				Star(px, W, H, 0.5f, 0.5f, 0.055f, 0f, C(16568598u));
				Star(px, W, H, 0.3f, 0.045f, 0.03f, 0f, C(16568598u));
				Star(px, W, H, 0.5f, 0.045f, 0.03f, 0f, C(16568598u));
				Star(px, W, H, 0.7f, 0.045f, 0.03f, 0f, C(16568598u));
				Star(px, W, H, 0.3f, 0.955f, 0.03f, 0f, C(16568598u));
				Star(px, W, H, 0.5f, 0.955f, 0.03f, 0f, C(16568598u));
				Star(px, W, H, 0.7f, 0.955f, 0.03f, 0f, C(16568598u));
			});
			P("Guatemala", delegate(Color32[] px, int W, int H)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				VStripes(px, W, H, 4822992u, 16777215u, 4822992u);
				Ring(px, W, H, 0.5f, 0.5f, 0.07f, 0.015f, C(1089102u));
				Disc(px, W, H, 0.5f, 0.5f, 0.03f, C(9214808u));
			});
			P("Guinea", delegate(Color32[] px, int W, int H)
			{
				VStripes(px, W, H, 13504806u, 16568598u, 37984u);
			});
			P("Guinea-Bissau", delegate(Color32[] px, int W, int H)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				Band(px, W, H, 0.35f, 0f, 1f, 0.5f, C(16568598u));
				Band(px, W, H, 0.35f, 0.5f, 1f, 1f, C(40521u));
				Band(px, W, H, 0f, 0f, 0.35f, 1f, C(13504806u));
				Star(px, W, H, 0.175f, 0.5f, 0.07f, 0f, C(1052688u));
			});
			P("Guyana", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
				//IL_0104: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(40521u));
				Tri(px, W, H, V(0f, 0.02f), V(0.98f, 0.5f), V(0f, 0.98f), Color32.op_Implicit(Color.white));
				Tri(px, W, H, V(0f, 0.06f), V(0.9f, 0.5f), V(0f, 0.94f), C(16568598u));
				Tri(px, W, H, V(0f, 0.14f), V(0.55f, 0.5f), V(0f, 0.86f), C(1052688u));
				Tri(px, W, H, V(0f, 0.2f), V(0.47f, 0.5f), V(0f, 0.8f), C(13504806u));
			});
			P("Haiti", delegate(Color32[] px, int W, int H)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 8351u, 13766708u);
				Band(px, W, H, 0.42f, 0.42f, 0.58f, 0.58f, Color32.op_Implicit(Color.white));
				Disc(px, W, H, 0.5f, 0.5f, 0.032f, C(92694u));
			});
			P("Honduras", delegate(Color32[] px, int W, int H)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 29647u, 16777215u, 29647u);
				Star(px, W, H, 0.35f, 0.42f, 0.032f, 0f, C(29647u));
				Star(px, W, H, 0.65f, 0.42f, 0.032f, 0f, C(29647u));
				Star(px, W, H, 0.5f, 0.5f, 0.032f, 0f, C(29647u));
				Star(px, W, H, 0.35f, 0.58f, 0.032f, 0f, C(29647u));
				Star(px, W, H, 0.65f, 0.58f, 0.032f, 0f, C(29647u));
			});
			P("Hungary", delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 13510969u, 16777215u, 4681808u);
			});
			P("Iceland", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(152220u));
				NordicCross(px, W, H, 0.16f, Color32.op_Implicit(Color.white));
				NordicCross(px, W, H, 0.08f, C(14425653u));
			});
			P("India", delegate(Color32[] px, int W, int H)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 16750899u, 16777215u, 1280008u);
				Ring(px, W, H, 0.5f, 0.5f, 0.105f, 0.028f, C(128u));
			});
			P("Indonesia", delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 13504806u, 16777215u);
			});
			P("Iran", delegate(Color32[] px, int W, int H)
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 2334528u, 16777215u, 14286848u);
				Disc(px, W, H, 0.5f, 0.5f, 0.05f, C(14286848u));
				Band(px, W, H, 0.485f, 0.42f, 0.515f, 0.58f, C(14286848u));
			});
			P("Iraq", delegate(Color32[] px, int W, int H)
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 13504806u, 16777215u, 1052688u);
				Disc(px, W, H, 0.38f, 0.5f, 0.028f, C(31293u));
				Disc(px, W, H, 0.5f, 0.49f, 0.028f, C(31293u));
				Disc(px, W, H, 0.62f, 0.5f, 0.028f, C(31293u));
			});
			P("Ireland", delegate(Color32[] px, int W, int H)
			{
				VStripes(px, W, H, 1481570u, 16777215u, 16746558u);
			});
			P("Israel", delegate(Color32[] px, int W, int H)
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0f, 0.12f, 1f, 0.22f, C(14520u));
				Band(px, W, H, 0f, 0.78f, 1f, 0.88f, C(14520u));
				Tri(px, W, H, V(0.5f, 0.32f), V(0.35f, 0.5f), V(0.65f, 0.5f), C(14520u));
				Tri(px, W, H, V(0.5f, 0.62f), V(0.35f, 0.44f), V(0.65f, 0.44f), C(14520u));
			});
			P("Italy", delegate(Color32[] px, int W, int H)
			{
				VStripes(px, W, H, 35909u, 16777215u, 13443370u);
			});
			P("Jamaica", delegate(Color32[] px, int W, int H)
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_010f: Unknown result type (might be due to invalid IL or missing references)
				//IL_012c: Unknown result type (might be due to invalid IL or missing references)
				Tri(px, W, H, V(0f, 0f), V(1f, 0f), V(0.5f, 0.5f), C(39738u));
				Tri(px, W, H, V(0f, 1f), V(1f, 1f), V(0.5f, 0.5f), C(39738u));
				Tri(px, W, H, V(0f, 0f), V(0.5f, 0.5f), V(0f, 1f), C(1052688u));
				Tri(px, W, H, V(1f, 0f), V(0.5f, 0.5f), V(1f, 1f), C(1052688u));
				DiagBand(px, W, H, rising: true, 0f, 0.05f, C(16699648u));
				DiagBand(px, W, H, rising: false, 0f, 0.05f, C(16699648u));
			});
			P("Japan", delegate(Color32[] px, int W, int H)
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, Color32.op_Implicit(Color.white));
				Disc(px, W, H, 0.5f, 0.5f, 0.19f, C(12320813u));
			});
			P("Jordan", delegate(Color32[] px, int W, int H)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 1052688u, 16777215u, 31293u);
				Tri(px, W, H, V(0f, 0f), V(0.45f, 0.5f), V(0f, 1f), C(13504806u));
				Star(px, W, H, 0.15f, 0.5f, 0.035f, 0f, Color32.op_Implicit(Color.white));
			});
			P("Kazakhstan", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00da: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(45002u));
				Band(px, W, H, 0.02f, 0f, 0.1f, 1f, C(16696588u));
				for (int i = 0; i < 8; i++)
				{
					Rhomb(px, W, H, 0.06f, 0.06f + (float)i * 0.125f, 0.032f, 0.035f, C(45002u));
				}
				Sun(px, W, H, 0.55f, 0.4f, 0.09f, 0.05f, 16, C(16696588u));
				Quad(px, W, H, V(0.35f, 0.62f), V(0.55f, 0.58f), V(0.75f, 0.62f), V(0.55f, 0.66f), C(16696588u));
			});
			P("Kenya", delegate(Color32[] px, int W, int H)
			{
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				HStripesW(px, W, H, new uint[5] { 1052688u, 16777215u, 12255232u, 16777215u, 26112u }, new float[5] { 6f, 1f, 6f, 1f, 6f });
				Band(px, W, H, 0.49f, 0.22f, 0.51f, 0.78f, Color32.op_Implicit(Color.white));
				Disc(px, W, H, 0.5f, 0.5f, 0.085f, C(12255232u));
				Ring(px, W, H, 0.5f, 0.5f, 0.085f, 0.018f, Color32.op_Implicit(Color.white));
				Disc(px, W, H, 0.5f, 0.5f, 0.035f, C(1052688u));
			});
			P("Kiribati", delegate(Color32[] px, int W, int H)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Unknown result type (might be due to inv
Get the Thunderstore App

Decompiled source of ScorchedVoxels v0.20.69

ScorchedVoxels.dll

About

Developers
