using System;
using System.Collections.Generic;
using Microsoft.CodeAnalysis.Syntax.InternalSyntax;

namespace Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax;

internal static class SyntaxFactory
{
	private const string CrLf = "\r\n";

	internal static readonly SyntaxTrivia CarriageReturnLineFeed = EndOfLine("\r\n");

	internal static readonly SyntaxTrivia LineFeed = EndOfLine("\n");

	internal static readonly SyntaxTrivia CarriageReturn = EndOfLine("\r");

	internal static readonly SyntaxTrivia Space = Whitespace(" ");

	internal static readonly SyntaxTrivia Tab = Whitespace("\t");

	internal static readonly SyntaxTrivia ElasticCarriageReturnLineFeed = EndOfLine("\r\n", elastic: true);

	internal static readonly SyntaxTrivia ElasticLineFeed = EndOfLine("\n", elastic: true);

	internal static readonly SyntaxTrivia ElasticCarriageReturn = EndOfLine("\r", elastic: true);

	internal static readonly SyntaxTrivia ElasticSpace = Whitespace(" ", elastic: true);

	internal static readonly SyntaxTrivia ElasticTab = Whitespace("\t", elastic: true);

	internal static readonly SyntaxTrivia ElasticZeroSpace = Whitespace(string.Empty, elastic: true);

	private static SyntaxToken s_xmlCarriageReturnLineFeed;

	private static SyntaxToken XmlCarriageReturnLineFeed => s_xmlCarriageReturnLineFeed ?? (s_xmlCarriageReturnLineFeed = XmlTextNewLine("\r\n"));

	internal static SyntaxTrivia EndOfLine(string text, bool elastic = false)
	{
		SyntaxTrivia syntaxTrivia = null;
		switch (text)
		{
		case "\r":
			syntaxTrivia = (elastic ? ElasticCarriageReturn : CarriageReturn);
			break;
		case "\n":
			syntaxTrivia = (elastic ? ElasticLineFeed : LineFeed);
			break;
		case "\r\n":
			syntaxTrivia = (elastic ? ElasticCarriageReturnLineFeed : CarriageReturnLineFeed);
			break;
		}
		if (syntaxTrivia != null)
		{
			return syntaxTrivia;
		}
		syntaxTrivia = SyntaxTrivia.Create(SyntaxKind.EndOfLineTrivia, text);
		if (!elastic)
		{
			return syntaxTrivia;
		}
		return GreenNodeExtensions.WithAnnotationsGreen<SyntaxTrivia>(syntaxTrivia, (IEnumerable<SyntaxAnnotation>)(object)new SyntaxAnnotation[1] { SyntaxAnnotation.ElasticAnnotation });
	}

	internal static SyntaxTrivia Whitespace(string text, bool elastic = false)
	{
		SyntaxTrivia syntaxTrivia = SyntaxTrivia.Create(SyntaxKind.WhitespaceTrivia, text);
		if (!elastic)
		{
			return syntaxTrivia;
		}
		return GreenNodeExtensions.WithAnnotationsGreen<SyntaxTrivia>(syntaxTrivia, (IEnumerable<SyntaxAnnotation>)(object)new SyntaxAnnotation[1] { SyntaxAnnotation.ElasticAnnotation });
	}

	internal static SyntaxTrivia Comment(string text)
	{
		if (text.StartsWith("/*", StringComparison.Ordinal))
		{
			return SyntaxTrivia.Create(SyntaxKind.MultiLineCommentTrivia, text);
		}
		return SyntaxTrivia.Create(SyntaxKind.SingleLineCommentTrivia, text);
	}

	internal static SyntaxTrivia ConflictMarker(string text)
	{
		return SyntaxTrivia.Create(SyntaxKind.ConflictMarkerTrivia, text);
	}

	internal static SyntaxTrivia DisabledText(string text)
	{
		return SyntaxTrivia.Create(SyntaxKind.DisabledTextTrivia, text);
	}

	internal static SyntaxTrivia PreprocessingMessage(string text)
	{
		return SyntaxTrivia.Create(SyntaxKind.PreprocessingMessageTrivia, text);
	}

	public static SyntaxToken Token(SyntaxKind kind)
	{
		return SyntaxToken.Create(kind);
	}

	internal static SyntaxToken Token(GreenNode leading, SyntaxKind kind, GreenNode trailing)
	{
		return SyntaxToken.Create(kind, leading, trailing);
	}

	internal static SyntaxToken Token(GreenNode leading, SyntaxKind kind, string text, GreenNode trailing)
	{
		return Token(leading, kind, text, text, trailing);
	}

	internal static SyntaxToken Token(GreenNode leading, SyntaxKind kind, string text, string valueText, GreenNode trailing)
	{
		string text2 = SyntaxFacts.GetText(kind);
		if ((int)kind < 8193 || (int)kind > 8496 || !(text == text2) || !(valueText == text2))
		{
			return SyntaxToken.WithValue(kind, leading, text, valueText, trailing);
		}
		return Token(leading, kind, trailing);
	}

	internal static SyntaxToken MissingToken(SyntaxKind kind)
	{
		return SyntaxToken.CreateMissing(kind, null, null);
	}

	internal static SyntaxToken MissingToken(GreenNode leading, SyntaxKind kind, GreenNode trailing)
	{
		return SyntaxToken.CreateMissing(kind, leading, trailing);
	}

	internal static SyntaxToken Identifier(string text)
	{
		return Identifier(SyntaxKind.IdentifierToken, null, text, text, null);
	}

	internal static SyntaxToken Identifier(GreenNode leading, string text, GreenNode trailing)
	{
		return Identifier(SyntaxKind.IdentifierToken, leading, text, text, trailing);
	}

	internal static SyntaxToken Identifier(SyntaxKind contextualKind, GreenNode leading, string text, string valueText, GreenNode trailing)
	{
		return SyntaxToken.Identifier(contextualKind, leading, text, valueText, trailing);
	}

	internal static SyntaxToken Literal(GreenNode leading, string text, int value, GreenNode trailing)
	{
		return SyntaxToken.WithValue(SyntaxKind.NumericLiteralToken, leading, text, value, trailing);
	}

	internal static SyntaxToken Literal(GreenNode leading, string text, uint value, GreenNode trailing)
	{
		return SyntaxToken.WithValue(SyntaxKind.NumericLiteralToken, leading, text, value, trailing);
	}

	internal static SyntaxToken Literal(GreenNode leading, string text, long value, GreenNode trailing)
	{
		return SyntaxToken.WithValue(SyntaxKind.NumericLiteralToken, leading, text, value, trailing);
	}

	internal static SyntaxToken Literal(GreenNode leading, string text, ulong value, GreenNode trailing)
	{
		return SyntaxToken.WithValue(SyntaxKind.NumericLiteralToken, leading, text, value, trailing);
	}

	internal static SyntaxToken Literal(GreenNode leading, string text, float value, GreenNode trailing)
	{
		return SyntaxToken.WithValue(SyntaxKind.NumericLiteralToken, leading, text, value, trailing);
	}

	internal static SyntaxToken Literal(GreenNode leading, string text, double value, GreenNode trailing)
	{
		return SyntaxToken.WithValue(SyntaxKind.NumericLiteralToken, leading, text, value, trailing);
	}

	internal static SyntaxToken Literal(GreenNode leading, string text, decimal value, GreenNode trailing)
	{
		return SyntaxToken.WithValue(SyntaxKind.NumericLiteralToken, leading, text, value, trailing);
	}

	internal static SyntaxToken Literal(GreenNode leading, string text, string value, GreenNode trailing)
	{
		return SyntaxToken.WithValue(SyntaxKind.StringLiteralToken, leading, text, value, trailing);
	}

	internal static SyntaxToken Literal(GreenNode leading, string text, SyntaxKind kind, string value, GreenNode trailing)
	{
		return SyntaxToken.WithValue(kind, leading, text, value, trailing);
	}

	internal static SyntaxToken Literal(GreenNode leading, string text, char value, GreenNode trailing)
	{
		return SyntaxToken.WithValue(SyntaxKind.CharacterLiteralToken, leading, text, value, trailing);
	}

	internal static SyntaxToken BadToken(GreenNode leading, string text, GreenNode trailing)
	{
		return SyntaxToken.WithValue(SyntaxKind.BadToken, leading, text, text, trailing);
	}

	internal static SyntaxToken XmlTextLiteral(GreenNode leading, string text, string value, GreenNode trailing)
	{
		return SyntaxToken.WithValue(SyntaxKind.XmlTextLiteralToken, leading, text, value, trailing);
	}

	internal static SyntaxToken XmlTextNewLine(GreenNode leading, string text, string value, GreenNode trailing)
	{
		if (leading == null && trailing == null && text == "\r\n" && value == "\r\n")
		{
			return XmlCarriageReturnLineFeed;
		}
		return SyntaxToken.WithValue(SyntaxKind.XmlTextLiteralNewLineToken, leading, text, value, trailing);
	}

	internal static SyntaxToken XmlTextNewLine(string text)
	{
		return SyntaxToken.WithValue(SyntaxKind.XmlTextLiteralNewLineToken, null, text, text, null);
	}

	internal static SyntaxToken XmlEntity(GreenNode leading, string text, string value, GreenNode trailing)
	{
		return SyntaxToken.WithValue(SyntaxKind.XmlEntityLiteralToken, leading, text, value, trailing);
	}

	internal static SyntaxTrivia DocumentationCommentExteriorTrivia(string text)
	{
		return SyntaxTrivia.Create(SyntaxKind.DocumentationCommentExteriorTrivia, text);
	}

	public static SyntaxList<TNode> List<TNode>() where TNode : CSharpSyntaxNode
	{
		//IL_0002: 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)
		return default(SyntaxList<TNode>);
	}

