public ConceptDescriptor getDescriptor(String conceptFqName) {
   switch (Arrays.binarySearch(stringSwitchCases_1htk8d_a0a0b, conceptFqName)) {
     case 0:
       return new CompiledConceptDescriptor(
           "org.jetbrains.mps.samples.DecisionTable.structure.DecisionTable",
           "jetbrains.mps.baseLanguage.structure.Expression",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.Expression"},
           new String[] {},
           new String[] {});
     default:
       return StructureAspectInterpreted.getInstance().getDescriptor(conceptFqName);
   }
 }
 public ConceptDescriptor getDescriptor(String conceptFqName) {
   switch (Arrays.binarySearch(stringSwitchCases_1htk8d_a0a0a, conceptFqName)) {
     case 0:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.traceable.operations.structure.NList_CopyWithTraceOperation",
           "jetbrains.mps.baseLanguage.structure.Expression",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.Expression"},
           new String[] {},
           new String[] {});
     case 1:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.traceable.operations.structure.Node_CopyWithTraceOperation",
           "jetbrains.mps.lang.smodel.structure.SNodeOperation",
           false,
           new String[] {"jetbrains.mps.lang.smodel.structure.SNodeOperation"},
           new String[] {},
           new String[] {});
     default:
       return StructureAspectInterpreted.getInstance().getDescriptor(conceptFqName);
   }
 }
 public ConceptDescriptor getDescriptor(String conceptFqName) {
   switch (Arrays.binarySearch(stringSwitchCases_1htk8d_a0a0b, conceptFqName)) {
     case 0:
       return new ConceptDescriptorBuilder("jetbrains.mps.core.workflow.structure.WflowAssert")
           .super_("jetbrains.mps.core.workflow.structure.WflowStatement")
           .parents("jetbrains.mps.core.workflow.structure.WflowStatement")
           .children(new String[] {"actual", "expected"}, new boolean[] {false, false})
           .alias("assert", "")
           .create();
     case 1:
       return new ConceptDescriptorBuilder("jetbrains.mps.core.workflow.structure.WflowExecutable")
           .super_("jetbrains.mps.lang.core.structure.BaseConcept")
           .parents(
               "jetbrains.mps.lang.core.structure.BaseConcept",
               "jetbrains.mps.lang.core.structure.INamedConcept",
               "jetbrains.mps.lang.core.structure.ScopeProvider")
           .children(new String[] {"statements"}, new boolean[] {true})
           .alias("Workflow executable", "")
           .create();
     case 2:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.core.workflow.structure.WflowExpressionStatement")
           .super_("jetbrains.mps.core.workflow.structure.WflowStatement")
           .parents(
               "jetbrains.mps.core.workflow.structure.WflowStatement",
               "jetbrains.mps.core.query.structure.MqlVariableContainer",
               "jetbrains.mps.lang.core.structure.IDontSubstituteByDefault")
           .children(new String[] {"var", "expression"}, new boolean[] {false, false})
           .create();
     case 3:
       return new ConceptDescriptorBuilder("jetbrains.mps.core.workflow.structure.WflowStatement")
           .super_("jetbrains.mps.lang.core.structure.BaseConcept")
           .parents("jetbrains.mps.lang.core.structure.BaseConcept")
           .create();
     default:
       return StructureAspectInterpreted.getInstance().getDescriptor(conceptFqName);
   }
 }
 public ConceptDescriptor getDescriptor(String conceptFqName) {
   switch (Arrays.binarySearch(stringSwitchCases_1htk8d_a0a0b, conceptFqName)) {
     case 0:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.execution.settings.structure.ApplyTo_Function")
           .super_("jetbrains.mps.execution.settings.structure.EditorOperationDeclaration")
           .parents("jetbrains.mps.execution.settings.structure.EditorOperationDeclaration")
           .alias("apply to", "")
           .create();
     case 1:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.execution.settings.structure.CheckProperitesOperation")
           .super_("jetbrains.mps.lang.core.structure.BaseConcept")
           .parents(
               "jetbrains.mps.lang.core.structure.BaseConcept",
               "jetbrains.mps.baseLanguage.classifiers.structure.IMemberOperation")
           .references("checkProperties")
           .staticScope(StaticScope.NONE)
           .create();
     case 2:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.execution.settings.structure.CheckProperties_Function")
           .super_("jetbrains.mps.baseLanguage.structure.ConceptFunction")
           .parents(
               "jetbrains.mps.baseLanguage.structure.ConceptFunction",
               "jetbrains.mps.baseLanguage.classifiers.structure.IMember")
           .alias("check", "")
           .create();
     case 3:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.execution.settings.structure.Configuration_Parameter")
           .super_("jetbrains.mps.baseLanguage.structure.ConceptFunctionParameter")
           .parents("jetbrains.mps.baseLanguage.structure.ConceptFunctionParameter")
           .alias("configuration", "")
           .staticScope(StaticScope.NONE)
           .create();
     case 4:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.execution.settings.structure.CreateEditor_Function")
           .super_("jetbrains.mps.execution.settings.structure.EditorOperationDeclaration")
           .parents("jetbrains.mps.execution.settings.structure.EditorOperationDeclaration")
           .alias("create", "")
           .create();
     case 5:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.execution.settings.structure.DeprecatedAnnotation")
           .super_("jetbrains.mps.lang.core.structure.NodeAttribute")
           .parents("jetbrains.mps.lang.core.structure.NodeAttribute")
           .properties("since", "comment")
           .create();
     case 6:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.execution.settings.structure.Dispose_Function")
           .super_("jetbrains.mps.execution.settings.structure.EditorOperationDeclaration")
           .parents("jetbrains.mps.execution.settings.structure.EditorOperationDeclaration")
           .alias("dispose", "")
           .create();
     case 7:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.execution.settings.structure.EditorExpression")
           .super_("jetbrains.mps.baseLanguage.structure.Expression")
           .parents("jetbrains.mps.baseLanguage.structure.Expression")
           .references("persistentPropertyDeclaration")
           .alias("editor", "")
           .staticScope(StaticScope.NONE)
           .create();
     case 8:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.execution.settings.structure.EditorOperationCall")
           .super_("jetbrains.mps.lang.core.structure.BaseConcept")
           .parents(
               "jetbrains.mps.lang.core.structure.BaseConcept",
               "jetbrains.mps.baseLanguage.structure.IOperation")
           .references("editorOperationDeclaration")
           .children(new String[] {"arguments"}, new boolean[] {true})
           .staticScope(StaticScope.NONE)
           .create();
     case 9:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.execution.settings.structure.EditorOperationDeclaration")
           .super_("jetbrains.mps.baseLanguage.structure.ConceptFunction")
           .parents("jetbrains.mps.baseLanguage.structure.ConceptFunction")
           .abstract_()
           .create();
     case 10:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.execution.settings.structure.EditorPropertyDeclaration")
           .super_("jetbrains.mps.baseLanguage.structure.VariableDeclaration")
           .parents("jetbrains.mps.baseLanguage.structure.VariableDeclaration")
           .create();
     case 11:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.execution.settings.structure.EditorPropertyReference")
           .super_("jetbrains.mps.baseLanguage.structure.VariableReference")
           .parents("jetbrains.mps.baseLanguage.structure.VariableReference")
           .references("editorPropertyDeclaration")
           .staticScope(StaticScope.NONE)
           .create();
     case 12:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.execution.settings.structure.GetEditorOperation")
           .super_("jetbrains.mps.lang.core.structure.BaseConcept")
           .parents(
               "jetbrains.mps.lang.core.structure.BaseConcept",
               "jetbrains.mps.baseLanguage.structure.IOperation")
           .alias("editor", "")
           .staticScope(StaticScope.NONE)
           .create();
     case 13:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.execution.settings.structure.GridBagConstraints")
           .super_("jetbrains.mps.baseLanguage.structure.Expression")
           .parents("jetbrains.mps.baseLanguage.structure.Expression")
           .properties("constraintsKind")
           .children(new String[] {"order"}, new boolean[] {false})
           .alias("grid bag constraints", "")
           .staticScope(StaticScope.NONE)
           .create();
     case 14:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.execution.settings.structure.IPersistentPropertyHolder")
           .interface_()
           .parents("jetbrains.mps.lang.core.structure.INamedConcept")
           .children(new String[] {"persistentProperty"}, new boolean[] {true})
           .create();
     case 15:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.execution.settings.structure.PersistentConfiguration")
           .super_("jetbrains.mps.lang.core.structure.BaseConcept")
           .parents(
               "jetbrains.mps.lang.core.structure.BaseConcept",
               "jetbrains.mps.execution.settings.structure.IPersistentPropertyHolder",
               "jetbrains.mps.lang.core.structure.INamedConcept",
               "jetbrains.mps.baseLanguage.classifiers.structure.IClassifier",
               "jetbrains.mps.execution.common.structure.IGeneratedToClass")
           .children(
               new String[] {"editor", "checkProperties", "methods"},
               new boolean[] {false, false, true})
           .create();
     case 16:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.execution.settings.structure.PersistentConfigurationAssistent")
           .interface_()
           .references("configuration")
           .create();
     case 17:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.execution.settings.structure.PersistentConfigurationMethod")
           .super_(
               "jetbrains.mps.baseLanguage.classifiers.structure.DefaultClassifierMethodDeclaration")
           .parents(
               "jetbrains.mps.baseLanguage.classifiers.structure.DefaultClassifierMethodDeclaration")
           .create();
     case 18:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.execution.settings.structure.PersistentConfigurationTemplate")
           .super_("jetbrains.mps.execution.settings.structure.PersistentConfiguration")
           .parents("jetbrains.mps.execution.settings.structure.PersistentConfiguration")
           .children(new String[] {"templateParameter"}, new boolean[] {true})
           .alias("persistent configuration template", "")
           .create();
     case 19:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.execution.settings.structure.PersistentConfigurationTemplateInitializer")
           .super_("jetbrains.mps.baseLanguage.structure.AbstractCreator")
           .parents("jetbrains.mps.baseLanguage.structure.AbstractCreator")
           .references("template")
           .children(new String[] {"parameter"}, new boolean[] {true})
           .staticScope(StaticScope.NONE)
           .create();
     case 20:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.execution.settings.structure.PersistentConfigurationType")
           .super_("jetbrains.mps.baseLanguage.classifiers.structure.BaseClassifierType")
           .parents("jetbrains.mps.baseLanguage.classifiers.structure.BaseClassifierType")
           .references("persistentConfiguration")
           .alias("configuration", "persistent configuration type")
           .staticScope(StaticScope.NONE)
           .create();
     case 21:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.execution.settings.structure.PersistentPropertyDeclaration")
           .super_("jetbrains.mps.baseLanguage.structure.VariableDeclaration")
           .parents("jetbrains.mps.baseLanguage.structure.VariableDeclaration")
           .create();
     case 22:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.execution.settings.structure.PersistentPropertyReferenceOperation")
           .super_("jetbrains.mps.lang.core.structure.BaseConcept")
           .parents(
               "jetbrains.mps.lang.core.structure.BaseConcept",
               "jetbrains.mps.baseLanguage.structure.IOperation")
           .references("variableDeclaration")
           .alias("", "persistent property reference")
           .staticScope(StaticScope.NONE)
           .create();
     case 23:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.execution.settings.structure.ReportConfigurationErrorStatement")
           .super_("jetbrains.mps.baseLanguage.structure.Statement")
           .parents("jetbrains.mps.baseLanguage.structure.Statement")
           .children(new String[] {"expression"}, new boolean[] {false})
           .alias("report error", "")
           .staticScope(StaticScope.NONE)
           .create();
     case 24:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.execution.settings.structure.ResetFrom_Function")
           .super_("jetbrains.mps.execution.settings.structure.EditorOperationDeclaration")
           .parents("jetbrains.mps.execution.settings.structure.EditorOperationDeclaration")
           .alias("reset from", "")
           .create();
     case 25:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.execution.settings.structure.SettingsEditor")
           .super_("jetbrains.mps.lang.core.structure.BaseConcept")
           .parents("jetbrains.mps.lang.core.structure.BaseConcept")
           .children(
               new String[] {
                 "createEditor", "applyTo", "resetFrom", "dispose", "propertyDeclaration"
               },
               new boolean[] {false, false, false, false, true})
           .create();
     case 26:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.execution.settings.structure.SettingsEditorType")
           .super_("jetbrains.mps.baseLanguage.structure.Type")
           .parents("jetbrains.mps.baseLanguage.structure.Type")
           .references("configuration")
           .alias("editor", "")
           .staticScope(StaticScope.NONE)
           .create();
     case 27:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.execution.settings.structure.TemplateParameter")
           .super_("jetbrains.mps.baseLanguage.structure.VariableDeclaration")
           .parents("jetbrains.mps.baseLanguage.structure.VariableDeclaration")
           .alias("template parameter", "")
           .create();
     case 28:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.execution.settings.structure.TemplateParameterReference")
           .super_("jetbrains.mps.baseLanguage.structure.VariableReference")
           .parents("jetbrains.mps.baseLanguage.structure.VariableReference")
           .references("constructorParameterDeclaration")
           .staticScope(StaticScope.NONE)
           .create();
     case 29:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.execution.settings.structure.TemplatePersistentConfigurationType")
           .super_("jetbrains.mps.execution.settings.structure.PersistentConfigurationType")
           .parents("jetbrains.mps.execution.settings.structure.PersistentConfigurationType")
           .references("template")
           .alias("template configuration", "template configuration reference")
           .staticScope(StaticScope.NONE)
           .create();
     default:
       return StructureAspectInterpreted.getInstance().getDescriptor(conceptFqName);
   }
 }
 public ConceptDescriptor getDescriptor(String conceptFqName) {
   switch (Arrays.binarySearch(stringSwitchCases_1htk8d_a0a0b, conceptFqName)) {
     case 0:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.plugin.standalone.structure.ApplicationPluginDeclaration",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {
             "jetbrains.mps.lang.core.structure.BaseConcept",
             "jetbrains.mps.baseLanguage.classifiers.structure.IClassifier"
           },
           new String[] {},
           new String[] {});
     case 1:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.plugin.standalone.structure.ApplicationPluginDisposeBlock",
           "jetbrains.mps.baseLanguage.structure.ConceptFunction",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.ConceptFunction"},
           new String[] {},
           new String[] {});
     case 2:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.plugin.standalone.structure.ApplicationPluginInitBlock",
           "jetbrains.mps.baseLanguage.structure.ConceptFunction",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.ConceptFunction"},
           new String[] {},
           new String[] {});
     case 3:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.plugin.standalone.structure.ApplicationPluginType",
           "jetbrains.mps.baseLanguage.classifiers.structure.BaseClassifierType",
           false,
           new String[] {"jetbrains.mps.baseLanguage.classifiers.structure.BaseClassifierType"},
           new String[] {},
           new String[] {"plugin"});
     case 4:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.plugin.standalone.structure.GetPreferencesComponentInProjectOperation",
           "jetbrains.mps.lang.plugin.structure.BaseProjectOperation",
           false,
           new String[] {"jetbrains.mps.lang.plugin.structure.BaseProjectOperation"},
           new String[] {},
           new String[] {"componentDeclaration"});
     case 5:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.plugin.standalone.structure.GetToolInProjectOperation",
           "jetbrains.mps.lang.plugin.structure.BaseProjectOperation",
           false,
           new String[] {"jetbrains.mps.lang.plugin.structure.BaseProjectOperation"},
           new String[] {},
           new String[] {"tool"});
     case 6:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.plugin.standalone.structure.ProjectPluginDeclaration",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {
             "jetbrains.mps.lang.core.structure.BaseConcept",
             "jetbrains.mps.baseLanguage.classifiers.structure.IClassifier"
           },
           new String[] {},
           new String[] {});
     case 7:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.plugin.standalone.structure.ProjectPluginDisposeBlock",
           "jetbrains.mps.baseLanguage.structure.ConceptFunction",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.ConceptFunction"},
           new String[] {},
           new String[] {});
     case 8:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.plugin.standalone.structure.ProjectPluginInitBlock",
           "jetbrains.mps.baseLanguage.structure.ConceptFunction",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.ConceptFunction"},
           new String[] {},
           new String[] {});
     case 9:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.plugin.standalone.structure.ProjectPluginType",
           "jetbrains.mps.baseLanguage.classifiers.structure.BaseClassifierType",
           false,
           new String[] {"jetbrains.mps.baseLanguage.classifiers.structure.BaseClassifierType"},
           new String[] {},
           new String[] {"plugin"});
     case 10:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.plugin.standalone.structure.StandalonePluginDescriptor",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {"jetbrains.mps.lang.core.structure.BaseConcept"},
           new String[] {},
           new String[] {});
     default:
       return StructureAspectInterpreted.getInstance().getDescriptor(conceptFqName);
   }
 }
 public ConceptDescriptor getDescriptor(String conceptFqName) {
   switch (Arrays.binarySearch(stringSwitchCases_1htk8d_a0a0a, conceptFqName)) {
     case 0:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.core.structure.Attribute",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {"jetbrains.mps.lang.core.structure.BaseConcept"},
           new String[] {},
           new String[] {});
     case 1:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.core.structure.BaseConcept",
           null,
           false,
           new String[] {},
           new String[] {"shortDescription", "alias", "virtualPackage"},
           new String[] {});
     case 2:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.core.structure.ExportScope",
           "jetbrains.mps.lang.core.structure.NodeAttribute",
           false,
           new String[] {"jetbrains.mps.lang.core.structure.NodeAttribute"},
           new String[] {},
           new String[] {});
     case 3:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.core.structure.ExportScopeModule",
           "jetbrains.mps.lang.core.structure.ExportScope",
           false,
           new String[] {"jetbrains.mps.lang.core.structure.ExportScope"},
           new String[] {},
           new String[] {});
     case 4:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.core.structure.ExportScopeNamespace",
           "jetbrains.mps.lang.core.structure.ExportScope",
           false,
           new String[] {"jetbrains.mps.lang.core.structure.ExportScope"},
           new String[] {"namespace"},
           new String[] {});
     case 5:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.core.structure.ExportScopePublic",
           "jetbrains.mps.lang.core.structure.ExportScope",
           false,
           new String[] {"jetbrains.mps.lang.core.structure.ExportScope"},
           new String[] {},
           new String[] {});
     case 6:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.core.structure.IAntisuppressErrors",
           null,
           true,
           new String[] {},
           new String[] {},
           new String[] {});
     case 7:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.core.structure.ICanSuppressErrors",
           null,
           true,
           new String[] {},
           new String[] {},
           new String[] {});
     case 8:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.core.structure.IContainer",
           null,
           true,
           new String[] {},
           new String[] {},
           new String[] {});
     case 9:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.core.structure.IDeprecatable",
           null,
           true,
           new String[] {},
           new String[] {},
           new String[] {});
     case 10:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.core.structure.IMetaLevelChanger",
           null,
           true,
           new String[] {},
           new String[] {},
           new String[] {});
     case 11:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.core.structure.INamedConcept",
           null,
           true,
           new String[] {},
           new String[] {"name"},
           new String[] {});
     case 12:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.core.structure.IResolveInfo",
           null,
           true,
           new String[] {},
           new String[] {"resolveInfo"},
           new String[] {});
     case 13:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.core.structure.ISuppressErrors",
           null,
           true,
           new String[] {},
           new String[] {},
           new String[] {});
     case 14:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.core.structure.IType",
           null,
           true,
           new String[] {},
           new String[] {},
           new String[] {});
     case 15:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.core.structure.IWrapper",
           null,
           true,
           new String[] {},
           new String[] {},
           new String[] {});
     case 16:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.core.structure.LinkAttribute",
           "jetbrains.mps.lang.core.structure.Attribute",
           false,
           new String[] {"jetbrains.mps.lang.core.structure.Attribute"},
           new String[] {"linkRole"},
           new String[] {});
     case 17:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.core.structure.NodeAttribute",
           "jetbrains.mps.lang.core.structure.Attribute",
           false,
           new String[] {"jetbrains.mps.lang.core.structure.Attribute"},
           new String[] {},
           new String[] {});
     case 18:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.core.structure.PropertyAttribute",
           "jetbrains.mps.lang.core.structure.Attribute",
           false,
           new String[] {"jetbrains.mps.lang.core.structure.Attribute"},
           new String[] {"propertyName"},
           new String[] {});
     case 19:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.core.structure.ScopeProvider",
           null,
           true,
           new String[] {},
           new String[] {},
           new String[] {});
     case 20:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.core.structure.SuppressErrorsAnnotation",
           "jetbrains.mps.lang.core.structure.NodeAttribute",
           false,
           new String[] {
             "jetbrains.mps.lang.core.structure.NodeAttribute",
             "jetbrains.mps.lang.core.structure.ISuppressErrors"
           },
           new String[] {},
           new String[] {});
     default:
       return StructureAspectInterpreted.getInstance().getDescriptor(conceptFqName);
   }
 }
 public ConceptDescriptor getDescriptor(String conceptFqName) {
   switch (Arrays.binarySearch(stringSwitchCases_1htk8d_a0a0a, conceptFqName)) {
     case 0:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.debugger.api.lang.structure.BreakpointCreator",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {"jetbrains.mps.lang.core.structure.BaseConcept"},
           new String[] {},
           new String[] {});
     case 1:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.debugger.api.lang.structure.BreakpointableNodeItem",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {"jetbrains.mps.lang.core.structure.BaseConcept"},
           new String[] {},
           new String[] {"declaration"});
     case 2:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.debugger.api.lang.structure.ConceptDeclarationReference",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {"jetbrains.mps.lang.core.structure.BaseConcept"},
           new String[] {},
           new String[] {"conceptDeclaration"});
     case 3:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.debugger.api.lang.structure.ConceptFunctionParameter_Debug_Project",
           "jetbrains.mps.baseLanguage.structure.ConceptFunctionParameter",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.ConceptFunctionParameter"},
           new String[] {},
           new String[] {});
     case 4:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.debugger.api.lang.structure.ConceptFunctionParameter_DebuggableNode",
           "jetbrains.mps.baseLanguage.structure.ConceptFunctionParameter",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.ConceptFunctionParameter"},
           new String[] {},
           new String[] {});
     case 5:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.debugger.api.lang.structure.ConceptFunctionParameter_DebuggableNode_Deprecated",
           "jetbrains.mps.baseLanguage.structure.ConceptFunctionParameter",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.ConceptFunctionParameter"},
           new String[] {},
           new String[] {});
     case 6:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.debugger.api.lang.structure.ConceptFunctionParameter_ScopeNode",
           "jetbrains.mps.baseLanguage.structure.ConceptFunctionParameter",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.ConceptFunctionParameter"},
           new String[] {},
           new String[] {});
     case 7:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.debugger.api.lang.structure.ConceptFunctionParameter_UnitNode",
           "jetbrains.mps.baseLanguage.structure.ConceptFunctionParameter",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.ConceptFunctionParameter"},
           new String[] {},
           new String[] {});
     case 8:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.debugger.api.lang.structure.ConceptFunction_CreateBreakpoint",
           "jetbrains.mps.baseLanguage.structure.ConceptFunction",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.ConceptFunction"},
           new String[] {},
           new String[] {});
     case 9:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.debugger.api.lang.structure.ConceptFunction_CreateBreakpoint_Deprecated",
           "jetbrains.mps.baseLanguage.structure.ConceptFunction",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.ConceptFunction"},
           new String[] {},
           new String[] {});
     case 10:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.debugger.api.lang.structure.ConceptFunction_GetUnitName",
           "jetbrains.mps.baseLanguage.structure.ConceptFunction",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.ConceptFunction"},
           new String[] {},
           new String[] {});
     case 11:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.debugger.api.lang.structure.ConceptFunction_GetVariables",
           "jetbrains.mps.baseLanguage.structure.ConceptFunction",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.ConceptFunction"},
           new String[] {},
           new String[] {});
     case 12:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.debugger.api.lang.structure.ConceptFunction_PropertyStringGetter",
           "jetbrains.mps.baseLanguage.structure.ConceptFunction",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.ConceptFunction"},
           new String[] {},
           new String[] {});
     case 13:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.debugger.api.lang.structure.CreateBreakpointOperation",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {
             "jetbrains.mps.lang.core.structure.BaseConcept",
             "jetbrains.mps.baseLanguage.structure.IOperation"
           },
           new String[] {"kindName", "kindPresentation"},
           new String[] {});
     case 14:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.debugger.api.lang.structure.DebugInfoInitializer",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {"jetbrains.mps.lang.core.structure.BaseConcept"},
           new String[] {},
           new String[] {});
     case 15:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.debugger.api.lang.structure.DebuggableNodeItem",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {"jetbrains.mps.lang.core.structure.BaseConcept"},
           new String[] {},
           new String[] {"declaration"});
     case 16:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.debugger.api.lang.structure.DebuggerConfiguration",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {"jetbrains.mps.lang.core.structure.BaseConcept"},
           new String[] {},
           new String[] {});
     case 17:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.debugger.api.lang.structure.DebuggerReference",
           "jetbrains.mps.baseLanguage.structure.Expression",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.Expression"},
           new String[] {"debuggerName"},
           new String[] {});
     case 18:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.debugger.api.lang.structure.DebuggerType",
           "jetbrains.mps.baseLanguage.structure.Type",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.Type"},
           new String[] {"name"},
           new String[] {});
     case 19:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.debugger.api.lang.structure.GetDebuggerSettings_Function",
           "jetbrains.mps.baseLanguage.structure.ConceptFunction",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.ConceptFunction"},
           new String[] {},
           new String[] {});
     case 20:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.debugger.api.lang.structure.ScopeNodeItem",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {"jetbrains.mps.lang.core.structure.BaseConcept"},
           new String[] {},
           new String[] {"scopeConcept"});
     case 21:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.debugger.api.lang.structure.UnitNodeItem",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {"jetbrains.mps.lang.core.structure.BaseConcept"},
           new String[] {},
           new String[] {"unitConcept"});
     case 22:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.debugger.api.lang.structure.VariableNodeExpression",
           "jetbrains.mps.baseLanguage.structure.Expression",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.Expression"},
           new String[] {},
           new String[] {});
     case 23:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.debugger.api.lang.structure.VariableNodeItem",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {"jetbrains.mps.lang.core.structure.BaseConcept"},
           new String[] {},
           new String[] {"concept"});
     default:
       return StructureAspectInterpreted.getInstance().getDescriptor(conceptFqName);
   }
 }
 public ConceptDescriptor getDescriptor(String conceptFqName) {
   switch (Arrays.binarySearch(stringSwitchCases_1htk8d_a0a0b, conceptFqName)) {
     case 0:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.stubs.structure.CanCreateFunction",
           "jetbrains.mps.baseLanguage.structure.ConceptFunction",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.ConceptFunction"},
           new String[] {},
           new String[] {});
     case 1:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.stubs.structure.CreateBlock",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {"jetbrains.mps.lang.core.structure.BaseConcept"},
           new String[] {},
           new String[] {});
     case 2:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.stubs.structure.CreateFunction",
           "jetbrains.mps.baseLanguage.structure.ConceptFunction",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.ConceptFunction"},
           new String[] {},
           new String[] {});
     case 3:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.stubs.structure.DescriptorsFunction",
           "jetbrains.mps.baseLanguage.structure.ConceptFunction",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.ConceptFunction"},
           new String[] {},
           new String[] {});
     case 4:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.stubs.structure.IModule_ConceptFunctionParameter",
           "jetbrains.mps.baseLanguage.structure.ConceptFunctionParameter",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.ConceptFunctionParameter"},
           new String[] {},
           new String[] {});
     case 5:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.stubs.structure.LanguageRef",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {"jetbrains.mps.lang.core.structure.BaseConcept"},
           new String[] {"languageId", "languageFqName"},
           new String[] {});
     case 6:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.stubs.structure.ModelCreationSettings",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {"jetbrains.mps.lang.core.structure.BaseConcept"},
           new String[] {},
           new String[] {});
     case 7:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.stubs.structure.ModelManagerDeclaration",
           "jetbrains.mps.baseLanguage.classifiers.structure.DefaultClassifier",
           false,
           new String[] {
             "jetbrains.mps.baseLanguage.classifiers.structure.DefaultClassifier",
             "jetbrains.mps.baseLanguage.classifiers.structure.IClassifier"
           },
           new String[] {},
           new String[] {});
     case 8:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.stubs.structure.ModelRoot_ConceptFunctionParameter",
           "jetbrains.mps.baseLanguage.structure.ConceptFunctionParameter",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.ConceptFunctionParameter"},
           new String[] {},
           new String[] {});
     case 9:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.stubs.structure.Model_ConceptFunctionParameter",
           "jetbrains.mps.baseLanguage.structure.ConceptFunctionParameter",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.ConceptFunctionParameter"},
           new String[] {},
           new String[] {});
     case 10:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.stubs.structure.SModelFqName_ConceptFunctionParameter",
           "jetbrains.mps.baseLanguage.structure.ConceptFunctionParameter",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.ConceptFunctionParameter"},
           new String[] {},
           new String[] {});
     case 11:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.lang.stubs.structure.SModelRoot_ConceptFunctionParameter",
           "jetbrains.mps.baseLanguage.structure.ConceptFunctionParameter",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.ConceptFunctionParameter"},
           new String[] {},
           new String[] {});
     default:
       return StructureAspectInterpreted.getInstance().getDescriptor(conceptFqName);
   }
 }
 public ConceptDescriptor getDescriptor(String conceptFqName) {
   switch (Arrays.binarySearch(stringSwitchCases_1htk8d_a0a0b, conceptFqName)) {
     case 0:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.samples.secretCompartmentLanguage.structure.Event")
           .super_("jetbrains.mps.lang.core.structure.BaseConcept")
           .parents(
               "jetbrains.mps.lang.core.structure.BaseConcept",
               "jetbrains.mps.lang.core.structure.INamedConcept")
           .properties("eventName", "code")
           .create();
     case 1:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.samples.secretCompartmentLanguage.structure.HandleEvent")
           .super_("jetbrains.mps.lang.core.structure.BaseConcept")
           .parents("jetbrains.mps.lang.core.structure.BaseConcept")
           .references("event")
           .create();
     case 2:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.samples.secretCompartmentLanguage.structure.State")
           .super_("jetbrains.mps.lang.core.structure.BaseConcept")
           .parents(
               "jetbrains.mps.lang.core.structure.BaseConcept",
               "jetbrains.mps.lang.core.structure.INamedConcept")
           .properties("stateName")
           .children(new String[] {"transition"}, new boolean[] {true})
           .create();
     case 3:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.samples.secretCompartmentLanguage.structure.StateMachine")
           .super_("jetbrains.mps.lang.core.structure.BaseConcept")
           .parents(
               "jetbrains.mps.lang.core.structure.BaseConcept",
               "jetbrains.mps.lang.core.structure.INamedConcept")
           .properties("stateMachineName")
           .references("startState")
           .children(new String[] {"event", "state"}, new boolean[] {true, true})
           .create();
     case 4:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.samples.secretCompartmentLanguage.structure.StateMachineTest")
           .super_("jetbrains.mps.lang.core.structure.BaseConcept")
           .parents(
               "jetbrains.mps.lang.core.structure.BaseConcept",
               "jetbrains.mps.lang.core.structure.INamedConcept")
           .references("stateMachine")
           .children(new String[] {"testMethod"}, new boolean[] {true})
           .create();
     case 5:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.samples.secretCompartmentLanguage.structure.StateMachineTestMethod")
           .super_("jetbrains.mps.lang.core.structure.BaseConcept")
           .parents("jetbrains.mps.lang.core.structure.BaseConcept")
           .properties("methodName")
           .references("finalState")
           .children(new String[] {"handleEvent"}, new boolean[] {true})
           .create();
     case 6:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.samples.secretCompartmentLanguage.structure.Transition")
           .super_("jetbrains.mps.lang.core.structure.BaseConcept")
           .parents("jetbrains.mps.lang.core.structure.BaseConcept")
           .references("trigger", "target")
           .create();
     default:
       return StructureAspectInterpreted.getInstance().getDescriptor(conceptFqName);
   }
 }
 public ConceptDescriptor getDescriptor(String conceptFqName) {
   switch (Arrays.binarySearch(stringSwitchCases_1htk8d_a0a0b, conceptFqName)) {
     case 0:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.build.generictasks.structure.Attribute",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {"jetbrains.mps.lang.core.structure.BaseConcept"},
           new String[] {},
           new String[] {"attributeDeclaration"});
     case 1:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.build.generictasks.structure.AttributeDeclaration",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {
             "jetbrains.mps.lang.core.structure.BaseConcept",
             "jetbrains.mps.lang.core.structure.INamedConcept",
             "jetbrains.mps.baseLanguage.classifiers.structure.IMember"
           },
           new String[] {"deprecated", "required"},
           new String[] {});
     case 2:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.build.generictasks.structure.BuiltInTaskDeclaration",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {
             "jetbrains.mps.build.generictasks.structure.ITaskDeclaration",
             "jetbrains.mps.lang.core.structure.BaseConcept"
           },
           new String[] {"fake"},
           new String[] {});
     case 3:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.build.generictasks.structure.ITaskDeclaration",
           null,
           true,
           new String[] {
             "jetbrains.mps.buildlanguage.structure.IDeclaration",
             "jetbrains.mps.baseLanguage.classifiers.structure.IClassifier"
           },
           new String[] {"classname", "canHaveInternalText", "abstract", "depracated"},
           new String[] {});
     case 4:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.build.generictasks.structure.NestedDeclaration",
           "jetbrains.mps.build.generictasks.structure.TaskReference",
           false,
           new String[] {"jetbrains.mps.build.generictasks.structure.TaskReference"},
           new String[] {},
           new String[] {});
     case 5:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.build.generictasks.structure.PathReference",
           "jetbrains.mps.buildlanguage.structure.CallReference",
           false,
           new String[] {"jetbrains.mps.buildlanguage.structure.CallReference"},
           new String[] {},
           new String[] {});
     case 6:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.build.generictasks.structure.TaskCall",
           "jetbrains.mps.buildlanguage.structure.AbstractCall",
           false,
           new String[] {
             "jetbrains.mps.buildlanguage.structure.AbstractCall",
             "jetbrains.mps.lang.core.structure.INamedConcept"
           },
           new String[] {"id"},
           new String[] {"declaration"});
     case 7:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.build.generictasks.structure.TaskInterfaceDeclaration",
           "jetbrains.mps.build.generictasks.structure.BuiltInTaskDeclaration",
           false,
           new String[] {"jetbrains.mps.build.generictasks.structure.BuiltInTaskDeclaration"},
           new String[] {},
           new String[] {});
     case 8:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.build.generictasks.structure.TaskReference",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {"jetbrains.mps.lang.core.structure.BaseConcept"},
           new String[] {},
           new String[] {"declaration"});
     default:
       return StructureAspectInterpreted.getInstance().getDescriptor(conceptFqName);
   }
 }
 public ConceptDescriptor getDescriptor(String conceptFqName) {
   switch (Arrays.binarySearch(stringSwitchCases_1htk8d_a0a0a, conceptFqName)) {
     case 0:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.tuples.structure.IndexedTupleLiteral",
           "jetbrains.mps.baseLanguage.structure.Expression",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.Expression"},
           new String[] {},
           new String[] {});
     case 1:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.tuples.structure.IndexedTupleMemberAccessExpression",
           "jetbrains.mps.baseLanguage.structure.Expression",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.Expression"},
           new String[] {},
           new String[] {});
     case 2:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.tuples.structure.IndexedTupleType",
           "jetbrains.mps.baseLanguage.structure.Type",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.Type"},
           new String[] {},
           new String[] {});
     case 3:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.tuples.structure.NamedTupleComponentAccessOperation",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {
             "jetbrains.mps.lang.core.structure.BaseConcept",
             "jetbrains.mps.baseLanguage.structure.IOperation"
           },
           new String[] {},
           new String[] {"component"});
     case 4:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.tuples.structure.NamedTupleComponentDeclaration",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {
             "jetbrains.mps.lang.core.structure.BaseConcept",
             "jetbrains.mps.baseLanguage.structure.IValidIdentifier",
             "jetbrains.mps.baseLanguage.structure.HasAnnotation",
             "jetbrains.mps.baseLanguage.structure.TypeDerivable",
             "jetbrains.mps.baseLanguage.structure.TypeAnnotable",
             "jetbrains.mps.lang.core.structure.IResolveInfo"
           },
           new String[] {"final"},
           new String[] {});
     case 5:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.tuples.structure.NamedTupleComponentReference",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {"jetbrains.mps.lang.core.structure.BaseConcept"},
           new String[] {},
           new String[] {"componentDeclaration"});
     case 6:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.tuples.structure.NamedTupleDeclaration",
           "jetbrains.mps.baseLanguage.structure.Classifier",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.Classifier"},
           new String[] {},
           new String[] {});
     case 7:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.tuples.structure.NamedTupleLiteral",
           "jetbrains.mps.baseLanguage.structure.Expression",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.Expression"},
           new String[] {},
           new String[] {"tupleDeclaration"});
     case 8:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.tuples.structure.NamedTupleType",
           "jetbrains.mps.baseLanguage.structure.ClassifierType",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.ClassifierType"},
           new String[] {},
           new String[] {"tupleDeclaration"});
     default:
       return StructureAspectInterpreted.getInstance().getDescriptor(conceptFqName);
   }
 }
 public ConceptDescriptor getDescriptor(String conceptFqName) {
   switch (Arrays.binarySearch(stringSwitchCases_1htk8d_a0a0a, conceptFqName)) {
     case 0:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.AtLeastNTimesRegexp",
           "jetbrains.mps.baseLanguage.regexp.structure.UnaryRegexp",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.UnaryRegexp"},
           new String[] {"n"},
           new String[] {});
     case 1:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.BinaryRegexp",
           "jetbrains.mps.baseLanguage.regexp.structure.Regexp",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.Regexp"},
           new String[] {},
           new String[] {});
     case 2:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.CharacterSymbolClassPart",
           "jetbrains.mps.baseLanguage.regexp.structure.SymbolClassPart",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.SymbolClassPart"},
           new String[] {"character"},
           new String[] {});
     case 3:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.DotRegexp",
           "jetbrains.mps.baseLanguage.regexp.structure.Regexp",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.Regexp"},
           new String[] {},
           new String[] {});
     case 4:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.FindMatchExpression",
           "jetbrains.mps.baseLanguage.structure.Expression",
           false,
           new String[] {
             "jetbrains.mps.baseLanguage.structure.Expression",
             "jetbrains.mps.baseLanguage.regexp.structure.RegexpUsingConstruction"
           },
           new String[] {},
           new String[] {});
     case 5:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.FindMatchStatement",
           "jetbrains.mps.baseLanguage.structure.Statement",
           false,
           new String[] {
             "jetbrains.mps.baseLanguage.structure.Statement",
             "jetbrains.mps.baseLanguage.regexp.structure.RegexpUsingConstruction"
           },
           new String[] {},
           new String[] {});
     case 6:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.ForEachMatchStatement",
           "jetbrains.mps.baseLanguage.structure.Statement",
           false,
           new String[] {
             "jetbrains.mps.baseLanguage.structure.Statement",
             "jetbrains.mps.baseLanguage.regexp.structure.RegexpUsingConstruction"
           },
           new String[] {},
           new String[] {});
     case 7:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.FromNToMTimesRegexp",
           "jetbrains.mps.baseLanguage.regexp.structure.UnaryRegexp",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.UnaryRegexp"},
           new String[] {"n", "m"},
           new String[] {});
     case 8:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.InlineRegexpExpression",
           "jetbrains.mps.baseLanguage.regexp.structure.RegexpExpression",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.RegexpExpression"},
           new String[] {"dotAll", "multiLine", "caseInsensitive"},
           new String[] {});
     case 9:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.IntersectionSymbolClassPart",
           "jetbrains.mps.baseLanguage.regexp.structure.SymbolClassPart",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.SymbolClassPart"},
           new String[] {},
           new String[] {});
     case 10:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.IntervalSymbolClassPart",
           "jetbrains.mps.baseLanguage.regexp.structure.SymbolClassPart",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.SymbolClassPart"},
           new String[] {"start", "end"},
           new String[] {});
     case 11:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.LazyPlusRegexp",
           "jetbrains.mps.baseLanguage.regexp.structure.UnaryRegexp",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.UnaryRegexp"},
           new String[] {},
           new String[] {});
     case 12:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.LazyQuestionRegexp",
           "jetbrains.mps.baseLanguage.regexp.structure.UnaryRegexp",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.UnaryRegexp"},
           new String[] {},
           new String[] {});
     case 13:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.LazyStarRegexp",
           "jetbrains.mps.baseLanguage.regexp.structure.UnaryRegexp",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.UnaryRegexp"},
           new String[] {},
           new String[] {});
     case 14:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.LineEndRegexp",
           "jetbrains.mps.baseLanguage.regexp.structure.Regexp",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.Regexp"},
           new String[] {},
           new String[] {});
     case 15:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.LineStartRegexp",
           "jetbrains.mps.baseLanguage.regexp.structure.Regexp",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.Regexp"},
           new String[] {},
           new String[] {});
     case 16:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.LiteralReplacement",
           "jetbrains.mps.baseLanguage.regexp.structure.Replacement",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.Replacement"},
           new String[] {"text"},
           new String[] {});
     case 17:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.LookRegexp",
           "jetbrains.mps.baseLanguage.regexp.structure.Regexp",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.Regexp"},
           new String[] {},
           new String[] {});
     case 18:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.MatchParensRegexp",
           "jetbrains.mps.baseLanguage.regexp.structure.Regexp",
           false,
           new String[] {
             "jetbrains.mps.baseLanguage.regexp.structure.Regexp",
             "jetbrains.mps.lang.core.structure.INamedConcept",
             "jetbrains.mps.baseLanguage.structure.IVariableAssignment"
           },
           new String[] {},
           new String[] {});
     case 19:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.MatchRegexpExpression",
           "jetbrains.mps.baseLanguage.structure.Expression",
           false,
           new String[] {
             "jetbrains.mps.baseLanguage.structure.Expression",
             "jetbrains.mps.baseLanguage.regexp.structure.RegexpUsingConstruction"
           },
           new String[] {},
           new String[] {});
     case 20:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.MatchRegexpOperation",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {
             "jetbrains.mps.baseLanguage.structure.IOperation",
             "jetbrains.mps.baseLanguage.regexp.structure.RegexpUsingConstruction",
             "jetbrains.mps.lang.core.structure.BaseConcept"
           },
           new String[] {},
           new String[] {});
     case 21:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.MatchRegexpStatement",
           "jetbrains.mps.baseLanguage.structure.Statement",
           false,
           new String[] {
             "jetbrains.mps.baseLanguage.structure.Statement",
             "jetbrains.mps.baseLanguage.regexp.structure.RegexpUsingConstruction"
           },
           new String[] {},
           new String[] {});
     case 22:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.MatchVariableReference",
           "jetbrains.mps.baseLanguage.structure.Expression",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.Expression"},
           new String[] {},
           new String[] {"match"});
     case 23:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.MatchVariableReferenceRegexp",
           "jetbrains.mps.baseLanguage.regexp.structure.Regexp",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.Regexp"},
           new String[] {},
           new String[] {"match"});
     case 24:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.MatchVariableReferenceReplacement",
           "jetbrains.mps.baseLanguage.regexp.structure.Replacement",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.Replacement"},
           new String[] {},
           new String[] {"match"});
     case 25:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.NTimesRegexp",
           "jetbrains.mps.baseLanguage.regexp.structure.UnaryRegexp",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.UnaryRegexp"},
           new String[] {"n"},
           new String[] {});
     case 26:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.NegativeLookAheadRegexp",
           "jetbrains.mps.baseLanguage.regexp.structure.LookRegexp",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.LookRegexp"},
           new String[] {},
           new String[] {});
     case 27:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.NegativeLookBehindRegexp",
           "jetbrains.mps.baseLanguage.regexp.structure.LookRegexp",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.LookRegexp"},
           new String[] {},
           new String[] {});
     case 28:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.NegativeSymbolClassRegexp",
           "jetbrains.mps.baseLanguage.regexp.structure.SymbolClassRegexp",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.SymbolClassRegexp"},
           new String[] {},
           new String[] {});
     case 29:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.OrRegexp",
           "jetbrains.mps.baseLanguage.regexp.structure.BinaryRegexp",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.BinaryRegexp"},
           new String[] {},
           new String[] {});
     case 30:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.ParensRegexp",
           "jetbrains.mps.baseLanguage.regexp.structure.Regexp",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.Regexp"},
           new String[] {},
           new String[] {});
     case 31:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.PlusRegexp",
           "jetbrains.mps.baseLanguage.regexp.structure.UnaryRegexp",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.UnaryRegexp"},
           new String[] {},
           new String[] {});
     case 32:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.PositiveLookAheadRegexp",
           "jetbrains.mps.baseLanguage.regexp.structure.LookRegexp",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.LookRegexp"},
           new String[] {},
           new String[] {});
     case 33:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.PositiveLookBehindRegexp",
           "jetbrains.mps.baseLanguage.regexp.structure.LookRegexp",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.LookRegexp"},
           new String[] {},
           new String[] {});
     case 34:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.PositiveSymbolClassRegexp",
           "jetbrains.mps.baseLanguage.regexp.structure.SymbolClassRegexp",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.SymbolClassRegexp"},
           new String[] {},
           new String[] {});
     case 35:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.PredefinedSymbolClassDeclaration",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {
             "jetbrains.mps.lang.core.structure.BaseConcept",
             "jetbrains.mps.lang.core.structure.INamedConcept"
           },
           new String[] {"description"},
           new String[] {});
     case 36:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.PredefinedSymbolClassRegexp",
           "jetbrains.mps.baseLanguage.regexp.structure.Regexp",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.Regexp"},
           new String[] {},
           new String[] {"symbolClass"});
     case 37:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.PredefinedSymbolClassSymbolClassPart",
           "jetbrains.mps.baseLanguage.regexp.structure.SymbolClassPart",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.SymbolClassPart"},
           new String[] {},
           new String[] {"declaration"});
     case 38:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.PredefinedSymbolClasses",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {
             "jetbrains.mps.lang.core.structure.BaseConcept",
             "jetbrains.mps.lang.core.structure.INamedConcept"
           },
           new String[] {},
           new String[] {});
     case 39:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.QuestionRegexp",
           "jetbrains.mps.baseLanguage.regexp.structure.UnaryRegexp",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.UnaryRegexp"},
           new String[] {},
           new String[] {});
     case 40:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.Regexp",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {"jetbrains.mps.lang.core.structure.BaseConcept"},
           new String[] {},
           new String[] {});
     case 41:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.RegexpDeclaration",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {
             "jetbrains.mps.lang.core.structure.BaseConcept",
             "jetbrains.mps.lang.core.structure.INamedConcept"
           },
           new String[] {"description"},
           new String[] {});
     case 42:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.RegexpDeclarationReferenceRegexp",
           "jetbrains.mps.baseLanguage.regexp.structure.Regexp",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.Regexp"},
           new String[] {},
           new String[] {"regexp"});
     case 43:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.RegexpExpression",
           "jetbrains.mps.baseLanguage.structure.Expression",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.Expression"},
           new String[] {},
           new String[] {});
     case 44:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.RegexpUsingConstruction",
           null,
           true,
           new String[] {},
           new String[] {},
           new String[] {});
     case 45:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.Regexps",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {
             "jetbrains.mps.lang.core.structure.BaseConcept",
             "jetbrains.mps.lang.core.structure.INamedConcept"
           },
           new String[] {},
           new String[] {});
     case 46:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.ReplaceBlock",
           "jetbrains.mps.baseLanguage.structure.Closure",
           false,
           new String[] {"jetbrains.mps.baseLanguage.structure.Closure"},
           new String[] {},
           new String[] {});
     case 47:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.ReplaceRegexpOperation",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {
             "jetbrains.mps.baseLanguage.structure.IOperation",
             "jetbrains.mps.lang.core.structure.BaseConcept"
           },
           new String[] {"dotAll", "multiLine", "caseInsensitive", "globalReplace"},
           new String[] {});
     case 48:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.ReplaceWithRegexpExpression",
           "jetbrains.mps.baseLanguage.structure.Expression",
           false,
           new String[] {
             "jetbrains.mps.baseLanguage.structure.Expression",
             "jetbrains.mps.baseLanguage.regexp.structure.RegexpUsingConstruction"
           },
           new String[] {},
           new String[] {});
     case 49:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.ReplaceWithRegexpOperation",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {
             "jetbrains.mps.baseLanguage.structure.IOperation",
             "jetbrains.mps.baseLanguage.regexp.structure.RegexpUsingConstruction",
             "jetbrains.mps.lang.core.structure.BaseConcept"
           },
           new String[] {},
           new String[] {});
     case 50:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.Replacement",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {"jetbrains.mps.lang.core.structure.BaseConcept"},
           new String[] {},
           new String[] {});
     case 51:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.SeqRegexp",
           "jetbrains.mps.baseLanguage.regexp.structure.BinaryRegexp",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.BinaryRegexp"},
           new String[] {},
           new String[] {});
     case 52:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.SplitExpression",
           "jetbrains.mps.baseLanguage.structure.Expression",
           false,
           new String[] {
             "jetbrains.mps.baseLanguage.structure.Expression",
             "jetbrains.mps.baseLanguage.regexp.structure.RegexpUsingConstruction"
           },
           new String[] {},
           new String[] {});
     case 53:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.SplitOperation",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {
             "jetbrains.mps.baseLanguage.structure.IOperation",
             "jetbrains.mps.baseLanguage.regexp.structure.RegexpUsingConstruction",
             "jetbrains.mps.lang.core.structure.BaseConcept"
           },
           new String[] {},
           new String[] {});
     case 54:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.StarRegexp",
           "jetbrains.mps.baseLanguage.regexp.structure.UnaryRegexp",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.UnaryRegexp"},
           new String[] {},
           new String[] {});
     case 55:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.StringLiteralRegexp",
           "jetbrains.mps.baseLanguage.regexp.structure.Regexp",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.Regexp"},
           new String[] {"text"},
           new String[] {});
     case 56:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.SymbolClassPart",
           "jetbrains.mps.lang.core.structure.BaseConcept",
           false,
           new String[] {
             "jetbrains.mps.lang.core.structure.BaseConcept",
             "jetbrains.mps.baseLanguage.regexp.structure.SymbolClassRegexpAndPart"
           },
           new String[] {},
           new String[] {});
     case 57:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.SymbolClassRegexp",
           "jetbrains.mps.baseLanguage.regexp.structure.Regexp",
           false,
           new String[] {
             "jetbrains.mps.baseLanguage.regexp.structure.Regexp",
             "jetbrains.mps.baseLanguage.regexp.structure.SymbolClassRegexpAndPart"
           },
           new String[] {},
           new String[] {});
     case 58:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.SymbolClassRegexpAndPart",
           null,
           true,
           new String[] {},
           new String[] {},
           new String[] {});
     case 59:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.UnaryRegexp",
           "jetbrains.mps.baseLanguage.regexp.structure.Regexp",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.Regexp"},
           new String[] {},
           new String[] {});
     case 60:
       return new CompiledConceptDescriptor(
           "jetbrains.mps.baseLanguage.regexp.structure.UnicodeCharacterRegexp",
           "jetbrains.mps.baseLanguage.regexp.structure.Regexp",
           false,
           new String[] {"jetbrains.mps.baseLanguage.regexp.structure.Regexp"},
           new String[] {"code"},
           new String[] {});
     default:
       return StructureAspectInterpreted.getInstance().getDescriptor(conceptFqName);
   }
 }
 public ConceptDescriptor getDescriptor(String conceptFqName) {
   switch (Arrays.binarySearch(stringSwitchCases_1htk8d_a0a0b, conceptFqName)) {
     case 0:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.lang.textGen.structure.AbstractAppendPart")
           .super_("jetbrains.mps.lang.core.structure.BaseConcept")
           .parents("jetbrains.mps.lang.core.structure.BaseConcept")
           .abstract_()
           .create();
     case 1:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.lang.textGen.structure.AbstractTextGenDeclaration")
           .super_("jetbrains.mps.lang.core.structure.BaseConcept")
           .parents(
               "jetbrains.mps.lang.core.structure.BaseConcept",
               "jetbrains.mps.baseLanguage.structure.IValidIdentifier")
           .abstract_()
           .create();
     case 2:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.lang.textGen.structure.AbstractTextGenParameter")
           .super_("jetbrains.mps.baseLanguage.structure.ConceptFunctionParameter")
           .parents(
               "jetbrains.mps.baseLanguage.structure.ConceptFunctionParameter",
               "jetbrains.mps.lang.core.structure.IDontSubstituteByDefault")
           .abstract_()
           .staticScope(StaticScope.NONE)
           .create();
     case 3:
       return new ConceptDescriptorBuilder("jetbrains.mps.lang.textGen.structure.AppendOperation")
           .super_("jetbrains.mps.baseLanguage.structure.Statement")
           .parents("jetbrains.mps.baseLanguage.structure.Statement")
           .children(new String[] {"part"}, new boolean[] {true})
           .alias("append", "")
           .staticScope(StaticScope.NONE)
           .create();
     case 4:
       return new ConceptDescriptorBuilder("jetbrains.mps.lang.textGen.structure.BufferParameter")
           .super_("jetbrains.mps.lang.textGen.structure.AbstractTextGenParameter")
           .parents("jetbrains.mps.lang.textGen.structure.AbstractTextGenParameter")
           .alias("buffer", "")
           .staticScope(StaticScope.NONE)
           .create();
     case 5:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.lang.textGen.structure.CollectionAppendPart")
           .super_("jetbrains.mps.lang.textGen.structure.AbstractAppendPart")
           .parents("jetbrains.mps.lang.textGen.structure.AbstractAppendPart")
           .properties("separator", "withSeparator")
           .children(new String[] {"list"}, new boolean[] {false})
           .alias("$list{", "collection")
           .create();
     case 6:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.lang.textGen.structure.ConceptTextGenDeclaration")
           .super_("jetbrains.mps.lang.textGen.structure.AbstractTextGenDeclaration")
           .parents(
               "jetbrains.mps.lang.textGen.structure.AbstractTextGenDeclaration",
               "jetbrains.mps.lang.structure.structure.IConceptAspect")
           .references("conceptDeclaration")
           .children(
               new String[] {"extension", "encoding", "textGenBlock", "filename"},
               new boolean[] {false, false, false, false})
           .create();
     case 7:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.lang.textGen.structure.ConstantStringAppendPart")
           .super_("jetbrains.mps.lang.textGen.structure.AbstractAppendPart")
           .parents("jetbrains.mps.lang.textGen.structure.AbstractAppendPart")
           .properties("value", "withIndent")
           .alias("constant", "constant string")
           .create();
     case 8:
       return new ConceptDescriptorBuilder("jetbrains.mps.lang.textGen.structure.ContextParameter")
           .super_("jetbrains.mps.lang.textGen.structure.AbstractTextGenParameter")
           .parents("jetbrains.mps.lang.textGen.structure.AbstractTextGenParameter")
           .alias("context", "")
           .staticScope(StaticScope.NONE)
           .create();
     case 9:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.lang.textGen.structure.DecreaseDepthOperation")
           .super_("jetbrains.mps.lang.textGen.structure.SimpleTextGenOperation")
           .parents("jetbrains.mps.lang.textGen.structure.SimpleTextGenOperation")
           .alias("decrease depth", "")
           .staticScope(StaticScope.NONE)
           .create();
     case 10:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.lang.textGen.structure.EncodingDeclaration")
           .super_("jetbrains.mps.baseLanguage.structure.ConceptFunction")
           .parents(
               "jetbrains.mps.baseLanguage.structure.ConceptFunction",
               "jetbrains.mps.lang.textGen.structure.EncodingDeclarationBase")
           .alias("encoding", "")
           .staticScope(StaticScope.NONE)
           .create();
     case 11:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.lang.textGen.structure.EncodingDeclarationBase")
           .interface_()
           .create();
     case 12:
       return new ConceptDescriptorBuilder("jetbrains.mps.lang.textGen.structure.EncodingLiteral")
           .super_("jetbrains.mps.lang.core.structure.BaseConcept")
           .parents(
               "jetbrains.mps.lang.core.structure.BaseConcept",
               "jetbrains.mps.lang.textGen.structure.EncodingDeclarationBase")
           .properties("encoding")
           .alias("encoding literal", "")
           .create();
     case 13:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.lang.textGen.structure.ExtensionDeclaration")
           .super_("jetbrains.mps.baseLanguage.structure.ConceptFunction")
           .parents("jetbrains.mps.baseLanguage.structure.ConceptFunction")
           .alias("extension", "")
           .staticScope(StaticScope.NONE)
           .create();
     case 14:
       return new ConceptDescriptorBuilder("jetbrains.mps.lang.textGen.structure.FilenameFunction")
           .super_("jetbrains.mps.baseLanguage.structure.ConceptFunction")
           .parents("jetbrains.mps.baseLanguage.structure.ConceptFunction")
           .final_()
           .alias("filename", "name of output file")
           .create();
     case 15:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.lang.textGen.structure.FoundErrorOperation")
           .super_("jetbrains.mps.baseLanguage.structure.Statement")
           .parents("jetbrains.mps.baseLanguage.structure.Statement")
           .children(new String[] {"text"}, new boolean[] {false})
           .alias("found error", "")
           .staticScope(StaticScope.NONE)
           .create();
     case 16:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.lang.textGen.structure.GenerateTextDeclaration")
           .super_("jetbrains.mps.baseLanguage.structure.ConceptFunction")
           .parents("jetbrains.mps.baseLanguage.structure.ConceptFunction")
           .alias("do generate text", "")
           .staticScope(StaticScope.NONE)
           .create();
     case 17:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.lang.textGen.structure.IncreaseDepthOperation")
           .super_("jetbrains.mps.lang.textGen.structure.SimpleTextGenOperation")
           .parents("jetbrains.mps.lang.textGen.structure.SimpleTextGenOperation")
           .alias("increase depth", "")
           .staticScope(StaticScope.NONE)
           .create();
     case 18:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.lang.textGen.structure.IndentBufferOperation")
           .super_("jetbrains.mps.lang.textGen.structure.SimpleTextGenOperation")
           .parents("jetbrains.mps.lang.textGen.structure.SimpleTextGenOperation")
           .alias("indent buffer", "")
           .staticScope(StaticScope.NONE)
           .create();
     case 19:
       return new ConceptDescriptorBuilder("jetbrains.mps.lang.textGen.structure.InfoAppendPart")
           .super_("jetbrains.mps.lang.textGen.structure.AbstractAppendPart")
           .parents("jetbrains.mps.lang.textGen.structure.AbstractAppendPart")
           .children(new String[] {"value"}, new boolean[] {false})
           .alias("$resolve{", "resolve info")
           .create();
     case 20:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.lang.textGen.structure.LanguageTextGenDeclaration")
           .super_("jetbrains.mps.lang.textGen.structure.AbstractTextGenDeclaration")
           .parents("jetbrains.mps.lang.textGen.structure.AbstractTextGenDeclaration")
           .references("baseTextGen")
           .children(new String[] {"operation", "function"}, new boolean[] {true, true})
           .create();
     case 21:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.lang.textGen.structure.NewLineAppendPart")
           .super_("jetbrains.mps.lang.textGen.structure.AbstractAppendPart")
           .parents("jetbrains.mps.lang.textGen.structure.AbstractAppendPart")
           .alias("\\n", "new line")
           .create();
     case 22:
       return new ConceptDescriptorBuilder("jetbrains.mps.lang.textGen.structure.NodeAppendPart")
           .super_("jetbrains.mps.lang.textGen.structure.AbstractAppendPart")
           .parents("jetbrains.mps.lang.textGen.structure.AbstractAppendPart")
           .properties("withIndent")
           .children(new String[] {"value"}, new boolean[] {false})
           .alias("${", "node or property")
           .create();
     case 23:
       return new ConceptDescriptorBuilder("jetbrains.mps.lang.textGen.structure.NodeParameter")
           .super_("jetbrains.mps.lang.textGen.structure.AbstractTextGenParameter")
           .parents("jetbrains.mps.lang.textGen.structure.AbstractTextGenParameter")
           .alias("node", "")
           .staticScope(StaticScope.NONE)
           .create();
     case 24:
       return new ConceptDescriptorBuilder("jetbrains.mps.lang.textGen.structure.OperationCall")
           .super_("jetbrains.mps.lang.textGen.structure.AbstractAppendPart")
           .parents("jetbrains.mps.lang.textGen.structure.AbstractAppendPart")
           .references("function")
           .children(new String[] {"parameter"}, new boolean[] {true})
           .create();
     case 25:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.lang.textGen.structure.OperationDeclaration")
           .super_("jetbrains.mps.baseLanguage.structure.BaseMethodDeclaration")
           .parents("jetbrains.mps.baseLanguage.structure.BaseMethodDeclaration")
           .properties("operationName")
           .alias("new operation", "")
           .create();
     case 26:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.lang.textGen.structure.ReferenceAppendPart")
           .super_("jetbrains.mps.lang.textGen.structure.AbstractAppendPart")
           .parents("jetbrains.mps.lang.textGen.structure.AbstractAppendPart")
           .properties("uniqNameInFile")
           .children(new String[] {"reference"}, new boolean[] {false})
           .alias("$ref{", "reference")
           .create();
     case 27:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.lang.textGen.structure.SimpleTextGenOperation")
           .super_("jetbrains.mps.baseLanguage.structure.Statement")
           .parents("jetbrains.mps.baseLanguage.structure.Statement")
           .abstract_()
           .staticScope(StaticScope.NONE)
           .create();
     case 28:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.lang.textGen.structure.UtilityMethodCall")
           .super_("jetbrains.mps.baseLanguage.structure.Expression")
           .parents("jetbrains.mps.baseLanguage.structure.Expression")
           .references("function")
           .children(new String[] {"parameter"}, new boolean[] {true})
           .staticScope(StaticScope.NONE)
           .create();
     case 29:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.lang.textGen.structure.UtilityMethodDeclaration")
           .super_("jetbrains.mps.baseLanguage.structure.BaseMethodDeclaration")
           .parents("jetbrains.mps.baseLanguage.structure.BaseMethodDeclaration")
           .alias("new private function", "")
           .create();
     case 30:
       return new ConceptDescriptorBuilder(
               "jetbrains.mps.lang.textGen.structure.WithIndentOperation")
           .super_("jetbrains.mps.baseLanguage.structure.Statement")
           .parents("jetbrains.mps.baseLanguage.structure.Statement")
           .children(new String[] {"list"}, new boolean[] {false})
           .alias("with indent {", "code block")
           .staticScope(StaticScope.NONE)
           .create();
     default:
       return StructureAspectInterpreted.getInstance().getDescriptor(conceptFqName);
   }
 }