using System;

namespace System.Text.RegularExpressions
{
	// Token: 0x020002CE RID: 718
	internal class Interpreter : BaseMachine
	{
		// Token: 0x06001A1A RID: 6682 RVA: 0x0005D280 File Offset: 0x0005B480
		public Interpreter(ushort[] program)
		{
			this.program = program;
			this.qs = null;
			this.group_count = this.ReadProgramCount(1) + 1;
			this.match_min = this.ReadProgramCount(3);
			this.program_start = 7;
			this.groups = new int[this.group_count];
		}

		// Token: 0x06001A1B RID: 6683 RVA: 0x0005D2E4 File Offset: 0x0005B4E4
		private int ReadProgramCount(int ptr)
		{
			int num = (int)this.program[ptr + 1];
			num <<= 16;
			return num + (int)this.program[ptr];
		}

		// Token: 0x06001A1C RID: 6684 RVA: 0x0005D310 File Offset: 0x0005B510
		public override Match Scan(Regex regex, string text, int start, int end)
		{
			this.text = text;
			this.text_end = end;
			this.scan_ptr = start;
			if (this.Eval(Interpreter.Mode.Match, ref this.scan_ptr, this.program_start))
			{
				return this.GenerateMatch(regex);
			}
			return Match.Empty;
		}

		// Token: 0x06001A1D RID: 6685 RVA: 0x0005D350 File Offset: 0x0005B550
		private void Reset()
		{
			this.ResetGroups();
			this.fast = (this.repeat = null);
		}