	public static SyntaxList<TNode> List<TNode>(TNode node) where TNode : CSharpSyntaxNode
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		return new SyntaxList<TNode>(SyntaxList.List((GreenNode)(object)node));
	}

	public static SyntaxList<TNode> List<TNode>(TNode node0, TNode node1) where TNode : CSharpSyntaxNode
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		return new SyntaxList<TNode>((GreenNode)(object)SyntaxList.List((GreenNode)(object)node0, (GreenNode)(object)node1));
	}

	internal static GreenNode ListNode(CSharpSyntaxNode node0, CSharpSyntaxNode node1)
	{
		return (GreenNode)(object)SyntaxList.List((GreenNode)(object)node0, (GreenNode)(object)node1);
	}

	public static SyntaxList<TNode> List<TNode>(TNode node0, TNode node1, TNode node2) where TNode : CSharpSyntaxNode
	{
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		return new SyntaxList<TNode>((GreenNode)(object)SyntaxList.List((GreenNode)(object)node0, (GreenNode)(object)node1, (GreenNode)(object)node2));
	}

	internal static GreenNode ListNode(CSharpSyntaxNode node0, CSharpSyntaxNode node1, CSharpSyntaxNode node2)
	{
		return (GreenNode)(object)SyntaxList.List((GreenNode)(object)node0, (GreenNode)(object)node1, (GreenNode)(object)node2);
	}

	public static SyntaxList<TNode> List<TNode>(params TNode[] nodes) where TNode : CSharpSyntaxNode
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: 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)
		if (nodes != null)
		{
			return new SyntaxList<TNode>(SyntaxList.List((GreenNode[])(object)nodes));
		}
		return default(SyntaxList<TNode>);
	}

	internal static GreenNode ListNode(params ArrayElement<GreenNode>[] nodes)
	{
		return (GreenNode)(object)SyntaxList.List(nodes);
	}

	public static SeparatedSyntaxList<TNode> SeparatedList<TNode>(TNode node) where TNode : CSharpSyntaxNode
	{
		//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_0010: Unknown result type (might be due to invalid IL or missing references)
		return new SeparatedSyntaxList<TNode>(SyntaxList<CSharpSyntaxNode>.op_Implicit(new SyntaxList<CSharpSyntaxNode>((GreenNode)(object)node)));
	}

	public static SeparatedSyntaxList<TNode> SeparatedList<TNode>(SyntaxToken token) where TNode : CSharpSyntaxNode
	{
		//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)
		return new SeparatedSyntaxList<TNode>(SyntaxList<CSharpSyntaxNode>.op_Implicit(new SyntaxList<CSharpSyntaxNode>((GreenNode)(object)token)));
	}

	public static SeparatedSyntaxList<TNode> SeparatedList<TNode>(TNode node1, SyntaxToken token, TNode node2) where TNode : CSharpSyntaxNode
	{
		//IL_0012: 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)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		return new SeparatedSyntaxList<TNode>(SyntaxList<CSharpSyntaxNode>.op_Implicit(new SyntaxList<CSharpSyntaxNode>((GreenNode)(object)SyntaxList.List((GreenNode)(object)node1, (GreenNode)(object)token, (GreenNode)(object)node2))));
	}

	public static SeparatedSyntaxList<TNode> SeparatedList<TNode>(params CSharpSyntaxNode[] nodes) where TNode : CSharpSyntaxNode
	{
		//IL_0018: 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_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		if (nodes != null)
		{
			return new SeparatedSyntaxList<TNode>(SyntaxList<GreenNode>.op_Implicit(SyntaxList.List((GreenNode[])(object)nodes)));
		}
		return default(SeparatedSyntaxList<TNode>);
	}

	internal static IEnumerable<SyntaxTrivia> GetWellKnownTrivia()
	{
		yield return CarriageReturnLineFeed;
		yield return LineFeed;
		yield return CarriageReturn;
		yield return Space;
		yield return Tab;
		yield return ElasticCarriageReturnLineFeed;
		yield return ElasticLineFeed;
		yield return ElasticCarriageReturn;
		yield return ElasticSpace;
		yield return ElasticTab;
		yield return ElasticZeroSpace;
	}

	internal static IEnumerable<SyntaxToken> GetWellKnownTokens()
	{
		return SyntaxToken.GetWellKnownTokens();
	}

	public static IdentifierNameSyntax IdentifierName(SyntaxToken identifier)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8616, (GreenNode)(object)identifier, ref num);
		if (val != null)
		{
			return (IdentifierNameSyntax)(object)val;
		}
		IdentifierNameSyntax identifierNameSyntax = new IdentifierNameSyntax(SyntaxKind.IdentifierName, identifier);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)identifierNameSyntax, num);
		}
		return identifierNameSyntax;
	}

	public static QualifiedNameSyntax QualifiedName(NameSyntax left, SyntaxToken dotToken, SimpleNameSyntax right)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8617, (GreenNode)(object)left, (GreenNode)(object)dotToken, (GreenNode)(object)right, ref num);
		if (val != null)
		{
			return (QualifiedNameSyntax)(object)val;
		}
		QualifiedNameSyntax qualifiedNameSyntax = new QualifiedNameSyntax(SyntaxKind.QualifiedName, left, dotToken, right);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)qualifiedNameSyntax, num);
		}
		return qualifiedNameSyntax;
	}

	public static GenericNameSyntax GenericName(SyntaxToken identifier, TypeArgumentListSyntax typeArgumentList)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8618, (GreenNode)(object)identifier, (GreenNode)(object)typeArgumentList, ref num);
		if (val != null)
		{
			return (GenericNameSyntax)(object)val;
		}
		GenericNameSyntax genericNameSyntax = new GenericNameSyntax(SyntaxKind.GenericName, identifier, typeArgumentList);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)genericNameSyntax, num);
		}
		return genericNameSyntax;
	}

	public static TypeArgumentListSyntax TypeArgumentList(SyntaxToken lessThanToken, SeparatedSyntaxList<TypeSyntax> arguments, SyntaxToken greaterThanToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8619, (GreenNode)(object)lessThanToken, arguments.Node, (GreenNode)(object)greaterThanToken, ref num);
		if (val != null)
		{
			return (TypeArgumentListSyntax)(object)val;
		}
		TypeArgumentListSyntax typeArgumentListSyntax = new TypeArgumentListSyntax(SyntaxKind.TypeArgumentList, lessThanToken, arguments.Node, greaterThanToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)typeArgumentListSyntax, num);
		}
		return typeArgumentListSyntax;
	}

	public static AliasQualifiedNameSyntax AliasQualifiedName(IdentifierNameSyntax alias, SyntaxToken colonColonToken, SimpleNameSyntax name)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8620, (GreenNode)(object)alias, (GreenNode)(object)colonColonToken, (GreenNode)(object)name, ref num);
		if (val != null)
		{
			return (AliasQualifiedNameSyntax)(object)val;
		}
		AliasQualifiedNameSyntax aliasQualifiedNameSyntax = new AliasQualifiedNameSyntax(SyntaxKind.AliasQualifiedName, alias, colonColonToken, name);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)aliasQualifiedNameSyntax, num);
		}
		return aliasQualifiedNameSyntax;
	}

	public static PredefinedTypeSyntax PredefinedType(SyntaxToken keyword)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8621, (GreenNode)(object)keyword, ref num);
		if (val != null)
		{
			return (PredefinedTypeSyntax)(object)val;
		}
		PredefinedTypeSyntax predefinedTypeSyntax = new PredefinedTypeSyntax(SyntaxKind.PredefinedType, keyword);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)predefinedTypeSyntax, num);
		}
		return predefinedTypeSyntax;
	}

	public static ArrayTypeSyntax ArrayType(TypeSyntax elementType, SyntaxList<ArrayRankSpecifierSyntax> rankSpecifiers)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8622, (GreenNode)(object)elementType, rankSpecifiers.Node, ref num);
		if (val != null)
		{
			return (ArrayTypeSyntax)(object)val;
		}
		ArrayTypeSyntax arrayTypeSyntax = new ArrayTypeSyntax(SyntaxKind.ArrayType, elementType, rankSpecifiers.Node);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)arrayTypeSyntax, num);
		}
		return arrayTypeSyntax;
	}

	public static ArrayRankSpecifierSyntax ArrayRankSpecifier(SyntaxToken openBracketToken, SeparatedSyntaxList<ExpressionSyntax> sizes, SyntaxToken closeBracketToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8623, (GreenNode)(object)openBracketToken, sizes.Node, (GreenNode)(object)closeBracketToken, ref num);
		if (val != null)
		{
			return (ArrayRankSpecifierSyntax)(object)val;
		}
		ArrayRankSpecifierSyntax arrayRankSpecifierSyntax = new ArrayRankSpecifierSyntax(SyntaxKind.ArrayRankSpecifier, openBracketToken, sizes.Node, closeBracketToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)arrayRankSpecifierSyntax, num);
		}
		return arrayRankSpecifierSyntax;
	}

	public static PointerTypeSyntax PointerType(TypeSyntax elementType, SyntaxToken asteriskToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8624, (GreenNode)(object)elementType, (GreenNode)(object)asteriskToken, ref num);
		if (val != null)
		{
			return (PointerTypeSyntax)(object)val;
		}
		PointerTypeSyntax pointerTypeSyntax = new PointerTypeSyntax(SyntaxKind.PointerType, elementType, asteriskToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)pointerTypeSyntax, num);
		}
		return pointerTypeSyntax;
	}

	public static FunctionPointerTypeSyntax FunctionPointerType(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterListSyntax parameterList)
	{
		return new FunctionPointerTypeSyntax(SyntaxKind.FunctionPointerType, delegateKeyword, asteriskToken, callingConvention, parameterList);
	}

	public static FunctionPointerParameterListSyntax FunctionPointerParameterList(SyntaxToken lessThanToken, SeparatedSyntaxList<FunctionPointerParameterSyntax> parameters, SyntaxToken greaterThanToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(9058, (GreenNode)(object)lessThanToken, parameters.Node, (GreenNode)(object)greaterThanToken, ref num);
		if (val != null)
		{
			return (FunctionPointerParameterListSyntax)(object)val;
		}
		FunctionPointerParameterListSyntax functionPointerParameterListSyntax = new FunctionPointerParameterListSyntax(SyntaxKind.FunctionPointerParameterList, lessThanToken, parameters.Node, greaterThanToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)functionPointerParameterListSyntax, num);
		}
		return functionPointerParameterListSyntax;
	}

	public static FunctionPointerCallingConventionSyntax FunctionPointerCallingConvention(SyntaxToken managedOrUnmanagedKeyword, FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(9059, (GreenNode)(object)managedOrUnmanagedKeyword, (GreenNode)(object)unmanagedCallingConventionList, ref num);
		if (val != null)
		{
			return (FunctionPointerCallingConventionSyntax)(object)val;
		}
		FunctionPointerCallingConventionSyntax functionPointerCallingConventionSyntax = new FunctionPointerCallingConventionSyntax(SyntaxKind.FunctionPointerCallingConvention, managedOrUnmanagedKeyword, unmanagedCallingConventionList);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)functionPointerCallingConventionSyntax, num);
		}
		return functionPointerCallingConventionSyntax;
	}

	public static FunctionPointerUnmanagedCallingConventionListSyntax FunctionPointerUnmanagedCallingConventionList(SyntaxToken openBracketToken, SeparatedSyntaxList<FunctionPointerUnmanagedCallingConventionSyntax> callingConventions, SyntaxToken closeBracketToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(9066, (GreenNode)(object)openBracketToken, callingConventions.Node, (GreenNode)(object)closeBracketToken, ref num);
		if (val != null)
		{
			return (FunctionPointerUnmanagedCallingConventionListSyntax)(object)val;
		}
		FunctionPointerUnmanagedCallingConventionListSyntax functionPointerUnmanagedCallingConventionListSyntax = new FunctionPointerUnmanagedCallingConventionListSyntax(SyntaxKind.FunctionPointerUnmanagedCallingConventionList, openBracketToken, callingConventions.Node, closeBracketToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)functionPointerUnmanagedCallingConventionListSyntax, num);
		}
		return functionPointerUnmanagedCallingConventionListSyntax;
	}

	public static FunctionPointerUnmanagedCallingConventionSyntax FunctionPointerUnmanagedCallingConvention(SyntaxToken name)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(9067, (GreenNode)(object)name, ref num);
		if (val != null)
		{
			return (FunctionPointerUnmanagedCallingConventionSyntax)(object)val;
		}
		FunctionPointerUnmanagedCallingConventionSyntax functionPointerUnmanagedCallingConventionSyntax = new FunctionPointerUnmanagedCallingConventionSyntax(SyntaxKind.FunctionPointerUnmanagedCallingConvention, name);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)functionPointerUnmanagedCallingConventionSyntax, num);
		}
		return functionPointerUnmanagedCallingConventionSyntax;
	}

	public static NullableTypeSyntax NullableType(TypeSyntax elementType, SyntaxToken questionToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8625, (GreenNode)(object)elementType, (GreenNode)(object)questionToken, ref num);
		if (val != null)
		{
			return (NullableTypeSyntax)(object)val;
		}
		NullableTypeSyntax nullableTypeSyntax = new NullableTypeSyntax(SyntaxKind.NullableType, elementType, questionToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)nullableTypeSyntax, num);
		}
		return nullableTypeSyntax;
	}

	public static TupleTypeSyntax TupleType(SyntaxToken openParenToken, SeparatedSyntaxList<TupleElementSyntax> elements, SyntaxToken closeParenToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8924, (GreenNode)(object)openParenToken, elements.Node, (GreenNode)(object)closeParenToken, ref num);
		if (val != null)
		{
			return (TupleTypeSyntax)(object)val;
		}
		TupleTypeSyntax tupleTypeSyntax = new TupleTypeSyntax(SyntaxKind.TupleType, openParenToken, elements.Node, closeParenToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)tupleTypeSyntax, num);
		}
		return tupleTypeSyntax;
	}

	public static TupleElementSyntax TupleElement(TypeSyntax type, SyntaxToken? identifier)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8925, (GreenNode)(object)type, (GreenNode)(object)identifier, ref num);
		if (val != null)
		{
			return (TupleElementSyntax)(object)val;
		}
		TupleElementSyntax tupleElementSyntax = new TupleElementSyntax(SyntaxKind.TupleElement, type, identifier);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)tupleElementSyntax, num);
		}
		return tupleElementSyntax;
	}

	public static OmittedTypeArgumentSyntax OmittedTypeArgument(SyntaxToken omittedTypeArgumentToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8626, (GreenNode)(object)omittedTypeArgumentToken, ref num);
		if (val != null)
		{
			return (OmittedTypeArgumentSyntax)(object)val;
		}
		OmittedTypeArgumentSyntax omittedTypeArgumentSyntax = new OmittedTypeArgumentSyntax(SyntaxKind.OmittedTypeArgument, omittedTypeArgumentToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)omittedTypeArgumentSyntax, num);
		}
		return omittedTypeArgumentSyntax;
	}

	public static RefTypeSyntax RefType(SyntaxToken refKeyword, SyntaxToken? readOnlyKeyword, TypeSyntax type)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(9051, (GreenNode)(object)refKeyword, (GreenNode)(object)readOnlyKeyword, (GreenNode)(object)type, ref num);
		if (val != null)
		{
			return (RefTypeSyntax)(object)val;
		}
		RefTypeSyntax refTypeSyntax = new RefTypeSyntax(SyntaxKind.RefType, refKeyword, readOnlyKeyword, type);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)refTypeSyntax, num);
		}
		return refTypeSyntax;
	}

	public static ScopedTypeSyntax ScopedType(SyntaxToken scopedKeyword, TypeSyntax type)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(9075, (GreenNode)(object)scopedKeyword, (GreenNode)(object)type, ref num);
		if (val != null)
		{
			return (ScopedTypeSyntax)(object)val;
		}
		ScopedTypeSyntax scopedTypeSyntax = new ScopedTypeSyntax(SyntaxKind.ScopedType, scopedKeyword, type);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)scopedTypeSyntax, num);
		}
		return scopedTypeSyntax;
	}

	public static ParenthesizedExpressionSyntax ParenthesizedExpression(SyntaxToken openParenToken, ExpressionSyntax expression, SyntaxToken closeParenToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8632, (GreenNode)(object)openParenToken, (GreenNode)(object)expression, (GreenNode)(object)closeParenToken, ref num);
		if (val != null)
		{
			return (ParenthesizedExpressionSyntax)(object)val;
		}
		ParenthesizedExpressionSyntax parenthesizedExpressionSyntax = new ParenthesizedExpressionSyntax(SyntaxKind.ParenthesizedExpression, openParenToken, expression, closeParenToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)parenthesizedExpressionSyntax, num);
		}
		return parenthesizedExpressionSyntax;
	}

	public static TupleExpressionSyntax TupleExpression(SyntaxToken openParenToken, SeparatedSyntaxList<ArgumentSyntax> arguments, SyntaxToken closeParenToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8926, (GreenNode)(object)openParenToken, arguments.Node, (GreenNode)(object)closeParenToken, ref num);
		if (val != null)
		{
			return (TupleExpressionSyntax)(object)val;
		}
		TupleExpressionSyntax tupleExpressionSyntax = new TupleExpressionSyntax(SyntaxKind.TupleExpression, openParenToken, arguments.Node, closeParenToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)tupleExpressionSyntax, num);
		}
		return tupleExpressionSyntax;
	}

	public static PrefixUnaryExpressionSyntax PrefixUnaryExpression(SyntaxKind kind, SyntaxToken operatorToken, ExpressionSyntax operand)
	{
		if (kind - 8730 > (SyntaxKind)7 && kind != SyntaxKind.IndexExpression)
		{
			throw new ArgumentException("kind");
		}
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode((int)kind, (GreenNode)(object)operatorToken, (GreenNode)(object)operand, ref num);
		if (val != null)
		{
			return (PrefixUnaryExpressionSyntax)(object)val;
		}
		PrefixUnaryExpressionSyntax prefixUnaryExpressionSyntax = new PrefixUnaryExpressionSyntax(kind, operatorToken, operand);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)prefixUnaryExpressionSyntax, num);
		}
		return prefixUnaryExpressionSyntax;
	}

	public static AwaitExpressionSyntax AwaitExpression(SyntaxToken awaitKeyword, ExpressionSyntax expression)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8740, (GreenNode)(object)awaitKeyword, (GreenNode)(object)expression, ref num);
		if (val != null)
		{
			return (AwaitExpressionSyntax)(object)val;
		}
		AwaitExpressionSyntax awaitExpressionSyntax = new AwaitExpressionSyntax(SyntaxKind.AwaitExpression, awaitKeyword, expression);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)awaitExpressionSyntax, num);
		}
		return awaitExpressionSyntax;
	}

	public static PostfixUnaryExpressionSyntax PostfixUnaryExpression(SyntaxKind kind, ExpressionSyntax operand, SyntaxToken operatorToken)
	{
		if (kind - 8738 > SyntaxKind.List && kind != SyntaxKind.SuppressNullableWarningExpression)
		{
			throw new ArgumentException("kind");
		}
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode((int)kind, (GreenNode)(object)operand, (GreenNode)(object)operatorToken, ref num);
		if (val != null)
		{
			return (PostfixUnaryExpressionSyntax)(object)val;
		}
		PostfixUnaryExpressionSyntax postfixUnaryExpressionSyntax = new PostfixUnaryExpressionSyntax(kind, operand, operatorToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)postfixUnaryExpressionSyntax, num);
		}
		return postfixUnaryExpressionSyntax;
	}

	public static MemberAccessExpressionSyntax MemberAccessExpression(SyntaxKind kind, ExpressionSyntax expression, SyntaxToken operatorToken, SimpleNameSyntax name)
	{
		if (kind - 8689 > SyntaxKind.List)
		{
			throw new ArgumentException("kind");
		}
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode((int)kind, (GreenNode)(object)expression, (GreenNode)(object)operatorToken, (GreenNode)(object)name, ref num);
		if (val != null)
		{
			return (MemberAccessExpressionSyntax)(object)val;
		}
		MemberAccessExpressionSyntax memberAccessExpressionSyntax = new MemberAccessExpressionSyntax(kind, expression, operatorToken, name);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)memberAccessExpressionSyntax, num);
		}
		return memberAccessExpressionSyntax;
	}

	public static ConditionalAccessExpressionSyntax ConditionalAccessExpression(ExpressionSyntax expression, SyntaxToken operatorToken, ExpressionSyntax whenNotNull)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8691, (GreenNode)(object)expression, (GreenNode)(object)operatorToken, (GreenNode)(object)whenNotNull, ref num);
		if (val != null)
		{
			return (ConditionalAccessExpressionSyntax)(object)val;
		}
		ConditionalAccessExpressionSyntax conditionalAccessExpressionSyntax = new ConditionalAccessExpressionSyntax(SyntaxKind.ConditionalAccessExpression, expression, operatorToken, whenNotNull);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)conditionalAccessExpressionSyntax, num);
		}
		return conditionalAccessExpressionSyntax;
	}

	public static MemberBindingExpressionSyntax MemberBindingExpression(SyntaxToken operatorToken, SimpleNameSyntax name)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8707, (GreenNode)(object)operatorToken, (GreenNode)(object)name, ref num);
		if (val != null)
		{
			return (MemberBindingExpressionSyntax)(object)val;
		}
		MemberBindingExpressionSyntax memberBindingExpressionSyntax = new MemberBindingExpressionSyntax(SyntaxKind.MemberBindingExpression, operatorToken, name);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)memberBindingExpressionSyntax, num);
		}
		return memberBindingExpressionSyntax;
	}

	public static ElementBindingExpressionSyntax ElementBindingExpression(BracketedArgumentListSyntax argumentList)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8708, (GreenNode)(object)argumentList, ref num);
		if (val != null)
		{
			return (ElementBindingExpressionSyntax)(object)val;
		}
		ElementBindingExpressionSyntax elementBindingExpressionSyntax = new ElementBindingExpressionSyntax(SyntaxKind.ElementBindingExpression, argumentList);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)elementBindingExpressionSyntax, num);
		}
		return elementBindingExpressionSyntax;
	}

	public static RangeExpressionSyntax RangeExpression(ExpressionSyntax? leftOperand, SyntaxToken operatorToken, ExpressionSyntax? rightOperand)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8658, (GreenNode)(object)leftOperand, (GreenNode)(object)operatorToken, (GreenNode)(object)rightOperand, ref num);
		if (val != null)
		{
			return (RangeExpressionSyntax)(object)val;
		}
		RangeExpressionSyntax rangeExpressionSyntax = new RangeExpressionSyntax(SyntaxKind.RangeExpression, leftOperand, operatorToken, rightOperand);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)rangeExpressionSyntax, num);
		}
		return rangeExpressionSyntax;
	}

	public static ImplicitElementAccessSyntax ImplicitElementAccess(BracketedArgumentListSyntax argumentList)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8656, (GreenNode)(object)argumentList, ref num);
		if (val != null)
		{
			return (ImplicitElementAccessSyntax)(object)val;
		}
		ImplicitElementAccessSyntax implicitElementAccessSyntax = new ImplicitElementAccessSyntax(SyntaxKind.ImplicitElementAccess, argumentList);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)implicitElementAccessSyntax, num);
		}
		return implicitElementAccessSyntax;
	}

	public static BinaryExpressionSyntax BinaryExpression(SyntaxKind kind, ExpressionSyntax left, SyntaxToken operatorToken, ExpressionSyntax right)
	{
		if (kind - 8668 > (SyntaxKind)20 && kind != SyntaxKind.UnsignedRightShiftExpression)
		{
			throw new ArgumentException("kind");
		}
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode((int)kind, (GreenNode)(object)left, (GreenNode)(object)operatorToken, (GreenNode)(object)right, ref num);
		if (val != null)
		{
			return (BinaryExpressionSyntax)(object)val;
		}
		BinaryExpressionSyntax binaryExpressionSyntax = new BinaryExpressionSyntax(kind, left, operatorToken, right);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)binaryExpressionSyntax, num);
		}
		return binaryExpressionSyntax;
	}

	public static AssignmentExpressionSyntax AssignmentExpression(SyntaxKind kind, ExpressionSyntax left, SyntaxToken operatorToken, ExpressionSyntax right)
	{
		if (kind - 8714 > (SyntaxKind)12)
		{
			throw new ArgumentException("kind");
		}
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode((int)kind, (GreenNode)(object)left, (GreenNode)(object)operatorToken, (GreenNode)(object)right, ref num);
		if (val != null)
		{
			return (AssignmentExpressionSyntax)(object)val;
		}
		AssignmentExpressionSyntax assignmentExpressionSyntax = new AssignmentExpressionSyntax(kind, left, operatorToken, right);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)assignmentExpressionSyntax, num);
		}
		return assignmentExpressionSyntax;
	}

	public static ConditionalExpressionSyntax ConditionalExpression(ExpressionSyntax condition, SyntaxToken questionToken, ExpressionSyntax whenTrue, SyntaxToken colonToken, ExpressionSyntax whenFalse)
	{
		return new ConditionalExpressionSyntax(SyntaxKind.ConditionalExpression, condition, questionToken, whenTrue, colonToken, whenFalse);
	}

	public static ThisExpressionSyntax ThisExpression(SyntaxToken token)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8746, (GreenNode)(object)token, ref num);
		if (val != null)
		{
			return (ThisExpressionSyntax)(object)val;
		}
		ThisExpressionSyntax thisExpressionSyntax = new ThisExpressionSyntax(SyntaxKind.ThisExpression, token);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)thisExpressionSyntax, num);
		}
		return thisExpressionSyntax;
	}

	public static BaseExpressionSyntax BaseExpression(SyntaxToken token)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8747, (GreenNode)(object)token, ref num);
		if (val != null)
		{
			return (BaseExpressionSyntax)(object)val;
		}
		BaseExpressionSyntax baseExpressionSyntax = new BaseExpressionSyntax(SyntaxKind.BaseExpression, token);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)baseExpressionSyntax, num);
		}
		return baseExpressionSyntax;
	}

	public static LiteralExpressionSyntax LiteralExpression(SyntaxKind kind, SyntaxToken token)
	{
		if (kind - 8748 > (SyntaxKind)8)
		{
			throw new ArgumentException("kind");
		}
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode((int)kind, (GreenNode)(object)token, ref num);
		if (val != null)
		{
			return (LiteralExpressionSyntax)(object)val;
		}
		LiteralExpressionSyntax literalExpressionSyntax = new LiteralExpressionSyntax(kind, token);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)literalExpressionSyntax, num);
		}
		return literalExpressionSyntax;
	}

	public static MakeRefExpressionSyntax MakeRefExpression(SyntaxToken keyword, SyntaxToken openParenToken, ExpressionSyntax expression, SyntaxToken closeParenToken)
	{
		return new MakeRefExpressionSyntax(SyntaxKind.MakeRefExpression, keyword, openParenToken, expression, closeParenToken);
	}

	public static RefTypeExpressionSyntax RefTypeExpression(SyntaxToken keyword, SyntaxToken openParenToken, ExpressionSyntax expression, SyntaxToken closeParenToken)
	{
		return new RefTypeExpressionSyntax(SyntaxKind.RefTypeExpression, keyword, openParenToken, expression, closeParenToken);
	}

	public static RefValueExpressionSyntax RefValueExpression(SyntaxToken keyword, SyntaxToken openParenToken, ExpressionSyntax expression, SyntaxToken comma, TypeSyntax type, SyntaxToken closeParenToken)
	{
		return new RefValueExpressionSyntax(SyntaxKind.RefValueExpression, keyword, openParenToken, expression, comma, type, closeParenToken);
	}

	public static CheckedExpressionSyntax CheckedExpression(SyntaxKind kind, SyntaxToken keyword, SyntaxToken openParenToken, ExpressionSyntax expression, SyntaxToken closeParenToken)
	{
		if (kind - 8762 > SyntaxKind.List)
		{
			throw new ArgumentException("kind");
		}
		return new CheckedExpressionSyntax(kind, keyword, openParenToken, expression, closeParenToken);
	}

	public static DefaultExpressionSyntax DefaultExpression(SyntaxToken keyword, SyntaxToken openParenToken, TypeSyntax type, SyntaxToken closeParenToken)
	{
		return new DefaultExpressionSyntax(SyntaxKind.DefaultExpression, keyword, openParenToken, type, closeParenToken);
	}

	public static TypeOfExpressionSyntax TypeOfExpression(SyntaxToken keyword, SyntaxToken openParenToken, TypeSyntax type, SyntaxToken closeParenToken)
	{
		return new TypeOfExpressionSyntax(SyntaxKind.TypeOfExpression, keyword, openParenToken, type, closeParenToken);
	}

	public static SizeOfExpressionSyntax SizeOfExpression(SyntaxToken keyword, SyntaxToken openParenToken, TypeSyntax type, SyntaxToken closeParenToken)
	{
		return new SizeOfExpressionSyntax(SyntaxKind.SizeOfExpression, keyword, openParenToken, type, closeParenToken);
	}

	public static InvocationExpressionSyntax InvocationExpression(ExpressionSyntax expression, ArgumentListSyntax argumentList)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8634, (GreenNode)(object)expression, (GreenNode)(object)argumentList, ref num);
		if (val != null)
		{
			return (InvocationExpressionSyntax)(object)val;
		}
		InvocationExpressionSyntax invocationExpressionSyntax = new InvocationExpressionSyntax(SyntaxKind.InvocationExpression, expression, argumentList);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)invocationExpressionSyntax, num);
		}
		return invocationExpressionSyntax;
	}

	public static ElementAccessExpressionSyntax ElementAccessExpression(ExpressionSyntax expression, BracketedArgumentListSyntax argumentList)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8635, (GreenNode)(object)expression, (GreenNode)(object)argumentList, ref num);
		if (val != null)
		{
			return (ElementAccessExpressionSyntax)(object)val;
		}
		ElementAccessExpressionSyntax elementAccessExpressionSyntax = new ElementAccessExpressionSyntax(SyntaxKind.ElementAccessExpression, expression, argumentList);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)elementAccessExpressionSyntax, num);
		}
		return elementAccessExpressionSyntax;
	}

	public static ArgumentListSyntax ArgumentList(SyntaxToken openParenToken, SeparatedSyntaxList<ArgumentSyntax> arguments, SyntaxToken closeParenToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8636, (GreenNode)(object)openParenToken, arguments.Node, (GreenNode)(object)closeParenToken, ref num);
		if (val != null)
		{
			return (ArgumentListSyntax)(object)val;
		}
		ArgumentListSyntax argumentListSyntax = new ArgumentListSyntax(SyntaxKind.ArgumentList, openParenToken, arguments.Node, closeParenToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)argumentListSyntax, num);
		}
		return argumentListSyntax;
	}

	public static BracketedArgumentListSyntax BracketedArgumentList(SyntaxToken openBracketToken, SeparatedSyntaxList<ArgumentSyntax> arguments, SyntaxToken closeBracketToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8637, (GreenNode)(object)openBracketToken, arguments.Node, (GreenNode)(object)closeBracketToken, ref num);
		if (val != null)
		{
			return (BracketedArgumentListSyntax)(object)val;
		}
		BracketedArgumentListSyntax bracketedArgumentListSyntax = new BracketedArgumentListSyntax(SyntaxKind.BracketedArgumentList, openBracketToken, arguments.Node, closeBracketToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)bracketedArgumentListSyntax, num);
		}
		return bracketedArgumentListSyntax;
	}

	public static ArgumentSyntax Argument(NameColonSyntax? nameColon, SyntaxToken? refKindKeyword, ExpressionSyntax expression)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8638, (GreenNode)(object)nameColon, (GreenNode)(object)refKindKeyword, (GreenNode)(object)expression, ref num);
		if (val != null)
		{
			return (ArgumentSyntax)(object)val;
		}
		ArgumentSyntax argumentSyntax = new ArgumentSyntax(SyntaxKind.Argument, nameColon, refKindKeyword, expression);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)argumentSyntax, num);
		}
		return argumentSyntax;
	}

	public static ExpressionColonSyntax ExpressionColon(ExpressionSyntax expression, SyntaxToken colonToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(9069, (GreenNode)(object)expression, (GreenNode)(object)colonToken, ref num);
		if (val != null)
		{
			return (ExpressionColonSyntax)(object)val;
		}
		ExpressionColonSyntax expressionColonSyntax = new ExpressionColonSyntax(SyntaxKind.ExpressionColon, expression, colonToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)expressionColonSyntax, num);
		}
		return expressionColonSyntax;
	}

	public static NameColonSyntax NameColon(IdentifierNameSyntax name, SyntaxToken colonToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8639, (GreenNode)(object)name, (GreenNode)(object)colonToken, ref num);
		if (val != null)
		{
			return (NameColonSyntax)(object)val;
		}
		NameColonSyntax nameColonSyntax = new NameColonSyntax(SyntaxKind.NameColon, name, colonToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)nameColonSyntax, num);
		}
		return nameColonSyntax;
	}

	public static DeclarationExpressionSyntax DeclarationExpression(TypeSyntax type, VariableDesignationSyntax designation)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(9040, (GreenNode)(object)type, (GreenNode)(object)designation, ref num);
		if (val != null)
		{
			return (DeclarationExpressionSyntax)(object)val;
		}
		DeclarationExpressionSyntax declarationExpressionSyntax = new DeclarationExpressionSyntax(SyntaxKind.DeclarationExpression, type, designation);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)declarationExpressionSyntax, num);
		}
		return declarationExpressionSyntax;
	}

	public static CastExpressionSyntax CastExpression(SyntaxToken openParenToken, TypeSyntax type, SyntaxToken closeParenToken, ExpressionSyntax expression)
	{
		return new CastExpressionSyntax(SyntaxKind.CastExpression, openParenToken, type, closeParenToken, expression);
	}

	public static AnonymousMethodExpressionSyntax AnonymousMethodExpression(SyntaxList<SyntaxToken> modifiers, SyntaxToken delegateKeyword, ParameterListSyntax? parameterList, BlockSyntax block, ExpressionSyntax? expressionBody)
	{
		return new AnonymousMethodExpressionSyntax(SyntaxKind.AnonymousMethodExpression, modifiers.Node, delegateKeyword, parameterList, block, expressionBody);
	}

	public static SimpleLambdaExpressionSyntax SimpleLambdaExpression(SyntaxList<AttributeListSyntax> attributeLists, SyntaxList<SyntaxToken> modifiers, ParameterSyntax parameter, SyntaxToken arrowToken, BlockSyntax? block, ExpressionSyntax? expressionBody)
	{
		return new SimpleLambdaExpressionSyntax(SyntaxKind.SimpleLambdaExpression, attributeLists.Node, modifiers.Node, parameter, arrowToken, block, expressionBody);
	}

	public static RefExpressionSyntax RefExpression(SyntaxToken refKeyword, ExpressionSyntax expression)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(9050, (GreenNode)(object)refKeyword, (GreenNode)(object)expression, ref num);
		if (val != null)
		{
			return (RefExpressionSyntax)(object)val;
		}
		RefExpressionSyntax refExpressionSyntax = new RefExpressionSyntax(SyntaxKind.RefExpression, refKeyword, expression);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)refExpressionSyntax, num);
		}
		return refExpressionSyntax;
	}

	public static ParenthesizedLambdaExpressionSyntax ParenthesizedLambdaExpression(SyntaxList<AttributeListSyntax> attributeLists, SyntaxList<SyntaxToken> modifiers, TypeSyntax? returnType, ParameterListSyntax parameterList, SyntaxToken arrowToken, BlockSyntax? block, ExpressionSyntax? expressionBody)
	{
		return new ParenthesizedLambdaExpressionSyntax(SyntaxKind.ParenthesizedLambdaExpression, attributeLists.Node, modifiers.Node, returnType, parameterList, arrowToken, block, expressionBody);
	}

	public static InitializerExpressionSyntax InitializerExpression(SyntaxKind kind, SyntaxToken openBraceToken, SeparatedSyntaxList<ExpressionSyntax> expressions, SyntaxToken closeBraceToken)
	{
		if (kind - 8644 > (SyntaxKind)2 && kind != SyntaxKind.ComplexElementInitializerExpression && kind != SyntaxKind.WithInitializerExpression)
		{
			throw new ArgumentException("kind");
		}
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode((int)kind, (GreenNode)(object)openBraceToken, expressions.Node, (GreenNode)(object)closeBraceToken, ref num);
		if (val != null)
		{
			return (InitializerExpressionSyntax)(object)val;
		}
		InitializerExpressionSyntax initializerExpressionSyntax = new InitializerExpressionSyntax(kind, openBraceToken, expressions.Node, closeBraceToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)initializerExpressionSyntax, num);
		}
		return initializerExpressionSyntax;
	}

	public static ImplicitObjectCreationExpressionSyntax ImplicitObjectCreationExpression(SyntaxToken newKeyword, ArgumentListSyntax argumentList, InitializerExpressionSyntax? initializer)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8659, (GreenNode)(object)newKeyword, (GreenNode)(object)argumentList, (GreenNode)(object)initializer, ref num);
		if (val != null)
		{
			return (ImplicitObjectCreationExpressionSyntax)(object)val;
		}
		ImplicitObjectCreationExpressionSyntax implicitObjectCreationExpressionSyntax = new ImplicitObjectCreationExpressionSyntax(SyntaxKind.ImplicitObjectCreationExpression, newKeyword, argumentList, initializer);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)implicitObjectCreationExpressionSyntax, num);
		}
		return implicitObjectCreationExpressionSyntax;
	}

	public static ObjectCreationExpressionSyntax ObjectCreationExpression(SyntaxToken newKeyword, TypeSyntax type, ArgumentListSyntax? argumentList, InitializerExpressionSyntax? initializer)
	{
		return new ObjectCreationExpressionSyntax(SyntaxKind.ObjectCreationExpression, newKeyword, type, argumentList, initializer);
	}

	public static WithExpressionSyntax WithExpression(ExpressionSyntax expression, SyntaxToken withKeyword, InitializerExpressionSyntax initializer)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(9061, (GreenNode)(object)expression, (GreenNode)(object)withKeyword, (GreenNode)(object)initializer, ref num);
		if (val != null)
		{
			return (WithExpressionSyntax)(object)val;
		}
		WithExpressionSyntax withExpressionSyntax = new WithExpressionSyntax(SyntaxKind.WithExpression, expression, withKeyword, initializer);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)withExpressionSyntax, num);
		}
		return withExpressionSyntax;
	}

	public static AnonymousObjectMemberDeclaratorSyntax AnonymousObjectMemberDeclarator(NameEqualsSyntax? nameEquals, ExpressionSyntax expression)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8647, (GreenNode)(object)nameEquals, (GreenNode)(object)expression, ref num);
		if (val != null)
		{
			return (AnonymousObjectMemberDeclaratorSyntax)(object)val;
		}
		AnonymousObjectMemberDeclaratorSyntax anonymousObjectMemberDeclaratorSyntax = new AnonymousObjectMemberDeclaratorSyntax(SyntaxKind.AnonymousObjectMemberDeclarator, nameEquals, expression);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)anonymousObjectMemberDeclaratorSyntax, num);
		}
		return anonymousObjectMemberDeclaratorSyntax;
	}

	public static AnonymousObjectCreationExpressionSyntax AnonymousObjectCreationExpression(SyntaxToken newKeyword, SyntaxToken openBraceToken, SeparatedSyntaxList<AnonymousObjectMemberDeclaratorSyntax> initializers, SyntaxToken closeBraceToken)
	{
		return new AnonymousObjectCreationExpressionSyntax(SyntaxKind.AnonymousObjectCreationExpression, newKeyword, openBraceToken, initializers.Node, closeBraceToken);
	}

	public static ArrayCreationExpressionSyntax ArrayCreationExpression(SyntaxToken newKeyword, ArrayTypeSyntax type, InitializerExpressionSyntax? initializer)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8651, (GreenNode)(object)newKeyword, (GreenNode)(object)type, (GreenNode)(object)initializer, ref num);
		if (val != null)
		{
			return (ArrayCreationExpressionSyntax)(object)val;
		}
		ArrayCreationExpressionSyntax arrayCreationExpressionSyntax = new ArrayCreationExpressionSyntax(SyntaxKind.ArrayCreationExpression, newKeyword, type, initializer);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)arrayCreationExpressionSyntax, num);
		}
		return arrayCreationExpressionSyntax;
	}

	public static ImplicitArrayCreationExpressionSyntax ImplicitArrayCreationExpression(SyntaxToken newKeyword, SyntaxToken openBracketToken, SyntaxList<SyntaxToken> commas, SyntaxToken closeBracketToken, InitializerExpressionSyntax initializer)
	{
		return new ImplicitArrayCreationExpressionSyntax(SyntaxKind.ImplicitArrayCreationExpression, newKeyword, openBracketToken, commas.Node, closeBracketToken, initializer);
	}

	public static StackAllocArrayCreationExpressionSyntax StackAllocArrayCreationExpression(SyntaxToken stackAllocKeyword, TypeSyntax type, InitializerExpressionSyntax? initializer)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8653, (GreenNode)(object)stackAllocKeyword, (GreenNode)(object)type, (GreenNode)(object)initializer, ref num);
		if (val != null)
		{
			return (StackAllocArrayCreationExpressionSyntax)(object)val;
		}
		StackAllocArrayCreationExpressionSyntax stackAllocArrayCreationExpressionSyntax = new StackAllocArrayCreationExpressionSyntax(SyntaxKind.StackAllocArrayCreationExpression, stackAllocKeyword, type, initializer);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)stackAllocArrayCreationExpressionSyntax, num);
		}
		return stackAllocArrayCreationExpressionSyntax;
	}

	public static ImplicitStackAllocArrayCreationExpressionSyntax ImplicitStackAllocArrayCreationExpression(SyntaxToken stackAllocKeyword, SyntaxToken openBracketToken, SyntaxToken closeBracketToken, InitializerExpressionSyntax initializer)
	{
		return new ImplicitStackAllocArrayCreationExpressionSyntax(SyntaxKind.ImplicitStackAllocArrayCreationExpression, stackAllocKeyword, openBracketToken, closeBracketToken, initializer);
	}

	public static CollectionExpressionSyntax CollectionExpression(SyntaxToken openBracketToken, SeparatedSyntaxList<CollectionElementSyntax> elements, SyntaxToken closeBracketToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(9076, (GreenNode)(object)openBracketToken, elements.Node, (GreenNode)(object)closeBracketToken, ref num);
		if (val != null)
		{
			return (CollectionExpressionSyntax)(object)val;
		}
		CollectionExpressionSyntax collectionExpressionSyntax = new CollectionExpressionSyntax(SyntaxKind.CollectionExpression, openBracketToken, elements.Node, closeBracketToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)collectionExpressionSyntax, num);
		}
		return collectionExpressionSyntax;
	}

	public static ExpressionElementSyntax ExpressionElement(ExpressionSyntax expression)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(9077, (GreenNode)(object)expression, ref num);
		if (val != null)
		{
			return (ExpressionElementSyntax)(object)val;
		}
		ExpressionElementSyntax expressionElementSyntax = new ExpressionElementSyntax(SyntaxKind.ExpressionElement, expression);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)expressionElementSyntax, num);
		}
		return expressionElementSyntax;
	}

	public static SpreadElementSyntax SpreadElement(SyntaxToken operatorToken, ExpressionSyntax expression)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(9078, (GreenNode)(object)operatorToken, (GreenNode)(object)expression, ref num);
		if (val != null)
		{
			return (SpreadElementSyntax)(object)val;
		}
		SpreadElementSyntax spreadElementSyntax = new SpreadElementSyntax(SyntaxKind.SpreadElement, operatorToken, expression);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)spreadElementSyntax, num);
		}
		return spreadElementSyntax;
	}

	public static QueryExpressionSyntax QueryExpression(FromClauseSyntax fromClause, QueryBodySyntax body)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8774, (GreenNode)(object)fromClause, (GreenNode)(object)body, ref num);
		if (val != null)
		{
			return (QueryExpressionSyntax)(object)val;
		}
		QueryExpressionSyntax queryExpressionSyntax = new QueryExpressionSyntax(SyntaxKind.QueryExpression, fromClause, body);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)queryExpressionSyntax, num);
		}
		return queryExpressionSyntax;
	}

	public static QueryBodySyntax QueryBody(SyntaxList<QueryClauseSyntax> clauses, SelectOrGroupClauseSyntax selectOrGroup, QueryContinuationSyntax? continuation)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8775, clauses.Node, (GreenNode)(object)selectOrGroup, (GreenNode)(object)continuation, ref num);
		if (val != null)
		{
			return (QueryBodySyntax)(object)val;
		}
		QueryBodySyntax queryBodySyntax = new QueryBodySyntax(SyntaxKind.QueryBody, clauses.Node, selectOrGroup, continuation);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)queryBodySyntax, num);
		}
		return queryBodySyntax;
	}

	public static FromClauseSyntax FromClause(SyntaxToken fromKeyword, TypeSyntax? type, SyntaxToken identifier, SyntaxToken inKeyword, ExpressionSyntax expression)
	{
		return new FromClauseSyntax(SyntaxKind.FromClause, fromKeyword, type, identifier, inKeyword, expression);
	}

	public static LetClauseSyntax LetClause(SyntaxToken letKeyword, SyntaxToken identifier, SyntaxToken equalsToken, ExpressionSyntax expression)
	{
		return new LetClauseSyntax(SyntaxKind.LetClause, letKeyword, identifier, equalsToken, expression);
	}

	public static JoinClauseSyntax JoinClause(SyntaxToken joinKeyword, TypeSyntax? type, SyntaxToken identifier, SyntaxToken inKeyword, ExpressionSyntax inExpression, SyntaxToken onKeyword, ExpressionSyntax leftExpression, SyntaxToken equalsKeyword, ExpressionSyntax rightExpression, JoinIntoClauseSyntax? into)
	{
		return new JoinClauseSyntax(SyntaxKind.JoinClause, joinKeyword, type, identifier, inKeyword, inExpression, onKeyword, leftExpression, equalsKeyword, rightExpression, into);
	}

	public static JoinIntoClauseSyntax JoinIntoClause(SyntaxToken intoKeyword, SyntaxToken identifier)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8779, (GreenNode)(object)intoKeyword, (GreenNode)(object)identifier, ref num);
		if (val != null)
		{
			return (JoinIntoClauseSyntax)(object)val;
		}
		JoinIntoClauseSyntax joinIntoClauseSyntax = new JoinIntoClauseSyntax(SyntaxKind.JoinIntoClause, intoKeyword, identifier);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)joinIntoClauseSyntax, num);
		}
		return joinIntoClauseSyntax;
	}

	public static WhereClauseSyntax WhereClause(SyntaxToken whereKeyword, ExpressionSyntax condition)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8780, (GreenNode)(object)whereKeyword, (GreenNode)(object)condition, ref num);
		if (val != null)
		{
			return (WhereClauseSyntax)(object)val;
		}
		WhereClauseSyntax whereClauseSyntax = new WhereClauseSyntax(SyntaxKind.WhereClause, whereKeyword, condition);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)whereClauseSyntax, num);
		}
		return whereClauseSyntax;
	}

	public static OrderByClauseSyntax OrderByClause(SyntaxToken orderByKeyword, SeparatedSyntaxList<OrderingSyntax> orderings)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8781, (GreenNode)(object)orderByKeyword, orderings.Node, ref num);
		if (val != null)
		{
			return (OrderByClauseSyntax)(object)val;
		}
		OrderByClauseSyntax orderByClauseSyntax = new OrderByClauseSyntax(SyntaxKind.OrderByClause, orderByKeyword, orderings.Node);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)orderByClauseSyntax, num);
		}
		return orderByClauseSyntax;
	}

	public static OrderingSyntax Ordering(SyntaxKind kind, ExpressionSyntax expression, SyntaxToken? ascendingOrDescendingKeyword)
	{
		if (kind - 8782 > SyntaxKind.List)
		{
			throw new ArgumentException("kind");
		}
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode((int)kind, (GreenNode)(object)expression, (GreenNode)(object)ascendingOrDescendingKeyword, ref num);
		if (val != null)
		{
			return (OrderingSyntax)(object)val;
		}
		OrderingSyntax orderingSyntax = new OrderingSyntax(kind, expression, ascendingOrDescendingKeyword);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)orderingSyntax, num);
		}
		return orderingSyntax;
	}

	public static SelectClauseSyntax SelectClause(SyntaxToken selectKeyword, ExpressionSyntax expression)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8784, (GreenNode)(object)selectKeyword, (GreenNode)(object)expression, ref num);
		if (val != null)
		{
			return (SelectClauseSyntax)(object)val;
		}
		SelectClauseSyntax selectClauseSyntax = new SelectClauseSyntax(SyntaxKind.SelectClause, selectKeyword, expression);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)selectClauseSyntax, num);
		}
		return selectClauseSyntax;
	}

	public static GroupClauseSyntax GroupClause(SyntaxToken groupKeyword, ExpressionSyntax groupExpression, SyntaxToken byKeyword, ExpressionSyntax byExpression)
	{
		return new GroupClauseSyntax(SyntaxKind.GroupClause, groupKeyword, groupExpression, byKeyword, byExpression);
	}

	public static QueryContinuationSyntax QueryContinuation(SyntaxToken intoKeyword, SyntaxToken identifier, QueryBodySyntax body)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8786, (GreenNode)(object)intoKeyword, (GreenNode)(object)identifier, (GreenNode)(object)body, ref num);
		if (val != null)
		{
			return (QueryContinuationSyntax)(object)val;
		}
		QueryContinuationSyntax queryContinuationSyntax = new QueryContinuationSyntax(SyntaxKind.QueryContinuation, intoKeyword, identifier, body);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)queryContinuationSyntax, num);
		}
		return queryContinuationSyntax;
	}

	public static OmittedArraySizeExpressionSyntax OmittedArraySizeExpression(SyntaxToken omittedArraySizeExpressionToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8654, (GreenNode)(object)omittedArraySizeExpressionToken, ref num);
		if (val != null)
		{
			return (OmittedArraySizeExpressionSyntax)(object)val;
		}
		OmittedArraySizeExpressionSyntax omittedArraySizeExpressionSyntax = new OmittedArraySizeExpressionSyntax(SyntaxKind.OmittedArraySizeExpression, omittedArraySizeExpressionToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)omittedArraySizeExpressionSyntax, num);
		}
		return omittedArraySizeExpressionSyntax;
	}

	public static InterpolatedStringExpressionSyntax InterpolatedStringExpression(SyntaxToken stringStartToken, SyntaxList<InterpolatedStringContentSyntax> contents, SyntaxToken stringEndToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8655, (GreenNode)(object)stringStartToken, contents.Node, (GreenNode)(object)stringEndToken, ref num);
		if (val != null)
		{
			return (InterpolatedStringExpressionSyntax)(object)val;
		}
		InterpolatedStringExpressionSyntax interpolatedStringExpressionSyntax = new InterpolatedStringExpressionSyntax(SyntaxKind.InterpolatedStringExpression, stringStartToken, contents.Node, stringEndToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)interpolatedStringExpressionSyntax, num);
		}
		return interpolatedStringExpressionSyntax;
	}

	public static IsPatternExpressionSyntax IsPatternExpression(ExpressionSyntax expression, SyntaxToken isKeyword, PatternSyntax pattern)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8657, (GreenNode)(object)expression, (GreenNode)(object)isKeyword, (GreenNode)(object)pattern, ref num);
		if (val != null)
		{
			return (IsPatternExpressionSyntax)(object)val;
		}
		IsPatternExpressionSyntax isPatternExpressionSyntax = new IsPatternExpressionSyntax(SyntaxKind.IsPatternExpression, expression, isKeyword, pattern);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)isPatternExpressionSyntax, num);
		}
		return isPatternExpressionSyntax;
	}

	public static ThrowExpressionSyntax ThrowExpression(SyntaxToken throwKeyword, ExpressionSyntax expression)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(9052, (GreenNode)(object)throwKeyword, (GreenNode)(object)expression, ref num);
		if (val != null)
		{
			return (ThrowExpressionSyntax)(object)val;
		}
		ThrowExpressionSyntax throwExpressionSyntax = new ThrowExpressionSyntax(SyntaxKind.ThrowExpression, throwKeyword, expression);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)throwExpressionSyntax, num);
		}
		return throwExpressionSyntax;
	}

	public static WhenClauseSyntax WhenClause(SyntaxToken whenKeyword, ExpressionSyntax condition)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(9013, (GreenNode)(object)whenKeyword, (GreenNode)(object)condition, ref num);
		if (val != null)
		{
			return (WhenClauseSyntax)(object)val;
		}
		WhenClauseSyntax whenClauseSyntax = new WhenClauseSyntax(SyntaxKind.WhenClause, whenKeyword, condition);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)whenClauseSyntax, num);
		}
		return whenClauseSyntax;
	}

	public static DiscardPatternSyntax DiscardPattern(SyntaxToken underscoreToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(9024, (GreenNode)(object)underscoreToken, ref num);
		if (val != null)
		{
			return (DiscardPatternSyntax)(object)val;
		}
		DiscardPatternSyntax discardPatternSyntax = new DiscardPatternSyntax(SyntaxKind.DiscardPattern, underscoreToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)discardPatternSyntax, num);
		}
		return discardPatternSyntax;
	}

	public static DeclarationPatternSyntax DeclarationPattern(TypeSyntax type, VariableDesignationSyntax designation)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(9000, (GreenNode)(object)type, (GreenNode)(object)designation, ref num);
		if (val != null)
		{
			return (DeclarationPatternSyntax)(object)val;
		}
		DeclarationPatternSyntax declarationPatternSyntax = new DeclarationPatternSyntax(SyntaxKind.DeclarationPattern, type, designation);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)declarationPatternSyntax, num);
		}
		return declarationPatternSyntax;
	}

	public static VarPatternSyntax VarPattern(SyntaxToken varKeyword, VariableDesignationSyntax designation)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(9027, (GreenNode)(object)varKeyword, (GreenNode)(object)designation, ref num);
		if (val != null)
		{
			return (VarPatternSyntax)(object)val;
		}
		VarPatternSyntax varPatternSyntax = new VarPatternSyntax(SyntaxKind.VarPattern, varKeyword, designation);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)varPatternSyntax, num);
		}
		return varPatternSyntax;
	}

	public static RecursivePatternSyntax RecursivePattern(TypeSyntax? type, PositionalPatternClauseSyntax? positionalPatternClause, PropertyPatternClauseSyntax? propertyPatternClause, VariableDesignationSyntax? designation)
	{
		return new RecursivePatternSyntax(SyntaxKind.RecursivePattern, type, positionalPatternClause, propertyPatternClause, designation);
	}

	public static PositionalPatternClauseSyntax PositionalPatternClause(SyntaxToken openParenToken, SeparatedSyntaxList<SubpatternSyntax> subpatterns, SyntaxToken closeParenToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(9023, (GreenNode)(object)openParenToken, subpatterns.Node, (GreenNode)(object)closeParenToken, ref num);
		if (val != null)
		{
			return (PositionalPatternClauseSyntax)(object)val;
		}
		PositionalPatternClauseSyntax positionalPatternClauseSyntax = new PositionalPatternClauseSyntax(SyntaxKind.PositionalPatternClause, openParenToken, subpatterns.Node, closeParenToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)positionalPatternClauseSyntax, num);
		}
		return positionalPatternClauseSyntax;
	}

	public static PropertyPatternClauseSyntax PropertyPatternClause(SyntaxToken openBraceToken, SeparatedSyntaxList<SubpatternSyntax> subpatterns, SyntaxToken closeBraceToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(9021, (GreenNode)(object)openBraceToken, subpatterns.Node, (GreenNode)(object)closeBraceToken, ref num);
		if (val != null)
		{
			return (PropertyPatternClauseSyntax)(object)val;
		}
		PropertyPatternClauseSyntax propertyPatternClauseSyntax = new PropertyPatternClauseSyntax(SyntaxKind.PropertyPatternClause, openBraceToken, subpatterns.Node, closeBraceToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)propertyPatternClauseSyntax, num);
		}
		return propertyPatternClauseSyntax;
	}

	public static SubpatternSyntax Subpattern(BaseExpressionColonSyntax? expressionColon, PatternSyntax pattern)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(9022, (GreenNode)(object)expressionColon, (GreenNode)(object)pattern, ref num);
		if (val != null)
		{
			return (SubpatternSyntax)(object)val;
		}
		SubpatternSyntax subpatternSyntax = new SubpatternSyntax(SyntaxKind.Subpattern, expressionColon, pattern);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)subpatternSyntax, num);
		}
		return subpatternSyntax;
	}

	public static ConstantPatternSyntax ConstantPattern(ExpressionSyntax expression)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(9002, (GreenNode)(object)expression, ref num);
		if (val != null)
		{
			return (ConstantPatternSyntax)(object)val;
		}
		ConstantPatternSyntax constantPatternSyntax = new ConstantPatternSyntax(SyntaxKind.ConstantPattern, expression);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)constantPatternSyntax, num);
		}
		return constantPatternSyntax;
	}

	public static ParenthesizedPatternSyntax ParenthesizedPattern(SyntaxToken openParenToken, PatternSyntax pattern, SyntaxToken closeParenToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(9028, (GreenNode)(object)openParenToken, (GreenNode)(object)pattern, (GreenNode)(object)closeParenToken, ref num);
		if (val != null)
		{
			return (ParenthesizedPatternSyntax)(object)val;
		}
		ParenthesizedPatternSyntax parenthesizedPatternSyntax = new ParenthesizedPatternSyntax(SyntaxKind.ParenthesizedPattern, openParenToken, pattern, closeParenToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)parenthesizedPatternSyntax, num);
		}
		return parenthesizedPatternSyntax;
	}

	public static RelationalPatternSyntax RelationalPattern(SyntaxToken operatorToken, ExpressionSyntax expression)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(9029, (GreenNode)(object)operatorToken, (GreenNode)(object)expression, ref num);
		if (val != null)
		{
			return (RelationalPatternSyntax)(object)val;
		}
		RelationalPatternSyntax relationalPatternSyntax = new RelationalPatternSyntax(SyntaxKind.RelationalPattern, operatorToken, expression);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)relationalPatternSyntax, num);
		}
		return relationalPatternSyntax;
	}

	public static TypePatternSyntax TypePattern(TypeSyntax type)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(9030, (GreenNode)(object)type, ref num);
		if (val != null)
		{
			return (TypePatternSyntax)(object)val;
		}
		TypePatternSyntax typePatternSyntax = new TypePatternSyntax(SyntaxKind.TypePattern, type);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)typePatternSyntax, num);
		}
		return typePatternSyntax;
	}

	public static BinaryPatternSyntax BinaryPattern(SyntaxKind kind, PatternSyntax left, SyntaxToken operatorToken, PatternSyntax right)
	{
		if (kind - 9031 > SyntaxKind.List)
		{
			throw new ArgumentException("kind");
		}
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode((int)kind, (GreenNode)(object)left, (GreenNode)(object)operatorToken, (GreenNode)(object)right, ref num);
		if (val != null)
		{
			return (BinaryPatternSyntax)(object)val;
		}
		BinaryPatternSyntax binaryPatternSyntax = new BinaryPatternSyntax(kind, left, operatorToken, right);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)binaryPatternSyntax, num);
		}
		return binaryPatternSyntax;
	}

	public static UnaryPatternSyntax UnaryPattern(SyntaxToken operatorToken, PatternSyntax pattern)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(9033, (GreenNode)(object)operatorToken, (GreenNode)(object)pattern, ref num);
		if (val != null)
		{
			return (UnaryPatternSyntax)(object)val;
		}
		UnaryPatternSyntax unaryPatternSyntax = new UnaryPatternSyntax(SyntaxKind.NotPattern, operatorToken, pattern);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)unaryPatternSyntax, num);
		}
		return unaryPatternSyntax;
	}

	public static ListPatternSyntax ListPattern(SyntaxToken openBracketToken, SeparatedSyntaxList<PatternSyntax> patterns, SyntaxToken closeBracketToken, VariableDesignationSyntax? designation)
	{
		return new ListPatternSyntax(SyntaxKind.ListPattern, openBracketToken, patterns.Node, closeBracketToken, designation);
	}

	public static SlicePatternSyntax SlicePattern(SyntaxToken dotDotToken, PatternSyntax? pattern)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(9034, (GreenNode)(object)dotDotToken, (GreenNode)(object)pattern, ref num);
		if (val != null)
		{
			return (SlicePatternSyntax)(object)val;
		}
		SlicePatternSyntax slicePatternSyntax = new SlicePatternSyntax(SyntaxKind.SlicePattern, dotDotToken, pattern);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)slicePatternSyntax, num);
		}
		return slicePatternSyntax;
	}

	public static InterpolatedStringTextSyntax InterpolatedStringText(SyntaxToken textToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8919, (GreenNode)(object)textToken, ref num);
		if (val != null)
		{
			return (InterpolatedStringTextSyntax)(object)val;
		}
		InterpolatedStringTextSyntax interpolatedStringTextSyntax = new InterpolatedStringTextSyntax(SyntaxKind.InterpolatedStringText, textToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)interpolatedStringTextSyntax, num);
		}
		return interpolatedStringTextSyntax;
	}

	public static InterpolationSyntax Interpolation(SyntaxToken openBraceToken, ExpressionSyntax expression, InterpolationAlignmentClauseSyntax? alignmentClause, InterpolationFormatClauseSyntax? formatClause, SyntaxToken closeBraceToken)
	{
		return new InterpolationSyntax(SyntaxKind.Interpolation, openBraceToken, expression, alignmentClause, formatClause, closeBraceToken);
	}

	public static InterpolationAlignmentClauseSyntax InterpolationAlignmentClause(SyntaxToken commaToken, ExpressionSyntax value)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8920, (GreenNode)(object)commaToken, (GreenNode)(object)value, ref num);
		if (val != null)
		{
			return (InterpolationAlignmentClauseSyntax)(object)val;
		}
		InterpolationAlignmentClauseSyntax interpolationAlignmentClauseSyntax = new InterpolationAlignmentClauseSyntax(SyntaxKind.InterpolationAlignmentClause, commaToken, value);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)interpolationAlignmentClauseSyntax, num);
		}
		return interpolationAlignmentClauseSyntax;
	}

	public static InterpolationFormatClauseSyntax InterpolationFormatClause(SyntaxToken colonToken, SyntaxToken formatStringToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8921, (GreenNode)(object)colonToken, (GreenNode)(object)formatStringToken, ref num);
		if (val != null)
		{
			return (InterpolationFormatClauseSyntax)(object)val;
		}
		InterpolationFormatClauseSyntax interpolationFormatClauseSyntax = new InterpolationFormatClauseSyntax(SyntaxKind.InterpolationFormatClause, colonToken, formatStringToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)interpolationFormatClauseSyntax, num);
		}
		return interpolationFormatClauseSyntax;
	}

	public static GlobalStatementSyntax GlobalStatement(SyntaxList<AttributeListSyntax> attributeLists, SyntaxList<SyntaxToken> modifiers, StatementSyntax statement)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8841, attributeLists.Node, modifiers.Node, (GreenNode)(object)statement, ref num);
		if (val != null)
		{
			return (GlobalStatementSyntax)(object)val;
		}
		GlobalStatementSyntax globalStatementSyntax = new GlobalStatementSyntax(SyntaxKind.GlobalStatement, attributeLists.Node, modifiers.Node, statement);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)globalStatementSyntax, num);
		}
		return globalStatementSyntax;
	}

	public static BlockSyntax Block(SyntaxList<AttributeListSyntax> attributeLists, SyntaxToken openBraceToken, SyntaxList<StatementSyntax> statements, SyntaxToken closeBraceToken)
	{
		return new BlockSyntax(SyntaxKind.Block, attributeLists.Node, openBraceToken, statements.Node, closeBraceToken);
	}

	public static LocalFunctionStatementSyntax LocalFunctionStatement(SyntaxList<AttributeListSyntax> attributeLists, SyntaxList<SyntaxToken> modifiers, TypeSyntax returnType, SyntaxToken identifier, TypeParameterListSyntax? typeParameterList, ParameterListSyntax parameterList, SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken)
	{
		return new LocalFunctionStatementSyntax(SyntaxKind.LocalFunctionStatement, attributeLists.Node, modifiers.Node, returnType, identifier, typeParameterList, parameterList, constraintClauses.Node, body, expressionBody, semicolonToken);
	}

	public static LocalDeclarationStatementSyntax LocalDeclarationStatement(SyntaxList<AttributeListSyntax> attributeLists, SyntaxToken? awaitKeyword, SyntaxToken? usingKeyword, SyntaxList<SyntaxToken> modifiers, VariableDeclarationSyntax declaration, SyntaxToken semicolonToken)
	{
		return new LocalDeclarationStatementSyntax(SyntaxKind.LocalDeclarationStatement, attributeLists.Node, awaitKeyword, usingKeyword, modifiers.Node, declaration, semicolonToken);
	}

	public static VariableDeclarationSyntax VariableDeclaration(TypeSyntax type, SeparatedSyntaxList<VariableDeclaratorSyntax> variables)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8794, (GreenNode)(object)type, variables.Node, ref num);
		if (val != null)
		{
			return (VariableDeclarationSyntax)(object)val;
		}
		VariableDeclarationSyntax variableDeclarationSyntax = new VariableDeclarationSyntax(SyntaxKind.VariableDeclaration, type, variables.Node);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)variableDeclarationSyntax, num);
		}
		return variableDeclarationSyntax;
	}

	public static VariableDeclaratorSyntax VariableDeclarator(SyntaxToken identifier, BracketedArgumentListSyntax? argumentList, EqualsValueClauseSyntax? initializer)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8795, (GreenNode)(object)identifier, (GreenNode)(object)argumentList, (GreenNode)(object)initializer, ref num);
		if (val != null)
		{
			return (VariableDeclaratorSyntax)(object)val;
		}
		VariableDeclaratorSyntax variableDeclaratorSyntax = new VariableDeclaratorSyntax(SyntaxKind.VariableDeclarator, identifier, argumentList, initializer);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)variableDeclaratorSyntax, num);
		}
		return variableDeclaratorSyntax;
	}

	public static EqualsValueClauseSyntax EqualsValueClause(SyntaxToken equalsToken, ExpressionSyntax value)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8796, (GreenNode)(object)equalsToken, (GreenNode)(object)value, ref num);
		if (val != null)
		{
			return (EqualsValueClauseSyntax)(object)val;
		}
		EqualsValueClauseSyntax equalsValueClauseSyntax = new EqualsValueClauseSyntax(SyntaxKind.EqualsValueClause, equalsToken, value);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)equalsValueClauseSyntax, num);
		}
		return equalsValueClauseSyntax;
	}

	public static SingleVariableDesignationSyntax SingleVariableDesignation(SyntaxToken identifier)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8927, (GreenNode)(object)identifier, ref num);
		if (val != null)
		{
			return (SingleVariableDesignationSyntax)(object)val;
		}
		SingleVariableDesignationSyntax singleVariableDesignationSyntax = new SingleVariableDesignationSyntax(SyntaxKind.SingleVariableDesignation, identifier);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)singleVariableDesignationSyntax, num);
		}
		return singleVariableDesignationSyntax;
	}

	public static DiscardDesignationSyntax DiscardDesignation(SyntaxToken underscoreToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(9014, (GreenNode)(object)underscoreToken, ref num);
		if (val != null)
		{
			return (DiscardDesignationSyntax)(object)val;
		}
		DiscardDesignationSyntax discardDesignationSyntax = new DiscardDesignationSyntax(SyntaxKind.DiscardDesignation, underscoreToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)discardDesignationSyntax, num);
		}
		return discardDesignationSyntax;
	}

	public static ParenthesizedVariableDesignationSyntax ParenthesizedVariableDesignation(SyntaxToken openParenToken, SeparatedSyntaxList<VariableDesignationSyntax> variables, SyntaxToken closeParenToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8928, (GreenNode)(object)openParenToken, variables.Node, (GreenNode)(object)closeParenToken, ref num);
		if (val != null)
		{
			return (ParenthesizedVariableDesignationSyntax)(object)val;
		}
		ParenthesizedVariableDesignationSyntax parenthesizedVariableDesignationSyntax = new ParenthesizedVariableDesignationSyntax(SyntaxKind.ParenthesizedVariableDesignation, openParenToken, variables.Node, closeParenToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)parenthesizedVariableDesignationSyntax, num);
		}
		return parenthesizedVariableDesignationSyntax;
	}

	public static ExpressionStatementSyntax ExpressionStatement(SyntaxList<AttributeListSyntax> attributeLists, ExpressionSyntax expression, SyntaxToken semicolonToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8797, attributeLists.Node, (GreenNode)(object)expression, (GreenNode)(object)semicolonToken, ref num);
		if (val != null)
		{
			return (ExpressionStatementSyntax)(object)val;
		}
		ExpressionStatementSyntax expressionStatementSyntax = new ExpressionStatementSyntax(SyntaxKind.ExpressionStatement, attributeLists.Node, expression, semicolonToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)expressionStatementSyntax, num);
		}
		return expressionStatementSyntax;
	}

	public static EmptyStatementSyntax EmptyStatement(SyntaxList<AttributeListSyntax> attributeLists, SyntaxToken semicolonToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8798, attributeLists.Node, (GreenNode)(object)semicolonToken, ref num);
		if (val != null)
		{
			return (EmptyStatementSyntax)(object)val;
		}
		EmptyStatementSyntax emptyStatementSyntax = new EmptyStatementSyntax(SyntaxKind.EmptyStatement, attributeLists.Node, semicolonToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)emptyStatementSyntax, num);
		}
		return emptyStatementSyntax;
	}

	public static LabeledStatementSyntax LabeledStatement(SyntaxList<AttributeListSyntax> attributeLists, SyntaxToken identifier, SyntaxToken colonToken, StatementSyntax statement)
	{
		return new LabeledStatementSyntax(SyntaxKind.LabeledStatement, attributeLists.Node, identifier, colonToken, statement);
	}

	public static GotoStatementSyntax GotoStatement(SyntaxKind kind, SyntaxList<AttributeListSyntax> attributeLists, SyntaxToken gotoKeyword, SyntaxToken? caseOrDefaultKeyword, ExpressionSyntax? expression, SyntaxToken semicolonToken)
	{
		if (kind - 8800 > (SyntaxKind)2)
		{
			throw new ArgumentException("kind");
		}
		return new GotoStatementSyntax(kind, attributeLists.Node, gotoKeyword, caseOrDefaultKeyword, expression, semicolonToken);
	}

	public static BreakStatementSyntax BreakStatement(SyntaxList<AttributeListSyntax> attributeLists, SyntaxToken breakKeyword, SyntaxToken semicolonToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8803, attributeLists.Node, (GreenNode)(object)breakKeyword, (GreenNode)(object)semicolonToken, ref num);
		if (val != null)
		{
			return (BreakStatementSyntax)(object)val;
		}
		BreakStatementSyntax breakStatementSyntax = new BreakStatementSyntax(SyntaxKind.BreakStatement, attributeLists.Node, breakKeyword, semicolonToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)breakStatementSyntax, num);
		}
		return breakStatementSyntax;
	}

	public static ContinueStatementSyntax ContinueStatement(SyntaxList<AttributeListSyntax> attributeLists, SyntaxToken continueKeyword, SyntaxToken semicolonToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8804, attributeLists.Node, (GreenNode)(object)continueKeyword, (GreenNode)(object)semicolonToken, ref num);
		if (val != null)
		{
			return (ContinueStatementSyntax)(object)val;
		}
		ContinueStatementSyntax continueStatementSyntax = new ContinueStatementSyntax(SyntaxKind.ContinueStatement, attributeLists.Node, continueKeyword, semicolonToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)continueStatementSyntax, num);
		}
		return continueStatementSyntax;
	}

	public static ReturnStatementSyntax ReturnStatement(SyntaxList<AttributeListSyntax> attributeLists, SyntaxToken returnKeyword, ExpressionSyntax? expression, SyntaxToken semicolonToken)
	{
		return new ReturnStatementSyntax(SyntaxKind.ReturnStatement, attributeLists.Node, returnKeyword, expression, semicolonToken);
	}

	public static ThrowStatementSyntax ThrowStatement(SyntaxList<AttributeListSyntax> attributeLists, SyntaxToken throwKeyword, ExpressionSyntax? expression, SyntaxToken semicolonToken)
	{
		return new ThrowStatementSyntax(SyntaxKind.ThrowStatement, attributeLists.Node, throwKeyword, expression, semicolonToken);
	}

	public static YieldStatementSyntax YieldStatement(SyntaxKind kind, SyntaxList<AttributeListSyntax> attributeLists, SyntaxToken yieldKeyword, SyntaxToken returnOrBreakKeyword, ExpressionSyntax? expression, SyntaxToken semicolonToken)
	{
		if (kind - 8806 > SyntaxKind.List)
		{
			throw new ArgumentException("kind");
		}
		return new YieldStatementSyntax(kind, attributeLists.Node, yieldKeyword, returnOrBreakKeyword, expression, semicolonToken);
	}

	public static WhileStatementSyntax WhileStatement(SyntaxList<AttributeListSyntax> attributeLists, SyntaxToken whileKeyword, SyntaxToken openParenToken, ExpressionSyntax condition, SyntaxToken closeParenToken, StatementSyntax statement)
	{
		return new WhileStatementSyntax(SyntaxKind.WhileStatement, attributeLists.Node, whileKeyword, openParenToken, condition, closeParenToken, statement);
	}

	public static DoStatementSyntax DoStatement(SyntaxList<AttributeListSyntax> attributeLists, SyntaxToken doKeyword, StatementSyntax statement, SyntaxToken whileKeyword, SyntaxToken openParenToken, ExpressionSyntax condition, SyntaxToken closeParenToken, SyntaxToken semicolonToken)
	{
		return new DoStatementSyntax(SyntaxKind.DoStatement, attributeLists.Node, doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken);
	}

	public static ForStatementSyntax ForStatement(SyntaxList<AttributeListSyntax> attributeLists, SyntaxToken forKeyword, SyntaxToken openParenToken, VariableDeclarationSyntax? declaration, SeparatedSyntaxList<ExpressionSyntax> initializers, SyntaxToken firstSemicolonToken, ExpressionSyntax? condition, SyntaxToken secondSemicolonToken, SeparatedSyntaxList<ExpressionSyntax> incrementors, SyntaxToken closeParenToken, StatementSyntax statement)
	{
		return new ForStatementSyntax(SyntaxKind.ForStatement, attributeLists.Node, forKeyword, openParenToken, declaration, initializers.Node, firstSemicolonToken, condition, secondSemicolonToken, incrementors.Node, closeParenToken, statement);
	}

	public static ForEachStatementSyntax ForEachStatement(SyntaxList<AttributeListSyntax> attributeLists, SyntaxToken? awaitKeyword, SyntaxToken forEachKeyword, SyntaxToken openParenToken, TypeSyntax type, SyntaxToken identifier, SyntaxToken inKeyword, ExpressionSyntax expression, SyntaxToken closeParenToken, StatementSyntax statement)
	{
		return new ForEachStatementSyntax(SyntaxKind.ForEachStatement, attributeLists.Node, awaitKeyword, forEachKeyword, openParenToken, type, identifier, inKeyword, expression, closeParenToken, statement);
	}

	public static ForEachVariableStatementSyntax ForEachVariableStatement(SyntaxList<AttributeListSyntax> attributeLists, SyntaxToken? awaitKeyword, SyntaxToken forEachKeyword, SyntaxToken openParenToken, ExpressionSyntax variable, SyntaxToken inKeyword, ExpressionSyntax expression, SyntaxToken closeParenToken, StatementSyntax statement)
	{
		return new ForEachVariableStatementSyntax(SyntaxKind.ForEachVariableStatement, attributeLists.Node, awaitKeyword, forEachKeyword, openParenToken, variable, inKeyword, expression, closeParenToken, statement);
	}

	public static UsingStatementSyntax UsingStatement(SyntaxList<AttributeListSyntax> attributeLists, SyntaxToken? awaitKeyword, SyntaxToken usingKeyword, SyntaxToken openParenToken, VariableDeclarationSyntax? declaration, ExpressionSyntax? expression, SyntaxToken closeParenToken, StatementSyntax statement)
	{
		return new UsingStatementSyntax(SyntaxKind.UsingStatement, attributeLists.Node, awaitKeyword, usingKeyword, openParenToken, declaration, expression, closeParenToken, statement);
	}

	public static FixedStatementSyntax FixedStatement(SyntaxList<AttributeListSyntax> attributeLists, SyntaxToken fixedKeyword, SyntaxToken openParenToken, VariableDeclarationSyntax declaration, SyntaxToken closeParenToken, StatementSyntax statement)
	{
		return new FixedStatementSyntax(SyntaxKind.FixedStatement, attributeLists.Node, fixedKeyword, openParenToken, declaration, closeParenToken, statement);
	}

	public static CheckedStatementSyntax CheckedStatement(SyntaxKind kind, SyntaxList<AttributeListSyntax> attributeLists, SyntaxToken keyword, BlockSyntax block)
	{
		if (kind - 8815 > SyntaxKind.List)
		{
			throw new ArgumentException("kind");
		}
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode((int)kind, attributeLists.Node, (GreenNode)(object)keyword, (GreenNode)(object)block, ref num);
		if (val != null)
		{
			return (CheckedStatementSyntax)(object)val;
		}
		CheckedStatementSyntax checkedStatementSyntax = new CheckedStatementSyntax(kind, attributeLists.Node, keyword, block);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)checkedStatementSyntax, num);
		}
		return checkedStatementSyntax;
	}

	public static UnsafeStatementSyntax UnsafeStatement(SyntaxList<AttributeListSyntax> attributeLists, SyntaxToken unsafeKeyword, BlockSyntax block)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8817, attributeLists.Node, (GreenNode)(object)unsafeKeyword, (GreenNode)(object)block, ref num);
		if (val != null)
		{
			return (UnsafeStatementSyntax)(object)val;
		}
		UnsafeStatementSyntax unsafeStatementSyntax = new UnsafeStatementSyntax(SyntaxKind.UnsafeStatement, attributeLists.Node, unsafeKeyword, block);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)unsafeStatementSyntax, num);
		}
		return unsafeStatementSyntax;
	}

	public static LockStatementSyntax LockStatement(SyntaxList<AttributeListSyntax> attributeLists, SyntaxToken lockKeyword, SyntaxToken openParenToken, ExpressionSyntax expression, SyntaxToken closeParenToken, StatementSyntax statement)
	{
		return new LockStatementSyntax(SyntaxKind.LockStatement, attributeLists.Node, lockKeyword, openParenToken, expression, closeParenToken, statement);
	}

	public static IfStatementSyntax IfStatement(SyntaxList<AttributeListSyntax> attributeLists, SyntaxToken ifKeyword, SyntaxToken openParenToken, ExpressionSyntax condition, SyntaxToken closeParenToken, StatementSyntax statement, ElseClauseSyntax? @else)
	{
		return new IfStatementSyntax(SyntaxKind.IfStatement, attributeLists.Node, ifKeyword, openParenToken, condition, closeParenToken, statement, @else);
	}

	public static ElseClauseSyntax ElseClause(SyntaxToken elseKeyword, StatementSyntax statement)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8820, (GreenNode)(object)elseKeyword, (GreenNode)(object)statement, ref num);
		if (val != null)
		{
			return (ElseClauseSyntax)(object)val;
		}
		ElseClauseSyntax elseClauseSyntax = new ElseClauseSyntax(SyntaxKind.ElseClause, elseKeyword, statement);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)elseClauseSyntax, num);
		}
		return elseClauseSyntax;
	}

	public static SwitchStatementSyntax SwitchStatement(SyntaxList<AttributeListSyntax> attributeLists, SyntaxToken switchKeyword, SyntaxToken? openParenToken, ExpressionSyntax expression, SyntaxToken? closeParenToken, SyntaxToken openBraceToken, SyntaxList<SwitchSectionSyntax> sections, SyntaxToken closeBraceToken)
	{
		return new SwitchStatementSyntax(SyntaxKind.SwitchStatement, attributeLists.Node, switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, sections.Node, closeBraceToken);
	}

	public static SwitchSectionSyntax SwitchSection(SyntaxList<SwitchLabelSyntax> labels, SyntaxList<StatementSyntax> statements)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8822, labels.Node, statements.Node, ref num);
		if (val != null)
		{
			return (SwitchSectionSyntax)(object)val;
		}
		SwitchSectionSyntax switchSectionSyntax = new SwitchSectionSyntax(SyntaxKind.SwitchSection, labels.Node, statements.Node);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)switchSectionSyntax, num);
		}
		return switchSectionSyntax;
	}

	public static CasePatternSwitchLabelSyntax CasePatternSwitchLabel(SyntaxToken keyword, PatternSyntax pattern, WhenClauseSyntax? whenClause, SyntaxToken colonToken)
	{
		return new CasePatternSwitchLabelSyntax(SyntaxKind.CasePatternSwitchLabel, keyword, pattern, whenClause, colonToken);
	}

	public static CaseSwitchLabelSyntax CaseSwitchLabel(SyntaxToken keyword, ExpressionSyntax value, SyntaxToken colonToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8823, (GreenNode)(object)keyword, (GreenNode)(object)value, (GreenNode)(object)colonToken, ref num);
		if (val != null)
		{
			return (CaseSwitchLabelSyntax)(object)val;
		}
		CaseSwitchLabelSyntax caseSwitchLabelSyntax = new CaseSwitchLabelSyntax(SyntaxKind.CaseSwitchLabel, keyword, value, colonToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)caseSwitchLabelSyntax, num);
		}
		return caseSwitchLabelSyntax;
	}

	public static DefaultSwitchLabelSyntax DefaultSwitchLabel(SyntaxToken keyword, SyntaxToken colonToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8824, (GreenNode)(object)keyword, (GreenNode)(object)colonToken, ref num);
		if (val != null)
		{
			return (DefaultSwitchLabelSyntax)(object)val;
		}
		DefaultSwitchLabelSyntax defaultSwitchLabelSyntax = new DefaultSwitchLabelSyntax(SyntaxKind.DefaultSwitchLabel, keyword, colonToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)defaultSwitchLabelSyntax, num);
		}
		return defaultSwitchLabelSyntax;
	}

	public static SwitchExpressionSyntax SwitchExpression(ExpressionSyntax governingExpression, SyntaxToken switchKeyword, SyntaxToken openBraceToken, SeparatedSyntaxList<SwitchExpressionArmSyntax> arms, SyntaxToken closeBraceToken)
	{
		return new SwitchExpressionSyntax(SyntaxKind.SwitchExpression, governingExpression, switchKeyword, openBraceToken, arms.Node, closeBraceToken);
	}

	public static SwitchExpressionArmSyntax SwitchExpressionArm(PatternSyntax pattern, WhenClauseSyntax? whenClause, SyntaxToken equalsGreaterThanToken, ExpressionSyntax expression)
	{
		return new SwitchExpressionArmSyntax(SyntaxKind.SwitchExpressionArm, pattern, whenClause, equalsGreaterThanToken, expression);
	}

	public static TryStatementSyntax TryStatement(SyntaxList<AttributeListSyntax> attributeLists, SyntaxToken tryKeyword, BlockSyntax block, SyntaxList<CatchClauseSyntax> catches, FinallyClauseSyntax? @finally)
	{
		return new TryStatementSyntax(SyntaxKind.TryStatement, attributeLists.Node, tryKeyword, block, catches.Node, @finally);
	}

	public static CatchClauseSyntax CatchClause(SyntaxToken catchKeyword, CatchDeclarationSyntax? declaration, CatchFilterClauseSyntax? filter, BlockSyntax block)
	{
		return new CatchClauseSyntax(SyntaxKind.CatchClause, catchKeyword, declaration, filter, block);
	}

	public static CatchDeclarationSyntax CatchDeclaration(SyntaxToken openParenToken, TypeSyntax type, SyntaxToken? identifier, SyntaxToken closeParenToken)
	{
		return new CatchDeclarationSyntax(SyntaxKind.CatchDeclaration, openParenToken, type, identifier, closeParenToken);
	}

	public static CatchFilterClauseSyntax CatchFilterClause(SyntaxToken whenKeyword, SyntaxToken openParenToken, ExpressionSyntax filterExpression, SyntaxToken closeParenToken)
	{
		return new CatchFilterClauseSyntax(SyntaxKind.CatchFilterClause, whenKeyword, openParenToken, filterExpression, closeParenToken);
	}

	public static FinallyClauseSyntax FinallyClause(SyntaxToken finallyKeyword, BlockSyntax block)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8829, (GreenNode)(object)finallyKeyword, (GreenNode)(object)block, ref num);
		if (val != null)
		{
			return (FinallyClauseSyntax)(object)val;
		}
		FinallyClauseSyntax finallyClauseSyntax = new FinallyClauseSyntax(SyntaxKind.FinallyClause, finallyKeyword, block);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)finallyClauseSyntax, num);
		}
		return finallyClauseSyntax;
	}

	public static CompilationUnitSyntax CompilationUnit(SyntaxList<ExternAliasDirectiveSyntax> externs, SyntaxList<UsingDirectiveSyntax> usings, SyntaxList<AttributeListSyntax> attributeLists, SyntaxList<MemberDeclarationSyntax> members, SyntaxToken endOfFileToken)
	{
		return new CompilationUnitSyntax(SyntaxKind.CompilationUnit, externs.Node, usings.Node, attributeLists.Node, members.Node, endOfFileToken);
	}

	public static ExternAliasDirectiveSyntax ExternAliasDirective(SyntaxToken externKeyword, SyntaxToken aliasKeyword, SyntaxToken identifier, SyntaxToken semicolonToken)
	{
		return new ExternAliasDirectiveSyntax(SyntaxKind.ExternAliasDirective, externKeyword, aliasKeyword, identifier, semicolonToken);
	}

	public static UsingDirectiveSyntax UsingDirective(SyntaxToken? globalKeyword, SyntaxToken usingKeyword, SyntaxToken? staticKeyword, SyntaxToken? unsafeKeyword, NameEqualsSyntax? alias, TypeSyntax namespaceOrType, SyntaxToken semicolonToken)
	{
		return new UsingDirectiveSyntax(SyntaxKind.UsingDirective, globalKeyword, usingKeyword, staticKeyword, unsafeKeyword, alias, namespaceOrType, semicolonToken);
	}

	public static NamespaceDeclarationSyntax NamespaceDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxList<SyntaxToken> modifiers, SyntaxToken namespaceKeyword, NameSyntax name, SyntaxToken openBraceToken, SyntaxList<ExternAliasDirectiveSyntax> externs, SyntaxList<UsingDirectiveSyntax> usings, SyntaxList<MemberDeclarationSyntax> members, SyntaxToken closeBraceToken, SyntaxToken? semicolonToken)
	{
		return new NamespaceDeclarationSyntax(SyntaxKind.NamespaceDeclaration, attributeLists.Node, modifiers.Node, namespaceKeyword, name, openBraceToken, externs.Node, usings.Node, members.Node, closeBraceToken, semicolonToken);
	}

	public static FileScopedNamespaceDeclarationSyntax FileScopedNamespaceDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxList<SyntaxToken> modifiers, SyntaxToken namespaceKeyword, NameSyntax name, SyntaxToken semicolonToken, SyntaxList<ExternAliasDirectiveSyntax> externs, SyntaxList<UsingDirectiveSyntax> usings, SyntaxList<MemberDeclarationSyntax> members)
	{
		return new FileScopedNamespaceDeclarationSyntax(SyntaxKind.FileScopedNamespaceDeclaration, attributeLists.Node, modifiers.Node, namespaceKeyword, name, semicolonToken, externs.Node, usings.Node, members.Node);
	}

	public static AttributeListSyntax AttributeList(SyntaxToken openBracketToken, AttributeTargetSpecifierSyntax? target, SeparatedSyntaxList<AttributeSyntax> attributes, SyntaxToken closeBracketToken)
	{
		return new AttributeListSyntax(SyntaxKind.AttributeList, openBracketToken, target, attributes.Node, closeBracketToken);
	}

	public static AttributeTargetSpecifierSyntax AttributeTargetSpecifier(SyntaxToken identifier, SyntaxToken colonToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8848, (GreenNode)(object)identifier, (GreenNode)(object)colonToken, ref num);
		if (val != null)
		{
			return (AttributeTargetSpecifierSyntax)(object)val;
		}
		AttributeTargetSpecifierSyntax attributeTargetSpecifierSyntax = new AttributeTargetSpecifierSyntax(SyntaxKind.AttributeTargetSpecifier, identifier, colonToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)attributeTargetSpecifierSyntax, num);
		}
		return attributeTargetSpecifierSyntax;
	}

	public static AttributeSyntax Attribute(NameSyntax name, AttributeArgumentListSyntax? argumentList)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8849, (GreenNode)(object)name, (GreenNode)(object)argumentList, ref num);
		if (val != null)
		{
			return (AttributeSyntax)(object)val;
		}
		AttributeSyntax attributeSyntax = new AttributeSyntax(SyntaxKind.Attribute, name, argumentList);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)attributeSyntax, num);
		}
		return attributeSyntax;
	}

	public static AttributeArgumentListSyntax AttributeArgumentList(SyntaxToken openParenToken, SeparatedSyntaxList<AttributeArgumentSyntax> arguments, SyntaxToken closeParenToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8850, (GreenNode)(object)openParenToken, arguments.Node, (GreenNode)(object)closeParenToken, ref num);
		if (val != null)
		{
			return (AttributeArgumentListSyntax)(object)val;
		}
		AttributeArgumentListSyntax attributeArgumentListSyntax = new AttributeArgumentListSyntax(SyntaxKind.AttributeArgumentList, openParenToken, arguments.Node, closeParenToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)attributeArgumentListSyntax, num);
		}
		return attributeArgumentListSyntax;
	}

	public static AttributeArgumentSyntax AttributeArgument(NameEqualsSyntax? nameEquals, NameColonSyntax? nameColon, ExpressionSyntax expression)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8851, (GreenNode)(object)nameEquals, (GreenNode)(object)nameColon, (GreenNode)(object)expression, ref num);
		if (val != null)
		{
			return (AttributeArgumentSyntax)(object)val;
		}
		AttributeArgumentSyntax attributeArgumentSyntax = new AttributeArgumentSyntax(SyntaxKind.AttributeArgument, nameEquals, nameColon, expression);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)attributeArgumentSyntax, num);
		}
		return attributeArgumentSyntax;
	}

	public static NameEqualsSyntax NameEquals(IdentifierNameSyntax name, SyntaxToken equalsToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8852, (GreenNode)(object)name, (GreenNode)(object)equalsToken, ref num);
		if (val != null)
		{
			return (NameEqualsSyntax)(object)val;
		}
		NameEqualsSyntax nameEqualsSyntax = new NameEqualsSyntax(SyntaxKind.NameEquals, name, equalsToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)nameEqualsSyntax, num);
		}
		return nameEqualsSyntax;
	}

	public static TypeParameterListSyntax TypeParameterList(SyntaxToken lessThanToken, SeparatedSyntaxList<TypeParameterSyntax> parameters, SyntaxToken greaterThanToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8909, (GreenNode)(object)lessThanToken, parameters.Node, (GreenNode)(object)greaterThanToken, ref num);
		if (val != null)
		{
			return (TypeParameterListSyntax)(object)val;
		}
		TypeParameterListSyntax typeParameterListSyntax = new TypeParameterListSyntax(SyntaxKind.TypeParameterList, lessThanToken, parameters.Node, greaterThanToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)typeParameterListSyntax, num);
		}
		return typeParameterListSyntax;
	}

	public static TypeParameterSyntax TypeParameter(SyntaxList<AttributeListSyntax> attributeLists, SyntaxToken? varianceKeyword, SyntaxToken identifier)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8910, attributeLists.Node, (GreenNode)(object)varianceKeyword, (GreenNode)(object)identifier, ref num);
		if (val != null)
		{
			return (TypeParameterSyntax)(object)val;
		}
		TypeParameterSyntax typeParameterSyntax = new TypeParameterSyntax(SyntaxKind.TypeParameter, attributeLists.Node, varianceKeyword, identifier);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)typeParameterSyntax, num);
		}
		return typeParameterSyntax;
	}

	public static ClassDeclarationSyntax ClassDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxList<SyntaxToken> modifiers, SyntaxToken keyword, SyntaxToken identifier, TypeParameterListSyntax? typeParameterList, ParameterListSyntax? parameterList, BaseListSyntax? baseList, SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxToken? openBraceToken, SyntaxList<MemberDeclarationSyntax> members, SyntaxToken? closeBraceToken, SyntaxToken? semicolonToken)
	{
		return new ClassDeclarationSyntax(SyntaxKind.ClassDeclaration, attributeLists.Node, modifiers.Node, keyword, identifier, typeParameterList, parameterList, baseList, constraintClauses.Node, openBraceToken, members.Node, closeBraceToken, semicolonToken);
	}

	public static StructDeclarationSyntax StructDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxList<SyntaxToken> modifiers, SyntaxToken keyword, SyntaxToken identifier, TypeParameterListSyntax? typeParameterList, ParameterListSyntax? parameterList, BaseListSyntax? baseList, SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxToken? openBraceToken, SyntaxList<MemberDeclarationSyntax> members, SyntaxToken? closeBraceToken, SyntaxToken? semicolonToken)
	{
		return new StructDeclarationSyntax(SyntaxKind.StructDeclaration, attributeLists.Node, modifiers.Node, keyword, identifier, typeParameterList, parameterList, baseList, constraintClauses.Node, openBraceToken, members.Node, closeBraceToken, semicolonToken);
	}

	public static InterfaceDeclarationSyntax InterfaceDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxList<SyntaxToken> modifiers, SyntaxToken keyword, SyntaxToken identifier, TypeParameterListSyntax? typeParameterList, ParameterListSyntax? parameterList, BaseListSyntax? baseList, SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxToken? openBraceToken, SyntaxList<MemberDeclarationSyntax> members, SyntaxToken? closeBraceToken, SyntaxToken? semicolonToken)
	{
		return new InterfaceDeclarationSyntax(SyntaxKind.InterfaceDeclaration, attributeLists.Node, modifiers.Node, keyword, identifier, typeParameterList, parameterList, baseList, constraintClauses.Node, openBraceToken, members.Node, closeBraceToken, semicolonToken);
	}

	public static RecordDeclarationSyntax RecordDeclaration(SyntaxKind kind, SyntaxList<AttributeListSyntax> attributeLists, SyntaxList<SyntaxToken> modifiers, SyntaxToken keyword, SyntaxToken? classOrStructKeyword, SyntaxToken identifier, TypeParameterListSyntax? typeParameterList, ParameterListSyntax? parameterList, BaseListSyntax? baseList, SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxToken? openBraceToken, SyntaxList<MemberDeclarationSyntax> members, SyntaxToken? closeBraceToken, SyntaxToken? semicolonToken)
	{
		if (kind != SyntaxKind.RecordDeclaration && kind != SyntaxKind.RecordStructDeclaration)
		{
			throw new ArgumentException("kind");
		}
		return new RecordDeclarationSyntax(kind, attributeLists.Node, modifiers.Node, keyword, classOrStructKeyword, identifier, typeParameterList, parameterList, baseList, constraintClauses.Node, openBraceToken, members.Node, closeBraceToken, semicolonToken);
	}

	public static EnumDeclarationSyntax EnumDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxList<SyntaxToken> modifiers, SyntaxToken enumKeyword, SyntaxToken identifier, BaseListSyntax? baseList, SyntaxToken? openBraceToken, SeparatedSyntaxList<EnumMemberDeclarationSyntax> members, SyntaxToken? closeBraceToken, SyntaxToken? semicolonToken)
	{
		return new EnumDeclarationSyntax(SyntaxKind.EnumDeclaration, attributeLists.Node, modifiers.Node, enumKeyword, identifier, baseList, openBraceToken, members.Node, closeBraceToken, semicolonToken);
	}

	public static DelegateDeclarationSyntax DelegateDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxList<SyntaxToken> modifiers, SyntaxToken delegateKeyword, TypeSyntax returnType, SyntaxToken identifier, TypeParameterListSyntax? typeParameterList, ParameterListSyntax parameterList, SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxToken semicolonToken)
	{
		return new DelegateDeclarationSyntax(SyntaxKind.DelegateDeclaration, attributeLists.Node, modifiers.Node, delegateKeyword, returnType, identifier, typeParameterList, parameterList, constraintClauses.Node, semicolonToken);
	}

	public static EnumMemberDeclarationSyntax EnumMemberDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxList<SyntaxToken> modifiers, SyntaxToken identifier, EqualsValueClauseSyntax? equalsValue)
	{
		return new EnumMemberDeclarationSyntax(SyntaxKind.EnumMemberDeclaration, attributeLists.Node, modifiers.Node, identifier, equalsValue);
	}

	public static BaseListSyntax BaseList(SyntaxToken colonToken, SeparatedSyntaxList<BaseTypeSyntax> types)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8864, (GreenNode)(object)colonToken, types.Node, ref num);
		if (val != null)
		{
			return (BaseListSyntax)(object)val;
		}
		BaseListSyntax baseListSyntax = new BaseListSyntax(SyntaxKind.BaseList, colonToken, types.Node);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)baseListSyntax, num);
		}
		return baseListSyntax;
	}

	public static SimpleBaseTypeSyntax SimpleBaseType(TypeSyntax type)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8865, (GreenNode)(object)type, ref num);
		if (val != null)
		{
			return (SimpleBaseTypeSyntax)(object)val;
		}
		SimpleBaseTypeSyntax simpleBaseTypeSyntax = new SimpleBaseTypeSyntax(SyntaxKind.SimpleBaseType, type);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)simpleBaseTypeSyntax, num);
		}
		return simpleBaseTypeSyntax;
	}

	public static PrimaryConstructorBaseTypeSyntax PrimaryConstructorBaseType(TypeSyntax type, ArgumentListSyntax argumentList)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(9065, (GreenNode)(object)type, (GreenNode)(object)argumentList, ref num);
		if (val != null)
		{
			return (PrimaryConstructorBaseTypeSyntax)(object)val;
		}
		PrimaryConstructorBaseTypeSyntax primaryConstructorBaseTypeSyntax = new PrimaryConstructorBaseTypeSyntax(SyntaxKind.PrimaryConstructorBaseType, type, argumentList);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)primaryConstructorBaseTypeSyntax, num);
		}
		return primaryConstructorBaseTypeSyntax;
	}

	public static TypeParameterConstraintClauseSyntax TypeParameterConstraintClause(SyntaxToken whereKeyword, IdentifierNameSyntax name, SyntaxToken colonToken, SeparatedSyntaxList<TypeParameterConstraintSyntax> constraints)
	{
		return new TypeParameterConstraintClauseSyntax(SyntaxKind.TypeParameterConstraintClause, whereKeyword, name, colonToken, constraints.Node);
	}

	public static ConstructorConstraintSyntax ConstructorConstraint(SyntaxToken newKeyword, SyntaxToken openParenToken, SyntaxToken closeParenToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8867, (GreenNode)(object)newKeyword, (GreenNode)(object)openParenToken, (GreenNode)(object)closeParenToken, ref num);
		if (val != null)
		{
			return (ConstructorConstraintSyntax)(object)val;
		}
		ConstructorConstraintSyntax constructorConstraintSyntax = new ConstructorConstraintSyntax(SyntaxKind.ConstructorConstraint, newKeyword, openParenToken, closeParenToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)constructorConstraintSyntax, num);
		}
		return constructorConstraintSyntax;
	}

	public static ClassOrStructConstraintSyntax ClassOrStructConstraint(SyntaxKind kind, SyntaxToken classOrStructKeyword, SyntaxToken? questionToken)
	{
		if (kind - 8868 > SyntaxKind.List)
		{
			throw new ArgumentException("kind");
		}
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode((int)kind, (GreenNode)(object)classOrStructKeyword, (GreenNode)(object)questionToken, ref num);
		if (val != null)
		{
			return (ClassOrStructConstraintSyntax)(object)val;
		}
		ClassOrStructConstraintSyntax classOrStructConstraintSyntax = new ClassOrStructConstraintSyntax(kind, classOrStructKeyword, questionToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)classOrStructConstraintSyntax, num);
		}
		return classOrStructConstraintSyntax;
	}

	public static TypeConstraintSyntax TypeConstraint(TypeSyntax type)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8870, (GreenNode)(object)type, ref num);
		if (val != null)
		{
			return (TypeConstraintSyntax)(object)val;
		}
		TypeConstraintSyntax typeConstraintSyntax = new TypeConstraintSyntax(SyntaxKind.TypeConstraint, type);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)typeConstraintSyntax, num);
		}
		return typeConstraintSyntax;
	}

	public static DefaultConstraintSyntax DefaultConstraint(SyntaxToken defaultKeyword)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(9064, (GreenNode)(object)defaultKeyword, ref num);
		if (val != null)
		{
			return (DefaultConstraintSyntax)(object)val;
		}
		DefaultConstraintSyntax defaultConstraintSyntax = new DefaultConstraintSyntax(SyntaxKind.DefaultConstraint, defaultKeyword);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)defaultConstraintSyntax, num);
		}
		return defaultConstraintSyntax;
	}

	public static FieldDeclarationSyntax FieldDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxList<SyntaxToken> modifiers, VariableDeclarationSyntax declaration, SyntaxToken semicolonToken)
	{
		return new FieldDeclarationSyntax(SyntaxKind.FieldDeclaration, attributeLists.Node, modifiers.Node, declaration, semicolonToken);
	}

	public static EventFieldDeclarationSyntax EventFieldDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxList<SyntaxToken> modifiers, SyntaxToken eventKeyword, VariableDeclarationSyntax declaration, SyntaxToken semicolonToken)
	{
		return new EventFieldDeclarationSyntax(SyntaxKind.EventFieldDeclaration, attributeLists.Node, modifiers.Node, eventKeyword, declaration, semicolonToken);
	}

	public static ExplicitInterfaceSpecifierSyntax ExplicitInterfaceSpecifier(NameSyntax name, SyntaxToken dotToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8871, (GreenNode)(object)name, (GreenNode)(object)dotToken, ref num);
		if (val != null)
		{
			return (ExplicitInterfaceSpecifierSyntax)(object)val;
		}
		ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifierSyntax = new ExplicitInterfaceSpecifierSyntax(SyntaxKind.ExplicitInterfaceSpecifier, name, dotToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)explicitInterfaceSpecifierSyntax, num);
		}
		return explicitInterfaceSpecifierSyntax;
	}

	public static MethodDeclarationSyntax MethodDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxList<SyntaxToken> modifiers, TypeSyntax returnType, ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken identifier, TypeParameterListSyntax? typeParameterList, ParameterListSyntax parameterList, SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken)
	{
		return new MethodDeclarationSyntax(SyntaxKind.MethodDeclaration, attributeLists.Node, modifiers.Node, returnType, explicitInterfaceSpecifier, identifier, typeParameterList, parameterList, constraintClauses.Node, body, expressionBody, semicolonToken);
	}

	public static OperatorDeclarationSyntax OperatorDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxList<SyntaxToken> modifiers, TypeSyntax returnType, ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken operatorKeyword, SyntaxToken? checkedKeyword, SyntaxToken operatorToken, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken)
	{
		return new OperatorDeclarationSyntax(SyntaxKind.OperatorDeclaration, attributeLists.Node, modifiers.Node, returnType, explicitInterfaceSpecifier, operatorKeyword, checkedKeyword, operatorToken, parameterList, body, expressionBody, semicolonToken);
	}

	public static ConversionOperatorDeclarationSyntax ConversionOperatorDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxList<SyntaxToken> modifiers, SyntaxToken implicitOrExplicitKeyword, ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken operatorKeyword, SyntaxToken? checkedKeyword, TypeSyntax type, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken)
	{
		return new ConversionOperatorDeclarationSyntax(SyntaxKind.ConversionOperatorDeclaration, attributeLists.Node, modifiers.Node, implicitOrExplicitKeyword, explicitInterfaceSpecifier, operatorKeyword, checkedKeyword, type, parameterList, body, expressionBody, semicolonToken);
	}

	public static ConstructorDeclarationSyntax ConstructorDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxList<SyntaxToken> modifiers, SyntaxToken identifier, ParameterListSyntax parameterList, ConstructorInitializerSyntax? initializer, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken)
	{
		return new ConstructorDeclarationSyntax(SyntaxKind.ConstructorDeclaration, attributeLists.Node, modifiers.Node, identifier, parameterList, initializer, body, expressionBody, semicolonToken);
	}

	public static ConstructorInitializerSyntax ConstructorInitializer(SyntaxKind kind, SyntaxToken colonToken, SyntaxToken thisOrBaseKeyword, ArgumentListSyntax argumentList)
	{
		if (kind - 8889 > SyntaxKind.List)
		{
			throw new ArgumentException("kind");
		}
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode((int)kind, (GreenNode)(object)colonToken, (GreenNode)(object)thisOrBaseKeyword, (GreenNode)(object)argumentList, ref num);
		if (val != null)
		{
			return (ConstructorInitializerSyntax)(object)val;
		}
		ConstructorInitializerSyntax constructorInitializerSyntax = new ConstructorInitializerSyntax(kind, colonToken, thisOrBaseKeyword, argumentList);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)constructorInitializerSyntax, num);
		}
		return constructorInitializerSyntax;
	}

	public static DestructorDeclarationSyntax DestructorDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxList<SyntaxToken> modifiers, SyntaxToken tildeToken, SyntaxToken identifier, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken)
	{
		return new DestructorDeclarationSyntax(SyntaxKind.DestructorDeclaration, attributeLists.Node, modifiers.Node, tildeToken, identifier, parameterList, body, expressionBody, semicolonToken);
	}

	public static PropertyDeclarationSyntax PropertyDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxList<SyntaxToken> modifiers, TypeSyntax type, ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken identifier, AccessorListSyntax? accessorList, ArrowExpressionClauseSyntax? expressionBody, EqualsValueClauseSyntax? initializer, SyntaxToken? semicolonToken)
	{
		return new PropertyDeclarationSyntax(SyntaxKind.PropertyDeclaration, attributeLists.Node, modifiers.Node, type, explicitInterfaceSpecifier, identifier, accessorList, expressionBody, initializer, semicolonToken);
	}

	public static ArrowExpressionClauseSyntax ArrowExpressionClause(SyntaxToken arrowToken, ExpressionSyntax expression)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8917, (GreenNode)(object)arrowToken, (GreenNode)(object)expression, ref num);
		if (val != null)
		{
			return (ArrowExpressionClauseSyntax)(object)val;
		}
		ArrowExpressionClauseSyntax arrowExpressionClauseSyntax = new ArrowExpressionClauseSyntax(SyntaxKind.ArrowExpressionClause, arrowToken, expression);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)arrowExpressionClauseSyntax, num);
		}
		return arrowExpressionClauseSyntax;
	}

	public static EventDeclarationSyntax EventDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxList<SyntaxToken> modifiers, SyntaxToken eventKeyword, TypeSyntax type, ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken identifier, AccessorListSyntax? accessorList, SyntaxToken? semicolonToken)
	{
		return new EventDeclarationSyntax(SyntaxKind.EventDeclaration, attributeLists.Node, modifiers.Node, eventKeyword, type, explicitInterfaceSpecifier, identifier, accessorList, semicolonToken);
	}

	public static IndexerDeclarationSyntax IndexerDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxList<SyntaxToken> modifiers, TypeSyntax type, ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken thisKeyword, BracketedParameterListSyntax parameterList, AccessorListSyntax? accessorList, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken)
	{
		return new IndexerDeclarationSyntax(SyntaxKind.IndexerDeclaration, attributeLists.Node, modifiers.Node, type, explicitInterfaceSpecifier, thisKeyword, parameterList, accessorList, expressionBody, semicolonToken);
	}

	public static AccessorListSyntax AccessorList(SyntaxToken openBraceToken, SyntaxList<AccessorDeclarationSyntax> accessors, SyntaxToken closeBraceToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8895, (GreenNode)(object)openBraceToken, accessors.Node, (GreenNode)(object)closeBraceToken, ref num);
		if (val != null)
		{
			return (AccessorListSyntax)(object)val;
		}
		AccessorListSyntax accessorListSyntax = new AccessorListSyntax(SyntaxKind.AccessorList, openBraceToken, accessors.Node, closeBraceToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)accessorListSyntax, num);
		}
		return accessorListSyntax;
	}

	public static AccessorDeclarationSyntax AccessorDeclaration(SyntaxKind kind, SyntaxList<AttributeListSyntax> attributeLists, SyntaxList<SyntaxToken> modifiers, SyntaxToken keyword, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken)
	{
		if (kind - 8896 > (SyntaxKind)4 && kind != SyntaxKind.InitAccessorDeclaration)
		{
			throw new ArgumentException("kind");
		}
		return new AccessorDeclarationSyntax(kind, attributeLists.Node, modifiers.Node, keyword, body, expressionBody, semicolonToken);
	}

	public static ParameterListSyntax ParameterList(SyntaxToken openParenToken, SeparatedSyntaxList<ParameterSyntax> parameters, SyntaxToken closeParenToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8906, (GreenNode)(object)openParenToken, parameters.Node, (GreenNode)(object)closeParenToken, ref num);
		if (val != null)
		{
			return (ParameterListSyntax)(object)val;
		}
		ParameterListSyntax parameterListSyntax = new ParameterListSyntax(SyntaxKind.ParameterList, openParenToken, parameters.Node, closeParenToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)parameterListSyntax, num);
		}
		return parameterListSyntax;
	}

	public static BracketedParameterListSyntax BracketedParameterList(SyntaxToken openBracketToken, SeparatedSyntaxList<ParameterSyntax> parameters, SyntaxToken closeBracketToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8907, (GreenNode)(object)openBracketToken, parameters.Node, (GreenNode)(object)closeBracketToken, ref num);
		if (val != null)
		{
			return (BracketedParameterListSyntax)(object)val;
		}
		BracketedParameterListSyntax bracketedParameterListSyntax = new BracketedParameterListSyntax(SyntaxKind.BracketedParameterList, openBracketToken, parameters.Node, closeBracketToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)bracketedParameterListSyntax, num);
		}
		return bracketedParameterListSyntax;
	}

	public static ParameterSyntax Parameter(SyntaxList<AttributeListSyntax> attributeLists, SyntaxList<SyntaxToken> modifiers, TypeSyntax? type, SyntaxToken identifier, EqualsValueClauseSyntax? @default)
	{
		return new ParameterSyntax(SyntaxKind.Parameter, attributeLists.Node, modifiers.Node, type, identifier, @default);
	}

	public static FunctionPointerParameterSyntax FunctionPointerParameter(SyntaxList<AttributeListSyntax> attributeLists, SyntaxList<SyntaxToken> modifiers, TypeSyntax type)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(9057, attributeLists.Node, modifiers.Node, (GreenNode)(object)type, ref num);
		if (val != null)
		{
			return (FunctionPointerParameterSyntax)(object)val;
		}
		FunctionPointerParameterSyntax functionPointerParameterSyntax = new FunctionPointerParameterSyntax(SyntaxKind.FunctionPointerParameter, attributeLists.Node, modifiers.Node, type);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)functionPointerParameterSyntax, num);
		}
		return functionPointerParameterSyntax;
	}

	public static IncompleteMemberSyntax IncompleteMember(SyntaxList<AttributeListSyntax> attributeLists, SyntaxList<SyntaxToken> modifiers, TypeSyntax? type)
	{
		return new IncompleteMemberSyntax(SyntaxKind.IncompleteMember, attributeLists.Node, modifiers.Node, type);
	}

	public static SkippedTokensTriviaSyntax SkippedTokensTrivia(SyntaxList<SyntaxToken> tokens)
	{
		return new SkippedTokensTriviaSyntax(SyntaxKind.SkippedTokensTrivia, tokens.Node);
	}

	public static DocumentationCommentTriviaSyntax DocumentationCommentTrivia(SyntaxKind kind, SyntaxList<XmlNodeSyntax> content, SyntaxToken endOfComment)
	{
		if (kind - 8544 > SyntaxKind.List)
		{
			throw new ArgumentException("kind");
		}
		return new DocumentationCommentTriviaSyntax(kind, content.Node, endOfComment);
	}

	public static TypeCrefSyntax TypeCref(TypeSyntax type)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8597, (GreenNode)(object)type, ref num);
		if (val != null)
		{
			return (TypeCrefSyntax)(object)val;
		}
		TypeCrefSyntax typeCrefSyntax = new TypeCrefSyntax(SyntaxKind.TypeCref, type);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)typeCrefSyntax, num);
		}
		return typeCrefSyntax;
	}

	public static QualifiedCrefSyntax QualifiedCref(TypeSyntax container, SyntaxToken dotToken, MemberCrefSyntax member)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8598, (GreenNode)(object)container, (GreenNode)(object)dotToken, (GreenNode)(object)member, ref num);
		if (val != null)
		{
			return (QualifiedCrefSyntax)(object)val;
		}
		QualifiedCrefSyntax qualifiedCrefSyntax = new QualifiedCrefSyntax(SyntaxKind.QualifiedCref, container, dotToken, member);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)qualifiedCrefSyntax, num);
		}
		return qualifiedCrefSyntax;
	}

	public static NameMemberCrefSyntax NameMemberCref(TypeSyntax name, CrefParameterListSyntax? parameters)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8599, (GreenNode)(object)name, (GreenNode)(object)parameters, ref num);
		if (val != null)
		{
			return (NameMemberCrefSyntax)(object)val;
		}
		NameMemberCrefSyntax nameMemberCrefSyntax = new NameMemberCrefSyntax(SyntaxKind.NameMemberCref, name, parameters);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)nameMemberCrefSyntax, num);
		}
		return nameMemberCrefSyntax;
	}

	public static IndexerMemberCrefSyntax IndexerMemberCref(SyntaxToken thisKeyword, CrefBracketedParameterListSyntax? parameters)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8600, (GreenNode)(object)thisKeyword, (GreenNode)(object)parameters, ref num);
		if (val != null)
		{
			return (IndexerMemberCrefSyntax)(object)val;
		}
		IndexerMemberCrefSyntax indexerMemberCrefSyntax = new IndexerMemberCrefSyntax(SyntaxKind.IndexerMemberCref, thisKeyword, parameters);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)indexerMemberCrefSyntax, num);
		}
		return indexerMemberCrefSyntax;
	}

	public static OperatorMemberCrefSyntax OperatorMemberCref(SyntaxToken operatorKeyword, SyntaxToken? checkedKeyword, SyntaxToken operatorToken, CrefParameterListSyntax? parameters)
	{
		return new OperatorMemberCrefSyntax(SyntaxKind.OperatorMemberCref, operatorKeyword, checkedKeyword, operatorToken, parameters);
	}

	public static ConversionOperatorMemberCrefSyntax ConversionOperatorMemberCref(SyntaxToken implicitOrExplicitKeyword, SyntaxToken operatorKeyword, SyntaxToken? checkedKeyword, TypeSyntax type, CrefParameterListSyntax? parameters)
	{
		return new ConversionOperatorMemberCrefSyntax(SyntaxKind.ConversionOperatorMemberCref, implicitOrExplicitKeyword, operatorKeyword, checkedKeyword, type, parameters);
	}

	public static CrefParameterListSyntax CrefParameterList(SyntaxToken openParenToken, SeparatedSyntaxList<CrefParameterSyntax> parameters, SyntaxToken closeParenToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8603, (GreenNode)(object)openParenToken, parameters.Node, (GreenNode)(object)closeParenToken, ref num);
		if (val != null)
		{
			return (CrefParameterListSyntax)(object)val;
		}
		CrefParameterListSyntax crefParameterListSyntax = new CrefParameterListSyntax(SyntaxKind.CrefParameterList, openParenToken, parameters.Node, closeParenToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)crefParameterListSyntax, num);
		}
		return crefParameterListSyntax;
	}

	public static CrefBracketedParameterListSyntax CrefBracketedParameterList(SyntaxToken openBracketToken, SeparatedSyntaxList<CrefParameterSyntax> parameters, SyntaxToken closeBracketToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8604, (GreenNode)(object)openBracketToken, parameters.Node, (GreenNode)(object)closeBracketToken, ref num);
		if (val != null)
		{
			return (CrefBracketedParameterListSyntax)(object)val;
		}
		CrefBracketedParameterListSyntax crefBracketedParameterListSyntax = new CrefBracketedParameterListSyntax(SyntaxKind.CrefBracketedParameterList, openBracketToken, parameters.Node, closeBracketToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)crefBracketedParameterListSyntax, num);
		}
		return crefBracketedParameterListSyntax;
	}

	public static CrefParameterSyntax CrefParameter(SyntaxToken? refKindKeyword, SyntaxToken? readOnlyKeyword, TypeSyntax type)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8605, (GreenNode)(object)refKindKeyword, (GreenNode)(object)readOnlyKeyword, (GreenNode)(object)type, ref num);
		if (val != null)
		{
			return (CrefParameterSyntax)(object)val;
		}
		CrefParameterSyntax crefParameterSyntax = new CrefParameterSyntax(SyntaxKind.CrefParameter, refKindKeyword, readOnlyKeyword, type);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)crefParameterSyntax, num);
		}
		return crefParameterSyntax;
	}

	public static XmlElementSyntax XmlElement(XmlElementStartTagSyntax startTag, SyntaxList<XmlNodeSyntax> content, XmlElementEndTagSyntax endTag)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8574, (GreenNode)(object)startTag, content.Node, (GreenNode)(object)endTag, ref num);
		if (val != null)
		{
			return (XmlElementSyntax)(object)val;
		}
		XmlElementSyntax xmlElementSyntax = new XmlElementSyntax(SyntaxKind.XmlElement, startTag, content.Node, endTag);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)xmlElementSyntax, num);
		}
		return xmlElementSyntax;
	}

	public static XmlElementStartTagSyntax XmlElementStartTag(SyntaxToken lessThanToken, XmlNameSyntax name, SyntaxList<XmlAttributeSyntax> attributes, SyntaxToken greaterThanToken)
	{
		return new XmlElementStartTagSyntax(SyntaxKind.XmlElementStartTag, lessThanToken, name, attributes.Node, greaterThanToken);
	}

	public static XmlElementEndTagSyntax XmlElementEndTag(SyntaxToken lessThanSlashToken, XmlNameSyntax name, SyntaxToken greaterThanToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8576, (GreenNode)(object)lessThanSlashToken, (GreenNode)(object)name, (GreenNode)(object)greaterThanToken, ref num);
		if (val != null)
		{
			return (XmlElementEndTagSyntax)(object)val;
		}
		XmlElementEndTagSyntax xmlElementEndTagSyntax = new XmlElementEndTagSyntax(SyntaxKind.XmlElementEndTag, lessThanSlashToken, name, greaterThanToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)xmlElementEndTagSyntax, num);
		}
		return xmlElementEndTagSyntax;
	}

	public static XmlEmptyElementSyntax XmlEmptyElement(SyntaxToken lessThanToken, XmlNameSyntax name, SyntaxList<XmlAttributeSyntax> attributes, SyntaxToken slashGreaterThanToken)
	{
		return new XmlEmptyElementSyntax(SyntaxKind.XmlEmptyElement, lessThanToken, name, attributes.Node, slashGreaterThanToken);
	}

	public static XmlNameSyntax XmlName(XmlPrefixSyntax? prefix, SyntaxToken localName)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8581, (GreenNode)(object)prefix, (GreenNode)(object)localName, ref num);
		if (val != null)
		{
			return (XmlNameSyntax)(object)val;
		}
		XmlNameSyntax xmlNameSyntax = new XmlNameSyntax(SyntaxKind.XmlName, prefix, localName);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)xmlNameSyntax, num);
		}
		return xmlNameSyntax;
	}

	public static XmlPrefixSyntax XmlPrefix(SyntaxToken prefix, SyntaxToken colonToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8582, (GreenNode)(object)prefix, (GreenNode)(object)colonToken, ref num);
		if (val != null)
		{
			return (XmlPrefixSyntax)(object)val;
		}
		XmlPrefixSyntax xmlPrefixSyntax = new XmlPrefixSyntax(SyntaxKind.XmlPrefix, prefix, colonToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)xmlPrefixSyntax, num);
		}
		return xmlPrefixSyntax;
	}

	public static XmlTextAttributeSyntax XmlTextAttribute(XmlNameSyntax name, SyntaxToken equalsToken, SyntaxToken startQuoteToken, SyntaxList<SyntaxToken> textTokens, SyntaxToken endQuoteToken)
	{
		return new XmlTextAttributeSyntax(SyntaxKind.XmlTextAttribute, name, equalsToken, startQuoteToken, textTokens.Node, endQuoteToken);
	}

	public static XmlCrefAttributeSyntax XmlCrefAttribute(XmlNameSyntax name, SyntaxToken equalsToken, SyntaxToken startQuoteToken, CrefSyntax cref, SyntaxToken endQuoteToken)
	{
		return new XmlCrefAttributeSyntax(SyntaxKind.XmlCrefAttribute, name, equalsToken, startQuoteToken, cref, endQuoteToken);
	}

	public static XmlNameAttributeSyntax XmlNameAttribute(XmlNameSyntax name, SyntaxToken equalsToken, SyntaxToken startQuoteToken, IdentifierNameSyntax identifier, SyntaxToken endQuoteToken)
	{
		return new XmlNameAttributeSyntax(SyntaxKind.XmlNameAttribute, name, equalsToken, startQuoteToken, identifier, endQuoteToken);
	}

	public static XmlTextSyntax XmlText(SyntaxList<SyntaxToken> textTokens)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8583, textTokens.Node, ref num);
		if (val != null)
		{
			return (XmlTextSyntax)(object)val;
		}
		XmlTextSyntax xmlTextSyntax = new XmlTextSyntax(SyntaxKind.XmlText, textTokens.Node);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)xmlTextSyntax, num);
		}
		return xmlTextSyntax;
	}

	public static XmlCDataSectionSyntax XmlCDataSection(SyntaxToken startCDataToken, SyntaxList<SyntaxToken> textTokens, SyntaxToken endCDataToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8584, (GreenNode)(object)startCDataToken, textTokens.Node, (GreenNode)(object)endCDataToken, ref num);
		if (val != null)
		{
			return (XmlCDataSectionSyntax)(object)val;
		}
		XmlCDataSectionSyntax xmlCDataSectionSyntax = new XmlCDataSectionSyntax(SyntaxKind.XmlCDataSection, startCDataToken, textTokens.Node, endCDataToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)xmlCDataSectionSyntax, num);
		}
		return xmlCDataSectionSyntax;
	}

	public static XmlProcessingInstructionSyntax XmlProcessingInstruction(SyntaxToken startProcessingInstructionToken, XmlNameSyntax name, SyntaxList<SyntaxToken> textTokens, SyntaxToken endProcessingInstructionToken)
	{
		return new XmlProcessingInstructionSyntax(SyntaxKind.XmlProcessingInstruction, startProcessingInstructionToken, name, textTokens.Node, endProcessingInstructionToken);
	}

	public static XmlCommentSyntax XmlComment(SyntaxToken lessThanExclamationMinusMinusToken, SyntaxList<SyntaxToken> textTokens, SyntaxToken minusMinusGreaterThanToken)
	{
		int num = default(int);
		GreenNode val = SyntaxNodeCache.TryGetNode(8585, (GreenNode)(object)lessThanExclamationMinusMinusToken, textTokens.Node, (GreenNode)(object)minusMinusGreaterThanToken, ref num);
		if (val != null)
		{
			return (XmlCommentSyntax)(object)val;
		}
		XmlCommentSyntax xmlCommentSyntax = new XmlCommentSyntax(SyntaxKind.XmlComment, lessThanExclamationMinusMinusToken, textTokens.Node, minusMinusGreaterThanToken);
		if (num >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)xmlCommentSyntax, num);
		}
		return xmlCommentSyntax;
	}

	public static IfDirectiveTriviaSyntax IfDirectiveTrivia(SyntaxToken hashToken, SyntaxToken ifKeyword, ExpressionSyntax condition, SyntaxToken endOfDirectiveToken, bool isActive, bool branchTaken, bool conditionValue)
	{
		return new IfDirectiveTriviaSyntax(SyntaxKind.IfDirectiveTrivia, hashToken, ifKeyword, condition, endOfDirectiveToken, isActive, branchTaken, conditionValue);
	}

	public static ElifDirectiveTriviaSyntax ElifDirectiveTrivia(SyntaxToken hashToken, SyntaxToken elifKeyword, ExpressionSyntax condition, SyntaxToken endOfDirectiveToken, bool isActive, bool branchTaken, bool conditionValue)
	{
		return new ElifDirectiveTriviaSyntax(SyntaxKind.ElifDirectiveTrivia, hashToken, elifKeyword, condition, endOfDirectiveToken, isActive, branchTaken, conditionValue);
	}

	public static ElseDirectiveTriviaSyntax ElseDirectiveTrivia(SyntaxToken hashToken, SyntaxToken elseKeyword, SyntaxToken endOfDirectiveToken, bool isActive, bool branchTaken)
	{
		return new ElseDirectiveTriviaSyntax(SyntaxKind.ElseDirectiveTrivia, hashToken, elseKeyword, endOfDirectiveToken, isActive, branchTaken);
	}

	public static EndIfDirectiveTriviaSyntax EndIfDirectiveTrivia(SyntaxToken hashToken, SyntaxToken endIfKeyword, SyntaxToken endOfDirectiveToken, bool isActive)
	{
		return new EndIfDirectiveTriviaSyntax(SyntaxKind.EndIfDirectiveTrivia, hashToken, endIfKeyword, endOfDirectiveToken, isActive);
	}

	public static RegionDirectiveTriviaSyntax RegionDirectiveTrivia(SyntaxToken hashToken, SyntaxToken regionKeyword, SyntaxToken endOfDirectiveToken, bool isActive)
	{
		return new RegionDirectiveTriviaSyntax(SyntaxKind.RegionDirectiveTrivia, hashToken, regionKeyword, endOfDirectiveToken, isActive);
	}

	public static EndRegionDirectiveTriviaSyntax EndRegionDirectiveTrivia(SyntaxToken hashToken, SyntaxToken endRegionKeyword, SyntaxToken endOfDirectiveToken, bool isActive)
	{
		return new EndRegionDirectiveTriviaSyntax(SyntaxKind.EndRegionDirectiveTrivia, hashToken, endRegionKeyword, endOfDirectiveToken, isActive);
	}

	public static ErrorDirectiveTriviaSyntax ErrorDirectiveTrivia(SyntaxToken hashToken, SyntaxToken errorKeyword, SyntaxToken endOfDirectiveToken, bool isActive)
	{
		return new ErrorDirectiveTriviaSyntax(SyntaxKind.ErrorDirectiveTrivia, hashToken, errorKeyword, endOfDirectiveToken, isActive);
	}

	public static WarningDirectiveTriviaSyntax WarningDirectiveTrivia(SyntaxToken hashToken, SyntaxToken warningKeyword, SyntaxToken endOfDirectiveToken, bool isActive)
	{
		return new WarningDirectiveTriviaSyntax(SyntaxKind.WarningDirectiveTrivia, hashToken, warningKeyword, endOfDirectiveToken, isActive);
	}

	public static BadDirectiveTriviaSyntax BadDirectiveTrivia(SyntaxToken hashToken, SyntaxToken identifier, SyntaxToken endOfDirectiveToken, bool isActive)
	{
		return new BadDirectiveTriviaSyntax(SyntaxKind.BadDirectiveTrivia, hashToken, identifier, endOfDirectiveToken, isActive);
	}

	public static DefineDirectiveTriviaSyntax DefineDirectiveTrivia(SyntaxToken hashToken, SyntaxToken defineKeyword, SyntaxToken name, SyntaxToken endOfDirectiveToken, bool isActive)
	{
		return new DefineDirectiveTriviaSyntax(SyntaxKind.DefineDirectiveTrivia, hashToken, defineKeyword, name, endOfDirectiveToken, isActive);
	}

	public static UndefDirectiveTriviaSyntax UndefDirectiveTrivia(SyntaxToken hashToken, SyntaxToken undefKeyword, SyntaxToken name, SyntaxToken endOfDirectiveToken, bool isActive)
	{
		return new UndefDirectiveTriviaSyntax(SyntaxKind.UndefDirectiveTrivia, hashToken, undefKeyword, name, endOfDirectiveToken, isActive);
	}

	public static LineDirectiveTriviaSyntax LineDirectiveTrivia(SyntaxToken hashToken, SyntaxToken lineKeyword, SyntaxToken line, SyntaxToken? file, SyntaxToken endOfDirectiveToken, bool isActive)
	{
		return new LineDirectiveTriviaSyntax(SyntaxKind.LineDirectiveTrivia, hashToken, lineKeyword, line, file, endOfDirectiveToken, isActive);
	}

	public static LineDirectivePositionSyntax LineDirectivePosition(SyntaxToken openParenToken, SyntaxToken line, SyntaxToken commaToken, SyntaxToken character, SyntaxToken closeParenToken)
	{
		return new LineDirectivePositionSyntax(SyntaxKind.LineDirectivePosition, openParenToken, line, commaToken, character, closeParenToken);
	}

	public static LineSpanDirectiveTriviaSyntax LineSpanDirectiveTrivia(SyntaxToken hashToken, SyntaxToken lineKeyword, LineDirectivePositionSyntax start, SyntaxToken minusToken, LineDirectivePositionSyntax end, SyntaxToken? characterOffset, SyntaxToken file, SyntaxToken endOfDirectiveToken, bool isActive)
	{
		return new LineSpanDirectiveTriviaSyntax(SyntaxKind.LineSpanDirectiveTrivia, hashToken, lineKeyword, start, minusToken, end, characterOffset, file, endOfDirectiveToken, isActive);
	}

	public static PragmaWarningDirectiveTriviaSyntax PragmaWarningDirectiveTrivia(SyntaxToken hashToken, SyntaxToken pragmaKeyword, SyntaxToken warningKeyword, SyntaxToken disableOrRestoreKeyword, SeparatedSyntaxList<ExpressionSyntax> errorCodes, SyntaxToken endOfDirectiveToken, bool isActive)
	{
		return new PragmaWarningDirectiveTriviaSyntax(SyntaxKind.PragmaWarningDirectiveTrivia, hashToken, pragmaKeyword, warningKeyword, disableOrRestoreKeyword, errorCodes.Node, endOfDirectiveToken, isActive);
	}

	public static PragmaChecksumDirectiveTriviaSyntax PragmaChecksumDirectiveTrivia(SyntaxToken hashToken, SyntaxToken pragmaKeyword, SyntaxToken checksumKeyword, SyntaxToken file, SyntaxToken guid, SyntaxToken bytes, SyntaxToken endOfDirectiveToken, bool isActive)
	{
		return new PragmaChecksumDirectiveTriviaSyntax(SyntaxKind.PragmaChecksumDirectiveTrivia, hashToken, pragmaKeyword, checksumKeyword, file, guid, bytes, endOfDirectiveToken, isActive);
	}

	public static ReferenceDirectiveTriviaSyntax ReferenceDirectiveTrivia(SyntaxToken hashToken, SyntaxToken referenceKeyword, SyntaxToken file, SyntaxToken endOfDirectiveToken, bool isActive)
	{
		return new ReferenceDirectiveTriviaSyntax(SyntaxKind.ReferenceDirectiveTrivia, hashToken, referenceKeyword, file, endOfDirectiveToken, isActive);
	}

	public static LoadDirectiveTriviaSyntax LoadDirectiveTrivia(SyntaxToken hashToken, SyntaxToken loadKeyword, SyntaxToken file, SyntaxToken endOfDirectiveToken, bool isActive)
	{
		return new LoadDirectiveTriviaSyntax(SyntaxKind.LoadDirectiveTrivia, hashToken, loadKeyword, file, endOfDirectiveToken, isActive);
	}

	public static ShebangDirectiveTriviaSyntax ShebangDirectiveTrivia(SyntaxToken hashToken, SyntaxToken exclamationToken, SyntaxToken endOfDirectiveToken, bool isActive)
	{
		return new ShebangDirectiveTriviaSyntax(SyntaxKind.ShebangDirectiveTrivia, hashToken, exclamationToken, endOfDirectiveToken, isActive);
	}

	public static NullableDirectiveTriviaSyntax NullableDirectiveTrivia(SyntaxToken hashToken, SyntaxToken nullableKeyword, SyntaxToken settingToken, SyntaxToken? targetToken, SyntaxToken endOfDirectiveToken, bool isActive)
	{
		return new NullableDirectiveTriviaSyntax(SyntaxKind.NullableDirectiveTrivia, hashToken, nullableKeyword, settingToken, targetToken, endOfDirectiveToken, isActive);
	}
}