// Auto generated on 11th April 2003
// Generator parameters: csharp syntactic_grammar
// Generator author: Jon Jagger, {JSL}
// URL   http://www.jaggersoft.com
// email jon@jaggersoft.com

#include "csharp/syntactic_grammar.hpp"
#include "csharp/syntactic_grammar_visitor.hpp"

#include "array/end_of.hpp"
#include "grammar/infinity.hpp"
#include "grammar/qualified_symbol_definition.hpp"

namespace
{
    template<typename iterator_type>
    const ::grammar::non_terminal_symbol_definition *
    extract(iterator_type position, iterator_type end)
    {
        return (position != end) ? position->second : 0;
    }
}

namespace csharp // syntactic_grammar - associative look up
{
    const ::grammar::non_terminal_symbol_definition *
    syntactic_grammar::operator[](const char * name) const
    {
        return extract(::grammar::base::symbols.find(name), ::grammar::base::symbols.end());
    }
}

namespace csharp // syntactic_grammar - configuration
{

    void syntactic_grammar::Configure_namespace_name()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(namespace_or_type_name, 1, 1),
            };
            namespace_name.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[namespace_name.name] = &namespace_name;
    }

    void syntactic_grammar::Configure_type_name()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(namespace_or_type_name, 1, 1),
            };
            type_name.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[type_name.name] = &type_name;
    }

    void syntactic_grammar::Configure_namespace_or_type_name()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(qualified_identifier, 1, 1),
            };
            namespace_or_type_name.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[namespace_or_type_name.name] = &namespace_or_type_name;
    }

    void syntactic_grammar::Configure_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pointer_type, 1, 1),
            };
            type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(reference_type, 1, 1),
            };
            type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(value_type, 1, 1),
            };
            type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[type.name] = &type;
    }

    void syntactic_grammar::Configure_value_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(struct_type, 1, 1),
            };
            value_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(enum_type, 1, 1),
            };
            value_type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[value_type.name] = &value_type;
    }

    void syntactic_grammar::Configure_struct_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(type_name, 1, 1),
            };
            struct_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(simple_type, 1, 1),
            };
            struct_type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[struct_type.name] = &struct_type;
    }

    void syntactic_grammar::Configure_simple_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(numeric_type, 1, 1),
            };
            simple_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("bool"), 1, 1),
            };
            simple_type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[simple_type.name] = &simple_type;
    }

    void syntactic_grammar::Configure_numeric_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(integral_type, 1, 1),
            };
            numeric_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(floating_point_type, 1, 1),
            };
            numeric_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("decimal"), 1, 1),
            };
            numeric_type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[numeric_type.name] = &numeric_type;
    }

    void syntactic_grammar::Configure_integral_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("sbyte"), 1, 1),
            };
            integral_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("byte"), 1, 1),
            };
            integral_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("short"), 1, 1),
            };
            integral_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("ushort"), 1, 1),
            };
            integral_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("int"), 1, 1),
            };
            integral_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("uint"), 1, 1),
            };
            integral_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("long"), 1, 1),
            };
            integral_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("ulong"), 1, 1),
            };
            integral_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("char"), 1, 1),
            };
            integral_type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[integral_type.name] = &integral_type;
    }

    void syntactic_grammar::Configure_floating_point_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("float"), 1, 1),
            };
            floating_point_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("double"), 1, 1),
            };
            floating_point_type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[floating_point_type.name] = &floating_point_type;
    }

    void syntactic_grammar::Configure_enum_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(type_name, 1, 1),
            };
            enum_type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[enum_type.name] = &enum_type;
    }

    void syntactic_grammar::Configure_reference_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(array_type, 1, 1),
            };
            reference_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(class_type, 1, 1),
            };
            reference_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(interface_type, 1, 1),
            };
            reference_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(delegate_type, 1, 1),
            };
            reference_type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[reference_type.name] = &reference_type;
    }

    void syntactic_grammar::Configure_class_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(type_name, 1, 1),
            };
            class_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("object"), 1, 1),
            };
            class_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("string"), 1, 1),
            };
            class_type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[class_type.name] = &class_type;
    }

    void syntactic_grammar::Configure_interface_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(type_name, 1, 1),
            };
            interface_type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[interface_type.name] = &interface_type;
    }

    void syntactic_grammar::Configure_delegate_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(type_name, 1, 1),
            };
            delegate_type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[delegate_type.name] = &delegate_type;
    }

    void syntactic_grammar::Configure_variable_reference()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(expression, 1, 1),
            };
            variable_reference.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[variable_reference.name] = &variable_reference;
    }

    void syntactic_grammar::Configure_argument_list()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(argument, 1, 1),
                ::grammar::base::create(arguments, 0, 1),
            };
            argument_list.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[argument_list.name] = &argument_list;
    }

    void syntactic_grammar::Configure_arguments()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(","), 1, 1),
                ::grammar::base::create(argument_list, 1, 1),
            };
            arguments.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[arguments.name] = &arguments;
    }

    void syntactic_grammar::Configure_argument()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("ref"), 1, 1),
                ::grammar::base::create(variable_reference, 1, 1),
            };
            argument.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("out"), 1, 1),
                ::grammar::base::create(variable_reference, 1, 1),
            };
            argument.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(expression, 1, 1),
            };
            argument.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[argument.name] = &argument;
    }

    void syntactic_grammar::Configure_primary_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(array_creation_expression, 1, 1),
            };
            primary_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(primary_no_array_creation_expression, 1, 1),
            };
            primary_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[primary_expression.name] = &primary_expression;
    }

    void syntactic_grammar::Configure_primary_no_array_creation_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(literal, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(simple_name, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(parenthesized_expression, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(this_access, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(base_access, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(object_creation_expression, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(delegate_creation_expression, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(typeof_expression, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(checked_expression, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(unchecked_expression, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(sizeof_expression, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(predefined_type, 1, 1),
                ::grammar::base::create(member_access_suffix, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[primary_no_array_creation_expression.name] = &primary_no_array_creation_expression;
    }

    void syntactic_grammar::Configure_primary_suffix()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(member_access_suffix, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(invocation_expression_suffix, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(element_access_suffix, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(post_increment_suffix, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(post_decrement_suffix, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pointer_member_access_suffix, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[primary_suffix.name] = &primary_suffix;
    }

    void syntactic_grammar::Configure_member_access_suffix()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("."), 1, 1),
                ::grammar::base::create(identifier, 1, 1),
            };
            member_access_suffix.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[member_access_suffix.name] = &member_access_suffix;
    }

    void syntactic_grammar::Configure_invocation_expression_suffix()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(argument_list, 0, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
            };
            invocation_expression_suffix.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[invocation_expression_suffix.name] = &invocation_expression_suffix;
    }

    void syntactic_grammar::Configure_element_access_suffix()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("["), 1, 1),
                ::grammar::base::create(expression_list, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("]"), 1, 1),
            };
            element_access_suffix.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[element_access_suffix.name] = &element_access_suffix;
    }

    void syntactic_grammar::Configure_post_increment_suffix()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("++"), 1, 1),
            };
            post_increment_suffix.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[post_increment_suffix.name] = &post_increment_suffix;
    }

    void syntactic_grammar::Configure_post_decrement_suffix()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("--"), 1, 1),
            };
            post_decrement_suffix.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[post_decrement_suffix.name] = &post_decrement_suffix;
    }

    void syntactic_grammar::Configure_expression_list()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(expression, 1, 1),
                ::grammar::base::create(expressions, 0, 1),
            };
            expression_list.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[expression_list.name] = &expression_list;
    }

    void syntactic_grammar::Configure_expressions()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(","), 1, 1),
                ::grammar::base::create(expression_list, 1, 1),
            };
            expressions.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[expressions.name] = &expressions;
    }

    void syntactic_grammar::Configure_simple_name()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(identifier, 1, 1),
            };
            simple_name.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[simple_name.name] = &simple_name;
    }

    void syntactic_grammar::Configure_parenthesized_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
            };
            parenthesized_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[parenthesized_expression.name] = &parenthesized_expression;
    }

    void syntactic_grammar::Configure_predefined_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("bool"), 1, 1),
            };
            predefined_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("byte"), 1, 1),
            };
            predefined_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("char"), 1, 1),
            };
            predefined_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("decimal"), 1, 1),
            };
            predefined_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("double"), 1, 1),
            };
            predefined_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("float"), 1, 1),
            };
            predefined_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("int"), 1, 1),
            };
            predefined_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("long"), 1, 1),
            };
            predefined_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("object"), 1, 1),
            };
            predefined_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("sbyte"), 1, 1),
            };
            predefined_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("short"), 1, 1),
            };
            predefined_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("string"), 1, 1),
            };
            predefined_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("uint"), 1, 1),
            };
            predefined_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("ulong"), 1, 1),
            };
            predefined_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("ushort"), 1, 1),
            };
            predefined_type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[predefined_type.name] = &predefined_type;
    }

    void syntactic_grammar::Configure_invocation_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(ie_primary_no_array_creation_expression, 1, 1),
                ::grammar::base::create(invocation_expression_suffix, 1, ::grammar::infinity()),
            };
            invocation_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[invocation_expression.name] = &invocation_expression;
    }

    void syntactic_grammar::Configure_ie_primary_no_array_creation_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(literal, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(simple_name, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(parenthesized_expression, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(this_access, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(base_access, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(object_creation_expression, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(delegate_creation_expression, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(typeof_expression, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(checked_expression, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(unchecked_expression, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(sizeof_expression, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(predefined_type, 1, 1),
                ::grammar::base::create(member_access_suffix, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[ie_primary_no_array_creation_expression.name] = &ie_primary_no_array_creation_expression;
    }

    void syntactic_grammar::Configure_ie_primary_suffix()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(member_access_suffix, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(invocation_expression_suffix, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 1, 1),
            };
            ie_primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(element_access_suffix, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(post_increment_suffix, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(post_decrement_suffix, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pointer_member_access_suffix, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[ie_primary_suffix.name] = &ie_primary_suffix;
    }

    void syntactic_grammar::Configure_post_increment_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pide_primary_no_array_creation_expression, 1, 1),
                ::grammar::base::create(post_increment_suffix, 1, 1),
            };
            post_increment_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[post_increment_expression.name] = &post_increment_expression;
    }

    void syntactic_grammar::Configure_post_decrement_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pide_primary_no_array_creation_expression, 1, 1),
                ::grammar::base::create(post_decrement_suffix, 1, 1),
            };
            post_decrement_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[post_decrement_expression.name] = &post_decrement_expression;
    }

    void syntactic_grammar::Configure_pide_primary_no_array_creation_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(simple_name, 1, 1),
                ::grammar::base::create(pide_primary_suffix, 0, 1),
            };
            pide_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(parenthesized_expression, 1, 1),
                ::grammar::base::create(pide_primary_suffix, 0, 1),
            };
            pide_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(this_access, 1, 1),
                ::grammar::base::create(pide_primary_suffix, 0, 1),
            };
            pide_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(base_access, 1, 1),
                ::grammar::base::create(pide_primary_suffix, 0, 1),
            };
            pide_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pide_primary_no_array_creation_expression.name] = &pide_primary_no_array_creation_expression;
    }

    void syntactic_grammar::Configure_pide_primary_suffix()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(member_access_suffix, 1, 1),
                ::grammar::base::create(pide_primary_suffix, 0, 1),
            };
            pide_primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(invocation_expression_suffix, 1, 1),
                ::grammar::base::create(pide_primary_suffix, 0, 1),
            };
            pide_primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(element_access_suffix, 1, 1),
                ::grammar::base::create(pide_primary_suffix, 0, 1),
            };
            pide_primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pointer_member_access_suffix, 1, 1),
                ::grammar::base::create(pide_primary_suffix, 0, 1),
            };
            pide_primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pide_primary_suffix.name] = &pide_primary_suffix;
    }

    void syntactic_grammar::Configure_this_access()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("this"), 1, 1),
            };
            this_access.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[this_access.name] = &this_access;
    }

    void syntactic_grammar::Configure_base_access()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("base"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("."), 1, 1),
                ::grammar::base::create(identifier, 1, 1),
            };
            base_access.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("base"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("["), 1, 1),
                ::grammar::base::create(expression_list, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("]"), 1, 1),
            };
            base_access.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[base_access.name] = &base_access;
    }

    void syntactic_grammar::Configure_object_creation_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("new"), 1, 1),
                ::grammar::base::create(type, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(argument_list, 0, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
            };
            object_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[object_creation_expression.name] = &object_creation_expression;
    }

    void syntactic_grammar::Configure_array_creation_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("new"), 1, 1),
                ::grammar::base::create(non_array_type, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("["), 1, 1),
                ::grammar::base::create(expression_list, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("]"), 1, 1),
                ::grammar::base::create(rank_specifiers, 0, 1),
                ::grammar::base::create(array_initializer, 0, 1),
            };
            array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("new"), 1, 1),
                ::grammar::base::create(array_type, 1, 1),
                ::grammar::base::create(array_initializer, 1, 1),
            };
            array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[array_creation_expression.name] = &array_creation_expression;
    }

    void syntactic_grammar::Configure_delegate_creation_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("new"), 1, 1),
                ::grammar::base::create(delegate_type, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
            };
            delegate_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[delegate_creation_expression.name] = &delegate_creation_expression;
    }

    void syntactic_grammar::Configure_typeof_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("typeof"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(type, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
            };
            typeof_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("typeof"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("void"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
            };
            typeof_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[typeof_expression.name] = &typeof_expression;
    }

    void syntactic_grammar::Configure_checked_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("checked"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
            };
            checked_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[checked_expression.name] = &checked_expression;
    }

    void syntactic_grammar::Configure_unchecked_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("unchecked"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
            };
            unchecked_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[unchecked_expression.name] = &unchecked_expression;
    }

    void syntactic_grammar::Configure_unary_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("+"), 1, 1),
                ::grammar::base::create(unary_expression, 1, 1),
            };
            unary_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("-"), 1, 1),
                ::grammar::base::create(unary_expression, 1, 1),
            };
            unary_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("!"), 1, 1),
                ::grammar::base::create(unary_expression, 1, 1),
            };
            unary_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("~"), 1, 1),
                ::grammar::base::create(unary_expression, 1, 1),
            };
            unary_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("*"), 1, 1),
                ::grammar::base::create(unary_expression, 1, 1),
            };
            unary_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("&"), 1, 1),
                ::grammar::base::create(unary_expression, 1, 1),
            };
            unary_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pre_increment_expression, 1, 1),
            };
            unary_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pre_decrement_expression, 1, 1),
            };
            unary_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(cast_expression, 1, 1),
            };
            unary_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pointer_indirection_expression, 1, 1),
            };
            unary_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(addressof_expression, 1, 1),
            };
            unary_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(primary_expression, 1, 1),
            };
            unary_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[unary_expression.name] = &unary_expression;
    }

    void syntactic_grammar::Configure_pre_increment_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("++"), 1, 1),
                ::grammar::base::create(unary_expression, 1, 1),
            };
            pre_increment_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pre_increment_expression.name] = &pre_increment_expression;
    }

    void syntactic_grammar::Configure_pre_decrement_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("--"), 1, 1),
                ::grammar::base::create(unary_expression, 1, 1),
            };
            pre_decrement_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pre_decrement_expression.name] = &pre_decrement_expression;
    }

    void syntactic_grammar::Configure_cast_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(type, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
                ::grammar::base::create(unary_expression, 1, 1),
            };
            cast_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[cast_expression.name] = &cast_expression;
    }

    void syntactic_grammar::Configure_multiplicative_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(unary_expression, 1, 1),
                ::grammar::base::create(multiplicative_expressions, 0, 1),
            };
            multiplicative_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[multiplicative_expression.name] = &multiplicative_expression;
    }

    void syntactic_grammar::Configure_multiplicative_expressions()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("*"), 1, 1),
                ::grammar::base::create(multiplicative_expression, 1, 1),
            };
            multiplicative_expressions.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("/"), 1, 1),
                ::grammar::base::create(multiplicative_expression, 1, 1),
            };
            multiplicative_expressions.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("%"), 1, 1),
                ::grammar::base::create(multiplicative_expression, 1, 1),
            };
            multiplicative_expressions.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[multiplicative_expressions.name] = &multiplicative_expressions;
    }

    void syntactic_grammar::Configure_additive_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(multiplicative_expression, 1, 1),
                ::grammar::base::create(additive_expressions, 0, 1),
            };
            additive_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[additive_expression.name] = &additive_expression;
    }

    void syntactic_grammar::Configure_additive_expressions()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("+"), 1, 1),
                ::grammar::base::create(additive_expression, 1, 1),
            };
            additive_expressions.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("-"), 1, 1),
                ::grammar::base::create(additive_expression, 1, 1),
            };
            additive_expressions.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[additive_expressions.name] = &additive_expressions;
    }

    void syntactic_grammar::Configure_shift_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(additive_expression, 1, 1),
                ::grammar::base::create(shift_expressions, 0, 1),
            };
            shift_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[shift_expression.name] = &shift_expression;
    }

    void syntactic_grammar::Configure_shift_expressions()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("<<"), 1, 1),
                ::grammar::base::create(shift_expression, 1, 1),
            };
            shift_expressions.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(">>"), 1, 1),
                ::grammar::base::create(shift_expression, 1, 1),
            };
            shift_expressions.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[shift_expressions.name] = &shift_expressions;
    }

    void syntactic_grammar::Configure_relational_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(shift_expression, 1, 1),
                ::grammar::base::create(relational_expressions, 0, 1),
            };
            relational_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[relational_expression.name] = &relational_expression;
    }

    void syntactic_grammar::Configure_relational_expressions()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("<"), 1, 1),
                ::grammar::base::create(relational_expression, 1, 1),
            };
            relational_expressions.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(">"), 1, 1),
                ::grammar::base::create(relational_expression, 1, 1),
            };
            relational_expressions.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("<="), 1, 1),
                ::grammar::base::create(relational_expression, 1, 1),
            };
            relational_expressions.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(">="), 1, 1),
                ::grammar::base::create(relational_expression, 1, 1),
            };
            relational_expressions.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("is"), 1, 1),
                ::grammar::base::create(type, 1, 1),
            };
            relational_expressions.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("as"), 1, 1),
                ::grammar::base::create(type, 1, 1),
            };
            relational_expressions.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[relational_expressions.name] = &relational_expressions;
    }

    void syntactic_grammar::Configure_equality_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(relational_expression, 1, 1),
                ::grammar::base::create(equality_expressions, 0, 1),
            };
            equality_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[equality_expression.name] = &equality_expression;
    }

    void syntactic_grammar::Configure_equality_expressions()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("=="), 1, 1),
                ::grammar::base::create(equality_expression, 1, 1),
            };
            equality_expressions.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("!="), 1, 1),
                ::grammar::base::create(equality_expression, 1, 1),
            };
            equality_expressions.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[equality_expressions.name] = &equality_expressions;
    }

    void syntactic_grammar::Configure_and_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(equality_expression, 1, 1),
                ::grammar::base::create(and_expressions, 0, 1),
            };
            and_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[and_expression.name] = &and_expression;
    }

    void syntactic_grammar::Configure_and_expressions()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("&"), 1, 1),
                ::grammar::base::create(and_expression, 1, 1),
            };
            and_expressions.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[and_expressions.name] = &and_expressions;
    }

    void syntactic_grammar::Configure_exclusive_or_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(and_expression, 1, 1),
                ::grammar::base::create(exclusive_or_expressions, 0, 1),
            };
            exclusive_or_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[exclusive_or_expression.name] = &exclusive_or_expression;
    }

    void syntactic_grammar::Configure_exclusive_or_expressions()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("^"), 1, 1),
                ::grammar::base::create(exclusive_or_expression, 1, 1),
            };
            exclusive_or_expressions.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[exclusive_or_expressions.name] = &exclusive_or_expressions;
    }

    void syntactic_grammar::Configure_inclusive_or_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(exclusive_or_expression, 1, 1),
                ::grammar::base::create(inclusive_or_expressions, 0, 1),
            };
            inclusive_or_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[inclusive_or_expression.name] = &inclusive_or_expression;
    }

    void syntactic_grammar::Configure_inclusive_or_expressions()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("|"), 1, 1),
                ::grammar::base::create(inclusive_or_expression, 1, 1),
            };
            inclusive_or_expressions.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[inclusive_or_expressions.name] = &inclusive_or_expressions;
    }

    void syntactic_grammar::Configure_conditional_and_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(inclusive_or_expression, 1, 1),
                ::grammar::base::create(conditional_and_expressions, 0, 1),
            };
            conditional_and_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[conditional_and_expression.name] = &conditional_and_expression;
    }

    void syntactic_grammar::Configure_conditional_and_expressions()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("&&"), 1, 1),
                ::grammar::base::create(conditional_and_expression, 1, 1),
            };
            conditional_and_expressions.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[conditional_and_expressions.name] = &conditional_and_expressions;
    }

    void syntactic_grammar::Configure_conditional_or_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(conditional_and_expression, 1, 1),
                ::grammar::base::create(conditional_or_expressions, 0, 1),
            };
            conditional_or_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[conditional_or_expression.name] = &conditional_or_expression;
    }

    void syntactic_grammar::Configure_conditional_or_expressions()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("||"), 1, 1),
                ::grammar::base::create(conditional_or_expression, 1, 1),
            };
            conditional_or_expressions.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[conditional_or_expressions.name] = &conditional_or_expressions;
    }

    void syntactic_grammar::Configure_conditional_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(conditional_or_expression, 1, 1),
            };
            conditional_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(conditional_or_expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("?"), 1, 1),
                ::grammar::base::create(expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(":"), 1, 1),
                ::grammar::base::create(expression, 1, 1),
            };
            conditional_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[conditional_expression.name] = &conditional_expression;
    }

    void syntactic_grammar::Configure_assignment()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(unary_expression, 1, 1),
                ::grammar::base::create(assignment_operator, 1, 1),
                ::grammar::base::create(expression, 1, 1),
            };
            assignment.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[assignment.name] = &assignment;
    }

    void syntactic_grammar::Configure_assignment_operator()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("="), 1, 1),
            };
            assignment_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("+="), 1, 1),
            };
            assignment_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("-="), 1, 1),
            };
            assignment_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("*="), 1, 1),
            };
            assignment_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("/="), 1, 1),
            };
            assignment_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("%="), 1, 1),
            };
            assignment_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("&="), 1, 1),
            };
            assignment_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("|="), 1, 1),
            };
            assignment_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("^="), 1, 1),
            };
            assignment_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("<<="), 1, 1),
            };
            assignment_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(">>="), 1, 1),
            };
            assignment_operator.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[assignment_operator.name] = &assignment_operator;
    }

    void syntactic_grammar::Configure_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(assignment, 1, 1),
            };
            expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(conditional_expression, 1, 1),
            };
            expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[expression.name] = &expression;
    }

    void syntactic_grammar::Configure_constant_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(expression, 1, 1),
            };
            constant_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[constant_expression.name] = &constant_expression;
    }

    void syntactic_grammar::Configure_boolean_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(expression, 1, 1),
            };
            boolean_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[boolean_expression.name] = &boolean_expression;
    }

    void syntactic_grammar::Configure_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(labeled_statement, 1, 1),
            };
            statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(declaration_statement, 1, 1),
            };
            statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(embedded_statement, 1, 1),
            };
            statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[statement.name] = &statement;
    }

    void syntactic_grammar::Configure_embedded_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(block, 1, 1),
            };
            embedded_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(expression_statement, 1, 1),
            };
            embedded_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(empty_statement, 1, 1),
            };
            embedded_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(selection_statement, 1, 1),
            };
            embedded_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(iteration_statement, 1, 1),
            };
            embedded_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(jump_statement, 1, 1),
            };
            embedded_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(try_statement, 1, 1),
            };
            embedded_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(checked_statement, 1, 1),
            };
            embedded_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(unchecked_statement, 1, 1),
            };
            embedded_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(lock_statement, 1, 1),
            };
            embedded_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(using_statement, 1, 1),
            };
            embedded_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(unsafe_statement, 1, 1),
            };
            embedded_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(fixed_statement, 1, 1),
            };
            embedded_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[embedded_statement.name] = &embedded_statement;
    }

    void syntactic_grammar::Configure_block()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("{"), 1, 1),
                ::grammar::base::create(statement_list, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("}"), 1, 1),
            };
            block.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[block.name] = &block;
    }

    void syntactic_grammar::Configure_statement_list()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(statement, 1, ::grammar::infinity()),
            };
            statement_list.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[statement_list.name] = &statement_list;
    }

    void syntactic_grammar::Configure_empty_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            empty_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[empty_statement.name] = &empty_statement;
    }

    void syntactic_grammar::Configure_labeled_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(":"), 1, 1),
                ::grammar::base::create(statement, 1, 1),
            };
            labeled_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[labeled_statement.name] = &labeled_statement;
    }

    void syntactic_grammar::Configure_declaration_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(local_variable_declaration, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            declaration_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(local_constant_declaration, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            declaration_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[declaration_statement.name] = &declaration_statement;
    }

    void syntactic_grammar::Configure_local_variable_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(type, 1, 1),
                ::grammar::base::create(local_variable_declarators, 1, 1),
            };
            local_variable_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[local_variable_declaration.name] = &local_variable_declaration;
    }

    void syntactic_grammar::Configure_local_variable_declarators()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(local_variable_declarator, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(","), 1, 1),
                ::grammar::base::create(local_variable_declarators, 1, 1),
            };
            local_variable_declarators.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(local_variable_declarator, 1, 1),
            };
            local_variable_declarators.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[local_variable_declarators.name] = &local_variable_declarators;
    }

    void syntactic_grammar::Configure_local_variable_declarator()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("="), 1, 1),
                ::grammar::base::create(local_variable_initializer, 1, 1),
            };
            local_variable_declarator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(identifier, 1, 1),
            };
            local_variable_declarator.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[local_variable_declarator.name] = &local_variable_declarator;
    }

    void syntactic_grammar::Configure_local_variable_initializer()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(expression, 1, 1),
            };
            local_variable_initializer.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(array_initializer, 1, 1),
            };
            local_variable_initializer.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(stackalloc_initializer, 1, 1),
            };
            local_variable_initializer.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[local_variable_initializer.name] = &local_variable_initializer;
    }

    void syntactic_grammar::Configure_local_constant_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("const"), 1, 1),
                ::grammar::base::create(type, 1, 1),
                ::grammar::base::create(constant_declarators, 1, 1),
            };
            local_constant_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[local_constant_declaration.name] = &local_constant_declaration;
    }

    void syntactic_grammar::Configure_expression_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(statement_expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            expression_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[expression_statement.name] = &expression_statement;
    }

    void syntactic_grammar::Configure_statement_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(invocation_expression, 1, 1),
            };
            statement_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(object_creation_expression, 1, 1),
            };
            statement_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(assignment, 1, 1),
            };
            statement_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(post_increment_expression, 1, 1),
            };
            statement_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(post_decrement_expression, 1, 1),
            };
            statement_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pre_increment_expression, 1, 1),
            };
            statement_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pre_decrement_expression, 1, 1),
            };
            statement_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[statement_expression.name] = &statement_expression;
    }

    void syntactic_grammar::Configure_selection_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(if_statement, 1, 1),
            };
            selection_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(switch_statement, 1, 1),
            };
            selection_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[selection_statement.name] = &selection_statement;
    }

    void syntactic_grammar::Configure_if_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("if"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(boolean_expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
                ::grammar::base::create(embedded_statement, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("else"), 1, 1),
                ::grammar::base::create(embedded_statement, 1, 1),
            };
            if_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("if"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(boolean_expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
                ::grammar::base::create(embedded_statement, 1, 1),
            };
            if_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[if_statement.name] = &if_statement;
    }

    void syntactic_grammar::Configure_switch_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("switch"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
                ::grammar::base::create(switch_block, 1, 1),
            };
            switch_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[switch_statement.name] = &switch_statement;
    }

    void syntactic_grammar::Configure_switch_block()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("{"), 1, 1),
                ::grammar::base::create(switch_sections, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("}"), 1, 1),
            };
            switch_block.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[switch_block.name] = &switch_block;
    }

    void syntactic_grammar::Configure_switch_sections()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(switch_section, 1, ::grammar::infinity()),
            };
            switch_sections.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[switch_sections.name] = &switch_sections;
    }

    void syntactic_grammar::Configure_switch_section()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(switch_labels, 1, 1),
                ::grammar::base::create(statement_list, 1, 1),
            };
            switch_section.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[switch_section.name] = &switch_section;
    }

    void syntactic_grammar::Configure_switch_labels()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(switch_label, 1, ::grammar::infinity()),
            };
            switch_labels.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[switch_labels.name] = &switch_labels;
    }

    void syntactic_grammar::Configure_switch_label()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("case"), 1, 1),
                ::grammar::base::create(constant_expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(":"), 1, 1),
            };
            switch_label.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("default"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal(":"), 1, 1),
            };
            switch_label.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[switch_label.name] = &switch_label;
    }

    void syntactic_grammar::Configure_iteration_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(while_statement, 1, 1),
            };
            iteration_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(do_statement, 1, 1),
            };
            iteration_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(for_statement, 1, 1),
            };
            iteration_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(foreach_statement, 1, 1),
            };
            iteration_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[iteration_statement.name] = &iteration_statement;
    }

    void syntactic_grammar::Configure_while_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("while"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(boolean_expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
                ::grammar::base::create(embedded_statement, 1, 1),
            };
            while_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[while_statement.name] = &while_statement;
    }

    void syntactic_grammar::Configure_do_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("do"), 1, 1),
                ::grammar::base::create(embedded_statement, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("while"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(boolean_expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            do_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[do_statement.name] = &do_statement;
    }

    void syntactic_grammar::Configure_for_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("for"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(for_initializer, 0, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
                ::grammar::base::create(for_condition, 0, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
                ::grammar::base::create(for_iterator, 0, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
                ::grammar::base::create(embedded_statement, 1, 1),
            };
            for_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[for_statement.name] = &for_statement;
    }

    void syntactic_grammar::Configure_for_initializer()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(local_variable_declaration, 1, 1),
            };
            for_initializer.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(statement_expression_list, 1, 1),
            };
            for_initializer.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[for_initializer.name] = &for_initializer;
    }

    void syntactic_grammar::Configure_for_condition()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(boolean_expression, 1, 1),
            };
            for_condition.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[for_condition.name] = &for_condition;
    }

    void syntactic_grammar::Configure_for_iterator()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(statement_expression_list, 1, 1),
            };
            for_iterator.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[for_iterator.name] = &for_iterator;
    }

    void syntactic_grammar::Configure_statement_expression_list()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(statement_expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(","), 1, 1),
                ::grammar::base::create(statement_expression_list, 1, 1),
            };
            statement_expression_list.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(statement_expression, 1, 1),
            };
            statement_expression_list.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[statement_expression_list.name] = &statement_expression_list;
    }

    void syntactic_grammar::Configure_foreach_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("foreach"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(type, 1, 1),
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("in"), 1, 1),
                ::grammar::base::create(expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
                ::grammar::base::create(embedded_statement, 1, 1),
            };
            foreach_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[foreach_statement.name] = &foreach_statement;
    }

    void syntactic_grammar::Configure_jump_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(break_statement, 1, 1),
            };
            jump_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(continue_statement, 1, 1),
            };
            jump_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(goto_statement, 1, 1),
            };
            jump_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(return_statement, 1, 1),
            };
            jump_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(throw_statement, 1, 1),
            };
            jump_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[jump_statement.name] = &jump_statement;
    }

    void syntactic_grammar::Configure_break_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("break"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            break_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[break_statement.name] = &break_statement;
    }

    void syntactic_grammar::Configure_continue_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("continue"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            continue_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[continue_statement.name] = &continue_statement;
    }

    void syntactic_grammar::Configure_goto_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("goto"), 1, 1),
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            goto_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("goto"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("case"), 1, 1),
                ::grammar::base::create(constant_expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            goto_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("goto"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("default"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            goto_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[goto_statement.name] = &goto_statement;
    }

    void syntactic_grammar::Configure_return_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("return"), 1, 1),
                ::grammar::base::create(expression, 0, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            return_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[return_statement.name] = &return_statement;
    }

    void syntactic_grammar::Configure_throw_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("throw"), 1, 1),
                ::grammar::base::create(expression, 0, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            throw_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[throw_statement.name] = &throw_statement;
    }

    void syntactic_grammar::Configure_try_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("try"), 1, 1),
                ::grammar::base::create(block, 1, 1),
                ::grammar::base::create(catch_clauses, 1, 1),
                ::grammar::base::create(finally_clause, 0, 1),
            };
            try_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("try"), 1, 1),
                ::grammar::base::create(block, 1, 1),
                ::grammar::base::create(finally_clause, 1, 1),
            };
            try_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[try_statement.name] = &try_statement;
    }

    void syntactic_grammar::Configure_catch_clauses()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(specific_catch_clauses, 1, 1),
                ::grammar::base::create(general_catch_clause, 0, 1),
            };
            catch_clauses.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(specific_catch_clauses, 0, 1),
                ::grammar::base::create(general_catch_clause, 1, 1),
            };
            catch_clauses.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[catch_clauses.name] = &catch_clauses;
    }

    void syntactic_grammar::Configure_specific_catch_clauses()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(specific_catch_clause, 1, ::grammar::infinity()),
            };
            specific_catch_clauses.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[specific_catch_clauses.name] = &specific_catch_clauses;
    }

    void syntactic_grammar::Configure_specific_catch_clause()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("catch"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(class_type, 1, 1),
                ::grammar::base::create(identifier, 0, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
                ::grammar::base::create(block, 1, 1),
            };
            specific_catch_clause.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[specific_catch_clause.name] = &specific_catch_clause;
    }

    void syntactic_grammar::Configure_general_catch_clause()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("catch"), 1, 1),
                ::grammar::base::create(block, 1, 1),
            };
            general_catch_clause.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[general_catch_clause.name] = &general_catch_clause;
    }

    void syntactic_grammar::Configure_finally_clause()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("finally"), 1, 1),
                ::grammar::base::create(block, 1, 1),
            };
            finally_clause.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[finally_clause.name] = &finally_clause;
    }

    void syntactic_grammar::Configure_checked_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("checked"), 1, 1),
                ::grammar::base::create(block, 1, 1),
            };
            checked_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[checked_statement.name] = &checked_statement;
    }

    void syntactic_grammar::Configure_unchecked_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("unchecked"), 1, 1),
                ::grammar::base::create(block, 1, 1),
            };
            unchecked_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[unchecked_statement.name] = &unchecked_statement;
    }

    void syntactic_grammar::Configure_lock_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("lock"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
                ::grammar::base::create(embedded_statement, 1, 1),
            };
            lock_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[lock_statement.name] = &lock_statement;
    }

    void syntactic_grammar::Configure_using_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("using"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(resource_acquisition, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
                ::grammar::base::create(embedded_statement, 1, 1),
            };
            using_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[using_statement.name] = &using_statement;
    }

    void syntactic_grammar::Configure_resource_acquisition()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(local_variable_declaration, 1, 1),
            };
            resource_acquisition.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(expression, 1, 1),
            };
            resource_acquisition.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[resource_acquisition.name] = &resource_acquisition;
    }

    void syntactic_grammar::Configure_compilation_unit()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(using_directives, 0, 1),
                ::grammar::base::create(global_attributes, 0, 1),
                ::grammar::base::create(namespace_member_declarations, 0, 1),
            };
            compilation_unit.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[compilation_unit.name] = &compilation_unit;
    }

    void syntactic_grammar::Configure_namespace_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("namespace"), 1, 1),
                ::grammar::base::create(qualified_identifier, 1, 1),
                ::grammar::base::create(namespace_body, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 0, 1),
            };
            namespace_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[namespace_declaration.name] = &namespace_declaration;
    }

    void syntactic_grammar::Configure_qualified_identifier()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(identifiers, 0, 1),
            };
            qualified_identifier.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[qualified_identifier.name] = &qualified_identifier;
    }

    void syntactic_grammar::Configure_identifiers()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("."), 1, 1),
                ::grammar::base::create(qualified_identifier, 1, 1),
            };
            identifiers.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[identifiers.name] = &identifiers;
    }

    void syntactic_grammar::Configure_namespace_body()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("{"), 1, 1),
                ::grammar::base::create(using_directives, 0, 1),
                ::grammar::base::create(namespace_member_declarations, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("}"), 1, 1),
            };
            namespace_body.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[namespace_body.name] = &namespace_body;
    }

    void syntactic_grammar::Configure_using_directives()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(using_directive, 1, ::grammar::infinity()),
            };
            using_directives.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[using_directives.name] = &using_directives;
    }

    void syntactic_grammar::Configure_using_directive()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(using_alias_directive, 1, 1),
            };
            using_directive.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(using_namespace_directive, 1, 1),
            };
            using_directive.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[using_directive.name] = &using_directive;
    }

    void syntactic_grammar::Configure_using_alias_directive()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("using"), 1, 1),
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("="), 1, 1),
                ::grammar::base::create(namespace_or_type_name, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            using_alias_directive.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[using_alias_directive.name] = &using_alias_directive;
    }

    void syntactic_grammar::Configure_using_namespace_directive()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("using"), 1, 1),
                ::grammar::base::create(namespace_name, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            using_namespace_directive.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[using_namespace_directive.name] = &using_namespace_directive;
    }

    void syntactic_grammar::Configure_namespace_member_declarations()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(namespace_member_declaration, 1, ::grammar::infinity()),
            };
            namespace_member_declarations.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[namespace_member_declarations.name] = &namespace_member_declarations;
    }

    void syntactic_grammar::Configure_namespace_member_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(namespace_declaration, 1, 1),
            };
            namespace_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(type_declaration, 1, 1),
            };
            namespace_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[namespace_member_declaration.name] = &namespace_member_declaration;
    }

    void syntactic_grammar::Configure_type_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(class_declaration, 1, 1),
            };
            type_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(struct_declaration, 1, 1),
            };
            type_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(interface_declaration, 1, 1),
            };
            type_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(enum_declaration, 1, 1),
            };
            type_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(delegate_declaration, 1, 1),
            };
            type_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[type_declaration.name] = &type_declaration;
    }

    void syntactic_grammar::Configure_class_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(class_modifiers, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("class"), 1, 1),
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(class_base, 0, 1),
                ::grammar::base::create(class_body, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 0, 1),
            };
            class_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[class_declaration.name] = &class_declaration;
    }

    void syntactic_grammar::Configure_class_modifiers()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(class_modifier, 1, ::grammar::infinity()),
            };
            class_modifiers.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[class_modifiers.name] = &class_modifiers;
    }

    void syntactic_grammar::Configure_class_modifier()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("new"), 1, 1),
            };
            class_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("public"), 1, 1),
            };
            class_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("protected"), 1, 1),
            };
            class_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("internal"), 1, 1),
            };
            class_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("private"), 1, 1),
            };
            class_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("abstract"), 1, 1),
            };
            class_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("sealed"), 1, 1),
            };
            class_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("unsafe"), 1, 1),
            };
            class_modifier.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[class_modifier.name] = &class_modifier;
    }

    void syntactic_grammar::Configure_class_base()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(":"), 1, 1),
                ::grammar::base::create(base_type, 1, 1),
                ::grammar::base::create(interface_type_list, 0, ::grammar::infinity()),
            };
            class_base.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[class_base.name] = &class_base;
    }

    void syntactic_grammar::Configure_base_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("object"), 1, 1),
            };
            base_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(type_name, 1, 1),
            };
            base_type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[base_type.name] = &base_type;
    }

    void syntactic_grammar::Configure_interface_type_list()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(","), 1, 1),
                ::grammar::base::create(interface_type, 1, 1),
            };
            interface_type_list.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[interface_type_list.name] = &interface_type_list;
    }

    void syntactic_grammar::Configure_class_body()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("{"), 1, 1),
                ::grammar::base::create(class_member_declarations, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("}"), 1, 1),
            };
            class_body.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[class_body.name] = &class_body;
    }

    void syntactic_grammar::Configure_class_member_declarations()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(class_member_declaration, 1, ::grammar::infinity()),
            };
            class_member_declarations.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[class_member_declarations.name] = &class_member_declarations;
    }

    void syntactic_grammar::Configure_class_member_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(constant_declaration, 1, 1),
            };
            class_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(field_declaration, 1, 1),
            };
            class_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(method_declaration, 1, 1),
            };
            class_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(property_declaration, 1, 1),
            };
            class_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(event_declaration, 1, 1),
            };
            class_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(indexer_declaration, 1, 1),
            };
            class_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(operator_declaration, 1, 1),
            };
            class_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(constructor_declaration, 1, 1),
            };
            class_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(destructor_declaration, 1, 1),
            };
            class_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(static_constructor_declaration, 1, 1),
            };
            class_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(type_declaration, 1, 1),
            };
            class_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[class_member_declaration.name] = &class_member_declaration;
    }

    void syntactic_grammar::Configure_constant_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(constant_modifiers, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("const"), 1, 1),
                ::grammar::base::create(type, 1, 1),
                ::grammar::base::create(constant_declarators, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            constant_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[constant_declaration.name] = &constant_declaration;
    }

    void syntactic_grammar::Configure_constant_modifiers()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(constant_modifier, 1, ::grammar::infinity()),
            };
            constant_modifiers.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[constant_modifiers.name] = &constant_modifiers;
    }

    void syntactic_grammar::Configure_constant_modifier()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("new"), 1, 1),
            };
            constant_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("public"), 1, 1),
            };
            constant_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("protected"), 1, 1),
            };
            constant_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("internal"), 1, 1),
            };
            constant_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("private"), 1, 1),
            };
            constant_modifier.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[constant_modifier.name] = &constant_modifier;
    }

    void syntactic_grammar::Configure_constant_declarators()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(constant_declarator, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(","), 1, 1),
                ::grammar::base::create(constant_declarators, 1, 1),
            };
            constant_declarators.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(constant_declarator, 1, 1),
            };
            constant_declarators.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[constant_declarators.name] = &constant_declarators;
    }

    void syntactic_grammar::Configure_constant_declarator()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("="), 1, 1),
                ::grammar::base::create(constant_expression, 1, 1),
            };
            constant_declarator.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[constant_declarator.name] = &constant_declarator;
    }

    void syntactic_grammar::Configure_field_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(field_modifiers, 0, 1),
                ::grammar::base::create(type, 1, 1),
                ::grammar::base::create(variable_declarators, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            field_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[field_declaration.name] = &field_declaration;
    }

    void syntactic_grammar::Configure_field_modifiers()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(field_modifier, 1, ::grammar::infinity()),
            };
            field_modifiers.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[field_modifiers.name] = &field_modifiers;
    }

    void syntactic_grammar::Configure_field_modifier()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("new"), 1, 1),
            };
            field_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("public"), 1, 1),
            };
            field_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("protected"), 1, 1),
            };
            field_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("internal"), 1, 1),
            };
            field_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("private"), 1, 1),
            };
            field_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("static"), 1, 1),
            };
            field_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("readonly"), 1, 1),
            };
            field_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("volatile"), 1, 1),
            };
            field_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("unsafe"), 1, 1),
            };
            field_modifier.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[field_modifier.name] = &field_modifier;
    }

    void syntactic_grammar::Configure_variable_declarators()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(variable_declarator, 1, 1),
                ::grammar::base::create(variable_declarator_list, 0, 1),
            };
            variable_declarators.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[variable_declarators.name] = &variable_declarators;
    }

    void syntactic_grammar::Configure_variable_declarator_list()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(","), 1, 1),
                ::grammar::base::create(variable_declarators, 1, 1),
            };
            variable_declarator_list.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[variable_declarator_list.name] = &variable_declarator_list;
    }

    void syntactic_grammar::Configure_variable_declarator()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("="), 1, 1),
                ::grammar::base::create(variable_initializer, 1, 1),
            };
            variable_declarator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(identifier, 1, 1),
            };
            variable_declarator.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[variable_declarator.name] = &variable_declarator;
    }

    void syntactic_grammar::Configure_variable_initializer()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(expression, 1, 1),
            };
            variable_initializer.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(array_initializer, 1, 1),
            };
            variable_initializer.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[variable_initializer.name] = &variable_initializer;
    }

    void syntactic_grammar::Configure_method_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(method_header, 1, 1),
                ::grammar::base::create(method_body, 1, 1),
            };
            method_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[method_declaration.name] = &method_declaration;
    }

    void syntactic_grammar::Configure_method_header()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(method_modifiers, 0, 1),
                ::grammar::base::create(return_type, 1, 1),
                ::grammar::base::create(member_name, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(formal_parameter_list, 0, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
            };
            method_header.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[method_header.name] = &method_header;
    }

    void syntactic_grammar::Configure_method_modifiers()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(method_modifier, 1, ::grammar::infinity()),
            };
            method_modifiers.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[method_modifiers.name] = &method_modifiers;
    }

    void syntactic_grammar::Configure_method_modifier()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("new"), 1, 1),
            };
            method_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("public"), 1, 1),
            };
            method_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("protected"), 1, 1),
            };
            method_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("internal"), 1, 1),
            };
            method_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("private"), 1, 1),
            };
            method_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("static"), 1, 1),
            };
            method_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("virtual"), 1, 1),
            };
            method_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("sealed"), 1, 1),
            };
            method_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("override"), 1, 1),
            };
            method_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("abstract"), 1, 1),
            };
            method_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("extern"), 1, 1),
            };
            method_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("unsafe"), 1, 1),
            };
            method_modifier.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[method_modifier.name] = &method_modifier;
    }

    void syntactic_grammar::Configure_return_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(type, 1, 1),
            };
            return_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("void"), 1, 1),
            };
            return_type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[return_type.name] = &return_type;
    }

    void syntactic_grammar::Configure_member_name()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(member_access_suffix, 0, ::grammar::infinity()),
            };
            member_name.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[member_name.name] = &member_name;
    }

    void syntactic_grammar::Configure_method_body()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(block, 1, 1),
            };
            method_body.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            method_body.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[method_body.name] = &method_body;
    }

    void syntactic_grammar::Configure_formal_parameter_list()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(fixed_parameters, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(","), 1, 1),
                ::grammar::base::create(parameter_array, 1, 1),
            };
            formal_parameter_list.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(fixed_parameters, 1, 1),
            };
            formal_parameter_list.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(parameter_array, 1, 1),
            };
            formal_parameter_list.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[formal_parameter_list.name] = &formal_parameter_list;
    }

    void syntactic_grammar::Configure_fixed_parameters()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(fixed_parameter, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(","), 1, 1),
                ::grammar::base::create(fixed_parameters, 1, 1),
            };
            fixed_parameters.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(fixed_parameter, 1, 1),
            };
            fixed_parameters.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[fixed_parameters.name] = &fixed_parameters;
    }

    void syntactic_grammar::Configure_fixed_parameter()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(parameter_modifier, 0, 1),
                ::grammar::base::create(type, 1, 1),
                ::grammar::base::create(identifier, 1, 1),
            };
            fixed_parameter.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[fixed_parameter.name] = &fixed_parameter;
    }

    void syntactic_grammar::Configure_parameter_modifier()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("ref"), 1, 1),
            };
            parameter_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("out"), 1, 1),
            };
            parameter_modifier.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[parameter_modifier.name] = &parameter_modifier;
    }

    void syntactic_grammar::Configure_parameter_array()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("params"), 1, 1),
                ::grammar::base::create(array_type, 1, 1),
                ::grammar::base::create(identifier, 1, 1),
            };
            parameter_array.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[parameter_array.name] = &parameter_array;
    }

    void syntactic_grammar::Configure_property_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(property_modifiers, 0, 1),
                ::grammar::base::create(type, 1, 1),
                ::grammar::base::create(member_name, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("{"), 1, 1),
                ::grammar::base::create(accessor_declarations, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("}"), 1, 1),
            };
            property_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[property_declaration.name] = &property_declaration;
    }

    void syntactic_grammar::Configure_property_modifiers()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(property_modifier, 1, ::grammar::infinity()),
            };
            property_modifiers.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[property_modifiers.name] = &property_modifiers;
    }

    void syntactic_grammar::Configure_property_modifier()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("new"), 1, 1),
            };
            property_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("public"), 1, 1),
            };
            property_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("protected"), 1, 1),
            };
            property_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("internal"), 1, 1),
            };
            property_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("private"), 1, 1),
            };
            property_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("static"), 1, 1),
            };
            property_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("virtual"), 1, 1),
            };
            property_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("sealed"), 1, 1),
            };
            property_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("override"), 1, 1),
            };
            property_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("abstract"), 1, 1),
            };
            property_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("extern"), 1, 1),
            };
            property_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("unsafe"), 1, 1),
            };
            property_modifier.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[property_modifier.name] = &property_modifier;
    }

    void syntactic_grammar::Configure_accessor_declarations()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(get_accessor_declaration, 1, 1),
                ::grammar::base::create(set_accessor_declaration, 0, 1),
            };
            accessor_declarations.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(set_accessor_declaration, 1, 1),
                ::grammar::base::create(get_accessor_declaration, 0, 1),
            };
            accessor_declarations.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[accessor_declarations.name] = &accessor_declarations;
    }

    void syntactic_grammar::Configure_get_accessor_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("get"), 1, 1),
                ::grammar::base::create(accessor_body, 1, 1),
            };
            get_accessor_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[get_accessor_declaration.name] = &get_accessor_declaration;
    }

    void syntactic_grammar::Configure_set_accessor_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("set"), 1, 1),
                ::grammar::base::create(accessor_body, 1, 1),
            };
            set_accessor_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[set_accessor_declaration.name] = &set_accessor_declaration;
    }

    void syntactic_grammar::Configure_accessor_body()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(block, 1, 1),
            };
            accessor_body.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            accessor_body.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[accessor_body.name] = &accessor_body;
    }

    void syntactic_grammar::Configure_event_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(event_modifiers, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("event"), 1, 1),
                ::grammar::base::create(type, 1, 1),
                ::grammar::base::create(variable_declarators, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            event_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(event_modifiers, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("event"), 1, 1),
                ::grammar::base::create(type, 1, 1),
                ::grammar::base::create(member_name, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("{"), 1, 1),
                ::grammar::base::create(event_accessor_declarations, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("}"), 1, 1),
            };
            event_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[event_declaration.name] = &event_declaration;
    }

    void syntactic_grammar::Configure_event_modifiers()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(event_modifier, 1, ::grammar::infinity()),
            };
            event_modifiers.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[event_modifiers.name] = &event_modifiers;
    }

    void syntactic_grammar::Configure_event_modifier()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("new"), 1, 1),
            };
            event_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("public"), 1, 1),
            };
            event_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("protected"), 1, 1),
            };
            event_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("internal"), 1, 1),
            };
            event_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("private"), 1, 1),
            };
            event_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("static"), 1, 1),
            };
            event_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("virtual"), 1, 1),
            };
            event_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("sealed"), 1, 1),
            };
            event_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("override"), 1, 1),
            };
            event_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("abstract"), 1, 1),
            };
            event_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("extern"), 1, 1),
            };
            event_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("unsafe"), 1, 1),
            };
            event_modifier.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[event_modifier.name] = &event_modifier;
    }

    void syntactic_grammar::Configure_event_accessor_declarations()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(add_accessor_declaration, 1, 1),
                ::grammar::base::create(remove_accessor_declaration, 1, 1),
            };
            event_accessor_declarations.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(remove_accessor_declaration, 1, 1),
                ::grammar::base::create(add_accessor_declaration, 1, 1),
            };
            event_accessor_declarations.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[event_accessor_declarations.name] = &event_accessor_declarations;
    }

    void syntactic_grammar::Configure_add_accessor_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("add"), 1, 1),
                ::grammar::base::create(block, 1, 1),
            };
            add_accessor_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[add_accessor_declaration.name] = &add_accessor_declaration;
    }

    void syntactic_grammar::Configure_remove_accessor_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("remove"), 1, 1),
                ::grammar::base::create(block, 1, 1),
            };
            remove_accessor_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[remove_accessor_declaration.name] = &remove_accessor_declaration;
    }

    void syntactic_grammar::Configure_indexer_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(indexer_modifiers, 0, 1),
                ::grammar::base::create(indexer_declarator, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("{"), 1, 1),
                ::grammar::base::create(accessor_declarations, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("}"), 1, 1),
            };
            indexer_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[indexer_declaration.name] = &indexer_declaration;
    }

    void syntactic_grammar::Configure_indexer_modifiers()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(indexer_modifier, 1, ::grammar::infinity()),
            };
            indexer_modifiers.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[indexer_modifiers.name] = &indexer_modifiers;
    }

    void syntactic_grammar::Configure_indexer_modifier()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("new"), 1, 1),
            };
            indexer_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("public"), 1, 1),
            };
            indexer_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("protected"), 1, 1),
            };
            indexer_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("internal"), 1, 1),
            };
            indexer_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("private"), 1, 1),
            };
            indexer_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("virtual"), 1, 1),
            };
            indexer_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("sealed"), 1, 1),
            };
            indexer_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("override"), 1, 1),
            };
            indexer_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("abstract"), 1, 1),
            };
            indexer_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("extern"), 1, 1),
            };
            indexer_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("unsafe"), 1, 1),
            };
            indexer_modifier.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[indexer_modifier.name] = &indexer_modifier;
    }

    void syntactic_grammar::Configure_indexer_declarator()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(type, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("this"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("["), 1, 1),
                ::grammar::base::create(formal_parameter_list, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("]"), 1, 1),
            };
            indexer_declarator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(type, 1, 1),
                ::grammar::base::create(interface_type, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("."), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("this"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("["), 1, 1),
                ::grammar::base::create(formal_parameter_list, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("]"), 1, 1),
            };
            indexer_declarator.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[indexer_declarator.name] = &indexer_declarator;
    }

    void syntactic_grammar::Configure_operator_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(operator_modifiers, 1, 1),
                ::grammar::base::create(operator_declarator, 1, 1),
                ::grammar::base::create(operator_body, 1, 1),
            };
            operator_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[operator_declaration.name] = &operator_declaration;
    }

    void syntactic_grammar::Configure_operator_modifiers()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(operator_modifier, 1, ::grammar::infinity()),
            };
            operator_modifiers.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[operator_modifiers.name] = &operator_modifiers;
    }

    void syntactic_grammar::Configure_operator_modifier()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("public"), 1, 1),
            };
            operator_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("static"), 1, 1),
            };
            operator_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("extern"), 1, 1),
            };
            operator_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("unsafe"), 1, 1),
            };
            operator_modifier.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[operator_modifier.name] = &operator_modifier;
    }

    void syntactic_grammar::Configure_operator_declarator()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(unary_operator_declarator, 1, 1),
            };
            operator_declarator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(binary_operator_declarator, 1, 1),
            };
            operator_declarator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(conversion_operator_declarator, 1, 1),
            };
            operator_declarator.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[operator_declarator.name] = &operator_declarator;
    }

    void syntactic_grammar::Configure_unary_operator_declarator()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(type, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("operator"), 1, 1),
                ::grammar::base::create(overloadable_unary_operator, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(type, 1, 1),
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
            };
            unary_operator_declarator.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[unary_operator_declarator.name] = &unary_operator_declarator;
    }

    void syntactic_grammar::Configure_overloadable_unary_operator()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("+"), 1, 1),
            };
            overloadable_unary_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("-"), 1, 1),
            };
            overloadable_unary_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("!"), 1, 1),
            };
            overloadable_unary_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("~"), 1, 1),
            };
            overloadable_unary_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("++"), 1, 1),
            };
            overloadable_unary_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("--"), 1, 1),
            };
            overloadable_unary_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("true"), 1, 1),
            };
            overloadable_unary_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("false"), 1, 1),
            };
            overloadable_unary_operator.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[overloadable_unary_operator.name] = &overloadable_unary_operator;
    }

    void syntactic_grammar::Configure_binary_operator_declarator()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(type, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("operator"), 1, 1),
                ::grammar::base::create(overloadable_binary_operator, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(type, 1, 1),
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(","), 1, 1),
                ::grammar::base::create(type, 1, 1),
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
            };
            binary_operator_declarator.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[binary_operator_declarator.name] = &binary_operator_declarator;
    }

    void syntactic_grammar::Configure_overloadable_binary_operator()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("+"), 1, 1),
            };
            overloadable_binary_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("-"), 1, 1),
            };
            overloadable_binary_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("*"), 1, 1),
            };
            overloadable_binary_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("/"), 1, 1),
            };
            overloadable_binary_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("%"), 1, 1),
            };
            overloadable_binary_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("&"), 1, 1),
            };
            overloadable_binary_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("|"), 1, 1),
            };
            overloadable_binary_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("^"), 1, 1),
            };
            overloadable_binary_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("<<"), 1, 1),
            };
            overloadable_binary_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(">>"), 1, 1),
            };
            overloadable_binary_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("=="), 1, 1),
            };
            overloadable_binary_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("!="), 1, 1),
            };
            overloadable_binary_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(">"), 1, 1),
            };
            overloadable_binary_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("<"), 1, 1),
            };
            overloadable_binary_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(">="), 1, 1),
            };
            overloadable_binary_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("<="), 1, 1),
            };
            overloadable_binary_operator.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[overloadable_binary_operator.name] = &overloadable_binary_operator;
    }

    void syntactic_grammar::Configure_conversion_operator_declarator()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("implicit"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("operator"), 1, 1),
                ::grammar::base::create(type, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(type, 1, 1),
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
            };
            conversion_operator_declarator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("explicit"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("operator"), 1, 1),
                ::grammar::base::create(type, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(type, 1, 1),
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
            };
            conversion_operator_declarator.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[conversion_operator_declarator.name] = &conversion_operator_declarator;
    }

    void syntactic_grammar::Configure_operator_body()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(block, 1, 1),
            };
            operator_body.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            operator_body.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[operator_body.name] = &operator_body;
    }

    void syntactic_grammar::Configure_constructor_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(constructor_modifiers, 0, 1),
                ::grammar::base::create(constructor_declarator, 1, 1),
                ::grammar::base::create(constructor_body, 1, 1),
            };
            constructor_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[constructor_declaration.name] = &constructor_declaration;
    }

    void syntactic_grammar::Configure_constructor_modifiers()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(constructor_modifier, 1, ::grammar::infinity()),
            };
            constructor_modifiers.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[constructor_modifiers.name] = &constructor_modifiers;
    }

    void syntactic_grammar::Configure_constructor_modifier()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("public"), 1, 1),
            };
            constructor_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("protected"), 1, 1),
            };
            constructor_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("internal"), 1, 1),
            };
            constructor_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("private"), 1, 1),
            };
            constructor_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("extern"), 1, 1),
            };
            constructor_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("unsafe"), 1, 1),
            };
            constructor_modifier.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[constructor_modifier.name] = &constructor_modifier;
    }

    void syntactic_grammar::Configure_constructor_declarator()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(formal_parameter_list, 0, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
                ::grammar::base::create(constructor_initializer, 0, 1),
            };
            constructor_declarator.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[constructor_declarator.name] = &constructor_declarator;
    }

    void syntactic_grammar::Configure_constructor_initializer()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(":"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("base"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(argument_list, 0, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
            };
            constructor_initializer.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(":"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("this"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(argument_list, 0, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
            };
            constructor_initializer.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[constructor_initializer.name] = &constructor_initializer;
    }

    void syntactic_grammar::Configure_constructor_body()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(block, 1, 1),
            };
            constructor_body.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            constructor_body.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[constructor_body.name] = &constructor_body;
    }

    void syntactic_grammar::Configure_static_constructor_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(static_constructor_modifiers, 1, 1),
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
                ::grammar::base::create(static_constructor_body, 1, 1),
            };
            static_constructor_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[static_constructor_declaration.name] = &static_constructor_declaration;
    }

    void syntactic_grammar::Configure_static_constructor_modifiers()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("extern"), 0, 1),
                ::grammar::base::create(::grammar::base::terminal("unsafe"), 0, 1),
                ::grammar::base::create(::grammar::base::terminal("static"), 1, 1),
            };
            static_constructor_modifiers.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("unsafe"), 0, 1),
                ::grammar::base::create(::grammar::base::terminal("extern"), 0, 1),
                ::grammar::base::create(::grammar::base::terminal("static"), 1, 1),
            };
            static_constructor_modifiers.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("extern"), 0, 1),
                ::grammar::base::create(::grammar::base::terminal("static"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("unsafe"), 0, 1),
            };
            static_constructor_modifiers.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("unsafe"), 0, 1),
                ::grammar::base::create(::grammar::base::terminal("static"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("extern"), 0, 1),
            };
            static_constructor_modifiers.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("static"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("extern"), 0, 1),
                ::grammar::base::create(::grammar::base::terminal("unsafe"), 0, 1),
            };
            static_constructor_modifiers.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("static"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("unsafe"), 0, 1),
                ::grammar::base::create(::grammar::base::terminal("extern"), 0, 1),
            };
            static_constructor_modifiers.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[static_constructor_modifiers.name] = &static_constructor_modifiers;
    }

    void syntactic_grammar::Configure_static_constructor_body()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(block, 1, 1),
            };
            static_constructor_body.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            static_constructor_body.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[static_constructor_body.name] = &static_constructor_body;
    }

    void syntactic_grammar::Configure_destructor_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("extern"), 0, 1),
                ::grammar::base::create(::grammar::base::terminal("unsafe"), 0, 1),
                ::grammar::base::create(::grammar::base::terminal("~"), 1, 1),
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
                ::grammar::base::create(destructor_body, 1, 1),
            };
            destructor_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("unsafe"), 0, 1),
                ::grammar::base::create(::grammar::base::terminal("extern"), 0, 1),
                ::grammar::base::create(::grammar::base::terminal("~"), 1, 1),
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
                ::grammar::base::create(destructor_body, 1, 1),
            };
            destructor_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[destructor_declaration.name] = &destructor_declaration;
    }

    void syntactic_grammar::Configure_destructor_body()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(block, 1, 1),
            };
            destructor_body.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            destructor_body.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[destructor_body.name] = &destructor_body;
    }

    void syntactic_grammar::Configure_struct_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(struct_modifiers, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("struct"), 1, 1),
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(struct_interfaces, 0, 1),
                ::grammar::base::create(struct_body, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 0, 1),
            };
            struct_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[struct_declaration.name] = &struct_declaration;
    }

    void syntactic_grammar::Configure_struct_modifiers()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(struct_modifier, 1, ::grammar::infinity()),
            };
            struct_modifiers.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[struct_modifiers.name] = &struct_modifiers;
    }

    void syntactic_grammar::Configure_struct_modifier()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("new"), 1, 1),
            };
            struct_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("public"), 1, 1),
            };
            struct_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("protected"), 1, 1),
            };
            struct_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("internal"), 1, 1),
            };
            struct_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("private"), 1, 1),
            };
            struct_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("unsafe"), 1, 1),
            };
            struct_modifier.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[struct_modifier.name] = &struct_modifier;
    }

    void syntactic_grammar::Configure_struct_interfaces()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(":"), 1, 1),
                ::grammar::base::create(interface_type, 1, 1),
                ::grammar::base::create(interface_type_list, 0, ::grammar::infinity()),
            };
            struct_interfaces.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[struct_interfaces.name] = &struct_interfaces;
    }

    void syntactic_grammar::Configure_struct_body()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("{"), 1, 1),
                ::grammar::base::create(struct_member_declarations, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("}"), 1, 1),
            };
            struct_body.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[struct_body.name] = &struct_body;
    }

    void syntactic_grammar::Configure_struct_member_declarations()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(struct_member_declaration, 1, ::grammar::infinity()),
            };
            struct_member_declarations.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[struct_member_declarations.name] = &struct_member_declarations;
    }

    void syntactic_grammar::Configure_struct_member_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(constant_declaration, 1, 1),
            };
            struct_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(field_declaration, 1, 1),
            };
            struct_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(method_declaration, 1, 1),
            };
            struct_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(property_declaration, 1, 1),
            };
            struct_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(event_declaration, 1, 1),
            };
            struct_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(indexer_declaration, 1, 1),
            };
            struct_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(operator_declaration, 1, 1),
            };
            struct_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(constructor_declaration, 1, 1),
            };
            struct_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(static_constructor_declaration, 1, 1),
            };
            struct_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(type_declaration, 1, 1),
            };
            struct_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[struct_member_declaration.name] = &struct_member_declaration;
    }

    void syntactic_grammar::Configure_array_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(non_array_type, 1, 1),
                ::grammar::base::create(rank_specifiers, 1, 1),
            };
            array_type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[array_type.name] = &array_type;
    }

    void syntactic_grammar::Configure_non_array_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pointer_type, 1, 1),
            };
            non_array_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(value_type, 1, 1),
            };
            non_array_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(class_type, 1, 1),
            };
            non_array_type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[non_array_type.name] = &non_array_type;
    }

    void syntactic_grammar::Configure_rank_specifiers()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(rank_specifier, 1, ::grammar::infinity()),
            };
            rank_specifiers.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[rank_specifiers.name] = &rank_specifiers;
    }

    void syntactic_grammar::Configure_rank_specifier()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("["), 1, 1),
                ::grammar::base::create(dim_separators, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("]"), 1, 1),
            };
            rank_specifier.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[rank_specifier.name] = &rank_specifier;
    }

    void syntactic_grammar::Configure_dim_separators()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(","), 1, ::grammar::infinity()),
            };
            dim_separators.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[dim_separators.name] = &dim_separators;
    }

    void syntactic_grammar::Configure_array_initializer()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("{"), 1, 1),
                ::grammar::base::create(variable_initializer_list, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("}"), 1, 1),
            };
            array_initializer.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("{"), 1, 1),
                ::grammar::base::create(variable_initializer_list, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(","), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("}"), 1, 1),
            };
            array_initializer.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[array_initializer.name] = &array_initializer;
    }

    void syntactic_grammar::Configure_variable_initializer_list()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(variable_initializer, 1, 1),
                ::grammar::base::create(variable_initializers, 0, 1),
            };
            variable_initializer_list.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[variable_initializer_list.name] = &variable_initializer_list;
    }

    void syntactic_grammar::Configure_variable_initializers()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(","), 1, 1),
                ::grammar::base::create(variable_initializer_list, 1, 1),
            };
            variable_initializers.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[variable_initializers.name] = &variable_initializers;
    }

    void syntactic_grammar::Configure_interface_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(interface_modifiers, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("interface"), 1, 1),
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(interface_base, 0, 1),
                ::grammar::base::create(interface_body, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 0, 1),
            };
            interface_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[interface_declaration.name] = &interface_declaration;
    }

    void syntactic_grammar::Configure_interface_modifiers()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(interface_modifier, 1, ::grammar::infinity()),
            };
            interface_modifiers.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[interface_modifiers.name] = &interface_modifiers;
    }

    void syntactic_grammar::Configure_interface_modifier()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("new"), 1, 1),
            };
            interface_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("public"), 1, 1),
            };
            interface_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("protected"), 1, 1),
            };
            interface_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("internal"), 1, 1),
            };
            interface_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("private"), 1, 1),
            };
            interface_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("unsafe"), 1, 1),
            };
            interface_modifier.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[interface_modifier.name] = &interface_modifier;
    }

    void syntactic_grammar::Configure_interface_base()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(":"), 1, 1),
                ::grammar::base::create(interface_type_list, 1, 1),
            };
            interface_base.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[interface_base.name] = &interface_base;
    }

    void syntactic_grammar::Configure_interface_body()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("{"), 1, 1),
                ::grammar::base::create(interface_member_declarations, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("}"), 1, 1),
            };
            interface_body.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[interface_body.name] = &interface_body;
    }

    void syntactic_grammar::Configure_interface_member_declarations()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(interface_member_declaration, 1, ::grammar::infinity()),
            };
            interface_member_declarations.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[interface_member_declarations.name] = &interface_member_declarations;
    }

    void syntactic_grammar::Configure_interface_member_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(interface_method_declaration, 1, 1),
            };
            interface_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(interface_property_declaration, 1, 1),
            };
            interface_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(interface_event_declaration, 1, 1),
            };
            interface_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(interface_indexer_declaration, 1, 1),
            };
            interface_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[interface_member_declaration.name] = &interface_member_declaration;
    }

    void syntactic_grammar::Configure_interface_method_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("new"), 0, 1),
                ::grammar::base::create(return_type, 1, 1),
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(formal_parameter_list, 0, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            interface_method_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[interface_method_declaration.name] = &interface_method_declaration;
    }

    void syntactic_grammar::Configure_interface_property_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("new"), 0, 1),
                ::grammar::base::create(type, 1, 1),
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("{"), 1, 1),
                ::grammar::base::create(interface_accessors, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("}"), 1, 1),
            };
            interface_property_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[interface_property_declaration.name] = &interface_property_declaration;
    }

    void syntactic_grammar::Configure_interface_accessors()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("get"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("set"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            interface_accessors.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("set"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("get"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            interface_accessors.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("get"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            interface_accessors.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("set"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            interface_accessors.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[interface_accessors.name] = &interface_accessors;
    }

    void syntactic_grammar::Configure_interface_event_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("new"), 0, 1),
                ::grammar::base::create(::grammar::base::terminal("event"), 1, 1),
                ::grammar::base::create(type, 1, 1),
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            interface_event_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[interface_event_declaration.name] = &interface_event_declaration;
    }

    void syntactic_grammar::Configure_interface_indexer_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("new"), 0, 1),
                ::grammar::base::create(type, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("this"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("["), 1, 1),
                ::grammar::base::create(formal_parameter_list, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("]"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("{"), 1, 1),
                ::grammar::base::create(interface_accessors, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("}"), 1, 1),
            };
            interface_indexer_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[interface_indexer_declaration.name] = &interface_indexer_declaration;
    }

    void syntactic_grammar::Configure_enum_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(enum_modifiers, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("enum"), 1, 1),
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(enum_base, 0, 1),
                ::grammar::base::create(enum_body, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 0, 1),
            };
            enum_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[enum_declaration.name] = &enum_declaration;
    }

    void syntactic_grammar::Configure_enum_base()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(":"), 1, 1),
                ::grammar::base::create(integral_type, 1, 1),
            };
            enum_base.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[enum_base.name] = &enum_base;
    }

    void syntactic_grammar::Configure_enum_body()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("{"), 1, 1),
                ::grammar::base::create(enum_member_declaration_list, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("}"), 1, 1),
            };
            enum_body.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("{"), 1, 1),
                ::grammar::base::create(enum_member_declaration_list, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(","), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("}"), 1, 1),
            };
            enum_body.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[enum_body.name] = &enum_body;
    }

    void syntactic_grammar::Configure_enum_modifiers()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(enum_modifier, 1, ::grammar::infinity()),
            };
            enum_modifiers.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[enum_modifiers.name] = &enum_modifiers;
    }

    void syntactic_grammar::Configure_enum_modifier()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("new"), 1, 1),
            };
            enum_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("public"), 1, 1),
            };
            enum_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("protected"), 1, 1),
            };
            enum_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("internal"), 1, 1),
            };
            enum_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("private"), 1, 1),
            };
            enum_modifier.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[enum_modifier.name] = &enum_modifier;
    }

    void syntactic_grammar::Configure_enum_member_declaration_list()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(enum_member_declaration, 1, 1),
                ::grammar::base::create(enum_member_declarations, 0, 1),
            };
            enum_member_declaration_list.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[enum_member_declaration_list.name] = &enum_member_declaration_list;
    }

    void syntactic_grammar::Configure_enum_member_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("="), 1, 1),
                ::grammar::base::create(constant_expression, 1, 1),
            };
            enum_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(identifier, 1, 1),
            };
            enum_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[enum_member_declaration.name] = &enum_member_declaration;
    }

    void syntactic_grammar::Configure_enum_member_declarations()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(","), 1, 1),
                ::grammar::base::create(enum_member_declaration_list, 1, 1),
            };
            enum_member_declarations.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[enum_member_declarations.name] = &enum_member_declarations;
    }

    void syntactic_grammar::Configure_delegate_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(delegate_modifiers, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("delegate"), 1, 1),
                ::grammar::base::create(return_type, 1, 1),
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(formal_parameter_list, 0, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            delegate_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[delegate_declaration.name] = &delegate_declaration;
    }

    void syntactic_grammar::Configure_delegate_modifiers()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(delegate_modifier, 1, ::grammar::infinity()),
            };
            delegate_modifiers.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[delegate_modifiers.name] = &delegate_modifiers;
    }

    void syntactic_grammar::Configure_delegate_modifier()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("new"), 1, 1),
            };
            delegate_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("public"), 1, 1),
            };
            delegate_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("protected"), 1, 1),
            };
            delegate_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("internal"), 1, 1),
            };
            delegate_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("private"), 1, 1),
            };
            delegate_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("unsafe"), 1, 1),
            };
            delegate_modifier.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[delegate_modifier.name] = &delegate_modifier;
    }

    void syntactic_grammar::Configure_global_attributes()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(global_attribute_sections, 1, 1),
            };
            global_attributes.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[global_attributes.name] = &global_attributes;
    }

    void syntactic_grammar::Configure_global_attribute_sections()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(global_attribute_section, 1, ::grammar::infinity()),
            };
            global_attribute_sections.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[global_attribute_sections.name] = &global_attribute_sections;
    }

    void syntactic_grammar::Configure_global_attribute_section()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("["), 1, 1),
                ::grammar::base::create(global_attribute_target_specifier, 1, 1),
                ::grammar::base::create(attribute_list, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("]"), 1, 1),
            };
            global_attribute_section.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("["), 1, 1),
                ::grammar::base::create(global_attribute_target_specifier, 1, 1),
                ::grammar::base::create(attribute_list, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(","), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("]"), 1, 1),
            };
            global_attribute_section.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[global_attribute_section.name] = &global_attribute_section;
    }

    void syntactic_grammar::Configure_global_attribute_target_specifier()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(global_attribute_target, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(":"), 1, 1),
            };
            global_attribute_target_specifier.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[global_attribute_target_specifier.name] = &global_attribute_target_specifier;
    }

    void syntactic_grammar::Configure_global_attribute_target()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("assembly"), 1, 1),
            };
            global_attribute_target.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[global_attribute_target.name] = &global_attribute_target;
    }

    void syntactic_grammar::Configure_attributes()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attribute_sections, 1, 1),
            };
            attributes.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[attributes.name] = &attributes;
    }

    void syntactic_grammar::Configure_attribute_sections()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attribute_section, 1, ::grammar::infinity()),
            };
            attribute_sections.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[attribute_sections.name] = &attribute_sections;
    }

    void syntactic_grammar::Configure_attribute_section()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("["), 1, 1),
                ::grammar::base::create(attribute_target_specifier, 0, 1),
                ::grammar::base::create(attribute_list, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("]"), 1, 1),
            };
            attribute_section.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("["), 1, 1),
                ::grammar::base::create(attribute_target_specifier, 0, 1),
                ::grammar::base::create(attribute_list, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(","), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("]"), 1, 1),
            };
            attribute_section.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[attribute_section.name] = &attribute_section;
    }

    void syntactic_grammar::Configure_attribute_target_specifier()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attribute_target, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(":"), 1, 1),
            };
            attribute_target_specifier.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[attribute_target_specifier.name] = &attribute_target_specifier;
    }

    void syntactic_grammar::Configure_attribute_target()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("field"), 1, 1),
            };
            attribute_target.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("event"), 1, 1),
            };
            attribute_target.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("method"), 1, 1),
            };
            attribute_target.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("param"), 1, 1),
            };
            attribute_target.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("property"), 1, 1),
            };
            attribute_target.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("return"), 1, 1),
            };
            attribute_target.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(type, 1, 1),
            };
            attribute_target.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[attribute_target.name] = &attribute_target;
    }

    void syntactic_grammar::Configure_attribute_list()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attribute, 1, 1),
            };
            attribute_list.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attribute, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(","), 1, 1),
                ::grammar::base::create(attribute_list, 1, 1),
            };
            attribute_list.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[attribute_list.name] = &attribute_list;
    }

    void syntactic_grammar::Configure_attribute()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attribute_name, 1, 1),
                ::grammar::base::create(attribute_arguments, 0, 1),
            };
            attribute.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[attribute.name] = &attribute;
    }

    void syntactic_grammar::Configure_attribute_name()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(type_name, 1, 1),
            };
            attribute_name.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[attribute_name.name] = &attribute_name;
    }

    void syntactic_grammar::Configure_attribute_arguments()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(attribute_argument_list, 0, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
            };
            attribute_arguments.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[attribute_arguments.name] = &attribute_arguments;
    }

    void syntactic_grammar::Configure_attribute_argument_list()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(named_argument_list, 1, 1),
            };
            attribute_argument_list.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(positional_argument, 1, 1),
                ::grammar::base::create(positional_arguments, 0, 1),
            };
            attribute_argument_list.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[attribute_argument_list.name] = &attribute_argument_list;
    }

    void syntactic_grammar::Configure_positional_argument()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attribute_argument_expression, 1, 1),
            };
            positional_argument.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[positional_argument.name] = &positional_argument;
    }

    void syntactic_grammar::Configure_positional_arguments()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(","), 1, 1),
                ::grammar::base::create(attribute_argument_list, 1, 1),
            };
            positional_arguments.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[positional_arguments.name] = &positional_arguments;
    }

    void syntactic_grammar::Configure_named_argument_list()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(named_argument, 1, 1),
                ::grammar::base::create(named_arguments, 0, 1),
            };
            named_argument_list.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[named_argument_list.name] = &named_argument_list;
    }

    void syntactic_grammar::Configure_named_argument()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("="), 1, 1),
                ::grammar::base::create(attribute_argument_expression, 1, 1),
            };
            named_argument.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[named_argument.name] = &named_argument;
    }

    void syntactic_grammar::Configure_named_arguments()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(","), 1, 1),
                ::grammar::base::create(named_argument_list, 1, 1),
            };
            named_arguments.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[named_arguments.name] = &named_arguments;
    }

    void syntactic_grammar::Configure_attribute_argument_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(expression, 1, 1),
            };
            attribute_argument_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[attribute_argument_expression.name] = &attribute_argument_expression;
    }

    void syntactic_grammar::Configure_unsafe_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("unsafe"), 1, 1),
                ::grammar::base::create(block, 1, 1),
            };
            unsafe_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[unsafe_statement.name] = &unsafe_statement;
    }

    void syntactic_grammar::Configure_pointer_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(value_type, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("*"), 1, ::grammar::infinity()),
            };
            pointer_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("object"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("*"), 1, ::grammar::infinity()),
            };
            pointer_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("string"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("*"), 1, ::grammar::infinity()),
            };
            pointer_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("void"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("*"), 1, ::grammar::infinity()),
            };
            pointer_type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pointer_type.name] = &pointer_type;
    }

    void syntactic_grammar::Configure_unmanaged_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(value_type, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("*"), 0, ::grammar::infinity()),
            };
            unmanaged_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("void"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("*"), 1, ::grammar::infinity()),
            };
            unmanaged_type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[unmanaged_type.name] = &unmanaged_type;
    }

    void syntactic_grammar::Configure_pointer_indirection_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("*"), 1, 1),
                ::grammar::base::create(unary_expression, 1, 1),
            };
            pointer_indirection_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pointer_indirection_expression.name] = &pointer_indirection_expression;
    }

    void syntactic_grammar::Configure_pointer_member_access()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pma_primary_no_array_creation_expression, 1, 1),
                ::grammar::base::create(pointer_member_access_suffix, 1, 1),
            };
            pointer_member_access.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pointer_member_access.name] = &pointer_member_access;
    }

    void syntactic_grammar::Configure_pointer_member_access_suffix()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("->"), 1, 1),
                ::grammar::base::create(identifier, 1, 1),
            };
            pointer_member_access_suffix.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pointer_member_access_suffix.name] = &pointer_member_access_suffix;
    }

    void syntactic_grammar::Configure_pma_primary_no_array_creation_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(simple_name, 1, 1),
                ::grammar::base::create(pma_primary_suffix, 0, 1),
            };
            pma_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(parenthesized_expression, 1, 1),
                ::grammar::base::create(pma_primary_suffix, 0, 1),
            };
            pma_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(this_access, 1, 1),
                ::grammar::base::create(pma_primary_suffix, 0, 1),
            };
            pma_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(base_access, 1, 1),
                ::grammar::base::create(pma_primary_suffix, 0, 1),
            };
            pma_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(object_creation_expression, 1, 1),
                ::grammar::base::create(pma_primary_suffix, 0, 1),
            };
            pma_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(delegate_creation_expression, 1, 1),
                ::grammar::base::create(pma_primary_suffix, 0, 1),
            };
            pma_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pma_primary_no_array_creation_expression.name] = &pma_primary_no_array_creation_expression;
    }

    void syntactic_grammar::Configure_pma_primary_suffix()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pointer_member_access_suffix, 1, 1),
                ::grammar::base::create(pma_primary_suffix, 1, 1),
            };
            pma_primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(member_access_suffix, 1, 1),
                ::grammar::base::create(pma_primary_suffix, 0, 1),
            };
            pma_primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(invocation_expression_suffix, 1, 1),
                ::grammar::base::create(pma_primary_suffix, 0, 1),
            };
            pma_primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(element_access_suffix, 1, 1),
                ::grammar::base::create(pma_primary_suffix, 0, 1),
            };
            pma_primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(post_increment_suffix, 1, 1),
                ::grammar::base::create(pma_primary_suffix, 0, 1),
            };
            pma_primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(post_decrement_suffix, 1, 1),
                ::grammar::base::create(pma_primary_suffix, 0, 1),
            };
            pma_primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pma_primary_suffix.name] = &pma_primary_suffix;
    }

    void syntactic_grammar::Configure_addressof_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("&"), 1, 1),
                ::grammar::base::create(unary_expression, 1, 1),
            };
            addressof_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[addressof_expression.name] = &addressof_expression;
    }

    void syntactic_grammar::Configure_sizeof_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("sizeof"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(unmanaged_type, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
            };
            sizeof_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[sizeof_expression.name] = &sizeof_expression;
    }

    void syntactic_grammar::Configure_fixed_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("fixed"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(pointer_type, 1, 1),
                ::grammar::base::create(fixed_pointer_declarator_list, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
                ::grammar::base::create(embedded_statement, 1, 1),
            };
            fixed_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[fixed_statement.name] = &fixed_statement;
    }

    void syntactic_grammar::Configure_fixed_pointer_declarator_list()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(fixed_pointer_declarator, 1, 1),
                ::grammar::base::create(fixed_pointer_declarators, 0, 1),
            };
            fixed_pointer_declarator_list.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[fixed_pointer_declarator_list.name] = &fixed_pointer_declarator_list;
    }

    void syntactic_grammar::Configure_fixed_pointer_declarator()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("="), 1, 1),
                ::grammar::base::create(fixed_pointer_initializer, 1, 1),
            };
            fixed_pointer_declarator.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[fixed_pointer_declarator.name] = &fixed_pointer_declarator;
    }

    void syntactic_grammar::Configure_fixed_pointer_declarators()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(","), 1, 1),
                ::grammar::base::create(fixed_pointer_declarator_list, 1, 1),
            };
            fixed_pointer_declarators.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[fixed_pointer_declarators.name] = &fixed_pointer_declarators;
    }

    void syntactic_grammar::Configure_fixed_pointer_initializer()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("&"), 1, 1),
                ::grammar::base::create(variable_reference, 1, 1),
            };
            fixed_pointer_initializer.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(expression, 1, 1),
            };
            fixed_pointer_initializer.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[fixed_pointer_initializer.name] = &fixed_pointer_initializer;
    }

    void syntactic_grammar::Configure_stackalloc_initializer()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("stackalloc"), 1, 1),
                ::grammar::base::create(unmanaged_type, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("["), 1, 1),
                ::grammar::base::create(expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("]"), 1, 1),
            };
            stackalloc_initializer.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[stackalloc_initializer.name] = &stackalloc_initializer;
    }
}