		// Token: 0x06001A1E RID: 6686 RVA: 0x0005D374 File Offset: 0x0005B574
		private bool Eval(Interpreter.Mode mode, ref int ref_ptr, int pc)
		{
			int num = ref_ptr;
			Interpreter.RepeatContext repeatContext;
			int start;
			int count;
			for (;;)
			{
				OpFlags opFlags;
				for (;;)
				{
					ushort num2 = this.program[pc];
					OpCode opCode = (OpCode)(num2 & 255);
					opFlags = (OpFlags)(num2 & 65280);
					switch (opCode)
					{
					case OpCode.False:
						goto IL_4B8;
					case OpCode.True:
						goto IL_4BD;
					case OpCode.Position:
						if (!this.IsPosition((Position)this.program[pc + 1], num))
						{
							goto Block_44;
						}
						pc += 2;
						break;
					case OpCode.String:
					{
						bool flag = (ushort)(opFlags & OpFlags.RightToLeft) != 0;
						bool flag2 = (ushort)(opFlags & OpFlags.IgnoreCase) != 0;
						int num3 = (int)this.program[pc + 1];
						if (flag)
						{
							num -= num3;
							if (num < 0)
							{
								goto Block_46;
							}
						}
						else if (num + num3 > this.text_end)
						{
							goto Block_47;
						}
						pc += 2;
						for (int i = 0; i < num3; i++)
						{
							char c = this.text[num + i];
							if (flag2)
							{
								c = char.ToLower(c);
							}
							if (c != (char)this.program[pc++])
							{
								goto Block_49;
							}
						}
						if (!flag)
						{
							num += num3;
						}
						break;
					}
					case OpCode.Reference:
					{
						bool flag3 = (ushort)(opFlags & OpFlags.RightToLeft) != 0;
						bool flag4 = (ushort)(opFlags & OpFlags.IgnoreCase) != 0;
						int lastDefined = this.GetLastDefined((int)this.program[pc + 1]);
						if (lastDefined < 0)
						{
							goto Block_52;
						}
						int index = this.marks[lastDefined].Index;
						int length = this.marks[lastDefined].Length;
						if (flag3)
						{
							num -= length;
							if (num < 0)
							{
								goto Block_54;
							}
						}
						else if (num + length > this.text_end)
						{
							goto Block_55;
						}
						pc += 2;
						if (flag4)
						{
							for (int j = 0; j < length; j++)
							{
								if (char.ToLower(this.text[num + j]) != char.ToLower(this.text[index + j]))
								{
									goto Block_57;
								}
							}
						}
						else
						{
							for (int k = 0; k < length; k++)
							{
								if (this.text[num + k] != this.text[index + k])
								{
									goto Block_59;
								}
							}
						}
						if (!flag3)
						{
							num += length;
						}
						break;
					}
					case OpCode.Character:
					case OpCode.Category:
					case OpCode.NotCategory:
					case OpCode.Range:
					case OpCode.Set:
						if (!this.EvalChar(mode, ref num, ref pc, false))
						{
							goto Block_61;
						}
						break;
					case OpCode.In:
					{
						int num4 = pc + (int)this.program[pc + 1];
						pc += 2;
						if (!this.EvalChar(mode, ref num, ref pc, true))
						{
							goto Block_62;
						}
						pc = num4;
						break;
					}
					case OpCode.Open:
						this.Open((int)this.program[pc + 1], num);
						pc += 2;
						break;
					case OpCode.Close:
						this.Close((int)this.program[pc + 1], num);
						pc += 2;
						break;
					case OpCode.Balance:
						goto IL_7DB;
					case OpCode.BalanceStart:
					{
						int num5 = num;
						if (!this.Eval(Interpreter.Mode.Match, ref num, pc + 5))
						{
							goto Block_63;
						}
						if (!this.Balance((int)this.program[pc + 1], (int)this.program[pc + 2], this.program[pc + 3] == 1, num5))
						{
							goto Block_65;
						}
						pc += (int)this.program[pc + 4];
						break;
					}
					case OpCode.IfDefined:
					{
						int lastDefined2 = this.GetLastDefined((int)this.program[pc + 2]);
						if (lastDefined2 < 0)
						{
							pc += (int)this.program[pc + 1];
						}
						else
						{
							pc += 3;
						}
						break;
					}
					case OpCode.Sub:
						if (!this.Eval(Interpreter.Mode.Match, ref num, pc + 2))
						{
							goto Block_67;
						}
						pc += (int)this.program[pc + 1];
						break;
					case OpCode.Test:
					{
						int num6 = this.Checkpoint();
						int num7 = num;
						if (this.Eval(Interpreter.Mode.Match, ref num7, pc + 3))
						{
							pc += (int)this.program[pc + 1];
						}
						else
						{
							this.Backtrack(num6);
							pc += (int)this.program[pc + 2];
						}
						break;
					}
					case OpCode.Branch:
						goto IL_88A;
					case OpCode.Jump:
						pc += (int)this.program[pc + 1];
						break;
					case OpCode.Repeat:
						goto IL_8EE;
					case OpCode.Until:
						goto IL_957;
					case OpCode.FastRepeat:
						goto IL_C6F;
					case OpCode.Anchor:
						goto IL_96;
					case OpCode.Info:
						goto IL_FE9;
					}
				}
				for (;;)
				{
					IL_88A:
					int num8 = this.Checkpoint();
					if (this.Eval(Interpreter.Mode.Match, ref num, pc + 2))
					{
						break;
					}
					this.Backtrack(num8);
					pc += (int)this.program[pc + 1];
					if ((this.program[pc] & 255) == 0)
					{
						goto Block_70;
					}
				}
				IL_FF3:
				ref_ptr = num;
				if (mode == Interpreter.Mode.Match)
				{
					return true;
				}
				if (mode != Interpreter.Mode.Count)
				{
					break;
				}
				this.fast.Count++;
				if (this.fast.IsMaximum || (this.fast.IsLazy && this.fast.IsMinimum))
				{
					return true;
				}
				pc = this.fast.Expression;
				continue;
				IL_96:
				int num9 = (int)this.program[pc + 1];
				int num10 = (int)this.program[pc + 2];
				bool flag5 = (ushort)(opFlags & OpFlags.RightToLeft) != 0;
				int num11 = ((!flag5) ? (num + num10) : (num - num10));
				int num12 = this.text_end - this.match_min + num10;
				int num13 = 0;
				OpCode opCode2 = (OpCode)(this.program[pc + 3] & 255);
				if (opCode2 == OpCode.Position && num9 == 6)
				{
					switch (this.program[pc + 4])
					{
					case 2:
						if (flag5 || num10 == 0)
						{
							if (flag5)
							{
								num = num10;
							}
							if (this.TryMatch(ref num, pc + num9))
							{
								goto IL_FF3;
							}
						}
						break;
					case 3:
						if (num11 == 0)
						{
							num = 0;
							if (this.TryMatch(ref num, pc + num9))
							{
								goto IL_FF3;
							}
							num11++;
						}
						while ((flag5 && num11 >= 0) || (!flag5 && num11 <= num12))
						{
							if (num11 == 0 || this.text[num11 - 1] == '\n')
							{
								if (flag5)
								{
									num = ((num11 != num12) ? (num11 + num10) : num11);
								}
								else
								{
									num = ((num11 != 0) ? (num11 - num10) : num11);
								}
								if (this.TryMatch(ref num, pc + num9))
								{
									goto IL_FF3;
								}
							}
							if (flag5)
							{
								num11--;
							}
							else
							{
								num11++;
							}
						}
						break;
					case 4:
						if (num11 == this.scan_ptr)
						{
							num = ((!flag5) ? (this.scan_ptr - num10) : (this.scan_ptr + num10));
							if (this.TryMatch(ref num, pc + num9))
							{
								goto IL_FF3;
							}
						}
						break;
					}
					break;
				}
				if (this.qs != null || (opCode2 == OpCode.String && num9 == (int)(6 + this.program[pc + 4])))
				{
					bool flag6 = (this.program[pc + 3] & 1024) != 0;
					if (this.qs == null)
					{
						bool flag7 = (this.program[pc + 3] & 512) != 0;
						string @string = this.GetString(pc + 3);
						this.qs = new QuickSearch(@string, flag7, flag6);
					}
					while ((flag5 && num11 >= num13) || (!flag5 && num11 <= num12))
					{
						if (flag6)
						{
							num11 = this.qs.Search(this.text, num11, num13);
							if (num11 != -1)
							{
								num11 += this.qs.Length;
							}
						}
						else
						{
							num11 = this.qs.Search(this.text, num11, num12);
						}
						if (num11 < 0)
						{
							break;
						}
						num = ((!flag6) ? (num11 - num10) : (num11 + num10));
						if (this.TryMatch(ref num, pc + num9))
						{
							goto IL_FF3;
						}
						if (flag6)
						{
							num11 -= 2;
						}
						else
						{
							num11++;
						}
					}
					break;
				}
				if (opCode2 == OpCode.True)
				{
					while ((flag5 && num11 >= num13) || (!flag5 && num11 <= num12))
					{
						num = num11;
						if (this.TryMatch(ref num, pc + num9))
						{
							goto IL_FF3;
						}
						if (flag5)
						{
							num11--;
						}
						else
						{
							num11++;
						}
					}
					break;
				}
				while ((flag5 && num11 >= num13) || (!flag5 && num11 <= num12))
				{
					num = num11;
					if (this.Eval(Interpreter.Mode.Match, ref num, pc + 3))
					{
						num = ((!flag5) ? (num11 - num10) : (num11 + num10));
						if (this.TryMatch(ref num, pc + num9))
						{
							goto IL_FF3;
						}
					}
					if (flag5)
					{
						num11--;
					}
					else
					{
						num11++;
					}
				}
				break;
				IL_4BD:
				IL_7DB:
				goto IL_FF3;
				IL_8EE:
				this.repeat = new Interpreter.RepeatContext(this.repeat, this.ReadProgramCount(pc + 2), this.ReadProgramCount(pc + 4), (ushort)(opFlags & OpFlags.Lazy) != 0, pc + 6);
				if (this.Eval(Interpreter.Mode.Match, ref num, pc + (int)this.program[pc + 1]))
				{
					goto IL_FF3;
				}
				goto IL_941;
				IL_957:
				repeatContext = this.repeat;
				if (this.deep == repeatContext)
				{
					goto IL_FF3;
				}
				start = repeatContext.Start;
				count = repeatContext.Count;
				while (!repeatContext.IsMinimum)
				{
					repeatContext.Count++;
					repeatContext.Start = num;
					this.deep = repeatContext;
					if (!this.Eval(Interpreter.Mode.Match, ref num, repeatContext.Expression))
					{
						goto Block_73;
					}
					if (this.deep != repeatContext)
					{
						goto IL_FF3;
					}
				}
				if (num == repeatContext.Start)
				{
					this.repeat = repeatContext.Previous;
					this.deep = null;
					if (this.Eval(Interpreter.Mode.Match, ref num, pc + 1))
					{
						goto IL_FF3;
					}
					goto IL_A28;
				}
				else
				{
					if (repeatContext.IsLazy)
					{
						for (;;)
						{
							this.repeat = repeatContext.Previous;
							this.deep = null;
							int num14 = this.Checkpoint();
							if (this.Eval(Interpreter.Mode.Match, ref num, pc + 1))
							{
								break;
							}
							this.Backtrack(num14);
							this.repeat = repeatContext;
							if (repeatContext.IsMaximum)
							{
								goto Block_80;
							}
							repeatContext.Count++;
							repeatContext.Start = num;
							this.deep = repeatContext;
							if (!this.Eval(Interpreter.Mode.Match, ref num, repeatContext.Expression))
							{
								goto Block_81;
							}
							if (this.deep != repeatContext)
							{
								break;
							}
							if (num == repeatContext.Start)
							{
								goto Block_83;
							}
						}
						goto IL_FF3;
					}
					int count2 = this.stack.Count;
					while (!repeatContext.IsMaximum)
					{
						int num15 = this.Checkpoint();
						int num16 = num;
						int start2 = repeatContext.Start;
						repeatContext.Count++;
						repeatContext.Start = num;
						this.deep = repeatContext;
						if (!this.Eval(Interpreter.Mode.Match, ref num, repeatContext.Expression))
						{
							repeatContext.Count--;
							repeatContext.Start = start2;
							this.Backtrack(num15);
							break;
						}
						if (this.deep != repeatContext)
						{
							this.stack.Count = count2;
							goto IL_FF3;
						}
						this.stack.Push(num15);
						this.stack.Push(num16);
						if (num == repeatContext.Start)
						{
							break;
						}
					}
					this.repeat = repeatContext.Previous;
					for (;;)
					{
						this.deep = null;
						if (this.Eval(Interpreter.Mode.Match, ref num, pc + 1))
						{
							break;
						}
						if (this.stack.Count == count2)
						{
							goto Block_88;
						}
						repeatContext.Count--;
						num = this.stack.Pop();
						this.Backtrack(this.stack.Pop());
					}
					this.stack.Count = count2;
					goto IL_FF3;
				}
				IL_C6F:
				this.fast = new Interpreter.RepeatContext(this.fast, this.ReadProgramCount(pc + 2), this.ReadProgramCount(pc + 4), (ushort)(opFlags & OpFlags.Lazy) != 0, pc + 6);
				this.fast.Start = num;
				int num17 = this.Checkpoint();
				pc += (int)this.program[pc + 1];
				ushort num18 = this.program[pc];
				int num19 = -1;
				int num20 = -1;
				int num21 = 0;
				OpCode opCode3 = (OpCode)(num18 & 255);
				if (opCode3 == OpCode.Character || opCode3 == OpCode.String)
				{
					OpFlags opFlags2 = (OpFlags)(num18 & 65280);
					if ((ushort)(opFlags2 & OpFlags.Negate) == 0)
					{
						if (opCode3 == OpCode.String)
						{
							int num22 = 0;
							if ((ushort)(opFlags2 & OpFlags.RightToLeft) != 0)
							{
								num22 = (int)(this.program[pc + 1] - 1);
							}
							num19 = (int)this.program[pc + 2 + num22];
						}
						else
						{
							num19 = (int)this.program[pc + 1];
						}
						if ((ushort)(opFlags2 & OpFlags.IgnoreCase) != 0)
						{
							num20 = (int)char.ToUpper((char)num19);
						}
						else
						{
							num20 = num19;
						}
						if ((ushort)(opFlags2 & OpFlags.RightToLeft) != 0)
						{
							num21 = -1;
						}
						else
						{
							num21 = 0;
						}
					}
				}
				if (this.fast.IsLazy)
				{
					if (!this.fast.IsMinimum && !this.Eval(Interpreter.Mode.Count, ref num, this.fast.Expression))
					{
						goto Block_97;
					}
					for (;;)
					{
						int num23 = num + num21;
						if (num19 < 0 || (num23 >= 0 && num23 < this.text_end && (num19 == (int)this.text[num23] || num20 == (int)this.text[num23])))
						{
							this.deep = null;
							if (this.Eval(Interpreter.Mode.Match, ref num, pc))
							{
								break;
							}
						}
						if (this.fast.IsMaximum)
						{
							goto Block_103;
						}
						this.Backtrack(num17);
						if (!this.Eval(Interpreter.Mode.Count, ref num, this.fast.Expression))
						{
							goto Block_104;
						}
					}
					this.fast = this.fast.Previous;
					goto IL_FF3;
				}
				else
				{
					if (!this.Eval(Interpreter.Mode.Count, ref num, this.fast.Expression))
					{
						goto Block_105;
					}
					int num24;
					if (this.fast.Count > 0)
					{
						num24 = (num - this.fast.Start) / this.fast.Count;
					}
					else
					{
						num24 = 0;
					}
					for (;;)
					{
						int num25 = num + num21;
						if (num19 < 0 || (num25 >= 0 && num25 < this.text_end && (num19 == (int)this.text[num25] || num20 == (int)this.text[num25])))
						{
							this.deep = null;
							if (this.Eval(Interpreter.Mode.Match, ref num, pc))
							{
								break;
							}
						}
						this.fast.Count--;
						if (!this.fast.IsMinimum)
						{
							goto Block_112;
						}
						num -= num24;
						this.Backtrack(num17);
					}
					this.fast = this.fast.Previous;
					goto IL_FF3;
				}
			}
			IL_4B8:
			Block_44:
			Block_46:
			Block_47:
			Block_49:
			Block_52:
			Block_54:
			Block_55:
			Block_57:
			Block_59:
			Block_61:
			Block_62:
			Block_63:
			Block_65:
			Block_67:
			Block_70:
			goto IL_1067;
			IL_941:
			this.repeat = this.repeat.Previous;
			goto IL_1067;
			Block_73:
			repeatContext.Start = start;
			repeatContext.Count = count;
			goto IL_1067;
			IL_A28:
			this.repeat = repeatContext;
			Block_80:
			goto IL_1067;
			Block_81:
			repeatContext.Start = start;
			repeatContext.Count = count;
			Block_83:
			goto IL_1067;
			Block_88:
			this.repeat = repeatContext;
			goto IL_1067;
			Block_97:
			this.fast = this.fast.Previous;
			goto IL_1067;
			Block_103:
			this.fast = this.fast.Previous;
			goto IL_1067;
			Block_104:
			this.fast = this.fast.Previous;
			goto IL_1067;
			Block_105:
			this.fast = this.fast.Previous;
			goto IL_1067;
			Block_112:
			this.fast = this.fast.Previous;
			IL_FE9:
			IL_1067:
			if (mode == Interpreter.Mode.Match)
			{
				return false;
			}
			if (mode != Interpreter.Mode.Count)
			{
				return false;
			}
			if (!this.fast.IsLazy && this.fast.IsMinimum)
			{
				return true;
			}
			ref_ptr = this.fast.Start;
			return false;
		}

