PURErat-crack-scode/decompiled/Libraries/microsoft.codeanalysis.csharp/Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax/ContextAwareSyntax.cs

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

namespace Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax;

internal class ContextAwareSyntax
{
	private SyntaxFactoryContext context;

	public GlobalStatementSyntax GlobalStatement(StatementSyntax statement)
	{
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		return GlobalStatement(default(SyntaxList<AttributeListSyntax>), default(SyntaxList<SyntaxToken>), statement);
	}

	public ContextAwareSyntax(SyntaxFactoryContext context)
	{
		this.context = context;
	}

	public IdentifierNameSyntax IdentifierName(SyntaxToken identifier)
	{
		int hash;
		GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8616, (GreenNode)(object)identifier, context, out hash);
		if (val != null)
		{
			return (IdentifierNameSyntax)(object)val;
		}
		IdentifierNameSyntax identifierNameSyntax = new IdentifierNameSyntax(SyntaxKind.IdentifierName, identifier, context);
		if (hash >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)identifierNameSyntax, hash);
		}
		return identifierNameSyntax;
	}

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

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

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

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

	public PredefinedTypeSyntax PredefinedType(SyntaxToken keyword)
	{
		int hash;
		GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8621, (GreenNode)(object)keyword, context, out hash);
		if (val != null)
		{
			return (PredefinedTypeSyntax)(object)val;
		}
		PredefinedTypeSyntax predefinedTypeSyntax = new PredefinedTypeSyntax(SyntaxKind.PredefinedType, keyword, context);
		if (hash >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)predefinedTypeSyntax, hash);
		}
		return predefinedTypeSyntax;
	}

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

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

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

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

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

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

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

	public FunctionPointerUnmanagedCallingConventionSyntax FunctionPointerUnmanagedCallingConvention(SyntaxToken name)
	{
		int hash;
		GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9067, (GreenNode)(object)name, context, out hash);
		if (val != null)
		{
			return (FunctionPointerUnmanagedCallingConventionSyntax)(object)val;
		}
		FunctionPointerUnmanagedCallingConventionSyntax functionPointerUnmanagedCallingConventionSyntax = new FunctionPointerUnmanagedCallingConventionSyntax(SyntaxKind.FunctionPointerUnmanagedCallingConvention, name, context);
		if (hash >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)functionPointerUnmanagedCallingConventionSyntax, hash);
		}
		return functionPointerUnmanagedCallingConventionSyntax;
	}

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

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

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

	public OmittedTypeArgumentSyntax OmittedTypeArgument(SyntaxToken omittedTypeArgumentToken)
	{
		int hash;
		GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8626, (GreenNode)(object)omittedTypeArgumentToken, context, out hash);
		if (val != null)
		{
			return (OmittedTypeArgumentSyntax)(object)val;
		}
		OmittedTypeArgumentSyntax omittedTypeArgumentSyntax = new OmittedTypeArgumentSyntax(SyntaxKind.OmittedTypeArgument, omittedTypeArgumentToken, context);
		if (hash >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)omittedTypeArgumentSyntax, hash);
		}
		return omittedTypeArgumentSyntax;
	}

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

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

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

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

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

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

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

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

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

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

	public ElementBindingExpressionSyntax ElementBindingExpression(BracketedArgumentListSyntax argumentList)
	{
		int hash;
		GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8708, (GreenNode)(object)argumentList, context, out hash);
		if (val != null)
		{
			return (ElementBindingExpressionSyntax)(object)val;
		}
		ElementBindingExpressionSyntax elementBindingExpressionSyntax = new ElementBindingExpressionSyntax(SyntaxKind.ElementBindingExpression, argumentList, context);
		if (hash >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)elementBindingExpressionSyntax, hash);
		}
		return elementBindingExpressionSyntax;
	}

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

	public ImplicitElementAccessSyntax ImplicitElementAccess(BracketedArgumentListSyntax argumentList)
	{
		int hash;
		GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8656, (GreenNode)(object)argumentList, context, out hash);
		if (val != null)
		{
			return (ImplicitElementAccessSyntax)(object)val;
		}
		ImplicitElementAccessSyntax implicitElementAccessSyntax = new ImplicitElementAccessSyntax(SyntaxKind.ImplicitElementAccess, argumentList, context);
		if (hash >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)implicitElementAccessSyntax, hash);
		}
		return implicitElementAccessSyntax;
	}

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

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

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

	public ThisExpressionSyntax ThisExpression(SyntaxToken token)
	{
		int hash;
		GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8746, (GreenNode)(object)token, context, out hash);
		if (val != null)
		{
			return (ThisExpressionSyntax)(object)val;
		}
		ThisExpressionSyntax thisExpressionSyntax = new ThisExpressionSyntax(SyntaxKind.ThisExpression, token, context);
		if (hash >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)thisExpressionSyntax, hash);
		}
		return thisExpressionSyntax;
	}

	public BaseExpressionSyntax BaseExpression(SyntaxToken token)
	{
		int hash;
		GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8747, (GreenNode)(object)token, context, out hash);
		if (val != null)
		{
			return (BaseExpressionSyntax)(object)val;
		}
		BaseExpressionSyntax baseExpressionSyntax = new BaseExpressionSyntax(SyntaxKind.BaseExpression, token, context);
		if (hash >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)baseExpressionSyntax, hash);
		}
		return baseExpressionSyntax;
	}

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

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

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

	public 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, context);
	}

	public 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, context);
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

	public 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, context);
	}

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

	public 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, context);
	}

	public 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 hash;
		GreenNode val = CSharpSyntaxNodeCache.TryGetNode((int)kind, (GreenNode)(object)openBraceToken, expressions.Node, (GreenNode)(object)closeBraceToken, context, out hash);
		if (val != null)
		{
			return (InitializerExpressionSyntax)(object)val;
		}
		InitializerExpressionSyntax initializerExpressionSyntax = new InitializerExpressionSyntax(kind, openBraceToken, expressions.Node, closeBraceToken, context);
		if (hash >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)initializerExpressionSyntax, hash);
		}
		return initializerExpressionSyntax;
	}

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

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

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

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

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

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

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

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

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

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

	public ExpressionElementSyntax ExpressionElement(ExpressionSyntax expression)
	{
		int hash;
		GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9077, (GreenNode)(object)expression, context, out hash);
		if (val != null)
		{
			return (ExpressionElementSyntax)(object)val;
		}
		ExpressionElementSyntax expressionElementSyntax = new ExpressionElementSyntax(SyntaxKind.ExpressionElement, expression, context);
		if (hash >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)expressionElementSyntax, hash);
		}
		return expressionElementSyntax;
	}

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

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

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

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

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

	public 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, context);
	}

	public JoinIntoClauseSyntax JoinIntoClause(SyntaxToken intoKeyword, SyntaxToken identifier)
	{
		int hash;
		GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8779, (GreenNode)(object)intoKeyword, (GreenNode)(object)identifier, context, out hash);
		if (val != null)
		{
			return (JoinIntoClauseSyntax)(object)val;
		}
		JoinIntoClauseSyntax joinIntoClauseSyntax = new JoinIntoClauseSyntax(SyntaxKind.JoinIntoClause, intoKeyword, identifier, context);
		if (hash >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)joinIntoClauseSyntax, hash);
		}
		return joinIntoClauseSyntax;
	}

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

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

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

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

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

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

	public OmittedArraySizeExpressionSyntax OmittedArraySizeExpression(SyntaxToken omittedArraySizeExpressionToken)
	{
		int hash;
		GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8654, (GreenNode)(object)omittedArraySizeExpressionToken, context, out hash);
		if (val != null)
		{
			return (OmittedArraySizeExpressionSyntax)(object)val;
		}
		OmittedArraySizeExpressionSyntax omittedArraySizeExpressionSyntax = new OmittedArraySizeExpressionSyntax(SyntaxKind.OmittedArraySizeExpression, omittedArraySizeExpressionToken, context);
		if (hash >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)omittedArraySizeExpressionSyntax, hash);
		}
		return omittedArraySizeExpressionSyntax;
	}

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

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

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

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

	public DiscardPatternSyntax DiscardPattern(SyntaxToken underscoreToken)
	{
		int hash;
		GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9024, (GreenNode)(object)underscoreToken, context, out hash);
		if (val != null)
		{
			return (DiscardPatternSyntax)(object)val;
		}
		DiscardPatternSyntax discardPatternSyntax = new DiscardPatternSyntax(SyntaxKind.DiscardPattern, underscoreToken, context);
		if (hash >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)discardPatternSyntax, hash);
		}
		return discardPatternSyntax;
	}

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

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

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

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

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

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

	public ConstantPatternSyntax ConstantPattern(ExpressionSyntax expression)
	{
		int hash;
		GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9002, (GreenNode)(object)expression, context, out hash);
		if (val != null)
		{
			return (ConstantPatternSyntax)(object)val;
		}
		ConstantPatternSyntax constantPatternSyntax = new ConstantPatternSyntax(SyntaxKind.ConstantPattern, expression, context);
		if (hash >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)constantPatternSyntax, hash);
		}
		return constantPatternSyntax;
	}

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

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

	public TypePatternSyntax TypePattern(TypeSyntax type)
	{
		int hash;
		GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9030, (GreenNode)(object)type, context, out hash);
		if (val != null)
		{
			return (TypePatternSyntax)(object)val;
		}
		TypePatternSyntax typePatternSyntax = new TypePatternSyntax(SyntaxKind.TypePattern, type, context);
		if (hash >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)typePatternSyntax, hash);
		}
		return typePatternSyntax;
	}

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

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

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

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

	public InterpolatedStringTextSyntax InterpolatedStringText(SyntaxToken textToken)
	{
		int hash;
		GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8919, (GreenNode)(object)textToken, context, out hash);
		if (val != null)
		{
			return (InterpolatedStringTextSyntax)(object)val;
		}
		InterpolatedStringTextSyntax interpolatedStringTextSyntax = new InterpolatedStringTextSyntax(SyntaxKind.InterpolatedStringText, textToken, context);
		if (hash >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)interpolatedStringTextSyntax, hash);
		}
		return interpolatedStringTextSyntax;
	}

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

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

	public InterpolationFormatClauseSyntax InterpolationFormatClause(SyntaxToken colonToken, SyntaxToken formatStringToken)
	{
		int hash;
		GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8921, (GreenNode)(object)colonToken, (GreenNode)(object)formatStringToken, context, out hash);
		if (val != null)
		{
			return (InterpolationFormatClauseSyntax)(object)val;
		}
		InterpolationFormatClauseSyntax interpolationFormatClauseSyntax = new InterpolationFormatClauseSyntax(SyntaxKind.InterpolationFormatClause, colonToken, formatStringToken, context);
		if (hash >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)interpolationFormatClauseSyntax, hash);
		}
		return interpolationFormatClauseSyntax;
	}

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

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

	public 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, context);
	}

	public 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, context);
	}

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

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

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

	public SingleVariableDesignationSyntax SingleVariableDesignation(SyntaxToken identifier)
	{
		int hash;
		GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8927, (GreenNode)(object)identifier, context, out hash);
		if (val != null)
		{
			return (SingleVariableDesignationSyntax)(object)val;
		}
		SingleVariableDesignationSyntax singleVariableDesignationSyntax = new SingleVariableDesignationSyntax(SyntaxKind.SingleVariableDesignation, identifier, context);
		if (hash >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)singleVariableDesignationSyntax, hash);
		}
		return singleVariableDesignationSyntax;
	}

	public DiscardDesignationSyntax DiscardDesignation(SyntaxToken underscoreToken)
	{
		int hash;
		GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9014, (GreenNode)(object)underscoreToken, context, out hash);
		if (val != null)
		{
			return (DiscardDesignationSyntax)(object)val;
		}
		DiscardDesignationSyntax discardDesignationSyntax = new DiscardDesignationSyntax(SyntaxKind.DiscardDesignation, underscoreToken, context);
		if (hash >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)discardDesignationSyntax, hash);
		}
		return discardDesignationSyntax;
	}

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

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

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

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

	public 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, context);
	}

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

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

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

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

	public 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, context);
	}

	public 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, context);
	}

	public 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, context);
	}

	public 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, context);
	}

	public 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, context);
	}

	public 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, context);
	}

	public 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, context);
	}

	public 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, context);
	}

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

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

	public 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, context);
	}

	public 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, context);
	}

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

	public 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, context);
	}

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

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

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

	public DefaultSwitchLabelSyntax DefaultSwitchLabel(SyntaxToken keyword, SyntaxToken colonToken)
	{
		int hash;
		GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8824, (GreenNode)(object)keyword, (GreenNode)(object)colonToken, context, out hash);
		if (val != null)
		{
			return (DefaultSwitchLabelSyntax)(object)val;
		}
		DefaultSwitchLabelSyntax defaultSwitchLabelSyntax = new DefaultSwitchLabelSyntax(SyntaxKind.DefaultSwitchLabel, keyword, colonToken, context);
		if (hash >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)defaultSwitchLabelSyntax, hash);
		}
		return defaultSwitchLabelSyntax;
	}

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

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

	public 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, context);
	}

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

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

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

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

	public 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, context);
	}

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

	public 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, context);
	}

	public 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, context);
	}

	public 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, context);
	}

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

	public AttributeTargetSpecifierSyntax AttributeTargetSpecifier(SyntaxToken identifier, SyntaxToken colonToken)
	{
		int hash;
		GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8848, (GreenNode)(object)identifier, (GreenNode)(object)colonToken, context, out hash);
		if (val != null)
		{
			return (AttributeTargetSpecifierSyntax)(object)val;
		}
		AttributeTargetSpecifierSyntax attributeTargetSpecifierSyntax = new AttributeTargetSpecifierSyntax(SyntaxKind.AttributeTargetSpecifier, identifier, colonToken, context);
		if (hash >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)attributeTargetSpecifierSyntax, hash);
		}
		return attributeTargetSpecifierSyntax;
	}

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

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

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

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

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

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

	public 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, context);
	}

	public 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, context);
	}

	public 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, context);
	}

	public 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, context);
	}

	public 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, context);
	}

	public 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, context);
	}

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

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

	public SimpleBaseTypeSyntax SimpleBaseType(TypeSyntax type)
	{
		int hash;
		GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8865, (GreenNode)(object)type, context, out hash);
		if (val != null)
		{
			return (SimpleBaseTypeSyntax)(object)val;
		}
		SimpleBaseTypeSyntax simpleBaseTypeSyntax = new SimpleBaseTypeSyntax(SyntaxKind.SimpleBaseType, type, context);
		if (hash >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)simpleBaseTypeSyntax, hash);
		}
		return simpleBaseTypeSyntax;
	}

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

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

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

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

	public TypeConstraintSyntax TypeConstraint(TypeSyntax type)
	{
		int hash;
		GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8870, (GreenNode)(object)type, context, out hash);
		if (val != null)
		{
			return (TypeConstraintSyntax)(object)val;
		}
		TypeConstraintSyntax typeConstraintSyntax = new TypeConstraintSyntax(SyntaxKind.TypeConstraint, type, context);
		if (hash >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)typeConstraintSyntax, hash);
		}
		return typeConstraintSyntax;
	}

	public DefaultConstraintSyntax DefaultConstraint(SyntaxToken defaultKeyword)
	{
		int hash;
		GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9064, (GreenNode)(object)defaultKeyword, context, out hash);
		if (val != null)
		{
			return (DefaultConstraintSyntax)(object)val;
		}
		DefaultConstraintSyntax defaultConstraintSyntax = new DefaultConstraintSyntax(SyntaxKind.DefaultConstraint, defaultKeyword, context);
		if (hash >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)defaultConstraintSyntax, hash);
		}
		return defaultConstraintSyntax;
	}

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

	public 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, context);
	}

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

	public 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, context);
	}

	public 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, context);
	}

	public 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, context);
	}

	public 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, context);
	}

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

	public 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, context);
	}

	public 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, context);
	}

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

	public 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, context);
	}

	public 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, context);
	}

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

	public 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, context);
	}

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

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

	public 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, context);
	}

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

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

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

	public 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, context);
	}

	public TypeCrefSyntax TypeCref(TypeSyntax type)
	{
		int hash;
		GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8597, (GreenNode)(object)type, context, out hash);
		if (val != null)
		{
			return (TypeCrefSyntax)(object)val;
		}
		TypeCrefSyntax typeCrefSyntax = new TypeCrefSyntax(SyntaxKind.TypeCref, type, context);
		if (hash >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)typeCrefSyntax, hash);
		}
		return typeCrefSyntax;
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

	public XmlPrefixSyntax XmlPrefix(SyntaxToken prefix, SyntaxToken colonToken)
	{
		int hash;
		GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8582, (GreenNode)(object)prefix, (GreenNode)(object)colonToken, context, out hash);
		if (val != null)
		{
			return (XmlPrefixSyntax)(object)val;
		}
		XmlPrefixSyntax xmlPrefixSyntax = new XmlPrefixSyntax(SyntaxKind.XmlPrefix, prefix, colonToken, context);
		if (hash >= 0)
		{
			SyntaxNodeCache.AddNode((GreenNode)(object)xmlPrefixSyntax, hash);
		}
		return xmlPrefixSyntax;
	}

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

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

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

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

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

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

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

	public 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, context);
	}

	public 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, context);
	}

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

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

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

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

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

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

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

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

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

	public 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, context);
	}

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

	public 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, context);
	}

	public 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, context);
	}

	public 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, context);
	}

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

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

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

	public 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, context);
	}
}