namespace csharp // syntactic_grammar - 'tor
{
    syntactic_grammar::syntactic_grammar()
        : ::grammar::base()
        , namespace_name(key(), "namespace-name", 1)
        , type_name(key(), "type-name", 1)
        , namespace_or_type_name(key(), "namespace-or-type-name", 1)
        , type(key(), "type", 3)
        , value_type(key(), "value-type", 2)
        , struct_type(key(), "struct-type", 2)
        , simple_type(key(), "simple-type", 2)
        , numeric_type(key(), "numeric-type", 3)
        , integral_type(key(), "integral-type", 9)
        , floating_point_type(key(), "floating-point-type", 2)
        , enum_type(key(), "enum-type", 1)
        , reference_type(key(), "reference-type", 4)
        , class_type(key(), "class-type", 3)
        , interface_type(key(), "interface-type", 1)
        , delegate_type(key(), "delegate-type", 1)
        , variable_reference(key(), "variable-reference", 1)
        , argument_list(key(), "argument-list", 1)
        , arguments(key(), "arguments", 1)
        , argument(key(), "argument", 3)
        , primary_expression(key(), "primary-expression", 2)
        , primary_no_array_creation_expression(key(), "primary-no-array-creation-expression", 12)
        , primary_suffix(key(), "primary-suffix", 6)
        , member_access_suffix(key(), "member-access-suffix", 1)
        , invocation_expression_suffix(key(), "invocation-expression-suffix", 1)
        , element_access_suffix(key(), "element-access-suffix", 1)
        , post_increment_suffix(key(), "post-increment-suffix", 1)
        , post_decrement_suffix(key(), "post-decrement-suffix", 1)
        , expression_list(key(), "expression-list", 1)
        , expressions(key(), "expressions", 1)
        , simple_name(key(), "simple-name", 1)
        , parenthesized_expression(key(), "parenthesized-expression", 1)
        , predefined_type(key(), "predefined-type", 15)
        , invocation_expression(key(), "invocation-expression", 1)
        , ie_primary_no_array_creation_expression(key(), "ie-primary-no-array-creation-expression", 12)
        , ie_primary_suffix(key(), "ie-primary-suffix", 6)
        , post_increment_expression(key(), "post-increment-expression", 1)
        , post_decrement_expression(key(), "post-decrement-expression", 1)
        , pide_primary_no_array_creation_expression(key(), "pide-primary-no-array-creation-expression", 4)
        , pide_primary_suffix(key(), "pide-primary-suffix", 4)
        , this_access(key(), "this-access", 1)
        , base_access(key(), "base-access", 2)
        , object_creation_expression(key(), "object-creation-expression", 1)
        , array_creation_expression(key(), "array-creation-expression", 2)
        , delegate_creation_expression(key(), "delegate-creation-expression", 1)
        , typeof_expression(key(), "typeof-expression", 2)
        , checked_expression(key(), "checked-expression", 1)
        , unchecked_expression(key(), "unchecked-expression", 1)
        , unary_expression(key(), "unary-expression", 12)
        , pre_increment_expression(key(), "pre-increment-expression", 1)
        , pre_decrement_expression(key(), "pre-decrement-expression", 1)
        , cast_expression(key(), "cast-expression", 1)
        , multiplicative_expression(key(), "multiplicative-expression", 1)
        , multiplicative_expressions(key(), "multiplicative-expressions", 3)
        , additive_expression(key(), "additive-expression", 1)
        , additive_expressions(key(), "additive-expressions", 2)
        , shift_expression(key(), "shift-expression", 1)
        , shift_expressions(key(), "shift-expressions", 2)
        , relational_expression(key(), "relational-expression", 1)
        , relational_expressions(key(), "relational-expressions", 6)
        , equality_expression(key(), "equality-expression", 1)
        , equality_expressions(key(), "equality-expressions", 2)
        , and_expression(key(), "and-expression", 1)
        , and_expressions(key(), "and-expressions", 1)
        , exclusive_or_expression(key(), "exclusive-or-expression", 1)
        , exclusive_or_expressions(key(), "exclusive-or-expressions", 1)
        , inclusive_or_expression(key(), "inclusive-or-expression", 1)
        , inclusive_or_expressions(key(), "inclusive-or-expressions", 1)
        , conditional_and_expression(key(), "conditional-and-expression", 1)
        , conditional_and_expressions(key(), "conditional-and-expressions", 1)
        , conditional_or_expression(key(), "conditional-or-expression", 1)
        , conditional_or_expressions(key(), "conditional-or-expressions", 1)
        , conditional_expression(key(), "conditional-expression", 2)
        , assignment(key(), "assignment", 1)
        , assignment_operator(key(), "assignment-operator", 11)
        , expression(key(), "expression", 2)
        , constant_expression(key(), "constant-expression", 1)
        , boolean_expression(key(), "boolean-expression", 1)
        , statement(key(), "statement", 3)
        , embedded_statement(key(), "embedded-statement", 13)
        , block(key(), "block", 1)
        , statement_list(key(), "statement-list", 1)
        , empty_statement(key(), "empty-statement", 1)
        , labeled_statement(key(), "labeled-statement", 1)
        , declaration_statement(key(), "declaration-statement", 2)
        , local_variable_declaration(key(), "local-variable-declaration", 1)
        , local_variable_declarators(key(), "local-variable-declarators", 2)
        , local_variable_declarator(key(), "local-variable-declarator", 2)
        , local_variable_initializer(key(), "local-variable-initializer", 3)
        , local_constant_declaration(key(), "local-constant-declaration", 1)
        , expression_statement(key(), "expression-statement", 1)
        , statement_expression(key(), "statement-expression", 7)
        , selection_statement(key(), "selection-statement", 2)
        , if_statement(key(), "if-statement", 2)
        , switch_statement(key(), "switch-statement", 1)
        , switch_block(key(), "switch-block", 1)
        , switch_sections(key(), "switch-sections", 1)
        , switch_section(key(), "switch-section", 1)
        , switch_labels(key(), "switch-labels", 1)
        , switch_label(key(), "switch-label", 2)
        , iteration_statement(key(), "iteration-statement", 4)
        , while_statement(key(), "while-statement", 1)
        , do_statement(key(), "do-statement", 1)
        , for_statement(key(), "for-statement", 1)
        , for_initializer(key(), "for-initializer", 2)
        , for_condition(key(), "for-condition", 1)
        , for_iterator(key(), "for-iterator", 1)
        , statement_expression_list(key(), "statement-expression-list", 2)
        , foreach_statement(key(), "foreach-statement", 1)
        , jump_statement(key(), "jump-statement", 5)
        , break_statement(key(), "break-statement", 1)
        , continue_statement(key(), "continue-statement", 1)
        , goto_statement(key(), "goto-statement", 3)
        , return_statement(key(), "return-statement", 1)
        , throw_statement(key(), "throw-statement", 1)
        , try_statement(key(), "try-statement", 2)
        , catch_clauses(key(), "catch-clauses", 2)
        , specific_catch_clauses(key(), "specific-catch-clauses", 1)
        , specific_catch_clause(key(), "specific-catch-clause", 1)
        , general_catch_clause(key(), "general-catch-clause", 1)
        , finally_clause(key(), "finally-clause", 1)
        , checked_statement(key(), "checked-statement", 1)
        , unchecked_statement(key(), "unchecked-statement", 1)
        , lock_statement(key(), "lock-statement", 1)
        , using_statement(key(), "using-statement", 1)
        , resource_acquisition(key(), "resource-acquisition", 2)
        , compilation_unit(key(), "compilation-unit", 1)
        , namespace_declaration(key(), "namespace-declaration", 1)
        , qualified_identifier(key(), "qualified-identifier", 1)
        , identifiers(key(), "identifiers", 1)
        , namespace_body(key(), "namespace-body", 1)
        , using_directives(key(), "using-directives", 1)
        , using_directive(key(), "using-directive", 2)
        , using_alias_directive(key(), "using-alias-directive", 1)
        , using_namespace_directive(key(), "using-namespace-directive", 1)
        , namespace_member_declarations(key(), "namespace-member-declarations", 1)
        , namespace_member_declaration(key(), "namespace-member-declaration", 2)
        , type_declaration(key(), "type-declaration", 5)
        , class_declaration(key(), "class-declaration", 1)
        , class_modifiers(key(), "class-modifiers", 1)
        , class_modifier(key(), "class-modifier", 8)
        , class_base(key(), "class-base", 1)
        , base_type(key(), "base-type", 2)
        , interface_type_list(key(), "interface-type-list", 1)
        , class_body(key(), "class-body", 1)
        , class_member_declarations(key(), "class-member-declarations", 1)
        , class_member_declaration(key(), "class-member-declaration", 11)
        , constant_declaration(key(), "constant-declaration", 1)
        , constant_modifiers(key(), "constant-modifiers", 1)
        , constant_modifier(key(), "constant-modifier", 5)
        , constant_declarators(key(), "constant-declarators", 2)
        , constant_declarator(key(), "constant-declarator", 1)
        , field_declaration(key(), "field-declaration", 1)
        , field_modifiers(key(), "field-modifiers", 1)
        , field_modifier(key(), "field-modifier", 9)
        , variable_declarators(key(), "variable-declarators", 1)
        , variable_declarator_list(key(), "variable-declarator-list", 1)
        , variable_declarator(key(), "variable-declarator", 2)
        , variable_initializer(key(), "variable-initializer", 2)
        , method_declaration(key(), "method-declaration", 1)
        , method_header(key(), "method-header", 1)
        , method_modifiers(key(), "method-modifiers", 1)
        , method_modifier(key(), "method-modifier", 12)
        , return_type(key(), "return-type", 2)
        , member_name(key(), "member-name", 1)
        , method_body(key(), "method-body", 2)
        , formal_parameter_list(key(), "formal-parameter-list", 3)
        , fixed_parameters(key(), "fixed-parameters", 2)
        , fixed_parameter(key(), "fixed-parameter", 1)
        , parameter_modifier(key(), "parameter-modifier", 2)
        , parameter_array(key(), "parameter-array", 1)
        , property_declaration(key(), "property-declaration", 1)
        , property_modifiers(key(), "property-modifiers", 1)
        , property_modifier(key(), "property-modifier", 12)
        , accessor_declarations(key(), "accessor-declarations", 2)
        , get_accessor_declaration(key(), "get-accessor-declaration", 1)
        , set_accessor_declaration(key(), "set-accessor-declaration", 1)
        , accessor_body(key(), "accessor-body", 2)
        , event_declaration(key(), "event-declaration", 2)
        , event_modifiers(key(), "event-modifiers", 1)
        , event_modifier(key(), "event-modifier", 12)
        , event_accessor_declarations(key(), "event-accessor-declarations", 2)
        , add_accessor_declaration(key(), "add-accessor-declaration", 1)
        , remove_accessor_declaration(key(), "remove-accessor-declaration", 1)
        , indexer_declaration(key(), "indexer-declaration", 1)
        , indexer_modifiers(key(), "indexer-modifiers", 1)
        , indexer_modifier(key(), "indexer-modifier", 11)
        , indexer_declarator(key(), "indexer-declarator", 2)
        , operator_declaration(key(), "operator-declaration", 1)
        , operator_modifiers(key(), "operator-modifiers", 1)
        , operator_modifier(key(), "operator-modifier", 4)
        , operator_declarator(key(), "operator-declarator", 3)
        , unary_operator_declarator(key(), "unary-operator-declarator", 1)
        , overloadable_unary_operator(key(), "overloadable-unary-operator", 8)
        , binary_operator_declarator(key(), "binary-operator-declarator", 1)
        , overloadable_binary_operator(key(), "overloadable-binary-operator", 16)
        , conversion_operator_declarator(key(), "conversion-operator-declarator", 2)
        , operator_body(key(), "operator-body", 2)
        , constructor_declaration(key(), "constructor-declaration", 1)
        , constructor_modifiers(key(), "constructor-modifiers", 1)
        , constructor_modifier(key(), "constructor-modifier", 6)
        , constructor_declarator(key(), "constructor-declarator", 1)
        , constructor_initializer(key(), "constructor-initializer", 2)
        , constructor_body(key(), "constructor-body", 2)
        , static_constructor_declaration(key(), "static-constructor-declaration", 1)
        , static_constructor_modifiers(key(), "static-constructor-modifiers", 6)
        , static_constructor_body(key(), "static-constructor-body", 2)
        , destructor_declaration(key(), "destructor-declaration", 2)
        , destructor_body(key(), "destructor-body", 2)
        , struct_declaration(key(), "struct-declaration", 1)
        , struct_modifiers(key(), "struct-modifiers", 1)
        , struct_modifier(key(), "struct-modifier", 6)
        , struct_interfaces(key(), "struct-interfaces", 1)
        , struct_body(key(), "struct-body", 1)
        , struct_member_declarations(key(), "struct-member-declarations", 1)
        , struct_member_declaration(key(), "struct-member-declaration", 10)
        , array_type(key(), "array-type", 1)
        , non_array_type(key(), "non-array-type", 3)
        , rank_specifiers(key(), "rank-specifiers", 1)
        , rank_specifier(key(), "rank-specifier", 1)
        , dim_separators(key(), "dim-separators", 1)
        , array_initializer(key(), "array-initializer", 2)
        , variable_initializer_list(key(), "variable-initializer-list", 1)
        , variable_initializers(key(), "variable-initializers", 1)
        , interface_declaration(key(), "interface-declaration", 1)
        , interface_modifiers(key(), "interface-modifiers", 1)
        , interface_modifier(key(), "interface-modifier", 6)
        , interface_base(key(), "interface-base", 1)
        , interface_body(key(), "interface-body", 1)
        , interface_member_declarations(key(), "interface-member-declarations", 1)
        , interface_member_declaration(key(), "interface-member-declaration", 4)
        , interface_method_declaration(key(), "interface-method-declaration", 1)
        , interface_property_declaration(key(), "interface-property-declaration", 1)
        , interface_accessors(key(), "interface-accessors", 4)
        , interface_event_declaration(key(), "interface-event-declaration", 1)
        , interface_indexer_declaration(key(), "interface-indexer-declaration", 1)
        , enum_declaration(key(), "enum-declaration", 1)
        , enum_base(key(), "enum-base", 1)
        , enum_body(key(), "enum-body", 2)
        , enum_modifiers(key(), "enum-modifiers", 1)
        , enum_modifier(key(), "enum-modifier", 5)
        , enum_member_declaration_list(key(), "enum-member-declaration-list", 1)
        , enum_member_declaration(key(), "enum-member-declaration", 2)
        , enum_member_declarations(key(), "enum-member-declarations", 1)
        , delegate_declaration(key(), "delegate-declaration", 1)
        , delegate_modifiers(key(), "delegate-modifiers", 1)
        , delegate_modifier(key(), "delegate-modifier", 6)
        , global_attributes(key(), "global-attributes", 1)
        , global_attribute_sections(key(), "global-attribute-sections", 1)
        , global_attribute_section(key(), "global-attribute-section", 2)
        , global_attribute_target_specifier(key(), "global-attribute-target-specifier", 1)
        , global_attribute_target(key(), "global-attribute-target", 1)
        , attributes(key(), "attributes", 1)
        , attribute_sections(key(), "attribute-sections", 1)
        , attribute_section(key(), "attribute-section", 2)
        , attribute_target_specifier(key(), "attribute-target-specifier", 1)
        , attribute_target(key(), "attribute-target", 7)
        , attribute_list(key(), "attribute-list", 2)
        , attribute(key(), "attribute", 1)
        , attribute_name(key(), "attribute-name", 1)
        , attribute_arguments(key(), "attribute-arguments", 1)
        , attribute_argument_list(key(), "attribute-argument-list", 2)
        , positional_argument(key(), "positional-argument", 1)
        , positional_arguments(key(), "positional-arguments", 1)
        , named_argument_list(key(), "named-argument-list", 1)
        , named_argument(key(), "named-argument", 1)
        , named_arguments(key(), "named-arguments", 1)
        , attribute_argument_expression(key(), "attribute-argument-expression", 1)
        , unsafe_statement(key(), "unsafe-statement", 1)
        , pointer_type(key(), "pointer-type", 4)
        , unmanaged_type(key(), "unmanaged-type", 2)
        , pointer_indirection_expression(key(), "pointer-indirection-expression", 1)
        , pointer_member_access(key(), "pointer-member-access", 1)
        , pointer_member_access_suffix(key(), "pointer-member-access-suffix", 1)
        , pma_primary_no_array_creation_expression(key(), "pma-primary-no-array-creation-expression", 6)
        , pma_primary_suffix(key(), "pma-primary-suffix", 6)
        , addressof_expression(key(), "addressof-expression", 1)
        , sizeof_expression(key(), "sizeof-expression", 1)
        , fixed_statement(key(), "fixed-statement", 1)
        , fixed_pointer_declarator_list(key(), "fixed-pointer-declarator-list", 1)
        , fixed_pointer_declarator(key(), "fixed-pointer-declarator", 1)
        , fixed_pointer_declarators(key(), "fixed-pointer-declarators", 1)
        , fixed_pointer_initializer(key(), "fixed-pointer-initializer", 2)
        , stackalloc_initializer(key(), "stackalloc-initializer", 1)
        , identifier(key(), "identifier", &syntactic_grammar_visitor::identifier)
        , literal(key(), "literal", &syntactic_grammar_visitor::literal)
    {
        Configure_namespace_name();
        Configure_type_name();
        Configure_namespace_or_type_name();
        Configure_type();
        Configure_value_type();
        Configure_struct_type();
        Configure_simple_type();
        Configure_numeric_type();
        Configure_integral_type();
        Configure_floating_point_type();
        Configure_enum_type();
        Configure_reference_type();
        Configure_class_type();
        Configure_interface_type();
        Configure_delegate_type();
        Configure_variable_reference();
        Configure_argument_list();
        Configure_arguments();
        Configure_argument();
        Configure_primary_expression();
        Configure_primary_no_array_creation_expression();
        Configure_primary_suffix();
        Configure_member_access_suffix();
        Configure_invocation_expression_suffix();
        Configure_element_access_suffix();
        Configure_post_increment_suffix();
        Configure_post_decrement_suffix();
        Configure_expression_list();
        Configure_expressions();
        Configure_simple_name();
        Configure_parenthesized_expression();
        Configure_predefined_type();
        Configure_invocation_expression();
        Configure_ie_primary_no_array_creation_expression();
        Configure_ie_primary_suffix();
        Configure_post_increment_expression();
        Configure_post_decrement_expression();
        Configure_pide_primary_no_array_creation_expression();
        Configure_pide_primary_suffix();
        Configure_this_access();
        Configure_base_access();
        Configure_object_creation_expression();
        Configure_array_creation_expression();
        Configure_delegate_creation_expression();
        Configure_typeof_expression();
        Configure_checked_expression();
        Configure_unchecked_expression();
        Configure_unary_expression();
        Configure_pre_increment_expression();
        Configure_pre_decrement_expression();
        Configure_cast_expression();
        Configure_multiplicative_expression();
        Configure_multiplicative_expressions();
        Configure_additive_expression();
        Configure_additive_expressions();
        Configure_shift_expression();
        Configure_shift_expressions();
        Configure_relational_expression();
        Configure_relational_expressions();
        Configure_equality_expression();
        Configure_equality_expressions();
        Configure_and_expression();
        Configure_and_expressions();
        Configure_exclusive_or_expression();
        Configure_exclusive_or_expressions();
        Configure_inclusive_or_expression();
        Configure_inclusive_or_expressions();
        Configure_conditional_and_expression();
        Configure_conditional_and_expressions();
        Configure_conditional_or_expression();
        Configure_conditional_or_expressions();
        Configure_conditional_expression();
        Configure_assignment();
        Configure_assignment_operator();
        Configure_expression();
        Configure_constant_expression();
        Configure_boolean_expression();
        Configure_statement();
        Configure_embedded_statement();
        Configure_block();
        Configure_statement_list();
        Configure_empty_statement();
        Configure_labeled_statement();
        Configure_declaration_statement();
        Configure_local_variable_declaration();
        Configure_local_variable_declarators();
        Configure_local_variable_declarator();
        Configure_local_variable_initializer();
        Configure_local_constant_declaration();
        Configure_expression_statement();
        Configure_statement_expression();
        Configure_selection_statement();
        Configure_if_statement();
        Configure_switch_statement();
        Configure_switch_block();
        Configure_switch_sections();
        Configure_switch_section();
        Configure_switch_labels();
        Configure_switch_label();
        Configure_iteration_statement();
        Configure_while_statement();
        Configure_do_statement();
        Configure_for_statement();
        Configure_for_initializer();
        Configure_for_condition();
        Configure_for_iterator();
        Configure_statement_expression_list();
        Configure_foreach_statement();
        Configure_jump_statement();
        Configure_break_statement();
        Configure_continue_statement();
        Configure_goto_statement();
        Configure_return_statement();
        Configure_throw_statement();
        Configure_try_statement();
        Configure_catch_clauses();
        Configure_specific_catch_clauses();
        Configure_specific_catch_clause();
        Configure_general_catch_clause();
        Configure_finally_clause();
        Configure_checked_statement();
        Configure_unchecked_statement();
        Configure_lock_statement();
        Configure_using_statement();
        Configure_resource_acquisition();
        Configure_compilation_unit();
        Configure_namespace_declaration();
        Configure_qualified_identifier();
        Configure_identifiers();
        Configure_namespace_body();
        Configure_using_directives();
        Configure_using_directive();
        Configure_using_alias_directive();
        Configure_using_namespace_directive();
        Configure_namespace_member_declarations();
        Configure_namespace_member_declaration();
        Configure_type_declaration();
        Configure_class_declaration();
        Configure_class_modifiers();
        Configure_class_modifier();
        Configure_class_base();
        Configure_base_type();
        Configure_interface_type_list();
        Configure_class_body();
        Configure_class_member_declarations();
        Configure_class_member_declaration();
        Configure_constant_declaration();
        Configure_constant_modifiers();
        Configure_constant_modifier();
        Configure_constant_declarators();
        Configure_constant_declarator();
        Configure_field_declaration();
        Configure_field_modifiers();
        Configure_field_modifier();
        Configure_variable_declarators();
        Configure_variable_declarator_list();
        Configure_variable_declarator();
        Configure_variable_initializer();
        Configure_method_declaration();
        Configure_method_header();
        Configure_method_modifiers();
        Configure_method_modifier();
        Configure_return_type();
        Configure_member_name();
        Configure_method_body();
        Configure_formal_parameter_list();
        Configure_fixed_parameters();
        Configure_fixed_parameter();
        Configure_parameter_modifier();
        Configure_parameter_array();
        Configure_property_declaration();
        Configure_property_modifiers();
        Configure_property_modifier();
        Configure_accessor_declarations();
        Configure_get_accessor_declaration();
        Configure_set_accessor_declaration();
        Configure_accessor_body();
        Configure_event_declaration();
        Configure_event_modifiers();
        Configure_event_modifier();
        Configure_event_accessor_declarations();
        Configure_add_accessor_declaration();
        Configure_remove_accessor_declaration();
        Configure_indexer_declaration();
        Configure_indexer_modifiers();
        Configure_indexer_modifier();
        Configure_indexer_declarator();
        Configure_operator_declaration();
        Configure_operator_modifiers();
        Configure_operator_modifier();
        Configure_operator_declarator();
        Configure_unary_operator_declarator();
        Configure_overloadable_unary_operator();
        Configure_binary_operator_declarator();
        Configure_overloadable_binary_operator();
        Configure_conversion_operator_declarator();
        Configure_operator_body();
        Configure_constructor_declaration();
        Configure_constructor_modifiers();
        Configure_constructor_modifier();
        Configure_constructor_declarator();
        Configure_constructor_initializer();
        Configure_constructor_body();
        Configure_static_constructor_declaration();
        Configure_static_constructor_modifiers();
        Configure_static_constructor_body();
        Configure_destructor_declaration();
        Configure_destructor_body();
        Configure_struct_declaration();
        Configure_struct_modifiers();
        Configure_struct_modifier();
        Configure_struct_interfaces();
        Configure_struct_body();
        Configure_struct_member_declarations();
        Configure_struct_member_declaration();
        Configure_array_type();
        Configure_non_array_type();
        Configure_rank_specifiers();
        Configure_rank_specifier();
        Configure_dim_separators();
        Configure_array_initializer();
        Configure_variable_initializer_list();
        Configure_variable_initializers();
        Configure_interface_declaration();
        Configure_interface_modifiers();
        Configure_interface_modifier();
        Configure_interface_base();
        Configure_interface_body();
        Configure_interface_member_declarations();
        Configure_interface_member_declaration();
        Configure_interface_method_declaration();
        Configure_interface_property_declaration();
        Configure_interface_accessors();
        Configure_interface_event_declaration();
        Configure_interface_indexer_declaration();
        Configure_enum_declaration();
        Configure_enum_base();
        Configure_enum_body();
        Configure_enum_modifiers();
        Configure_enum_modifier();
        Configure_enum_member_declaration_list();
        Configure_enum_member_declaration();
        Configure_enum_member_declarations();
        Configure_delegate_declaration();
        Configure_delegate_modifiers();
        Configure_delegate_modifier();
        Configure_global_attributes();
        Configure_global_attribute_sections();
        Configure_global_attribute_section();
        Configure_global_attribute_target_specifier();
        Configure_global_attribute_target();
        Configure_attributes();
        Configure_attribute_sections();
        Configure_attribute_section();
        Configure_attribute_target_specifier();
        Configure_attribute_target();
        Configure_attribute_list();
        Configure_attribute();
        Configure_attribute_name();
        Configure_attribute_arguments();
        Configure_attribute_argument_list();
        Configure_positional_argument();
        Configure_positional_arguments();
        Configure_named_argument_list();
        Configure_named_argument();
        Configure_named_arguments();
        Configure_attribute_argument_expression();
        Configure_unsafe_statement();
        Configure_pointer_type();
        Configure_unmanaged_type();
        Configure_pointer_indirection_expression();
        Configure_pointer_member_access();
        Configure_pointer_member_access_suffix();
        Configure_pma_primary_no_array_creation_expression();
        Configure_pma_primary_suffix();
        Configure_addressof_expression();
        Configure_sizeof_expression();
        Configure_fixed_statement();
        Configure_fixed_pointer_declarator_list();
        Configure_fixed_pointer_declarator();
        Configure_fixed_pointer_declarators();
        Configure_fixed_pointer_initializer();
        Configure_stackalloc_initializer();
    }
}
namespace csharp // syntactic_grammar - instance
{
    const syntactic_grammar & syntactic_grammar::instance()
    {
        static const syntactic_grammar the_instance;
        return the_instance;
    }
}