		// Token: 0x06001A1F RID: 6687 RVA: 0x0005E434 File Offset: 0x0005C634
		private bool EvalChar(Interpreter.Mode mode, ref int ptr, ref int pc, bool multi)
		{
			bool flag = false;
			char c = '\0';
			bool flag3;
			for (;;)
			{
				ushort num = this.program[pc];
				OpCode opCode = (OpCode)(num & 255);
				OpFlags opFlags = (OpFlags)(num & 65280);
				pc++;
				bool flag2 = (ushort)(opFlags & OpFlags.IgnoreCase) != 0;
				if (!flag)
				{
					if ((ushort)(opFlags & OpFlags.RightToLeft) != 0)
					{
						if (ptr <= 0)
						{
							break;
						}
						c = this.text[--ptr];
					}
					else
					{
						if (ptr >= this.text_end)
						{
							return false;
						}
						c = this.text[ptr++];
					}
					if (flag2)
					{
						c = char.ToLower(c);
					}
					flag = true;
				}
				flag3 = (ushort)(opFlags & OpFlags.Negate) != 0;
				switch (opCode)
				{
				case OpCode.False:
					return false;
				case OpCode.True:
					return true;
				case OpCode.Character:
					if (c == (char)this.program[pc++])
					{
						goto Block_7;
					}
					break;
				case OpCode.Category:
					if (CategoryUtils.IsCategory((Category)this.program[pc++], c))
					{
						goto Block_8;
					}
					break;
				case OpCode.NotCategory:
					if (!CategoryUtils.IsCategory((Category)this.program[pc++], c))
					{
						goto Block_9;
					}
					break;
				case OpCode.Range:
				{
					int num2 = (int)this.program[pc++];
					int num3 = (int)this.program[pc++];
					if (num2 <= (int)c && (int)c <= num3)
					{
						goto Block_11;
					}
					break;
				}
				case OpCode.Set:
				{
					int num4 = (int)this.program[pc++];
					int num5 = (int)this.program[pc++];
					int num6 = pc;
					pc += num5;
					int num7 = (int)c - num4;
					if (num7 >= 0 && num7 < num5 << 4)
					{
						if (((int)this.program[num6 + (num7 >> 4)] & (1 << (num7 & 15))) != 0)
						{
							goto Block_13;
						}
					}
					break;
				}
				}
				if (!multi)
				{
					return flag3;
				}
			}
			return false;
			Block_7:
			return !flag3;
			Block_8:
			return !flag3;
			Block_9:
			return !flag3;
			Block_11:
			return !flag3;
			Block_13:
			return !flag3;
		}

