//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.42000
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace Microsoft.CodeAnalysis {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class WorkspacesResources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal WorkspacesResources() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Microsoft.CodeAnalysis.WorkspacesResources", typeof(WorkspacesResources).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; encountered an error and has been disabled..
        /// </summary>
        internal static string _0_encountered_an_error_and_has_been_disabled {
            get {
                return ResourceManager.GetString("_0_encountered_an_error_and_has_been_disabled", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; is already part of the workspace..
        /// </summary>
        internal static string _0_is_already_part_of_the_workspace {
            get {
                return ResourceManager.GetString("_0_is_already_part_of_the_workspace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} is already present..
        /// </summary>
        internal static string _0_is_already_present {
            get {
                return ResourceManager.GetString("_0_is_already_present", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; is already referenced..
        /// </summary>
        internal static string _0_is_already_referenced {
            get {
                return ResourceManager.GetString("_0_is_already_referenced", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; is not open..
        /// </summary>
        internal static string _0_is_not_open {
            get {
                return ResourceManager.GetString("_0_is_not_open", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; is not part of the workspace..
        /// </summary>
        internal static string _0_is_not_part_of_the_workspace {
            get {
                return ResourceManager.GetString("_0_is_not_part_of_the_workspace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} is not present..
        /// </summary>
        internal static string _0_is_not_present {
            get {
                return ResourceManager.GetString("_0_is_not_present", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; is not referenced..
        /// </summary>
        internal static string _0_is_not_referenced {
            get {
                return ResourceManager.GetString("_0_is_not_referenced", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} is still open..
        /// </summary>
        internal static string _0_is_still_open {
            get {
                return ResourceManager.GetString("_0_is_still_open", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &quot;{0}&quot; must be a non-null and non-empty string..
        /// </summary>
        internal static string _0_must_be_a_non_null_and_non_empty_string {
            get {
                return ResourceManager.GetString("_0_must_be_a_non_null_and_non_empty_string", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; returned an uninitialized ImmutableArray.
        /// </summary>
        internal static string _0_returned_an_uninitialized_ImmutableArray {
            get {
                return ResourceManager.GetString("_0_returned_an_uninitialized_ImmutableArray", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} still contains open documents..
        /// </summary>
        internal static string _0_still_contains_open_documents {
            get {
                return ResourceManager.GetString("_0_still_contains_open_documents", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A language name cannot be specified for this option..
        /// </summary>
        internal static string A_language_name_cannot_be_specified_for_this_option {
            get {
                return ResourceManager.GetString("A_language_name_cannot_be_specified_for_this_option", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A language name must be specified for this option..
        /// </summary>
        internal static string A_language_name_must_be_specified_for_this_option {
            get {
                return ResourceManager.GetString("A_language_name_must_be_specified_for_this_option", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A subtraction must be the last element in a character class.
        /// </summary>
        internal static string A_subtraction_must_be_the_last_element_in_a_character_class {
            get {
                return ResourceManager.GetString("A_subtraction_must_be_the_last_element_in_a_character_class", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Absolute path expected..
        /// </summary>
        internal static string Absolute_path_expected {
            get {
                return ResourceManager.GetString("Absolute_path_expected", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Abstract Method.
        /// </summary>
        internal static string Abstract_Method {
            get {
                return ResourceManager.GetString("Abstract_Method", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Add braces to &apos;{0}&apos; statement..
        /// </summary>
        internal static string Add_braces_to_0_statement {
            get {
                return ResourceManager.GetString("Add_braces_to_0_statement", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Added:.
        /// </summary>
        internal static string Added_colon {
            get {
                return ResourceManager.GetString("Added_colon", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Adding additional documents is not supported..
        /// </summary>
        internal static string Adding_additional_documents_is_not_supported {
            get {
                return ResourceManager.GetString("Adding_additional_documents_is_not_supported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Adding analyzer config documents is not supported..
        /// </summary>
        internal static string Adding_analyzer_config_documents_is_not_supported {
            get {
                return ResourceManager.GetString("Adding_analyzer_config_documents_is_not_supported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Adding analyzer references is not supported..
        /// </summary>
        internal static string Adding_analyzer_references_is_not_supported {
            get {
                return ResourceManager.GetString("Adding_analyzer_references_is_not_supported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Adding documents is not supported..
        /// </summary>
        internal static string Adding_documents_is_not_supported {
            get {
                return ResourceManager.GetString("Adding_documents_is_not_supported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Adding metadata references is not supported..
        /// </summary>
        internal static string Adding_metadata_references_is_not_supported {
            get {
                return ResourceManager.GetString("Adding_metadata_references_is_not_supported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Adding project reference from &apos;{0}&apos; to &apos;{1}&apos; will cause a circular reference..
        /// </summary>
        internal static string Adding_project_reference_from_0_to_1_will_cause_a_circular_reference {
            get {
                return ResourceManager.GetString("Adding_project_reference_from_0_to_1_will_cause_a_circular_reference", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Adding project references is not supported..
        /// </summary>
        internal static string Adding_project_references_is_not_supported {
            get {
                return ResourceManager.GetString("Adding_project_references_is_not_supported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Adding projects is not supported..
        /// </summary>
        internal static string Adding_projects_is_not_supported {
            get {
                return ResourceManager.GetString("Adding_projects_is_not_supported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to After:.
        /// </summary>
        internal static string After_colon {
            get {
                return ResourceManager.GetString("After_colon", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Alternation conditions cannot be comments.
        /// </summary>
        internal static string Alternation_conditions_cannot_be_comments {
            get {
                return ResourceManager.GetString("Alternation_conditions_cannot_be_comments", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Alternation conditions do not capture and cannot be named.
        /// </summary>
        internal static string Alternation_conditions_do_not_capture_and_cannot_be_named {
            get {
                return ResourceManager.GetString("Alternation_conditions_do_not_capture_and_cannot_be_named", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An element with the same key but a different value already exists..
        /// </summary>
        internal static string An_element_with_the_same_key_but_a_different_value_already_exists {
            get {
                return ResourceManager.GetString("An_element_with_the_same_key_but_a_different_value_already_exists", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An error occurred while reading the specified configuration file: {0}.
        /// </summary>
        internal static string An_error_occurred_while_reading_the_specified_configuration_file_colon_0 {
            get {
                return ResourceManager.GetString("An_error_occurred_while_reading_the_specified_configuration_file_colon_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Arrays with more than one dimension cannot be serialized..
        /// </summary>
        internal static string Arrays_with_more_than_one_dimension_cannot_be_serialized {
            get {
                return ResourceManager.GetString("Arrays_with_more_than_one_dimension_cannot_be_serialized", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Async Method.
        /// </summary>
        internal static string Async_Method {
            get {
                return ResourceManager.GetString("Async_Method", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to At least one diagnostic must be supplied..
        /// </summary>
        internal static string At_least_one_diagnostic_must_be_supplied {
            get {
                return ResourceManager.GetString("At_least_one_diagnostic_must_be_supplied", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Before:.
        /// </summary>
        internal static string Before_colon {
            get {
                return ResourceManager.GetString("Before_colon", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Begins with I.
        /// </summary>
        internal static string Begins_with_I {
            get {
                return ResourceManager.GetString("Begins_with_I", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Can&apos;t resolve analyzer reference: &apos;{0}&apos;..
        /// </summary>
        internal static string Can_t_resolve_analyzer_reference_colon_0 {
            get {
                return ResourceManager.GetString("Can_t_resolve_analyzer_reference_colon_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Can&apos;t resolve metadata reference: &apos;{0}&apos;..
        /// </summary>
        internal static string Can_t_resolve_metadata_reference_colon_0 {
            get {
                return ResourceManager.GetString("Can_t_resolve_metadata_reference_colon_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot deserialize type &apos;{0}&apos;..
        /// </summary>
        internal static string Cannot_deserialize_type_0 {
            get {
                return ResourceManager.GetString("Cannot_deserialize_type_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot generate code for unsupported operator &apos;{0}&apos;.
        /// </summary>
        internal static string Cannot_generate_code_for_unsupported_operator_0 {
            get {
                return ResourceManager.GetString("Cannot_generate_code_for_unsupported_operator_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot include class \{0} in character range.
        /// </summary>
        internal static string Cannot_include_class_0_in_character_range {
            get {
                return ResourceManager.GetString("Cannot_include_class_0_in_character_range", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot open project &apos;{0}&apos; because the file extension &apos;{1}&apos; is not associated with a language..
        /// </summary>
        internal static string Cannot_open_project_0_because_the_file_extension_1_is_not_associated_with_a_language {
            get {
                return ResourceManager.GetString("Cannot_open_project_0_because_the_file_extension_1_is_not_associated_with_a_langu" +
                        "age", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot open project &apos;{0}&apos; because the language &apos;{1}&apos; is not supported..
        /// </summary>
        internal static string Cannot_open_project_0_because_the_language_1_is_not_supported {
            get {
                return ResourceManager.GetString("Cannot_open_project_0_because_the_language_1_is_not_supported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot serialize type &apos;{0}&apos;..
        /// </summary>
        internal static string Cannot_serialize_type_0 {
            get {
                return ResourceManager.GetString("Cannot_serialize_type_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Capture group numbers must be less than or equal to Int32.MaxValue.
        /// </summary>
        internal static string Capture_group_numbers_must_be_less_than_or_equal_to_Int32_MaxValue {
            get {
                return ResourceManager.GetString("Capture_group_numbers_must_be_less_than_or_equal_to_Int32_MaxValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Capture number cannot be zero.
        /// </summary>
        internal static string Capture_number_cannot_be_zero {
            get {
                return ResourceManager.GetString("Capture_number_cannot_be_zero", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cast is redundant..
        /// </summary>
        internal static string Cast_is_redundant {
            get {
                return ResourceManager.GetString("Cast_is_redundant", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Changing additional documents is not supported..
        /// </summary>
        internal static string Changing_additional_documents_is_not_supported {
            get {
                return ResourceManager.GetString("Changing_additional_documents_is_not_supported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Changing analyzer config documents is not supported..
        /// </summary>
        internal static string Changing_analyzer_config_documents_is_not_supported {
            get {
                return ResourceManager.GetString("Changing_analyzer_config_documents_is_not_supported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Changing compilation options is not supported..
        /// </summary>
        internal static string Changing_compilation_options_is_not_supported {
            get {
                return ResourceManager.GetString("Changing_compilation_options_is_not_supported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Changing document &apos;{0}&apos; is not supported..
        /// </summary>
        internal static string Changing_document_0_is_not_supported {
            get {
                return ResourceManager.GetString("Changing_document_0_is_not_supported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Changing document properties is not supported.
        /// </summary>
        internal static string Changing_document_property_is_not_supported {
            get {
                return ResourceManager.GetString("Changing_document_property_is_not_supported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Changing documents is not supported..
        /// </summary>
        internal static string Changing_documents_is_not_supported {
            get {
                return ResourceManager.GetString("Changing_documents_is_not_supported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Changing parse options is not supported..
        /// </summary>
        internal static string Changing_parse_options_is_not_supported {
            get {
                return ResourceManager.GetString("Changing_parse_options_is_not_supported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Changing project properties is not supported..
        /// </summary>
        internal static string Changing_project_properties_is_not_supported {
            get {
                return ResourceManager.GetString("Changing_project_properties_is_not_supported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Class.
        /// </summary>
        internal static string Class {
            get {
                return ResourceManager.GetString("Class", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Compilation is required to accomplish the task but is not supported by project {0}..
        /// </summary>
        internal static string Compilation_is_required_to_accomplish_the_task_but_is_not_supported_by_project_0 {
            get {
                return ResourceManager.GetString("Compilation_is_required_to_accomplish_the_task_but_is_not_supported_by_project_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Core EditorConfig Options.
        /// </summary>
        internal static string Core_EditorConfig_Options {
            get {
                return ResourceManager.GetString("Core_EditorConfig_Options", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Could not find location to generation symbol into..
        /// </summary>
        internal static string Could_not_find_location_to_generation_symbol_into {
            get {
                return ResourceManager.GetString("Could_not_find_location_to_generation_symbol_into", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to C# files.
        /// </summary>
        internal static string CSharp_files {
            get {
                return ResourceManager.GetString("CSharp_files", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cycle detected in extensions.
        /// </summary>
        internal static string Cycle_detected_in_extensions {
            get {
                return ResourceManager.GetString("Cycle_detected_in_extensions", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to DateTimeKind must be Utc.
        /// </summary>
        internal static string DateTimeKind_must_be_Utc {
            get {
                return ResourceManager.GetString("DateTimeKind_must_be_Utc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Delegate.
        /// </summary>
        internal static string Delegate {
            get {
                return ResourceManager.GetString("Delegate", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Deserialization reader for &apos;{0}&apos; read incorrect number of values..
        /// </summary>
        internal static string Deserialization_reader_for_0_read_incorrect_number_of_values {
            get {
                return ResourceManager.GetString("Deserialization_reader_for_0_read_incorrect_number_of_values", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Destination location was from a different tree..
        /// </summary>
        internal static string Destination_location_was_from_a_different_tree {
            get {
                return ResourceManager.GetString("Destination_location_was_from_a_different_tree", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Destination location was not in source..
        /// </summary>
        internal static string Destination_location_was_not_in_source {
            get {
                return ResourceManager.GetString("Destination_location_was_not_in_source", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Destination type must be a {0}, {1}, {2} or {3}, but given one is {4}..
        /// </summary>
        internal static string Destination_type_must_be_a_0_1_2_or_3_but_given_one_is_4 {
            get {
                return ResourceManager.GetString("Destination_type_must_be_a_0_1_2_or_3_but_given_one_is_4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Destination type must be a {0}, {1} or {2}, but given one is {3}..
        /// </summary>
        internal static string Destination_type_must_be_a_0_1_or_2_but_given_one_is_3 {
            get {
                return ResourceManager.GetString("Destination_type_must_be_a_0_1_or_2_but_given_one_is_3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Destination type must be a {0}, but given one is {1}..
        /// </summary>
        internal static string Destination_type_must_be_a_0_but_given_one_is_1 {
            get {
                return ResourceManager.GetString("Destination_type_must_be_a_0_but_given_one_is_1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Destination type must be a {0} or a {1}, but given one is {2}..
        /// </summary>
        internal static string Destination_type_must_be_a_0_or_a_1_but_given_one_is_2 {
            get {
                return ResourceManager.GetString("Destination_type_must_be_a_0_or_a_1_but_given_one_is_2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Diagnostic must have span &apos;{0}&apos;.
        /// </summary>
        internal static string Diagnostic_must_have_span_0 {
            get {
                return ResourceManager.GetString("Diagnostic_must_have_span_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Document does not support syntax trees.
        /// </summary>
        internal static string Document_does_not_support_syntax_trees {
            get {
                return ResourceManager.GetString("Document_does_not_support_syntax_trees", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Documentation comment id must start with E, F, M, N, P or T.
        /// </summary>
        internal static string Documentation_comment_id_must_start_with_E_F_M_N_P_or_T {
            get {
                return ResourceManager.GetString("Documentation_comment_id_must_start_with_E_F_M_N_P_or_T", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to .NET Coding Conventions.
        /// </summary>
        internal static string dot_NET_Coding_Conventions {
            get {
                return ResourceManager.GetString("dot_NET_Coding_Conventions", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Duplicate source file &apos;{0}&apos; in project &apos;{1}&apos;.
        /// </summary>
        internal static string Duplicate_source_file_0_in_project_1 {
            get {
                return ResourceManager.GetString("Duplicate_source_file_0_in_project_1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Enable.
        /// </summary>
        internal static string Enable {
            get {
                return ResourceManager.GetString("Enable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Enable and ignore future errors.
        /// </summary>
        internal static string Enable_and_ignore_future_errors {
            get {
                return ResourceManager.GetString("Enable_and_ignore_future_errors", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Enum.
        /// </summary>
        internal static string Enum {
            get {
                return ResourceManager.GetString("Enum", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Error.
        /// </summary>
        internal static string Error {
            get {
                return ResourceManager.GetString("Error", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Error reading content of source file &apos;{0}&apos; -- &apos;{1}&apos;..
        /// </summary>
        internal static string Error_reading_content_of_source_file_0_1 {
            get {
                return ResourceManager.GetString("Error_reading_content_of_source_file_0_1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Event.
        /// </summary>
        internal static string Event {
            get {
                return ResourceManager.GetString("Event", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Exceptions:.
        /// </summary>
        internal static string Exceptions_colon {
            get {
                return ResourceManager.GetString("Exceptions_colon", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Expected {0}..
        /// </summary>
        internal static string Expected_0 {
            get {
                return ResourceManager.GetString("Expected_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Expected {0} line..
        /// </summary>
        internal static string Expected_0_line {
            get {
                return ResourceManager.GetString("Expected_0_line", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Expected end-of-file..
        /// </summary>
        internal static string Expected_end_of_file {
            get {
                return ResourceManager.GetString("Expected_end_of_file", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Expected header: &quot;{0}&quot;..
        /// </summary>
        internal static string Expected_header_colon_0 {
            get {
                return ResourceManager.GetString("Expected_header_colon_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Expression-level preferences.
        /// </summary>
        internal static string Expression_level_preferences {
            get {
                return ResourceManager.GetString("Expression_level_preferences", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Failure.
        /// </summary>
        internal static string Failure {
            get {
                return ResourceManager.GetString("Failure", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Field preferences.
        /// </summary>
        internal static string Field_preferences {
            get {
                return ResourceManager.GetString("Field_preferences", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to File &apos;{0}&apos; size of {1} exceeds maximum allowed size of {2}.
        /// </summary>
        internal static string File_0_size_of_1_exceeds_maximum_allowed_size_of_2 {
            get {
                return ResourceManager.GetString("File_0_size_of_1_exceeds_maximum_allowed_size_of_2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to File was externally modified: {0}..
        /// </summary>
        internal static string File_was_externally_modified_colon_0 {
            get {
                return ResourceManager.GetString("File_was_externally_modified_colon_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Fix all &apos;{0}&apos;.
        /// </summary>
        internal static string Fix_all_0 {
            get {
                return ResourceManager.GetString("Fix_all_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Fix all &apos;{0}&apos; in &apos;{1}&apos;.
        /// </summary>
        internal static string Fix_all_0_in_1 {
            get {
                return ResourceManager.GetString("Fix_all_0_in_1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Fix all &apos;{0}&apos; in Solution.
        /// </summary>
        internal static string Fix_all_0_in_Solution {
            get {
                return ResourceManager.GetString("Fix_all_0_in_Solution", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Illegal \ at end of pattern.
        /// </summary>
        internal static string Illegal_backslash_at_end_of_pattern {
            get {
                return ResourceManager.GetString("Illegal_backslash_at_end_of_pattern", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Illegal {x,y} with x &gt; y.
        /// </summary>
        internal static string Illegal_x_y_with_x_less_than_y {
            get {
                return ResourceManager.GetString("Illegal_x_y_with_x_less_than_y", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Incomplete \p{X} character escape.
        /// </summary>
        internal static string Incomplete_character_escape {
            get {
                return ResourceManager.GetString("Incomplete_character_escape", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Indentation and spacing.
        /// </summary>
        internal static string Indentation_and_spacing {
            get {
                return ResourceManager.GetString("Indentation_and_spacing", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Insufficient hexadecimal digits.
        /// </summary>
        internal static string Insufficient_hexadecimal_digits {
            get {
                return ResourceManager.GetString("Insufficient_hexadecimal_digits", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Interface.
        /// </summary>
        internal static string Interface {
            get {
                return ResourceManager.GetString("Interface", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid CodePage value: {0}.
        /// </summary>
        internal static string Invalid_CodePage_value_colon_0 {
            get {
                return ResourceManager.GetString("Invalid_CodePage_value_colon_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid group name: Group names must begin with a word character.
        /// </summary>
        internal static string Invalid_group_name_Group_names_must_begin_with_a_word_character {
            get {
                return ResourceManager.GetString("Invalid_group_name_Group_names_must_begin_with_a_word_character", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid number of parameters for binary operator..
        /// </summary>
        internal static string Invalid_number_of_parameters_for_binary_operator {
            get {
                return ResourceManager.GetString("Invalid_number_of_parameters_for_binary_operator", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid number of parameters for unary operator..
        /// </summary>
        internal static string Invalid_number_of_parameters_for_unary_operator {
            get {
                return ResourceManager.GetString("Invalid_number_of_parameters_for_unary_operator", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid project block, expected &quot;=&quot; after Project..
        /// </summary>
        internal static string Invalid_project_block_expected_after_Project {
            get {
                return ResourceManager.GetString("Invalid_project_block_expected_after_Project", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid project block, expected &quot;,&quot; after project name..
        /// </summary>
        internal static string Invalid_project_block_expected_after_project_name {
            get {
                return ResourceManager.GetString("Invalid_project_block_expected_after_project_name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid project block, expected &quot;,&quot; after project path..
        /// </summary>
        internal static string Invalid_project_block_expected_after_project_path {
            get {
                return ResourceManager.GetString("Invalid_project_block_expected_after_project_path", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid project file path: &apos;{0}&apos;.
        /// </summary>
        internal static string Invalid_project_file_path_colon_0 {
            get {
                return ResourceManager.GetString("Invalid_project_file_path_colon_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid solution file path: &apos;{0}&apos;.
        /// </summary>
        internal static string Invalid_solution_file_path_colon_0 {
            get {
                return ResourceManager.GetString("Invalid_solution_file_path_colon_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Label for node &apos;{0}&apos; is invalid, it must be within [0, {1})..
        /// </summary>
        internal static string Label_for_node_0_is_invalid_it_must_be_within_bracket_0_1 {
            get {
                return ResourceManager.GetString("Label_for_node_0_is_invalid_it_must_be_within_bracket_0_1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Language keywords vs BCL types preferences.
        /// </summary>
        internal static string Language_keywords_vs_BCL_types_preferences {
            get {
                return ResourceManager.GetString("Language_keywords_vs_BCL_types_preferences", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Location must be null or from source..
        /// </summary>
        internal static string Location_must_be_null_or_from_source {
            get {
                return ResourceManager.GetString("Location_must_be_null_or_from_source", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to malformed.
        /// </summary>
        internal static string Malformed {
            get {
                return ResourceManager.GetString("Malformed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Malformed \p{X} character escape.
        /// </summary>
        internal static string Malformed_character_escape {
            get {
                return ResourceManager.GetString("Malformed_character_escape", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Malformed \k&lt;...&gt; named back reference.
        /// </summary>
        internal static string Malformed_named_back_reference {
            get {
                return ResourceManager.GetString("Malformed_named_back_reference", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Matching nodes &apos;{0}&apos; and &apos;{1}&apos; must have the same label..
        /// </summary>
        internal static string Matching_nodes_0_and_1_must_have_the_same_label {
            get {
                return ResourceManager.GetString("Matching_nodes_0_and_1_must_have_the_same_label", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Member access should be qualified..
        /// </summary>
        internal static string Member_access_should_be_qualified {
            get {
                return ResourceManager.GetString("Member_access_should_be_qualified", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Metadata is already referenced..
        /// </summary>
        internal static string Metadata_is_already_referenced {
            get {
                return ResourceManager.GetString("Metadata_is_already_referenced", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Metadata is not referenced..
        /// </summary>
        internal static string Metadata_is_not_referenced {
            get {
                return ResourceManager.GetString("Metadata_is_not_referenced", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Method.
        /// </summary>
        internal static string Method {
            get {
                return ResourceManager.GetString("Method", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Missing control character.
        /// </summary>
        internal static string Missing_control_character {
            get {
                return ResourceManager.GetString("Missing_control_character", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Missing prefix: &apos;{0}&apos;.
        /// </summary>
        internal static string Missing_prefix_colon_0 {
            get {
                return ResourceManager.GetString("Missing_prefix_colon_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Missing suffix: &apos;{0}&apos;.
        /// </summary>
        internal static string Missing_suffix_colon_0 {
            get {
                return ResourceManager.GetString("Missing_suffix_colon_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Modifier preferences.
        /// </summary>
        internal static string Modifier_preferences {
            get {
                return ResourceManager.GetString("Modifier_preferences", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name can be simplified..
        /// </summary>
        internal static string Name_can_be_simplified {
            get {
                return ResourceManager.GetString("Name_can_be_simplified", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Naming rules.
        /// </summary>
        internal static string Naming_rules {
            get {
                return ResourceManager.GetString("Naming_rules", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Naming styles.
        /// </summary>
        internal static string Naming_styles {
            get {
                return ResourceManager.GetString("Naming_styles", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Nested quantifier {0}.
        /// </summary>
        internal static string Nested_quantifier_0 {
            get {
                return ResourceManager.GetString("Nested_quantifier_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to New line preferences.
        /// </summary>
        internal static string New_line_preferences {
            get {
                return ResourceManager.GetString("New_line_preferences", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No location provided to add statements to..
        /// </summary>
        internal static string No_location_provided_to_add_statements_to {
            get {
                return ResourceManager.GetString("No_location_provided_to_add_statements_to", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Node &apos;{0}&apos; must be contained in the new tree..
        /// </summary>
        internal static string Node_0_must_be_contained_in_the_new_tree {
            get {
                return ResourceManager.GetString("Node_0_must_be_contained_in_the_new_tree", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Node &apos;{0}&apos; must be contained in the old tree..
        /// </summary>
        internal static string Node_0_must_be_contained_in_the_old_tree {
            get {
                return ResourceManager.GetString("Node_0_must_be_contained_in_the_old_tree", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Node is of the wrong type..
        /// </summary>
        internal static string Node_is_of_the_wrong_type {
            get {
                return ResourceManager.GetString("Node_is_of_the_wrong_type", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Non-Field Members.
        /// </summary>
        internal static string Non_Field_Members {
            get {
                return ResourceManager.GetString("Non_Field_Members", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to None.
        /// </summary>
        internal static string None {
            get {
                return ResourceManager.GetString("None", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Not enough )&apos;s.
        /// </summary>
        internal static string Not_enough_close_parens {
            get {
                return ResourceManager.GetString("Not_enough_close_parens", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Options did not come from specified Solution.
        /// </summary>
        internal static string Options_did_not_come_from_specified_Solution {
            get {
                return ResourceManager.GetString("Options_did_not_come_from_specified_Solution", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Organize usings.
        /// </summary>
        internal static string Organize_usings {
            get {
                return ResourceManager.GetString("Organize_usings", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Parameter preferences.
        /// </summary>
        internal static string Parameter_preferences {
            get {
                return ResourceManager.GetString("Parameter_preferences", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Parentheses preferences.
        /// </summary>
        internal static string Parentheses_preferences {
            get {
                return ResourceManager.GetString("Parentheses_preferences", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Pascal Case.
        /// </summary>
        internal static string Pascal_Case {
            get {
                return ResourceManager.GetString("Pascal_Case", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Populate switch.
        /// </summary>
        internal static string Populate_switch {
            get {
                return ResourceManager.GetString("Populate_switch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Prefix &apos;{0}&apos; does not match expected prefix &apos;{1}&apos;.
        /// </summary>
        internal static string Prefix_0_does_not_match_expected_prefix_1 {
            get {
                return ResourceManager.GetString("Prefix_0_does_not_match_expected_prefix_1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Prefix &apos;{0}&apos; is not expected.
        /// </summary>
        internal static string Prefix_0_is_not_expected {
            get {
                return ResourceManager.GetString("Prefix_0_is_not_expected", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Private Method.
        /// </summary>
        internal static string Private_Method {
            get {
                return ResourceManager.GetString("Private_Method", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Private or Internal Field.
        /// </summary>
        internal static string Private_or_Internal_Field {
            get {
                return ResourceManager.GetString("Private_or_Internal_Field", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Private or Internal Static Field.
        /// </summary>
        internal static string Private_or_Internal_Static_Field {
            get {
                return ResourceManager.GetString("Private_or_Internal_Static_Field", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Project file not found: &apos;{0}&apos;.
        /// </summary>
        internal static string Project_file_not_found_colon_0 {
            get {
                return ResourceManager.GetString("Project_file_not_found_colon_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Project of ID {0} is required to accomplish the task but is not available from the solution.
        /// </summary>
        internal static string Project_of_ID_0_is_required_to_accomplish_the_task_but_is_not_available_from_the_solution {
            get {
                return ResourceManager.GetString("Project_of_ID_0_is_required_to_accomplish_the_task_but_is_not_available_from_the_" +
                        "solution", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Property.
        /// </summary>
        internal static string Property {
            get {
                return ResourceManager.GetString("Property", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Public or Protected Field.
        /// </summary>
        internal static string Public_or_Protected_Field {
            get {
                return ResourceManager.GetString("Public_or_Protected_Field", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Quantifier {x,y} following nothing.
        /// </summary>
        internal static string Quantifier_x_y_following_nothing {
            get {
                return ResourceManager.GetString("Quantifier_x_y_following_nothing", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Refactoring Only.
        /// </summary>
        internal static string Refactoring_Only {
            get {
                return ResourceManager.GetString("Refactoring_Only", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to reference to undefined group.
        /// </summary>
        internal static string Reference_to_undefined_group {
            get {
                return ResourceManager.GetString("Reference_to_undefined_group", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Reference to undefined group name {0}.
        /// </summary>
        internal static string Reference_to_undefined_group_name_0 {
            get {
                return ResourceManager.GetString("Reference_to_undefined_group_name_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Reference to undefined group number {0}.
        /// </summary>
        internal static string Reference_to_undefined_group_number_0 {
            get {
                return ResourceManager.GetString("Reference_to_undefined_group_number_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories..
        /// </summary>
        internal static string Regex_all_control_characters_long {
            get {
                return ResourceManager.GetString("Regex_all_control_characters_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to all control characters.
        /// </summary>
        internal static string Regex_all_control_characters_short {
            get {
                return ResourceManager.GetString("Regex_all_control_characters_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to All diacritic marks. This includes the Mn, Mc, and Me categories..
        /// </summary>
        internal static string Regex_all_diacritic_marks_long {
            get {
                return ResourceManager.GetString("Regex_all_diacritic_marks_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to all diacritic marks.
        /// </summary>
        internal static string Regex_all_diacritic_marks_short {
            get {
                return ResourceManager.GetString("Regex_all_diacritic_marks_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters..
        /// </summary>
        internal static string Regex_all_letter_characters_long {
            get {
                return ResourceManager.GetString("Regex_all_letter_characters_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to all letter characters.
        /// </summary>
        internal static string Regex_all_letter_characters_short {
            get {
                return ResourceManager.GetString("Regex_all_letter_characters_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to All numbers. This includes the Nd, Nl, and No categories..
        /// </summary>
        internal static string Regex_all_numbers_long {
            get {
                return ResourceManager.GetString("Regex_all_numbers_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to all numbers.
        /// </summary>
        internal static string Regex_all_numbers_short {
            get {
                return ResourceManager.GetString("Regex_all_numbers_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories..
        /// </summary>
        internal static string Regex_all_punctuation_characters_long {
            get {
                return ResourceManager.GetString("Regex_all_punctuation_characters_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to all punctuation characters.
        /// </summary>
        internal static string Regex_all_punctuation_characters_short {
            get {
                return ResourceManager.GetString("Regex_all_punctuation_characters_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to All separator characters. This includes the Zs, Zl, and Zp categories..
        /// </summary>
        internal static string Regex_all_separator_characters_long {
            get {
                return ResourceManager.GetString("Regex_all_separator_characters_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to all separator characters.
        /// </summary>
        internal static string Regex_all_separator_characters_short {
            get {
                return ResourceManager.GetString("Regex_all_separator_characters_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to All symbols. This includes the Sm, Sc, Sk, and So categories..
        /// </summary>
        internal static string Regex_all_symbols_long {
            get {
                return ResourceManager.GetString("Regex_all_symbols_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to all symbols.
        /// </summary>
        internal static string Regex_all_symbols_short {
            get {
                return ResourceManager.GetString("Regex_all_symbols_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern..
        /// </summary>
        internal static string Regex_alternation_long {
            get {
                return ResourceManager.GetString("Regex_alternation_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to alternation.
        /// </summary>
        internal static string Regex_alternation_short {
            get {
                return ResourceManager.GetString("Regex_alternation_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The period character (.) matches any character except \n (the newline character, \u000A).  If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the &apos;s&apos; option, . matches any character..
        /// </summary>
        internal static string Regex_any_character_group_long {
            get {
                return ResourceManager.GetString("Regex_any_character_group_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to any character.
        /// </summary>
        internal static string Regex_any_character_group_short {
            get {
                return ResourceManager.GetString("Regex_any_character_group_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Matches a backspace character, \u0008.
        /// </summary>
        internal static string Regex_backspace_character_long {
            get {
                return ResourceManager.GetString("Regex_backspace_character_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to backspace character.
        /// </summary>
        internal static string Regex_backspace_character_short {
            get {
                return ResourceManager.GetString("Regex_backspace_character_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group.
        ///    
        ///&apos;name1&apos; is the current group (optional), &apos;name2&apos; is a previously defined group, and &apos;subexpression&apos; is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Be [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string Regex_balancing_group_long {
            get {
                return ResourceManager.GetString("Regex_balancing_group_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to balancing group.
        /// </summary>
        internal static string Regex_balancing_group_short {
            get {
                return ResourceManager.GetString("Regex_balancing_group_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to base-group.
        /// </summary>
        internal static string Regex_base_group {
            get {
                return ResourceManager.GetString("Regex_base_group", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Matches a bell (alarm) character, \u0007.
        /// </summary>
        internal static string Regex_bell_character_long {
            get {
                return ResourceManager.GetString("Regex_bell_character_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to bell character.
        /// </summary>
        internal static string Regex_bell_character_short {
            get {
                return ResourceManager.GetString("Regex_bell_character_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Matches a carriage-return character, \u000D.  Note that \r is not equivalent to the newline character, \n..
        /// </summary>
        internal static string Regex_carriage_return_character_long {
            get {
                return ResourceManager.GetString("Regex_carriage_return_character_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to carriage-return character.
        /// </summary>
        internal static string Regex_carriage_return_character_short {
            get {
                return ResourceManager.GetString("Regex_carriage_return_character_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class.
        ///
        ///&apos;base_group&apos; is a positive or negative character group or range. The &apos;excluded_group&apos; component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions)..
        /// </summary>
        internal static string Regex_character_class_subtraction_long {
            get {
                return ResourceManager.GetString("Regex_character_class_subtraction_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to character class subtraction.
        /// </summary>
        internal static string Regex_character_class_subtraction_short {
            get {
                return ResourceManager.GetString("Regex_character_class_subtraction_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to character-group.
        /// </summary>
        internal static string Regex_character_group {
            get {
                return ResourceManager.GetString("Regex_character_group", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to comment.
        /// </summary>
        internal static string Regex_comment {
            get {
                return ResourceManager.GetString("Regex_comment", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This language element attempts to match one of two patterns depending on whether it can match an initial pattern.
        ///
        ///&apos;expression&apos; is the initial pattern to match, &apos;yes&apos; is the pattern to match if expression is matched, and &apos;no&apos; is the optional pattern to match if expression is not matched..
        /// </summary>
        internal static string Regex_conditional_expression_match_long {
            get {
                return ResourceManager.GetString("Regex_conditional_expression_match_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to conditional expression match.
        /// </summary>
        internal static string Regex_conditional_expression_match_short {
            get {
                return ResourceManager.GetString("Regex_conditional_expression_match_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group.
        ///
        ///&apos;name&apos; is the name (or number) of a capturing group, &apos;yes&apos; is the expression to match if &apos;name&apos; (or &apos;number&apos;) has a match, and &apos;no&apos; is the optional expression to match if it does not..
        /// </summary>
        internal static string Regex_conditional_group_match_long {
            get {
                return ResourceManager.GetString("Regex_conditional_group_match_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to conditional group match.
        /// </summary>
        internal static string Regex_conditional_group_match_short {
            get {
                return ResourceManager.GetString("Regex_conditional_group_match_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous..
        /// </summary>
        internal static string Regex_contiguous_matches_long {
            get {
                return ResourceManager.GetString("Regex_contiguous_matches_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to contiguous matches.
        /// </summary>
        internal static string Regex_contiguous_matches_short {
            get {
                return ResourceManager.GetString("Regex_contiguous_matches_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C..
        /// </summary>
        internal static string Regex_control_character_long {
            get {
                return ResourceManager.GetString("Regex_control_character_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to control character.
        /// </summary>
        internal static string Regex_control_character_short {
            get {
                return ResourceManager.GetString("Regex_control_character_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets.
        ///
        ///If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9].
        /// </summary>
        internal static string Regex_decimal_digit_character_long {
            get {
                return ResourceManager.GetString("Regex_decimal_digit_character_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to decimal-digit character.
        /// </summary>
        internal static string Regex_decimal_digit_character_short {
            get {
                return ResourceManager.GetString("Regex_decimal_digit_character_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method..
        /// </summary>
        internal static string Regex_end_of_line_comment_long {
            get {
                return ResourceManager.GetString("Regex_end_of_line_comment_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to end-of-line comment.
        /// </summary>
        internal static string Regex_end_of_line_comment_short {
            get {
                return ResourceManager.GetString("Regex_end_of_line_comment_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string..
        /// </summary>
        internal static string Regex_end_of_string_only_long {
            get {
                return ResourceManager.GetString("Regex_end_of_string_only_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to end of string only.
        /// </summary>
        internal static string Regex_end_of_string_only_short {
            get {
                return ResourceManager.GetString("Regex_end_of_string_only_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n.
        ///
        ///The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern..
        /// </summary>
        internal static string Regex_end_of_string_or_before_ending_newline_long {
            get {
                return ResourceManager.GetString("Regex_end_of_string_or_before_ending_newline_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to end of string or before ending newline.
        /// </summary>
        internal static string Regex_end_of_string_or_before_ending_newline_short {
            get {
                return ResourceManager.GetString("Regex_end_of_string_or_before_ending_newline_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line.
        ///
        ///The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern..
        /// </summary>
        internal static string Regex_end_of_string_or_line_long {
            get {
                return ResourceManager.GetString("Regex_end_of_string_or_line_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to end of string or line.
        /// </summary>
        internal static string Regex_end_of_string_or_line_short {
            get {
                return ResourceManager.GetString("Regex_end_of_string_or_line_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Matches an escape character, \u001B.
        /// </summary>
        internal static string Regex_escape_character_long {
            get {
                return ResourceManager.GetString("Regex_escape_character_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to escape character.
        /// </summary>
        internal static string Regex_escape_character_short {
            get {
                return ResourceManager.GetString("Regex_escape_character_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to excluded-group.
        /// </summary>
        internal static string Regex_excluded_group {
            get {
                return ResourceManager.GetString("Regex_excluded_group", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to expression.
        /// </summary>
        internal static string Regex_expression {
            get {
                return ResourceManager.GetString("Regex_expression", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Matches a form-feed character, \u000C.
        /// </summary>
        internal static string Regex_form_feed_character_long {
            get {
                return ResourceManager.GetString("Regex_form_feed_character_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to form-feed character.
        /// </summary>
        internal static string Regex_form_feed_character_short {
            get {
                return ResourceManager.GetString("Regex_form_feed_character_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are:
        ///
        ///    i	Use case-insensitive matching.
        ///    m	Use multiline mode, where ^ and $ match the beginning and end of each line
        ///	(instead of the beginning and end of the input string).
        ///    s	Use single-line mode, where the period (.) matches every character
        ///	(instead of every character exc [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string Regex_group_options_long {
            get {
                return ResourceManager.GetString("Regex_group_options_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to group options.
        /// </summary>
        internal static string Regex_group_options_short {
            get {
                return ResourceManager.GetString("Regex_group_options_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Matches an ASCII character, where ## is a two-digit hexadecimal character code..
        /// </summary>
        internal static string Regex_hexadecimal_escape_long {
            get {
                return ResourceManager.GetString("Regex_hexadecimal_escape_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to hexadecimal escape.
        /// </summary>
        internal static string Regex_hexadecimal_escape_short {
            get {
                return ResourceManager.GetString("Regex_hexadecimal_escape_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis..
        /// </summary>
        internal static string Regex_inline_comment_long {
            get {
                return ResourceManager.GetString("Regex_inline_comment_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to inline comment.
        /// </summary>
        internal static string Regex_inline_comment_short {
            get {
                return ResourceManager.GetString("Regex_inline_comment_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are:
        ///
        ///    i	Use case-insensitive matching.
        ///    m	Use multiline mode, where ^ and $ match the beginning and end of each line
        ///	(instead of the beginning and end of the input string).
        ///    s	Use single-line mode, where the period (.) matches every character
        ///	(instead of every charac [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string Regex_inline_options_long {
            get {
                return ResourceManager.GetString("Regex_inline_options_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to inline options.
        /// </summary>
        internal static string Regex_inline_options_short {
            get {
                return ResourceManager.GetString("Regex_inline_options_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Regex issue: {0}.
        /// </summary>
        internal static string Regex_issue_0 {
            get {
                return ResourceManager.GetString("Regex_issue_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to letter, lowercase.
        /// </summary>
        internal static string Regex_letter_lowercase {
            get {
                return ResourceManager.GetString("Regex_letter_lowercase", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to letter, modifier.
        /// </summary>
        internal static string Regex_letter_modifier {
            get {
                return ResourceManager.GetString("Regex_letter_modifier", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to letter, other.
        /// </summary>
        internal static string Regex_letter_other {
            get {
                return ResourceManager.GetString("Regex_letter_other", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to letter, titlecase.
        /// </summary>
        internal static string Regex_letter_titlecase {
            get {
                return ResourceManager.GetString("Regex_letter_titlecase", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to letter, uppercase.
        /// </summary>
        internal static string Regex_letter_uppercase {
            get {
                return ResourceManager.GetString("Regex_letter_uppercase", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to mark, enclosing.
        /// </summary>
        internal static string Regex_mark_enclosing {
            get {
                return ResourceManager.GetString("Regex_mark_enclosing", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to mark, nonspacing.
        /// </summary>
        internal static string Regex_mark_nonspacing {
            get {
                return ResourceManager.GetString("Regex_mark_nonspacing", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to mark, spacing combining.
        /// </summary>
        internal static string Regex_mark_spacing_combining {
            get {
                return ResourceManager.GetString("Regex_mark_spacing_combining", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,}.
        /// </summary>
        internal static string Regex_match_at_least_n_times_lazy_long {
            get {
                return ResourceManager.GetString("Regex_match_at_least_n_times_lazy_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to match at least &apos;n&apos; times (lazy).
        /// </summary>
        internal static string Regex_match_at_least_n_times_lazy_short {
            get {
                return ResourceManager.GetString("Regex_match_at_least_n_times_lazy_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}?.
        /// </summary>
        internal static string Regex_match_at_least_n_times_long {
            get {
                return ResourceManager.GetString("Regex_match_at_least_n_times_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to match at least &apos;n&apos; times.
        /// </summary>
        internal static string Regex_match_at_least_n_times_short {
            get {
                return ResourceManager.GetString("Regex_match_at_least_n_times_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m}.
        /// </summary>
        internal static string Regex_match_between_m_and_n_times_lazy_long {
            get {
                return ResourceManager.GetString("Regex_match_between_m_and_n_times_lazy_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to match at least &apos;n&apos; times (lazy).
        /// </summary>
        internal static string Regex_match_between_m_and_n_times_lazy_short {
            get {
                return ResourceManager.GetString("Regex_match_between_m_and_n_times_lazy_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}?.
        /// </summary>
        internal static string Regex_match_between_m_and_n_times_long {
            get {
                return ResourceManager.GetString("Regex_match_between_m_and_n_times_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to match between &apos;m&apos; and &apos;n&apos; times.
        /// </summary>
        internal static string Regex_match_between_m_and_n_times_short {
            get {
                return ResourceManager.GetString("Regex_match_between_m_and_n_times_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+.
        /// </summary>
        internal static string Regex_match_exactly_n_times_lazy_long {
            get {
                return ResourceManager.GetString("Regex_match_exactly_n_times_lazy_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to match exactly &apos;n&apos; times (lazy).
        /// </summary>
        internal static string Regex_match_exactly_n_times_lazy_short {
            get {
                return ResourceManager.GetString("Regex_match_exactly_n_times_lazy_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}?.
        /// </summary>
        internal static string Regex_match_exactly_n_times_long {
            get {
                return ResourceManager.GetString("Regex_match_exactly_n_times_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to match exactly &apos;n&apos; times.
        /// </summary>
        internal static string Regex_match_exactly_n_times_short {
            get {
                return ResourceManager.GetString("Regex_match_exactly_n_times_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier +.
        /// </summary>
        internal static string Regex_match_one_or_more_times_lazy_long {
            get {
                return ResourceManager.GetString("Regex_match_one_or_more_times_lazy_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to match one or more times (lazy).
        /// </summary>
        internal static string Regex_match_one_or_more_times_lazy_short {
            get {
                return ResourceManager.GetString("Regex_match_one_or_more_times_lazy_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?..
        /// </summary>
        internal static string Regex_match_one_or_more_times_long {
            get {
                return ResourceManager.GetString("Regex_match_one_or_more_times_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to match one or more times.
        /// </summary>
        internal static string Regex_match_one_or_more_times_short {
            get {
                return ResourceManager.GetString("Regex_match_one_or_more_times_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier *.
        /// </summary>
        internal static string Regex_match_zero_or_more_times_lazy_long {
            get {
                return ResourceManager.GetString("Regex_match_zero_or_more_times_lazy_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to match zero or more times (lazy).
        /// </summary>
        internal static string Regex_match_zero_or_more_times_lazy_short {
            get {
                return ResourceManager.GetString("Regex_match_zero_or_more_times_lazy_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?..
        /// </summary>
        internal static string Regex_match_zero_or_more_times_long {
            get {
                return ResourceManager.GetString("Regex_match_zero_or_more_times_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to match zero or more times.
        /// </summary>
        internal static string Regex_match_zero_or_more_times_short {
            get {
                return ResourceManager.GetString("Regex_match_zero_or_more_times_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ?.
        /// </summary>
        internal static string Regex_match_zero_or_one_time_lazy_long {
            get {
                return ResourceManager.GetString("Regex_match_zero_or_one_time_lazy_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to match zero or one time (lazy).
        /// </summary>
        internal static string Regex_match_zero_or_one_time_lazy_short {
            get {
                return ResourceManager.GetString("Regex_match_zero_or_one_time_lazy_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??..
        /// </summary>
        internal static string Regex_match_zero_or_one_time_long {
            get {
                return ResourceManager.GetString("Regex_match_zero_or_one_time_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to match zero or one time.
        /// </summary>
        internal static string Regex_match_zero_or_one_time_short {
            get {
                return ResourceManager.GetString("Regex_match_zero_or_one_time_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This grouping construct captures a matched &apos;subexpression&apos;, where &apos;subexpression&apos; is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern..
        /// </summary>
        internal static string Regex_matched_subexpression_long {
            get {
                return ResourceManager.GetString("Regex_matched_subexpression_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to matched subexpression.
        /// </summary>
        internal static string Regex_matched_subexpression_short {
            get {
                return ResourceManager.GetString("Regex_matched_subexpression_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to name.
        /// </summary>
        internal static string Regex_name {
            get {
                return ResourceManager.GetString("Regex_name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to name-or-number.
        /// </summary>
        internal static string Regex_name_or_number {
            get {
                return ResourceManager.GetString("Regex_name_or_number", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to name1.
        /// </summary>
        internal static string Regex_name1 {
            get {
                return ResourceManager.GetString("Regex_name1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to name2.
        /// </summary>
        internal static string Regex_name2 {
            get {
                return ResourceManager.GetString("Regex_name2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A named or numbered backreference.
        ///
        ///&apos;name&apos; is the name of a capturing group defined in the regular expression pattern..
        /// </summary>
        internal static string Regex_named_backreference_long {
            get {
                return ResourceManager.GetString("Regex_named_backreference_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to named backreference.
        /// </summary>
        internal static string Regex_named_backreference_short {
            get {
                return ResourceManager.GetString("Regex_named_backreference_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Captures a matched subexpression and lets you access it by name or by number.
        ///
        ///&apos;name&apos; is a valid group name, and &apos;subexpression&apos; is any valid regular expression pattern. &apos;name&apos; must not contain any punctuation characters and cannot begin with a number.
        ///
        ///If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing gro [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string Regex_named_matched_subexpression_long {
            get {
                return ResourceManager.GetString("Regex_named_matched_subexpression_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to named matched subexpression.
        /// </summary>
        internal static string Regex_named_matched_subexpression_short {
            get {
                return ResourceManager.GetString("Regex_named_matched_subexpression_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually.
        ///
        ///Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from &quot;0&quot; through &quot;9&quot;, the range of lowercase letters from &quot;a&quot; through &quot;f&quot;, and the range of uppercase letters from &quot;A&quot; through &quot;F&quot;, use [0-9a-fA-F]..
        /// </summary>
        internal static string Regex_negative_character_group_long {
            get {
                return ResourceManager.GetString("Regex_negative_character_group_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to negative character group.
        /// </summary>
        internal static string Regex_negative_character_group_short {
            get {
                return ResourceManager.GetString("Regex_negative_character_group_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A negative character range specifies a list of characters that must not appear in an input string for a match to occur. &apos;firstCharacter&apos; is the character that begins the range, and &apos;lastCharacter&apos; is the character that ends the range.
        ///
        ///Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from &quot;0&quot; through &quot;9&quot;, the range of lowercase letters from &quot;a&quot; through &quot;f&quot;, and the range of uppercase letters from &quot;A&quot; through &quot;F&quot;, use [0-9a-fA-F]..
        /// </summary>
        internal static string Regex_negative_character_range_long {
            get {
                return ResourceManager.GetString("Regex_negative_character_range_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to negative character range.
        /// </summary>
        internal static string Regex_negative_character_range_short {
            get {
                return ResourceManager.GetString("Regex_negative_character_range_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name..
        /// </summary>
        internal static string Regex_negative_unicode_category_long {
            get {
                return ResourceManager.GetString("Regex_negative_unicode_category_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to negative unicode category.
        /// </summary>
        internal static string Regex_negative_unicode_category_short {
            get {
                return ResourceManager.GetString("Regex_negative_unicode_category_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Matches a new-line character, \u000A.
        /// </summary>
        internal static string Regex_new_line_character_long {
            get {
                return ResourceManager.GetString("Regex_new_line_character_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to new-line character.
        /// </summary>
        internal static string Regex_new_line_character_short {
            get {
                return ResourceManager.GetString("Regex_new_line_character_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to no.
        /// </summary>
        internal static string Regex_no {
            get {
                return ResourceManager.GetString("Regex_no", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern.
        ///
        ///If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9].
        /// </summary>
        internal static string Regex_non_digit_character_long {
            get {
                return ResourceManager.GetString("Regex_non_digit_character_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to non-digit character.
        /// </summary>
        internal static string Regex_non_digit_character_short {
            get {
                return ResourceManager.GetString("Regex_non_digit_character_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters.
        ///
        ///If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v].
        /// </summary>
        internal static string Regex_non_white_space_character_long {
            get {
                return ResourceManager.GetString("Regex_non_white_space_character_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to non-white-space character.
        /// </summary>
        internal static string Regex_non_white_space_character_short {
            get {
                return ResourceManager.GetString("Regex_non_white_space_character_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor..
        /// </summary>
        internal static string Regex_non_word_boundary_long {
            get {
                return ResourceManager.GetString("Regex_non_word_boundary_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to non-word boundary.
        /// </summary>
        internal static string Regex_non_word_boundary_short {
            get {
                return ResourceManager.GetString("Regex_non_word_boundary_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to \W matches any non-word character. It matches any character except for those in the following Unicode categories:
        ///
        ///    Ll	Letter, Lowercase
        ///    Lu	Letter, Uppercase
        ///    Lt	Letter, Titlecase
        ///    Lo	Letter, Other
        ///    Lm	Letter, Modifier
        ///    Mn	Mark, Nonspacing
        ///    Nd	Number, Decimal Digit
        ///    Pc	Punctuation, Connector
        ///
        ///If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9].
        /// </summary>
        internal static string Regex_non_word_character_long {
            get {
                return ResourceManager.GetString("Regex_non_word_character_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to non-word character.
        /// </summary>
        internal static string Regex_non_word_character_short {
            get {
                return ResourceManager.GetString("Regex_non_word_character_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.)
        ///
        ///This option is recommended if you know that backtracking will not succeed. Preven [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string Regex_nonbacktracking_subexpression_long {
            get {
                return ResourceManager.GetString("Regex_nonbacktracking_subexpression_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to nonbacktracking subexpression.
        /// </summary>
        internal static string Regex_nonbacktracking_subexpression_short {
            get {
                return ResourceManager.GetString("Regex_nonbacktracking_subexpression_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This construct does not capture the substring that is matched by a subexpression:
        ///
        ///The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest.
        ///
        ///If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs..
        /// </summary>
        internal static string Regex_noncapturing_group_long {
            get {
                return ResourceManager.GetString("Regex_noncapturing_group_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to noncapturing group.
        /// </summary>
        internal static string Regex_noncapturing_group_short {
            get {
                return ResourceManager.GetString("Regex_noncapturing_group_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to number, decimal digit.
        /// </summary>
        internal static string Regex_number_decimal_digit {
            get {
                return ResourceManager.GetString("Regex_number_decimal_digit", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to number, letter.
        /// </summary>
        internal static string Regex_number_letter {
            get {
                return ResourceManager.GetString("Regex_number_letter", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to number, other.
        /// </summary>
        internal static string Regex_number_other {
            get {
                return ResourceManager.GetString("Regex_number_other", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A numbered backreference, where &apos;number&apos; is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group.
        ///
        ///There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k&lt;name&gt; notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot b [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string Regex_numbered_backreference_long {
            get {
                return ResourceManager.GetString("Regex_numbered_backreference_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to numbered backreference.
        /// </summary>
        internal static string Regex_numbered_backreference_short {
            get {
                return ResourceManager.GetString("Regex_numbered_backreference_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to other, control.
        /// </summary>
        internal static string Regex_other_control {
            get {
                return ResourceManager.GetString("Regex_other_control", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to other, format.
        /// </summary>
        internal static string Regex_other_format {
            get {
                return ResourceManager.GetString("Regex_other_format", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to other, not assigned.
        /// </summary>
        internal static string Regex_other_not_assigned {
            get {
                return ResourceManager.GetString("Regex_other_not_assigned", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to other, private use.
        /// </summary>
        internal static string Regex_other_private_use {
            get {
                return ResourceManager.GetString("Regex_other_private_use", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to other, surrogate.
        /// </summary>
        internal static string Regex_other_surrogate {
            get {
                return ResourceManager.GetString("Regex_other_surrogate", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur..
        /// </summary>
        internal static string Regex_positive_character_group_long {
            get {
                return ResourceManager.GetString("Regex_positive_character_group_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to positive character group.
        /// </summary>
        internal static string Regex_positive_character_group_short {
            get {
                return ResourceManager.GetString("Regex_positive_character_group_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur.  &apos;firstCharacter&apos; is the character that begins the range and &apos;lastCharacter&apos; is the character that ends the range. .
        /// </summary>
        internal static string Regex_positive_character_range_long {
            get {
                return ResourceManager.GetString("Regex_positive_character_range_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to positive character range.
        /// </summary>
        internal static string Regex_positive_character_range_short {
            get {
                return ResourceManager.GetString("Regex_positive_character_range_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to punctuation, close.
        /// </summary>
        internal static string Regex_punctuation_close {
            get {
                return ResourceManager.GetString("Regex_punctuation_close", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to punctuation, connector.
        /// </summary>
        internal static string Regex_punctuation_connector {
            get {
                return ResourceManager.GetString("Regex_punctuation_connector", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to punctuation, dash.
        /// </summary>
        internal static string Regex_punctuation_dash {
            get {
                return ResourceManager.GetString("Regex_punctuation_dash", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to punctuation, final quote.
        /// </summary>
        internal static string Regex_punctuation_final_quote {
            get {
                return ResourceManager.GetString("Regex_punctuation_final_quote", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to punctuation, initial quote.
        /// </summary>
        internal static string Regex_punctuation_initial_quote {
            get {
                return ResourceManager.GetString("Regex_punctuation_initial_quote", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to punctuation, open.
        /// </summary>
        internal static string Regex_punctuation_open {
            get {
                return ResourceManager.GetString("Regex_punctuation_open", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to punctuation, other.
        /// </summary>
        internal static string Regex_punctuation_other {
            get {
                return ResourceManager.GetString("Regex_punctuation_other", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to separator, line.
        /// </summary>
        internal static string Regex_separator_line {
            get {
                return ResourceManager.GetString("Regex_separator_line", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to separator, paragraph.
        /// </summary>
        internal static string Regex_separator_paragraph {
            get {
                return ResourceManager.GetString("Regex_separator_paragraph", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to separator, space.
        /// </summary>
        internal static string Regex_separator_space {
            get {
                return ResourceManager.GetString("Regex_separator_space", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string..
        /// </summary>
        internal static string Regex_start_of_string_only_long {
            get {
                return ResourceManager.GetString("Regex_start_of_string_only_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to start of string only.
        /// </summary>
        internal static string Regex_start_of_string_only_short {
            get {
                return ResourceManager.GetString("Regex_start_of_string_only_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line..
        /// </summary>
        internal static string Regex_start_of_string_or_line_long {
            get {
                return ResourceManager.GetString("Regex_start_of_string_or_line_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to start of string or line.
        /// </summary>
        internal static string Regex_start_of_string_or_line_short {
            get {
                return ResourceManager.GetString("Regex_start_of_string_or_line_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to subexpression.
        /// </summary>
        internal static string Regex_subexpression {
            get {
                return ResourceManager.GetString("Regex_subexpression", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to symbol, currency.
        /// </summary>
        internal static string Regex_symbol_currency {
            get {
                return ResourceManager.GetString("Regex_symbol_currency", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to symbol, math.
        /// </summary>
        internal static string Regex_symbol_math {
            get {
                return ResourceManager.GetString("Regex_symbol_math", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to symbol, modifier.
        /// </summary>
        internal static string Regex_symbol_modifier {
            get {
                return ResourceManager.GetString("Regex_symbol_modifier", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to symbol, other.
        /// </summary>
        internal static string Regex_symbol_other {
            get {
                return ResourceManager.GetString("Regex_symbol_other", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Matches a tab character, \u0009.
        /// </summary>
        internal static string Regex_tab_character_long {
            get {
                return ResourceManager.GetString("Regex_tab_character_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to tab character.
        /// </summary>
        internal static string Regex_tab_character_short {
            get {
                return ResourceManager.GetString("Regex_tab_character_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name..
        /// </summary>
        internal static string Regex_unicode_category_long {
            get {
                return ResourceManager.GetString("Regex_unicode_category_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to unicode category.
        /// </summary>
        internal static string Regex_unicode_category_short {
            get {
                return ResourceManager.GetString("Regex_unicode_category_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Matches a UTF-16 code unit whose value is #### hexadecimal..
        /// </summary>
        internal static string Regex_unicode_escape_long {
            get {
                return ResourceManager.GetString("Regex_unicode_escape_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to unicode escape.
        /// </summary>
        internal static string Regex_unicode_escape_short {
            get {
                return ResourceManager.GetString("Regex_unicode_escape_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unicode General Category: {0}.
        /// </summary>
        internal static string Regex_unicode_general_category_0 {
            get {
                return ResourceManager.GetString("Regex_unicode_general_category_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Matches a vertical-tab character, \u000B.
        /// </summary>
        internal static string Regex_vertical_tab_character_long {
            get {
                return ResourceManager.GetString("Regex_vertical_tab_character_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to vertical-tab character.
        /// </summary>
        internal static string Regex_vertical_tab_character_short {
            get {
                return ResourceManager.GetString("Regex_vertical_tab_character_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories:
        ///
        ///    \f	The form feed character, \u000C
        ///    \n	The newline character, \u000A
        ///    \r	The carriage return character, \u000D
        ///    \t	The tab character, \u0009
        ///    \v	The vertical tab character, \u000B
        ///    \x85	The ellipsis or NEXT LINE (NEL) character (…), \u0085
        ///    \p{Z}	Matches any separator character
        ///
        ///If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v].
        /// </summary>
        internal static string Regex_white_space_character_long {
            get {
                return ResourceManager.GetString("Regex_white_space_character_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to white-space character.
        /// </summary>
        internal static string Regex_white_space_character_short {
            get {
                return ResourceManager.GetString("Regex_white_space_character_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string.
        ///
        ///The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beg [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string Regex_word_boundary_long {
            get {
                return ResourceManager.GetString("Regex_word_boundary_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to word boundary.
        /// </summary>
        internal static string Regex_word_boundary_short {
            get {
                return ResourceManager.GetString("Regex_word_boundary_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to \w matches any word character. A word character is a member of any of the following Unicode categories:
        ///
        ///    Ll	Letter, Lowercase
        ///    Lu	Letter, Uppercase
        ///    Lt	Letter, Titlecase
        ///    Lo	Letter, Other
        ///    Lm	Letter, Modifier
        ///    Mn	Mark, Nonspacing
        ///    Nd	Number, Decimal Digit
        ///    Pc	Punctuation, Connector
        ///
        ///If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9].
        /// </summary>
        internal static string Regex_word_character_long {
            get {
                return ResourceManager.GetString("Regex_word_character_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to word character.
        /// </summary>
        internal static string Regex_word_character_short {
            get {
                return ResourceManager.GetString("Regex_word_character_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to yes.
        /// </summary>
        internal static string Regex_yes {
            get {
                return ResourceManager.GetString("Regex_yes", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result.
        ///
        ///A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string Regex_zero_width_negative_lookahead_assertion_long {
            get {
                return ResourceManager.GetString("Regex_zero_width_negative_lookahead_assertion_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to zero-width negative lookahead assertion.
        /// </summary>
        internal static string Regex_zero_width_negative_lookahead_assertion_short {
            get {
                return ResourceManager.GetString("Regex_zero_width_negative_lookahead_assertion_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A zero-width negative lookbehind assertion, where for a match to be successful, &apos;subexpression&apos; must not occur at the input string to the left of the current position. Any substring that does not match &apos;subexpression&apos; is not included in the match result.
        ///
        ///Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or character [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string Regex_zero_width_negative_lookbehind_assertion_long {
            get {
                return ResourceManager.GetString("Regex_zero_width_negative_lookbehind_assertion_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to zero-width negative lookbehind assertion.
        /// </summary>
        internal static string Regex_zero_width_negative_lookbehind_assertion_short {
            get {
                return ResourceManager.GetString("Regex_zero_width_negative_lookbehind_assertion_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in &apos;subexpression&apos;. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack.
        ///
        ///Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string Regex_zero_width_positive_lookahead_assertion_long {
            get {
                return ResourceManager.GetString("Regex_zero_width_positive_lookahead_assertion_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to zero-width positive lookahead assertion.
        /// </summary>
        internal static string Regex_zero_width_positive_lookahead_assertion_short {
            get {
                return ResourceManager.GetString("Regex_zero_width_positive_lookahead_assertion_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A zero-width positive lookbehind assertion, where for a match to be successful, &apos;subexpression&apos; must occur at the input string to the left of the current position. &apos;subexpression&apos; is not included in the match result. A zero-width positive lookbehind assertion does not backtrack.
        ///
        ///Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result..
        /// </summary>
        internal static string Regex_zero_width_positive_lookbehind_assertion_long {
            get {
                return ResourceManager.GetString("Regex_zero_width_positive_lookbehind_assertion_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to zero-width positive lookbehind assertion.
        /// </summary>
        internal static string Regex_zero_width_positive_lookbehind_assertion_short {
            get {
                return ResourceManager.GetString("Regex_zero_width_positive_lookbehind_assertion_short", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Remove the line below if you want to inherit .editorconfig settings from higher directories.
        /// </summary>
        internal static string Remove_the_line_below_if_you_want_to_inherit_dot_editorconfig_settings_from_higher_directories {
            get {
                return ResourceManager.GetString("Remove_the_line_below_if_you_want_to_inherit_dot_editorconfig_settings_from_highe" +
                        "r_directories", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Removed:.
        /// </summary>
        internal static string Removed_colon {
            get {
                return ResourceManager.GetString("Removed_colon", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Removing additional documents is not supported..
        /// </summary>
        internal static string Removing_additional_documents_is_not_supported {
            get {
                return ResourceManager.GetString("Removing_additional_documents_is_not_supported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Removing analyzer config documents is not supported..
        /// </summary>
        internal static string Removing_analyzer_config_documents_is_not_supported {
            get {
                return ResourceManager.GetString("Removing_analyzer_config_documents_is_not_supported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Removing analyzer references is not supported..
        /// </summary>
        internal static string Removing_analyzer_references_is_not_supported {
            get {
                return ResourceManager.GetString("Removing_analyzer_references_is_not_supported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Removing documents is not supported..
        /// </summary>
        internal static string Removing_documents_is_not_supported {
            get {
                return ResourceManager.GetString("Removing_documents_is_not_supported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Removing metadata references is not supported..
        /// </summary>
        internal static string Removing_metadata_references_is_not_supported {
            get {
                return ResourceManager.GetString("Removing_metadata_references_is_not_supported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Removing project references is not supported..
        /// </summary>
        internal static string Removing_project_references_is_not_supported {
            get {
                return ResourceManager.GetString("Removing_project_references_is_not_supported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Removing projects is not supported..
        /// </summary>
        internal static string Removing_projects_is_not_supported {
            get {
                return ResourceManager.GetString("Removing_projects_is_not_supported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Service of type &apos;{0}&apos; is required to accomplish the task but is not available from the workspace..
        /// </summary>
        internal static string Service_of_type_0_is_required_to_accomplish_the_task_but_is_not_available_from_the_workspace {
            get {
                return ResourceManager.GetString("Service_of_type_0_is_required_to_accomplish_the_task_but_is_not_available_from_th" +
                        "e_workspace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Show Stack Trace.
        /// </summary>
        internal static string Show_Stack_Trace {
            get {
                return ResourceManager.GetString("Show_Stack_Trace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Solution file not found: &apos;{0}&apos;.
        /// </summary>
        internal static string Solution_file_not_found_colon_0 {
            get {
                return ResourceManager.GetString("Solution_file_not_found_colon_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specified path must be absolute..
        /// </summary>
        internal static string Specified_path_must_be_absolute {
            get {
                return ResourceManager.GetString("Specified_path_must_be_absolute", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Static Field.
        /// </summary>
        internal static string Static_Field {
            get {
                return ResourceManager.GetString("Static_Field", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Static Method.
        /// </summary>
        internal static string Static_Method {
            get {
                return ResourceManager.GetString("Static_Method", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Stream is too long..
        /// </summary>
        internal static string Stream_is_too_long {
            get {
                return ResourceManager.GetString("Stream_is_too_long", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Struct.
        /// </summary>
        internal static string Struct {
            get {
                return ResourceManager.GetString("Struct", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Suggestion.
        /// </summary>
        internal static string Suggestion {
            get {
                return ResourceManager.GetString("Suggestion", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Supplied diagnostic cannot be null..
        /// </summary>
        internal static string Supplied_diagnostic_cannot_be_null {
            get {
                return ResourceManager.GetString("Supplied_diagnostic_cannot_be_null", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Symbol &quot;{0}&quot; is not from source..
        /// </summary>
        internal static string Symbol_0_is_not_from_source {
            get {
                return ResourceManager.GetString("Symbol_0_is_not_from_source", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Symbol specifications.
        /// </summary>
        internal static string Symbol_specifications {
            get {
                return ResourceManager.GetString("Symbol_specifications", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Syntax tree is required to accomplish the task but is not supported by document {0}..
        /// </summary>
        internal static string SyntaxTree_is_required_to_accomplish_the_task_but_is_not_supported_by_document_0 {
            get {
                return ResourceManager.GetString("SyntaxTree_is_required_to_accomplish_the_task_but_is_not_supported_by_document_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Temporary storage cannot be written more than once..
        /// </summary>
        internal static string Temporary_storage_cannot_be_written_more_than_once {
            get {
                return ResourceManager.GetString("Temporary_storage_cannot_be_written_more_than_once", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The first word, &apos;{0}&apos;, must begin with a lower case character.
        /// </summary>
        internal static string The_first_word_0_must_begin_with_a_lower_case_character {
            get {
                return ResourceManager.GetString("The_first_word_0_must_begin_with_a_lower_case_character", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The first word, &apos;{0}&apos;, must begin with an upper case character.
        /// </summary>
        internal static string The_first_word_0_must_begin_with_an_upper_case_character {
            get {
                return ResourceManager.GetString("The_first_word_0_must_begin_with_an_upper_case_character", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The language &apos;{0}&apos; is not supported..
        /// </summary>
        internal static string The_language_0_is_not_supported {
            get {
                return ResourceManager.GetString("The_language_0_is_not_supported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The member &apos;{0}&apos; is not declared within the declaration of the symbol..
        /// </summary>
        internal static string The_member_0_is_not_declared_within_the_declaration_of_the_symbol {
            get {
                return ResourceManager.GetString("The_member_0_is_not_declared_within_the_declaration_of_the_symbol", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The node is not part of the tree..
        /// </summary>
        internal static string The_node_is_not_part_of_the_tree {
            get {
                return ResourceManager.GetString("The_node_is_not_part_of_the_tree", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The position is not within the symbol&apos;s declaration.
        /// </summary>
        internal static string The_position_is_not_within_the_symbol_s_declaration {
            get {
                return ResourceManager.GetString("The_position_is_not_within_the_symbol_s_declaration", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The project already references the target project..
        /// </summary>
        internal static string The_project_already_references_the_target_project {
            get {
                return ResourceManager.GetString("The_project_already_references_the_target_project", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The project already transitively references the target project..
        /// </summary>
        internal static string The_project_already_transitively_references_the_target_project {
            get {
                return ResourceManager.GetString("The_project_already_transitively_references_the_target_project", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The solution already contains the specified document..
        /// </summary>
        internal static string The_solution_already_contains_the_specified_document {
            get {
                return ResourceManager.GetString("The_solution_already_contains_the_specified_document", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The solution already contains the specified project..
        /// </summary>
        internal static string The_solution_already_contains_the_specified_project {
            get {
                return ResourceManager.GetString("The_solution_already_contains_the_specified_project", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The solution does not contain the specified document..
        /// </summary>
        internal static string The_solution_does_not_contain_the_specified_document {
            get {
                return ResourceManager.GetString("The_solution_does_not_contain_the_specified_document", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The solution does not contain the specified project..
        /// </summary>
        internal static string The_solution_does_not_contain_the_specified_project {
            get {
                return ResourceManager.GetString("The_solution_does_not_contain_the_specified_project", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The specified document is not a version of this document..
        /// </summary>
        internal static string The_specified_document_is_not_a_version_of_this_document {
            get {
                return ResourceManager.GetString("The_specified_document_is_not_a_version_of_this_document", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The symbol &apos;{0}&apos; cannot be located within the current solution..
        /// </summary>
        internal static string The_symbol_0_cannot_be_located_within_the_current_solution {
            get {
                return ResourceManager.GetString("The_symbol_0_cannot_be_located_within_the_current_solution", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type &apos;{0}&apos; is not understood by the serialization binder..
        /// </summary>
        internal static string The_type_0_is_not_understood_by_the_serialization_binder {
            get {
                return ResourceManager.GetString("The_type_0_is_not_understood_by_the_serialization_binder", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to These non-leading words must begin with a lowercase letter: {0}.
        /// </summary>
        internal static string These_non_leading_words_must_begin_with_a_lowercase_letter_colon_0 {
            get {
                return ResourceManager.GetString("These_non_leading_words_must_begin_with_a_lowercase_letter_colon_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to These non-leading words must begin with an upper case letter: {0}.
        /// </summary>
        internal static string These_non_leading_words_must_begin_with_an_upper_case_letter_colon_0 {
            get {
                return ResourceManager.GetString("These_non_leading_words_must_begin_with_an_upper_case_letter_colon_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to These words cannot contain lower case characters: {0}.
        /// </summary>
        internal static string These_words_cannot_contain_lower_case_characters_colon_0 {
            get {
                return ResourceManager.GetString("These_words_cannot_contain_lower_case_characters_colon_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to These words cannot contain upper case characters: {0}.
        /// </summary>
        internal static string These_words_cannot_contain_upper_case_characters_colon_0 {
            get {
                return ResourceManager.GetString("These_words_cannot_contain_upper_case_characters_colon_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to These words must begin with upper case characters: {0}.
        /// </summary>
        internal static string These_words_must_begin_with_upper_case_characters_colon_0 {
            get {
                return ResourceManager.GetString("These_words_must_begin_with_upper_case_characters_colon_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to this. and Me. preferences.
        /// </summary>
        internal static string this_dot_and_Me_dot_preferences {
            get {
                return ResourceManager.GetString("this_dot_and_Me_dot_preferences", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This submission already references another submission project..
        /// </summary>
        internal static string This_submission_already_references_another_submission_project {
            get {
                return ResourceManager.GetString("This_submission_already_references_another_submission_project", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This workspace does not support opening and closing documents..
        /// </summary>
        internal static string This_workspace_does_not_support_opening_and_closing_documents {
            get {
                return ResourceManager.GetString("This_workspace_does_not_support_opening_and_closing_documents", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Too many | in (?()|).
        /// </summary>
        internal static string Too_many_bars_in_conditional_grouping {
            get {
                return ResourceManager.GetString("Too_many_bars_in_conditional_grouping", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Too many )&apos;s.
        /// </summary>
        internal static string Too_many_close_parens {
            get {
                return ResourceManager.GetString("Too_many_close_parens", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Types.
        /// </summary>
        internal static string Types {
            get {
                return ResourceManager.GetString("Types", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unknown identifier..
        /// </summary>
        internal static string Unknown_identifier {
            get {
                return ResourceManager.GetString("Unknown_identifier", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unknown property.
        /// </summary>
        internal static string Unknown_property {
            get {
                return ResourceManager.GetString("Unknown_property", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unknown property &apos;{0}&apos;.
        /// </summary>
        internal static string Unknown_property_0 {
            get {
                return ResourceManager.GetString("Unknown_property_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unmerged change from project &apos;{0}&apos;.
        /// </summary>
        internal static string Unmerged_change_from_project_0 {
            get {
                return ResourceManager.GetString("Unmerged_change_from_project_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unrecognized control character.
        /// </summary>
        internal static string Unrecognized_control_character {
            get {
                return ResourceManager.GetString("Unrecognized_control_character", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unrecognized escape sequence \{0}.
        /// </summary>
        internal static string Unrecognized_escape_sequence_0 {
            get {
                return ResourceManager.GetString("Unrecognized_escape_sequence_0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unrecognized grouping construct.
        /// </summary>
        internal static string Unrecognized_grouping_construct {
            get {
                return ResourceManager.GetString("Unrecognized_grouping_construct", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unrecognized language name..
        /// </summary>
        internal static string Unrecognized_language_name {
            get {
                return ResourceManager.GetString("Unrecognized_language_name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unterminated [] set.
        /// </summary>
        internal static string Unterminated_character_class_set {
            get {
                return ResourceManager.GetString("Unterminated_character_class_set", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unterminated (?#...) comment.
        /// </summary>
        internal static string Unterminated_regex_comment {
            get {
                return ResourceManager.GetString("Unterminated_regex_comment", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Value too large to be represented as a 30 bit unsigned integer..
        /// </summary>
        internal static string Value_too_large_to_be_represented_as_a_30_bit_unsigned_integer {
            get {
                return ResourceManager.GetString("Value_too_large_to_be_represented_as_a_30_bit_unsigned_integer", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Variables captured:.
        /// </summary>
        internal static string Variables_captured_colon {
            get {
                return ResourceManager.GetString("Variables_captured_colon", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Visual Basic files.
        /// </summary>
        internal static string Visual_Basic_files {
            get {
                return ResourceManager.GetString("Visual_Basic_files", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Warning.
        /// </summary>
        internal static string Warning {
            get {
                return ResourceManager.GetString("Warning", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Adding imports will bring an extension method into scope with the same name as &apos;{0}&apos;.
        /// </summary>
        internal static string Warning_adding_imports_will_bring_an_extension_method_into_scope_with_the_same_name_as_member_access {
            get {
                return ResourceManager.GetString("Warning_adding_imports_will_bring_an_extension_method_into_scope_with_the_same_na" +
                        "me_as_member_access", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Workspace error.
        /// </summary>
        internal static string Workspace_error {
            get {
                return ResourceManager.GetString("Workspace_error", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Workspace is not empty..
        /// </summary>
        internal static string Workspace_is_not_empty {
            get {
                return ResourceManager.GetString("Workspace_is_not_empty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to [x-y] range in reverse order.
        /// </summary>
        internal static string x_y_range_in_reverse_order {
            get {
                return ResourceManager.GetString("x_y_range_in_reverse_order", resourceCulture);
            }
        }
    }
}