		// Token: 0x06001A20 RID: 6688 RVA: 0x0005E66C File Offset: 0x0005C86C
		private bool TryMatch(ref int ref_ptr, int pc)
		{
			this.Reset();
			int num = ref_ptr;
			this.marks[this.groups[0]].Start = num;
			if (this.Eval(Interpreter.Mode.Match, ref num, pc))
			{
				this.marks[this.groups[0]].End = num;
				ref_ptr = num;
				return true;
			}
			return false;
		}

		// Token: 0x06001A21 RID: 6689 RVA: 0x0005E6CC File Offset: 0x0005C8CC
		private bool IsPosition(Position pos, int ptr)
		{
			switch (pos)
			{
			case Position.Start:
			case Position.StartOfString:
				return ptr == 0;
			case Position.StartOfLine:
				return ptr == 0 || this.text[ptr - 1] == '\n';
			case Position.StartOfScan:
				return ptr == this.scan_ptr;
			case Position.End:
				return ptr == this.text_end || (ptr == this.text_end - 1 && this.text[ptr] == '\n');
			case Position.EndOfString:
				return ptr == this.text_end;
			case Position.EndOfLine:
				return ptr == this.text_end || this.text[ptr] == '\n';
			case Position.Boundary:
				if (this.text_end == 0)
				{
					return false;
				}
				if (ptr == 0)
				{
					return this.IsWordChar(this.text[ptr]);
				}
				if (ptr == this.text_end)
				{
					return this.IsWordChar(this.text[ptr - 1]);
				}
				return this.IsWordChar(this.text[ptr]) != this.IsWordChar(this.text[ptr - 1]);
			case Position.NonBoundary:
				if (this.text_end == 0)
				{
					return false;
				}
				if (ptr == 0)
				{
					return !this.IsWordChar(this.text[ptr]);
				}
				if (ptr == this.text_end)
				{
					return !this.IsWordChar(this.text[ptr - 1]);
				}
				return this.IsWordChar(this.text[ptr]) == this.IsWordChar(this.text[ptr - 1]);
			default:
				return false;
			}
		}

		// Token: 0x06001A22 RID: 6690 RVA: 0x0005E87C File Offset: 0x0005CA7C
		private bool IsWordChar(char c)
		{
			return CategoryUtils.IsCategory(Category.Word, c);
		}

		// Token: 0x06001A23 RID: 6691 RVA: 0x0005E888 File Offset: 0x0005CA88
		private string GetString(int pc)
		{
			int num = (int)this.program[pc + 1];
			int num2 = pc + 2;
			char[] array = new char[num];
			for (int i = 0; i < num; i++)
			{
				array[i] = (char)this.program[num2++];
			}
			return new string(array);
		}

		// Token: 0x06001A24 RID: 6692 RVA: 0x0005E8D4 File Offset: 0x0005CAD4
		private void Open(int gid, int ptr)
		{
			int num = this.groups[gid];
			if (num < this.mark_start || this.marks[num].IsDefined)
			{
				num = this.CreateMark(num);
				this.groups[gid] = num;
			}
			this.marks[num].Start = ptr;
		}

		// Token: 0x06001A25 RID: 6693 RVA: 0x0005E930 File Offset: 0x0005CB30
		private void Close(int gid, int ptr)
		{
			this.marks[this.groups[gid]].End = ptr;
		}

		// Token: 0x06001A26 RID: 6694 RVA: 0x0005E94C File Offset: 0x0005CB4C
		private bool Balance(int gid, int balance_gid, bool capture, int ptr)
		{
			int num = this.groups[balance_gid];
			if (num == -1 || this.marks[num].Index < 0)
			{
				return false;
			}
			if (gid > 0 && capture)
			{
				this.Open(gid, this.marks[num].Index + this.marks[num].Length);
				this.Close(gid, ptr);
			}
			this.groups[balance_gid] = this.marks[num].Previous;
			return true;
		}

		// Token: 0x06001A27 RID: 6695 RVA: 0x0005E9DC File Offset: 0x0005CBDC
		private int Checkpoint()
		{
			this.mark_start = this.mark_end;
			return this.mark_start;
		}

		// Token: 0x06001A28 RID: 6696 RVA: 0x0005E9F0 File Offset: 0x0005CBF0
		private void Backtrack(int cp)
		{
			for (int i = 0; i < this.groups.Length; i++)
			{
				int num = this.groups[i];
				while (cp <= num)
				{
					num = this.marks[num].Previous;
				}
				this.groups[i] = num;
			}
		}

		// Token: 0x06001A29 RID: 6697 RVA: 0x0005EA48 File Offset: 0x0005CC48
		private void ResetGroups()
		{
			int num = this.groups.Length;
			if (this.marks == null)
			{
				this.marks = new Mark[num * 10];
			}
			for (int i = 0; i < num; i++)
			{
				this.groups[i] = i;
				this.marks[i].Start = -1;
				this.marks[i].End = -1;
				this.marks[i].Previous = -1;
			}
			this.mark_start = 0;
			this.mark_end = num;
		}

		// Token: 0x06001A2A RID: 6698 RVA: 0x0005EAD8 File Offset: 0x0005CCD8
		private int GetLastDefined(int gid)
		{
			int num = this.groups[gid];
			while (num >= 0 && !this.marks[num].IsDefined)
			{
				num = this.marks[num].Previous;
			}
			return num;
		}

		// Token: 0x06001A2B RID: 6699 RVA: 0x0005EB24 File Offset: 0x0005CD24
		private int CreateMark(int previous)
		{
			if (this.mark_end == this.marks.Length)
			{
				Mark[] array = new Mark[this.marks.Length * 2];
				this.marks.CopyTo(array, 0);
				this.marks = array;
			}
			int num = this.mark_end++;
			this.marks[num].Start = (this.marks[num].End = -1);
			this.marks[num].Previous = previous;
			return num;
		}

		// Token: 0x06001A2C RID: 6700 RVA: 0x0005EBB4 File Offset: 0x0005CDB4
		private void GetGroupInfo(int gid, out int first_mark_index, out int n_caps)
		{
			first_mark_index = -1;
			n_caps = 0;
			for (int i = this.groups[gid]; i >= 0; i = this.marks[i].Previous)
			{
				if (this.marks[i].IsDefined)
				{
					if (first_mark_index < 0)
					{
						first_mark_index = i;
					}
					n_caps++;
				}
			}
		}

		// Token: 0x06001A2D RID: 6701 RVA: 0x0005EC1C File Offset: 0x0005CE1C
		private void PopulateGroup(Group g, int first_mark_index, int n_caps)
		{
			int num = 1;
			for (int i = this.marks[first_mark_index].Previous; i >= 0; i = this.marks[i].Previous)
			{
				if (this.marks[i].IsDefined)
				{
					Capture capture = new Capture(this.text, this.marks[i].Index, this.marks[i].Length);
					g.Captures.SetValue(capture, n_caps - 1 - num);
					num++;
				}
			}
		}

		// Token: 0x06001A2E RID: 6702 RVA: 0x0005ECBC File Offset: 0x0005CEBC
		private Match GenerateMatch(Regex regex)
		{
			int num;
			int num2;
			this.GetGroupInfo(0, out num, out num2);
			if (!this.needs_groups_or_captures)
			{
				return new Match(regex, this, this.text, this.text_end, 0, this.marks[num].Index, this.marks[num].Length);
			}
			Match match = new Match(regex, this, this.text, this.text_end, this.groups.Length, this.marks[num].Index, this.marks[num].Length, num2);
			this.PopulateGroup(match, num, num2);
			for (int i = 1; i < this.groups.Length; i++)
			{
				this.GetGroupInfo(i, out num, out num2);
				Group group;
				if (num < 0)
				{
					group = Group.Fail;
				}
				else
				{
					group = new Group(this.text, this.marks[num].Index, this.marks[num].Length, num2);
					this.PopulateGroup(group, num, num2);
				}
				match.Groups.SetValue(group, i);
			}
			return match;
		}

		// Token: 0x0400157C RID: 5500
		private ushort[] program;

		// Token: 0x0400157D RID: 5501
		private int program_start;

		// Token: 0x0400157E RID: 5502
		private string text;

		// Token: 0x0400157F RID: 5503
		private int text_end;

		// Token: 0x04001580 RID: 5504
		private int group_count;

		// Token: 0x04001581 RID: 5505
		private int match_min;

		// Token: 0x04001582 RID: 5506
		private QuickSearch qs;

		// Token: 0x04001583 RID: 5507
		private int scan_ptr;

		// Token: 0x04001584 RID: 5508
		private Interpreter.RepeatContext repeat;

		// Token: 0x04001585 RID: 5509
		private Interpreter.RepeatContext fast;

		// Token: 0x04001586 RID: 5510
		private Interpreter.IntStack stack = default(Interpreter.IntStack);

		// Token: 0x04001587 RID: 5511
		private Interpreter.RepeatContext deep;

		// Token: 0x04001588 RID: 5512
		private Mark[] marks;

		// Token: 0x04001589 RID: 5513
		private int mark_start;

		// Token: 0x0400158A RID: 5514
		private int mark_end;

		// Token: 0x0400158B RID: 5515
		private int[] groups;

		// Token: 0x020002CF RID: 719
		private struct IntStack
		{
			// Token: 0x06001A2F RID: 6703 RVA: 0x0005EDE0 File Offset: 0x0005CFE0
			public int Pop()
			{
				return this.values[--this.count];
			}

			// Token: 0x06001A30 RID: 6704 RVA: 0x0005EE08 File Offset: 0x0005D008
			public void Push(int value)
			{
				if (this.values == null)
				{
					this.values = new int[8];
				}
				else if (this.count == this.values.Length)
				{
					int num = this.values.Length;
					num += num >> 1;
					int[] array = new int[num];
					for (int i = 0; i < this.count; i++)
					{
						array[i] = this.values[i];
					}
					this.values = array;
				}
				this.values[this.count++] = value;
			}

			// Token: 0x1700080B RID: 2059
			// (get) Token: 0x06001A31 RID: 6705 RVA: 0x0005EE9C File Offset: 0x0005D09C
			public int Top
			{
				get
				{
					return this.values[this.count - 1];
				}
			}

			// Token: 0x1700080C RID: 2060
			// (get) Token: 0x06001A32 RID: 6706 RVA: 0x0005EEB0 File Offset: 0x0005D0B0
			// (set) Token: 0x06001A33 RID: 6707 RVA: 0x0005EEB8 File Offset: 0x0005D0B8
			public int Count
			{
				get
				{
					return this.count;
				}
				set
				{
					if (value > this.count)
					{
						throw new SystemException("can only truncate the stack");
					}
					this.count = value;
				}
			}

			// Token: 0x0400158C RID: 5516
			private int[] values;

			// Token: 0x0400158D RID: 5517
			private int count;
		}

		// Token: 0x020002D0 RID: 720
		private class RepeatContext
		{
			// Token: 0x06001A34 RID: 6708 RVA: 0x0005EED8 File Offset: 0x0005D0D8
			public RepeatContext(Interpreter.RepeatContext previous, int min, int max, bool lazy, int expr_pc)
			{
				this.previous = previous;
				this.min = min;
				this.max = max;
				this.lazy = lazy;
				this.expr_pc = expr_pc;
				this.start = -1;
				this.count = 0;
			}

			// Token: 0x1700080D RID: 2061
			// (get) Token: 0x06001A35 RID: 6709 RVA: 0x0005EF14 File Offset: 0x0005D114
			// (set) Token: 0x06001A36 RID: 6710 RVA: 0x0005EF1C File Offset: 0x0005D11C
			public int Count
			{
				get
				{
					return this.count;
				}
				set
				{
					this.count = value;
				}
			}

			// Token: 0x1700080E RID: 2062
			// (get) Token: 0x06001A37 RID: 6711 RVA: 0x0005EF28 File Offset: 0x0005D128
			// (set) Token: 0x06001A38 RID: 6712 RVA: 0x0005EF30 File Offset: 0x0005D130
			public int Start
			{
				get
				{
					return this.start;
				}
				set
				{
					this.start = value;
				}
			}

			// Token: 0x1700080F RID: 2063
			// (get) Token: 0x06001A39 RID: 6713 RVA: 0x0005EF3C File Offset: 0x0005D13C
			public bool IsMinimum
			{
				get
				{
					return this.min <= this.count;
				}
			}

			// Token: 0x17000810 RID: 2064
			// (get) Token: 0x06001A3A RID: 6714 RVA: 0x0005EF50 File Offset: 0x0005D150
			public bool IsMaximum
			{
				get
				{
					return this.max <= this.count;
				}
			}

			// Token: 0x17000811 RID: 2065
			// (get) Token: 0x06001A3B RID: 6715 RVA: 0x0005EF64 File Offset: 0x0005D164
			public bool IsLazy
			{
				get
				{
					return this.lazy;
				}
			}

			// Token: 0x17000812 RID: 2066
			// (get) Token: 0x06001A3C RID: 6716 RVA: 0x0005EF6C File Offset: 0x0005D16C
			public int Expression
			{
				get
				{
					return this.expr_pc;
				}
			}

			// Token: 0x17000813 RID: 2067
			// (get) Token: 0x06001A3D RID: 6717 RVA: 0x0005EF74 File Offset: 0x0005D174
			public Interpreter.RepeatContext Previous
			{
				get
				{
					return this.previous;
				}
			}

			// Token: 0x0400158E RID: 5518
			private int start;

			// Token: 0x0400158F RID: 5519
			private int min;

			// Token: 0x04001590 RID: 5520
			private int max;

			// Token: 0x04001591 RID: 5521
			private bool lazy;

			// Token: 0x04001592 RID: 5522
			private int expr_pc;

			// Token: 0x04001593 RID: 5523
			private Interpreter.RepeatContext previous;

			// Token: 0x04001594 RID: 5524
			private int count;
		}

		// Token: 0x020002D1 RID: 721
		private enum Mode
		{
			// Token: 0x04001596 RID: 5526
			Search,
			// Token: 0x04001597 RID: 5527
			Match,
			// Token: 0x04001598 RID: 5528
			Count
		}
	}
}