opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/main/java/org/opendaylight/controller/antlrv4/code/gen/YangParser.java

   1 /*\r
   2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.\r
   3  *\r
   4  * This program and the accompanying materials are made available under the\r
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html\r
   7  */\r
   8 package org.opendaylight.controller.antlrv4.code.gen;\r
   9 \r
  10 import java.util.List;\r
  11 \r
  12 import org.antlr.v4.runtime.NoViableAltException;\r
  13 import org.antlr.v4.runtime.Parser;\r
  14 import org.antlr.v4.runtime.ParserRuleContext;\r
  15 import org.antlr.v4.runtime.RecognitionException;\r
  16 import org.antlr.v4.runtime.TokenStream;\r
  17 import org.antlr.v4.runtime.atn.ATN;\r
  18 import org.antlr.v4.runtime.atn.ATNSimulator;\r
  19 import org.antlr.v4.runtime.atn.ParserATNSimulator;\r
  20 import org.antlr.v4.runtime.atn.PredictionContextCache;\r
  21 import org.antlr.v4.runtime.dfa.DFA;\r
  22 import org.antlr.v4.runtime.tree.ParseTreeListener;\r
  23 import org.antlr.v4.runtime.tree.ParseTreeVisitor;\r
  24 import org.antlr.v4.runtime.tree.TerminalNode;\r
  25 \r
  26 @SuppressWarnings({ "all", "warnings", "unchecked", "unused", "cast" })\r
  27 public class YangParser extends Parser {\r
  28     protected static final DFA[] _decisionToDFA;\r
  29     protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache();\r
  30     public static final int CHOICE_KEYWORD = 65, YIN_ELEMENT_KEYWORD = 8,\r
  31             WHEN_KEYWORD = 10, REVISION_KEYWORD = 21, DESCRIPTION_KEYWORD = 60,\r
  32             NAMESPACE_KEYWORD = 35, MODULE_KEYWORD = 37,\r
  33             REFERENCE_KEYWORD = 24, CONTACT_KEYWORD = 63,\r
  34             LEAF_LIST_KEYWORD = 43, REVISION_DATE_KEYWORD = 20,\r
  35             BELONGS_TO_KEYWORD = 68, LEAF_KEYWORD = 44, PREFIX_KEYWORD = 27,\r
  36             DEFAULT_KEYWORD = 61, PRESENCE_KEYWORD = 26, ARGUMENT_KEYWORD = 71,\r
  37             NOTIFICATION_KEYWORD = 34, RPC_KEYWORD = 19,\r
  38             CONTAINER_KEYWORD = 62, DEVIATION_KEYWORD = 55,\r
  39             STATUS_KEYWORD = 18, IDENTITY_KEYWORD = 50, IDENTIFIER = 73,\r
  40             REFINE_KEYWORD = 23, USES_KEYWORD = 12, VALUE_KEYWORD = 11,\r
  41             IMPORT_KEYWORD = 48, BLOCK_COMMENT = 7, INPUT_KEYWORD = 46,\r
  42             IF_FEATURE_KEYWORD = 49, PLUS = 4, PATTERN_KEYWORD = 29,\r
  43             LENGTH_KEYWORD = 42, FEATURE_KEYWORD = 53,\r
  44             REQUIRE_INSTANCE_KEYWORD = 22, ORGANIZATION_KEYWORD = 32,\r
  45             UNIQUE_KEYWORD = 14, SUBMODULE_KEYWORD = 17, TYPE_KEYWORD = 16,\r
  46             RIGHT_BRACE = 3, ERROR_MESSAGE_KEYWORD = 57, LINE_COMMENT = 6,\r
  47             OUTPUT_KEYWORD = 31, MIN_ELEMENTS_KEYWORD = 38, MUST_KEYWORD = 36,\r
  48             SEMICOLON = 1, POSITION_KEYWORD = 28, PATH_KEYWORD = 30, S = 75,\r
  49             KEY_KEYWORD = 45, EXTENSION_KEYWORD = 56, WS = 5,\r
  50             MANDATORY_KEYWORD = 40, ORDERED_BY_KEYWORD = 33,\r
  51             ERROR_APP_TAG_KEYWORD = 58, INCLUDE_KEYWORD = 47,\r
  52             ANYXML_KEYWORD = 72, AUGMENT_KEYWORD = 70, DEVIATE_KEYWORD = 54,\r
  53             LEFT_BRACE = 2, YANG_VERSION_KEYWORD = 9, LIST_KEYWORD = 41,\r
  54             TYPEDEF_KEYWORD = 15, MAX_ELEMENTS_KEYWORD = 39, ENUM_KEYWORD = 59,\r
  55             CASE_KEYWORD = 66, UNITS_KEYWORD = 13, GROUPING_KEYWORD = 51,\r
  56             BASE_KEYWORD = 69, RANGE_KEYWORD = 25,\r
  57             FRACTION_DIGITS_KEYWORD = 52, CONFIG_KEYWORD = 64,\r
  58             BIT_KEYWORD = 67, STRING = 74;\r
  59     public static final String[] tokenNames = { "<INVALID>", "SEMICOLON",\r
  60             "LEFT_BRACE", "'}'", "'+'", "WS", "LINE_COMMENT", "BLOCK_COMMENT",\r
  61             "'yin-element'", "'yang-version'", "'when'", "'value'", "'uses'",\r
  62             "'units'", "'unique'", "'typedef'", "'type'", "'submodule'",\r
  63             "'status'", "'rpc'", "'revision-date'", "'revision'",\r
  64             "'require-instance'", "'refine'", "'reference'", "'range'",\r
  65             "'presence'", "'prefix'", "'position'", "'pattern'", "'path'",\r
  66             "'output'", "'organization'", "'ordered-by'", "'notification'",\r
  67             "'namespace'", "'must'", "'module'", "'min-elements'",\r
  68             "'max-elements'", "'mandatory'", "'list'", "'length'",\r
  69             "'leaf-list'", "'leaf'", "'key'", "'input'", "'include'",\r
  70             "'import'", "'if-feature'", "'identity'", "'grouping'",\r
  71             "'fraction-digits'", "'feature'", "'deviate'", "'deviation'",\r
  72             "'extension'", "'error-message'", "'error-app-tag'", "'enum'",\r
  73             "'description'", "'default'", "'container'", "'contact'",\r
  74             "'config'", "'choice'", "'case'", "'bit'", "'belongs-to'",\r
  75             "'base'", "'augment'", "'argument'", "'anyxml'", "IDENTIFIER",\r
  76             "STRING", "S" };\r
  77     public static final int RULE_yang = 0, RULE_string = 1,\r
  78             RULE_identifier_stmt = 2, RULE_stmtend = 3,\r
  79             RULE_deviate_replace_stmt = 4, RULE_deviate_delete_stmt = 5,\r
  80             RULE_deviate_add_stmt = 6, RULE_deviate_not_supported_stmt = 7,\r
  81             RULE_deviation_stmt = 8, RULE_notification_stmt = 9,\r
  82             RULE_output_stmt = 10, RULE_input_stmt = 11, RULE_rpc_stmt = 12,\r
  83             RULE_when_stmt = 13, RULE_augment_stmt = 14,\r
  84             RULE_uses_augment_stmt = 15, RULE_refine_anyxml_stmts = 16,\r
  85             RULE_refine_case_stmts = 17, RULE_refine_choice_stmts = 18,\r
  86             RULE_refine_list_stmts = 19, RULE_refine_leaf_list_stmts = 20,\r
  87             RULE_refine_leaf_stmts = 21, RULE_refine_container_stmts = 22,\r
  88             RULE_refune_pom = 23, RULE_refine_stmt = 24, RULE_uses_stmt = 25,\r
  89             RULE_anyxml_stmt = 26, RULE_case_stmt = 27,\r
  90             RULE_short_case_stmt = 28, RULE_choice_stmt = 29,\r
  91             RULE_unique_stmt = 30, RULE_key_stmt = 31, RULE_list_stmt = 32,\r
  92             RULE_leaf_list_stmt = 33, RULE_leaf_stmt = 34,\r
  93             RULE_container_stmt = 35, RULE_grouping_stmt = 36,\r
  94             RULE_value_stmt = 37, RULE_max_value_arg = 38,\r
  95             RULE_max_elements_stmt = 39, RULE_min_elements_stmt = 40,\r
  96             RULE_error_app_tag_stmt = 41, RULE_error_message_stmt = 42,\r
  97             RULE_must_stmt = 43, RULE_ordered_by_arg = 44,\r
  98             RULE_ordered_by_stmt = 45, RULE_presence_stmt = 46,\r
  99             RULE_mandatory_arg = 47, RULE_mandatory_stmt = 48,\r
 100             RULE_config_arg = 49, RULE_config_stmt = 50, RULE_status_arg = 51,\r
 101             RULE_status_stmt = 52, RULE_position_stmt = 53, RULE_bit_stmt = 54,\r
 102             RULE_bits_specification = 55, RULE_union_specification = 56,\r
 103             RULE_identityref_specification = 57,\r
 104             RULE_instance_identifier_specification = 58,\r
 105             RULE_require_instance_arg = 59, RULE_require_instance_stmt = 60,\r
 106             RULE_path_stmt = 61, RULE_leafref_specification = 62,\r
 107             RULE_enum_stmt = 63, RULE_enum_specification = 64,\r
 108             RULE_default_stmt = 65, RULE_pattern_stmt = 66,\r
 109             RULE_length_stmt = 67, RULE_string_restrictions = 68,\r
 110             RULE_fraction_digits_stmt = 69, RULE_decimal64_specification = 70,\r
 111             RULE_range_stmt = 71, RULE_numerical_restrictions = 72,\r
 112             RULE_type_body_stmts = 73, RULE_type_stmt = 74,\r
 113             RULE_typedef_stmt = 75, RULE_if_feature_stmt = 76,\r
 114             RULE_feature_stmt = 77, RULE_base_stmt = 78,\r
 115             RULE_identity_stmt = 79, RULE_yin_element_arg = 80,\r
 116             RULE_yin_element_stmt = 81, RULE_argument_stmt = 82,\r
 117             RULE_extension_stmt = 83, RULE_revision_date_stmt = 84,\r
 118             RULE_revision_stmt = 85, RULE_units_stmt = 86,\r
 119             RULE_reference_stmt = 87, RULE_description_stmt = 88,\r
 120             RULE_contact_stmt = 89, RULE_organization_stmt = 90,\r
 121             RULE_belongs_to_stmt = 91, RULE_prefix_stmt = 92,\r
 122             RULE_namespace_stmt = 93, RULE_include_stmt = 94,\r
 123             RULE_import_stmt = 95, RULE_yang_version_stmt = 96,\r
 124             RULE_data_def_stmt = 97, RULE_body_stmts = 98,\r
 125             RULE_revision_stmts = 99, RULE_linkage_stmts = 100,\r
 126             RULE_meta_stmts = 101, RULE_submodule_header_stmts = 102,\r
 127             RULE_module_header_stmts = 103, RULE_submodule_stmt = 104,\r
 128             RULE_module_stmt = 105;\r
 129     public static final String[] ruleNames = { "yang", "string",\r
 130             "identifier_stmt", "stmtend", "deviate_replace_stmt",\r
 131             "deviate_delete_stmt", "deviate_add_stmt",\r
 132             "deviate_not_supported_stmt", "deviation_stmt",\r
 133             "notification_stmt", "output_stmt", "input_stmt", "rpc_stmt",\r
 134             "when_stmt", "augment_stmt", "uses_augment_stmt",\r
 135             "refine_anyxml_stmts", "refine_case_stmts", "refine_choice_stmts",\r
 136             "refine_list_stmts", "refine_leaf_list_stmts", "refine_leaf_stmts",\r
 137             "refine_container_stmts", "refune_pom", "refine_stmt", "uses_stmt",\r
 138             "anyxml_stmt", "case_stmt", "short_case_stmt", "choice_stmt",\r
 139             "unique_stmt", "key_stmt", "list_stmt", "leaf_list_stmt",\r
 140             "leaf_stmt", "container_stmt", "grouping_stmt", "value_stmt",\r
 141             "max_value_arg", "max_elements_stmt", "min_elements_stmt",\r
 142             "error_app_tag_stmt", "error_message_stmt", "must_stmt",\r
 143             "ordered_by_arg", "ordered_by_stmt", "presence_stmt",\r
 144             "mandatory_arg", "mandatory_stmt", "config_arg", "config_stmt",\r
 145             "status_arg", "status_stmt", "position_stmt", "bit_stmt",\r
 146             "bits_specification", "union_specification",\r
 147             "identityref_specification", "instance_identifier_specification",\r
 148             "require_instance_arg", "require_instance_stmt", "path_stmt",\r
 149             "leafref_specification", "enum_stmt", "enum_specification",\r
 150             "default_stmt", "pattern_stmt", "length_stmt",\r
 151             "string_restrictions", "fraction_digits_stmt",\r
 152             "decimal64_specification", "range_stmt", "numerical_restrictions",\r
 153             "type_body_stmts", "type_stmt", "typedef_stmt", "if_feature_stmt",\r
 154             "feature_stmt", "base_stmt", "identity_stmt", "yin_element_arg",\r
 155             "yin_element_stmt", "argument_stmt", "extension_stmt",\r
 156             "revision_date_stmt", "revision_stmt", "units_stmt",\r
 157             "reference_stmt", "description_stmt", "contact_stmt",\r
 158             "organization_stmt", "belongs_to_stmt", "prefix_stmt",\r
 159             "namespace_stmt", "include_stmt", "import_stmt",\r
 160             "yang_version_stmt", "data_def_stmt", "body_stmts",\r
 161             "revision_stmts", "linkage_stmts", "meta_stmts",\r
 162             "submodule_header_stmts", "module_header_stmts", "submodule_stmt",\r
 163             "module_stmt" };\r
 164 \r
 165     @Override\r
 166     public String getGrammarFileName() {\r
 167         return "yangParser.g4";\r
 168     }\r
 169 \r
 170     @Override\r
 171     public String[] getTokenNames() {\r
 172         return tokenNames;\r
 173     }\r
 174 \r
 175     @Override\r
 176     public String[] getRuleNames() {\r
 177         return ruleNames;\r
 178     }\r
 179 \r
 180     @Override\r
 181     public ATN getATN() {\r
 182         return _ATN;\r
 183     }\r
 184 \r
 185     public YangParser(TokenStream input) {\r
 186         super(input);\r
 187         _interp = new ParserATNSimulator(this, _ATN, _decisionToDFA,\r
 188                 _sharedContextCache);\r
 189     }\r
 190 \r
 191     public static class YangContext extends ParserRuleContext {\r
 192         public Submodule_stmtContext submodule_stmt() {\r
 193             return getRuleContext(Submodule_stmtContext.class, 0);\r
 194         }\r
 195 \r
 196         public Module_stmtContext module_stmt() {\r
 197             return getRuleContext(Module_stmtContext.class, 0);\r
 198         }\r
 199 \r
 200         public YangContext(ParserRuleContext parent, int invokingState) {\r
 201             super(parent, invokingState);\r
 202         }\r
 203 \r
 204         @Override\r
 205         public int getRuleIndex() {\r
 206             return RULE_yang;\r
 207         }\r
 208 \r
 209         @Override\r
 210         public void enterRule(ParseTreeListener listener) {\r
 211             if (listener instanceof YangParserListener)\r
 212                 ((YangParserListener) listener).enterYang(this);\r
 213         }\r
 214 \r
 215         @Override\r
 216         public void exitRule(ParseTreeListener listener) {\r
 217             if (listener instanceof YangParserListener)\r
 218                 ((YangParserListener) listener).exitYang(this);\r
 219         }\r
 220 \r
 221         @Override\r
 222         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
 223             if (visitor instanceof YangParserVisitor)\r
 224                 return ((YangParserVisitor<? extends T>) visitor)\r
 225                         .visitYang(this);\r
 226             else\r
 227                 return visitor.visitChildren(this);\r
 228         }\r
 229     }\r
 230 \r
 231     public final YangContext yang() throws RecognitionException {\r
 232         YangContext _localctx = new YangContext(_ctx, getState());\r
 233         enterRule(_localctx, 0, RULE_yang);\r
 234         try {\r
 235             setState(214);\r
 236             switch (_input.LA(1)) {\r
 237             case MODULE_KEYWORD:\r
 238                 enterOuterAlt(_localctx, 1);\r
 239                 {\r
 240                     setState(212);\r
 241                     module_stmt();\r
 242                 }\r
 243                 break;\r
 244             case SUBMODULE_KEYWORD:\r
 245                 enterOuterAlt(_localctx, 2);\r
 246                 {\r
 247                     setState(213);\r
 248                     submodule_stmt();\r
 249                 }\r
 250                 break;\r
 251             default:\r
 252                 throw new NoViableAltException(this);\r
 253             }\r
 254         } catch (RecognitionException re) {\r
 255             _localctx.exception = re;\r
 256             _errHandler.reportError(this, re);\r
 257             _errHandler.recover(this, re);\r
 258         } finally {\r
 259             exitRule();\r
 260         }\r
 261         return _localctx;\r
 262     }\r
 263 \r
 264     public static class StringContext extends ParserRuleContext {\r
 265         public List<TerminalNode> PLUS() {\r
 266             return getTokens(YangParser.PLUS);\r
 267         }\r
 268 \r
 269         public TerminalNode STRING(int i) {\r
 270             return getToken(YangParser.STRING, i);\r
 271         }\r
 272 \r
 273         public TerminalNode PLUS(int i) {\r
 274             return getToken(YangParser.PLUS, i);\r
 275         }\r
 276 \r
 277         public List<TerminalNode> STRING() {\r
 278             return getTokens(YangParser.STRING);\r
 279         }\r
 280 \r
 281         public StringContext(ParserRuleContext parent, int invokingState) {\r
 282             super(parent, invokingState);\r
 283         }\r
 284 \r
 285         @Override\r
 286         public int getRuleIndex() {\r
 287             return RULE_string;\r
 288         }\r
 289 \r
 290         @Override\r
 291         public void enterRule(ParseTreeListener listener) {\r
 292             if (listener instanceof YangParserListener)\r
 293                 ((YangParserListener) listener).enterString(this);\r
 294         }\r
 295 \r
 296         @Override\r
 297         public void exitRule(ParseTreeListener listener) {\r
 298             if (listener instanceof YangParserListener)\r
 299                 ((YangParserListener) listener).exitString(this);\r
 300         }\r
 301 \r
 302         @Override\r
 303         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
 304             if (visitor instanceof YangParserVisitor)\r
 305                 return ((YangParserVisitor<? extends T>) visitor)\r
 306                         .visitString(this);\r
 307             else\r
 308                 return visitor.visitChildren(this);\r
 309         }\r
 310     }\r
 311 \r
 312     public final StringContext string() throws RecognitionException {\r
 313         StringContext _localctx = new StringContext(_ctx, getState());\r
 314         enterRule(_localctx, 2, RULE_string);\r
 315         int _la;\r
 316         try {\r
 317             enterOuterAlt(_localctx, 1);\r
 318             {\r
 319                 setState(216);\r
 320                 match(STRING);\r
 321                 setState(221);\r
 322                 _errHandler.sync(this);\r
 323                 _la = _input.LA(1);\r
 324                 while (_la == PLUS) {\r
 325                     {\r
 326                         {\r
 327                             setState(217);\r
 328                             match(PLUS);\r
 329                             setState(218);\r
 330                             match(STRING);\r
 331                         }\r
 332                     }\r
 333                     setState(223);\r
 334                     _errHandler.sync(this);\r
 335                     _la = _input.LA(1);\r
 336                 }\r
 337             }\r
 338         } catch (RecognitionException re) {\r
 339             _localctx.exception = re;\r
 340             _errHandler.reportError(this, re);\r
 341             _errHandler.recover(this, re);\r
 342         } finally {\r
 343             exitRule();\r
 344         }\r
 345         return _localctx;\r
 346     }\r
 347 \r
 348     public static class Identifier_stmtContext extends ParserRuleContext {\r
 349         public StringContext string() {\r
 350             return getRuleContext(StringContext.class, 0);\r
 351         }\r
 352 \r
 353         public StmtendContext stmtend() {\r
 354             return getRuleContext(StmtendContext.class, 0);\r
 355         }\r
 356 \r
 357         public TerminalNode IDENTIFIER() {\r
 358             return getToken(YangParser.IDENTIFIER, 0);\r
 359         }\r
 360 \r
 361         public Identifier_stmtContext(ParserRuleContext parent,\r
 362                 int invokingState) {\r
 363             super(parent, invokingState);\r
 364         }\r
 365 \r
 366         @Override\r
 367         public int getRuleIndex() {\r
 368             return RULE_identifier_stmt;\r
 369         }\r
 370 \r
 371         @Override\r
 372         public void enterRule(ParseTreeListener listener) {\r
 373             if (listener instanceof YangParserListener)\r
 374                 ((YangParserListener) listener).enterIdentifier_stmt(this);\r
 375         }\r
 376 \r
 377         @Override\r
 378         public void exitRule(ParseTreeListener listener) {\r
 379             if (listener instanceof YangParserListener)\r
 380                 ((YangParserListener) listener).exitIdentifier_stmt(this);\r
 381         }\r
 382 \r
 383         @Override\r
 384         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
 385             if (visitor instanceof YangParserVisitor)\r
 386                 return ((YangParserVisitor<? extends T>) visitor)\r
 387                         .visitIdentifier_stmt(this);\r
 388             else\r
 389                 return visitor.visitChildren(this);\r
 390         }\r
 391     }\r
 392 \r
 393     public final Identifier_stmtContext identifier_stmt()\r
 394             throws RecognitionException {\r
 395         Identifier_stmtContext _localctx = new Identifier_stmtContext(_ctx,\r
 396                 getState());\r
 397         enterRule(_localctx, 4, RULE_identifier_stmt);\r
 398         int _la;\r
 399         try {\r
 400             enterOuterAlt(_localctx, 1);\r
 401             {\r
 402                 setState(224);\r
 403                 match(IDENTIFIER);\r
 404                 setState(226);\r
 405                 _la = _input.LA(1);\r
 406                 if (_la == STRING) {\r
 407                     {\r
 408                         setState(225);\r
 409                         string();\r
 410                     }\r
 411                 }\r
 412 \r
 413                 setState(228);\r
 414                 stmtend();\r
 415             }\r
 416         } catch (RecognitionException re) {\r
 417             _localctx.exception = re;\r
 418             _errHandler.reportError(this, re);\r
 419             _errHandler.recover(this, re);\r
 420         } finally {\r
 421             exitRule();\r
 422         }\r
 423         return _localctx;\r
 424     }\r
 425 \r
 426     public static class StmtendContext extends ParserRuleContext {\r
 427         public TerminalNode RIGHT_BRACE() {\r
 428             return getToken(YangParser.RIGHT_BRACE, 0);\r
 429         }\r
 430 \r
 431         public TerminalNode SEMICOLON() {\r
 432             return getToken(YangParser.SEMICOLON, 0);\r
 433         }\r
 434 \r
 435         public Identifier_stmtContext identifier_stmt() {\r
 436             return getRuleContext(Identifier_stmtContext.class, 0);\r
 437         }\r
 438 \r
 439         public TerminalNode LEFT_BRACE() {\r
 440             return getToken(YangParser.LEFT_BRACE, 0);\r
 441         }\r
 442 \r
 443         public StmtendContext(ParserRuleContext parent, int invokingState) {\r
 444             super(parent, invokingState);\r
 445         }\r
 446 \r
 447         @Override\r
 448         public int getRuleIndex() {\r
 449             return RULE_stmtend;\r
 450         }\r
 451 \r
 452         @Override\r
 453         public void enterRule(ParseTreeListener listener) {\r
 454             if (listener instanceof YangParserListener)\r
 455                 ((YangParserListener) listener).enterStmtend(this);\r
 456         }\r
 457 \r
 458         @Override\r
 459         public void exitRule(ParseTreeListener listener) {\r
 460             if (listener instanceof YangParserListener)\r
 461                 ((YangParserListener) listener).exitStmtend(this);\r
 462         }\r
 463 \r
 464         @Override\r
 465         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
 466             if (visitor instanceof YangParserVisitor)\r
 467                 return ((YangParserVisitor<? extends T>) visitor)\r
 468                         .visitStmtend(this);\r
 469             else\r
 470                 return visitor.visitChildren(this);\r
 471         }\r
 472     }\r
 473 \r
 474     public final StmtendContext stmtend() throws RecognitionException {\r
 475         StmtendContext _localctx = new StmtendContext(_ctx, getState());\r
 476         enterRule(_localctx, 6, RULE_stmtend);\r
 477         int _la;\r
 478         try {\r
 479             setState(239);\r
 480             switch (_input.LA(1)) {\r
 481             case SEMICOLON:\r
 482                 enterOuterAlt(_localctx, 1);\r
 483                 {\r
 484                     {\r
 485                         setState(230);\r
 486                         match(SEMICOLON);\r
 487                         setState(232);\r
 488                         switch (getInterpreter().adaptivePredict(_input, 3,\r
 489                                 _ctx)) {\r
 490                         case 1: {\r
 491                             setState(231);\r
 492                             identifier_stmt();\r
 493                         }\r
 494                             break;\r
 495                         }\r
 496                     }\r
 497                 }\r
 498                 break;\r
 499             case LEFT_BRACE:\r
 500                 enterOuterAlt(_localctx, 2);\r
 501                 {\r
 502                     {\r
 503                         setState(234);\r
 504                         match(LEFT_BRACE);\r
 505                         setState(236);\r
 506                         _la = _input.LA(1);\r
 507                         if (_la == IDENTIFIER) {\r
 508                             {\r
 509                                 setState(235);\r
 510                                 identifier_stmt();\r
 511                             }\r
 512                         }\r
 513 \r
 514                         setState(238);\r
 515                         match(RIGHT_BRACE);\r
 516                     }\r
 517                 }\r
 518                 break;\r
 519             default:\r
 520                 throw new NoViableAltException(this);\r
 521             }\r
 522         } catch (RecognitionException re) {\r
 523             _localctx.exception = re;\r
 524             _errHandler.reportError(this, re);\r
 525             _errHandler.recover(this, re);\r
 526         } finally {\r
 527             exitRule();\r
 528         }\r
 529         return _localctx;\r
 530     }\r
 531 \r
 532     public static class Deviate_replace_stmtContext extends ParserRuleContext {\r
 533         public TerminalNode RIGHT_BRACE() {\r
 534             return getToken(YangParser.RIGHT_BRACE, 0);\r
 535         }\r
 536 \r
 537         public Units_stmtContext units_stmt(int i) {\r
 538             return getRuleContext(Units_stmtContext.class, i);\r
 539         }\r
 540 \r
 541         public Default_stmtContext default_stmt(int i) {\r
 542             return getRuleContext(Default_stmtContext.class, i);\r
 543         }\r
 544 \r
 545         public List<Units_stmtContext> units_stmt() {\r
 546             return getRuleContexts(Units_stmtContext.class);\r
 547         }\r
 548 \r
 549         public List<Max_elements_stmtContext> max_elements_stmt() {\r
 550             return getRuleContexts(Max_elements_stmtContext.class);\r
 551         }\r
 552 \r
 553         public Type_stmtContext type_stmt(int i) {\r
 554             return getRuleContext(Type_stmtContext.class, i);\r
 555         }\r
 556 \r
 557         public TerminalNode DEVIATE_KEYWORD() {\r
 558             return getToken(YangParser.DEVIATE_KEYWORD, 0);\r
 559         }\r
 560 \r
 561         public TerminalNode LEFT_BRACE() {\r
 562             return getToken(YangParser.LEFT_BRACE, 0);\r
 563         }\r
 564 \r
 565         public List<Mandatory_stmtContext> mandatory_stmt() {\r
 566             return getRuleContexts(Mandatory_stmtContext.class);\r
 567         }\r
 568 \r
 569         public List<Type_stmtContext> type_stmt() {\r
 570             return getRuleContexts(Type_stmtContext.class);\r
 571         }\r
 572 \r
 573         public Min_elements_stmtContext min_elements_stmt(int i) {\r
 574             return getRuleContext(Min_elements_stmtContext.class, i);\r
 575         }\r
 576 \r
 577         public List<Default_stmtContext> default_stmt() {\r
 578             return getRuleContexts(Default_stmtContext.class);\r
 579         }\r
 580 \r
 581         public Mandatory_stmtContext mandatory_stmt(int i) {\r
 582             return getRuleContext(Mandatory_stmtContext.class, i);\r
 583         }\r
 584 \r
 585         public Config_stmtContext config_stmt(int i) {\r
 586             return getRuleContext(Config_stmtContext.class, i);\r
 587         }\r
 588 \r
 589         public TerminalNode SEMICOLON() {\r
 590             return getToken(YangParser.SEMICOLON, 0);\r
 591         }\r
 592 \r
 593         public List<Min_elements_stmtContext> min_elements_stmt() {\r
 594             return getRuleContexts(Min_elements_stmtContext.class);\r
 595         }\r
 596 \r
 597         public StringContext string() {\r
 598             return getRuleContext(StringContext.class, 0);\r
 599         }\r
 600 \r
 601         public List<Config_stmtContext> config_stmt() {\r
 602             return getRuleContexts(Config_stmtContext.class);\r
 603         }\r
 604 \r
 605         public Max_elements_stmtContext max_elements_stmt(int i) {\r
 606             return getRuleContext(Max_elements_stmtContext.class, i);\r
 607         }\r
 608 \r
 609         public Deviate_replace_stmtContext(ParserRuleContext parent,\r
 610                 int invokingState) {\r
 611             super(parent, invokingState);\r
 612         }\r
 613 \r
 614         @Override\r
 615         public int getRuleIndex() {\r
 616             return RULE_deviate_replace_stmt;\r
 617         }\r
 618 \r
 619         @Override\r
 620         public void enterRule(ParseTreeListener listener) {\r
 621             if (listener instanceof YangParserListener)\r
 622                 ((YangParserListener) listener).enterDeviate_replace_stmt(this);\r
 623         }\r
 624 \r
 625         @Override\r
 626         public void exitRule(ParseTreeListener listener) {\r
 627             if (listener instanceof YangParserListener)\r
 628                 ((YangParserListener) listener).exitDeviate_replace_stmt(this);\r
 629         }\r
 630 \r
 631         @Override\r
 632         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
 633             if (visitor instanceof YangParserVisitor)\r
 634                 return ((YangParserVisitor<? extends T>) visitor)\r
 635                         .visitDeviate_replace_stmt(this);\r
 636             else\r
 637                 return visitor.visitChildren(this);\r
 638         }\r
 639     }\r
 640 \r
 641     public final Deviate_replace_stmtContext deviate_replace_stmt()\r
 642             throws RecognitionException {\r
 643         Deviate_replace_stmtContext _localctx = new Deviate_replace_stmtContext(\r
 644                 _ctx, getState());\r
 645         enterRule(_localctx, 8, RULE_deviate_replace_stmt);\r
 646         int _la;\r
 647         try {\r
 648             enterOuterAlt(_localctx, 1);\r
 649             {\r
 650                 setState(241);\r
 651                 match(DEVIATE_KEYWORD);\r
 652                 setState(242);\r
 653                 string();\r
 654                 setState(258);\r
 655                 switch (_input.LA(1)) {\r
 656                 case SEMICOLON: {\r
 657                     setState(243);\r
 658                     match(SEMICOLON);\r
 659                 }\r
 660                     break;\r
 661                 case LEFT_BRACE: {\r
 662                     {\r
 663                         setState(244);\r
 664                         match(LEFT_BRACE);\r
 665                         setState(254);\r
 666                         _errHandler.sync(this);\r
 667                         _la = _input.LA(1);\r
 668                         while (((((_la - 13)) & ~0x3f) == 0 && ((1L << (_la - 13)) & ((1L << (UNITS_KEYWORD - 13))\r
 669                                 | (1L << (TYPE_KEYWORD - 13))\r
 670                                 | (1L << (MIN_ELEMENTS_KEYWORD - 13))\r
 671                                 | (1L << (MAX_ELEMENTS_KEYWORD - 13))\r
 672                                 | (1L << (MANDATORY_KEYWORD - 13))\r
 673                                 | (1L << (DEFAULT_KEYWORD - 13)) | (1L << (CONFIG_KEYWORD - 13)))) != 0)) {\r
 674                             {\r
 675                                 setState(252);\r
 676                                 switch (_input.LA(1)) {\r
 677                                 case TYPE_KEYWORD: {\r
 678                                     setState(245);\r
 679                                     type_stmt();\r
 680                                 }\r
 681                                     break;\r
 682                                 case UNITS_KEYWORD: {\r
 683                                     setState(246);\r
 684                                     units_stmt();\r
 685                                 }\r
 686                                     break;\r
 687                                 case DEFAULT_KEYWORD: {\r
 688                                     setState(247);\r
 689                                     default_stmt();\r
 690                                 }\r
 691                                     break;\r
 692                                 case CONFIG_KEYWORD: {\r
 693                                     setState(248);\r
 694                                     config_stmt();\r
 695                                 }\r
 696                                     break;\r
 697                                 case MANDATORY_KEYWORD: {\r
 698                                     setState(249);\r
 699                                     mandatory_stmt();\r
 700                                 }\r
 701                                     break;\r
 702                                 case MIN_ELEMENTS_KEYWORD: {\r
 703                                     setState(250);\r
 704                                     min_elements_stmt();\r
 705                                 }\r
 706                                     break;\r
 707                                 case MAX_ELEMENTS_KEYWORD: {\r
 708                                     setState(251);\r
 709                                     max_elements_stmt();\r
 710                                 }\r
 711                                     break;\r
 712                                 default:\r
 713                                     throw new NoViableAltException(this);\r
 714                                 }\r
 715                             }\r
 716                             setState(256);\r
 717                             _errHandler.sync(this);\r
 718                             _la = _input.LA(1);\r
 719                         }\r
 720                         setState(257);\r
 721                         match(RIGHT_BRACE);\r
 722                     }\r
 723                 }\r
 724                     break;\r
 725                 default:\r
 726                     throw new NoViableAltException(this);\r
 727                 }\r
 728             }\r
 729         } catch (RecognitionException re) {\r
 730             _localctx.exception = re;\r
 731             _errHandler.reportError(this, re);\r
 732             _errHandler.recover(this, re);\r
 733         } finally {\r
 734             exitRule();\r
 735         }\r
 736         return _localctx;\r
 737     }\r
 738 \r
 739     public static class Deviate_delete_stmtContext extends ParserRuleContext {\r
 740         public Units_stmtContext units_stmt(int i) {\r
 741             return getRuleContext(Units_stmtContext.class, i);\r
 742         }\r
 743 \r
 744         public TerminalNode RIGHT_BRACE() {\r
 745             return getToken(YangParser.RIGHT_BRACE, 0);\r
 746         }\r
 747 \r
 748         public List<Default_stmtContext> default_stmt() {\r
 749             return getRuleContexts(Default_stmtContext.class);\r
 750         }\r
 751 \r
 752         public Default_stmtContext default_stmt(int i) {\r
 753             return getRuleContext(Default_stmtContext.class, i);\r
 754         }\r
 755 \r
 756         public List<Units_stmtContext> units_stmt() {\r
 757             return getRuleContexts(Units_stmtContext.class);\r
 758         }\r
 759 \r
 760         public TerminalNode SEMICOLON() {\r
 761             return getToken(YangParser.SEMICOLON, 0);\r
 762         }\r
 763 \r
 764         public List<Must_stmtContext> must_stmt() {\r
 765             return getRuleContexts(Must_stmtContext.class);\r
 766         }\r
 767 \r
 768         public StringContext string() {\r
 769             return getRuleContext(StringContext.class, 0);\r
 770         }\r
 771 \r
 772         public List<Unique_stmtContext> unique_stmt() {\r
 773             return getRuleContexts(Unique_stmtContext.class);\r
 774         }\r
 775 \r
 776         public TerminalNode DEVIATE_KEYWORD() {\r
 777             return getToken(YangParser.DEVIATE_KEYWORD, 0);\r
 778         }\r
 779 \r
 780         public TerminalNode LEFT_BRACE() {\r
 781             return getToken(YangParser.LEFT_BRACE, 0);\r
 782         }\r
 783 \r
 784         public Must_stmtContext must_stmt(int i) {\r
 785             return getRuleContext(Must_stmtContext.class, i);\r
 786         }\r
 787 \r
 788         public Unique_stmtContext unique_stmt(int i) {\r
 789             return getRuleContext(Unique_stmtContext.class, i);\r
 790         }\r
 791 \r
 792         public Deviate_delete_stmtContext(ParserRuleContext parent,\r
 793                 int invokingState) {\r
 794             super(parent, invokingState);\r
 795         }\r
 796 \r
 797         @Override\r
 798         public int getRuleIndex() {\r
 799             return RULE_deviate_delete_stmt;\r
 800         }\r
 801 \r
 802         @Override\r
 803         public void enterRule(ParseTreeListener listener) {\r
 804             if (listener instanceof YangParserListener)\r
 805                 ((YangParserListener) listener).enterDeviate_delete_stmt(this);\r
 806         }\r
 807 \r
 808         @Override\r
 809         public void exitRule(ParseTreeListener listener) {\r
 810             if (listener instanceof YangParserListener)\r
 811                 ((YangParserListener) listener).exitDeviate_delete_stmt(this);\r
 812         }\r
 813 \r
 814         @Override\r
 815         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
 816             if (visitor instanceof YangParserVisitor)\r
 817                 return ((YangParserVisitor<? extends T>) visitor)\r
 818                         .visitDeviate_delete_stmt(this);\r
 819             else\r
 820                 return visitor.visitChildren(this);\r
 821         }\r
 822     }\r
 823 \r
 824     public final Deviate_delete_stmtContext deviate_delete_stmt()\r
 825             throws RecognitionException {\r
 826         Deviate_delete_stmtContext _localctx = new Deviate_delete_stmtContext(\r
 827                 _ctx, getState());\r
 828         enterRule(_localctx, 10, RULE_deviate_delete_stmt);\r
 829         int _la;\r
 830         try {\r
 831             enterOuterAlt(_localctx, 1);\r
 832             {\r
 833                 setState(260);\r
 834                 match(DEVIATE_KEYWORD);\r
 835                 setState(261);\r
 836                 string();\r
 837                 setState(274);\r
 838                 switch (_input.LA(1)) {\r
 839                 case SEMICOLON: {\r
 840                     setState(262);\r
 841                     match(SEMICOLON);\r
 842                 }\r
 843                     break;\r
 844                 case LEFT_BRACE: {\r
 845                     {\r
 846                         setState(263);\r
 847                         match(LEFT_BRACE);\r
 848                         setState(270);\r
 849                         _errHandler.sync(this);\r
 850                         _la = _input.LA(1);\r
 851                         while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << UNITS_KEYWORD)\r
 852                                 | (1L << UNIQUE_KEYWORD) | (1L << MUST_KEYWORD) | (1L << DEFAULT_KEYWORD))) != 0)) {\r
 853                             {\r
 854                                 setState(268);\r
 855                                 switch (_input.LA(1)) {\r
 856                                 case UNITS_KEYWORD: {\r
 857                                     setState(264);\r
 858                                     units_stmt();\r
 859                                 }\r
 860                                     break;\r
 861                                 case MUST_KEYWORD: {\r
 862                                     setState(265);\r
 863                                     must_stmt();\r
 864                                 }\r
 865                                     break;\r
 866                                 case UNIQUE_KEYWORD: {\r
 867                                     setState(266);\r
 868                                     unique_stmt();\r
 869                                 }\r
 870                                     break;\r
 871                                 case DEFAULT_KEYWORD: {\r
 872                                     setState(267);\r
 873                                     default_stmt();\r
 874                                 }\r
 875                                     break;\r
 876                                 default:\r
 877                                     throw new NoViableAltException(this);\r
 878                                 }\r
 879                             }\r
 880                             setState(272);\r
 881                             _errHandler.sync(this);\r
 882                             _la = _input.LA(1);\r
 883                         }\r
 884                         setState(273);\r
 885                         match(RIGHT_BRACE);\r
 886                     }\r
 887                 }\r
 888                     break;\r
 889                 default:\r
 890                     throw new NoViableAltException(this);\r
 891                 }\r
 892             }\r
 893         } catch (RecognitionException re) {\r
 894             _localctx.exception = re;\r
 895             _errHandler.reportError(this, re);\r
 896             _errHandler.recover(this, re);\r
 897         } finally {\r
 898             exitRule();\r
 899         }\r
 900         return _localctx;\r
 901     }\r
 902 \r
 903     public static class Deviate_add_stmtContext extends ParserRuleContext {\r
 904         public TerminalNode RIGHT_BRACE() {\r
 905             return getToken(YangParser.RIGHT_BRACE, 0);\r
 906         }\r
 907 \r
 908         public Units_stmtContext units_stmt(int i) {\r
 909             return getRuleContext(Units_stmtContext.class, i);\r
 910         }\r
 911 \r
 912         public Default_stmtContext default_stmt(int i) {\r
 913             return getRuleContext(Default_stmtContext.class, i);\r
 914         }\r
 915 \r
 916         public List<Units_stmtContext> units_stmt() {\r
 917             return getRuleContexts(Units_stmtContext.class);\r
 918         }\r
 919 \r
 920         public List<Max_elements_stmtContext> max_elements_stmt() {\r
 921             return getRuleContexts(Max_elements_stmtContext.class);\r
 922         }\r
 923 \r
 924         public TerminalNode DEVIATE_KEYWORD() {\r
 925             return getToken(YangParser.DEVIATE_KEYWORD, 0);\r
 926         }\r
 927 \r
 928         public TerminalNode LEFT_BRACE() {\r
 929             return getToken(YangParser.LEFT_BRACE, 0);\r
 930         }\r
 931 \r
 932         public List<Mandatory_stmtContext> mandatory_stmt() {\r
 933             return getRuleContexts(Mandatory_stmtContext.class);\r
 934         }\r
 935 \r
 936         public Must_stmtContext must_stmt(int i) {\r
 937             return getRuleContext(Must_stmtContext.class, i);\r
 938         }\r
 939 \r
 940         public Min_elements_stmtContext min_elements_stmt(int i) {\r
 941             return getRuleContext(Min_elements_stmtContext.class, i);\r
 942         }\r
 943 \r
 944         public List<Default_stmtContext> default_stmt() {\r
 945             return getRuleContexts(Default_stmtContext.class);\r
 946         }\r
 947 \r
 948         public Mandatory_stmtContext mandatory_stmt(int i) {\r
 949             return getRuleContext(Mandatory_stmtContext.class, i);\r
 950         }\r
 951 \r
 952         public Config_stmtContext config_stmt(int i) {\r
 953             return getRuleContext(Config_stmtContext.class, i);\r
 954         }\r
 955 \r
 956         public TerminalNode SEMICOLON() {\r
 957             return getToken(YangParser.SEMICOLON, 0);\r
 958         }\r
 959 \r
 960         public List<Min_elements_stmtContext> min_elements_stmt() {\r
 961             return getRuleContexts(Min_elements_stmtContext.class);\r
 962         }\r
 963 \r
 964         public List<Config_stmtContext> config_stmt() {\r
 965             return getRuleContexts(Config_stmtContext.class);\r
 966         }\r
 967 \r
 968         public StringContext string() {\r
 969             return getRuleContext(StringContext.class, 0);\r
 970         }\r
 971 \r
 972         public List<Must_stmtContext> must_stmt() {\r
 973             return getRuleContexts(Must_stmtContext.class);\r
 974         }\r
 975 \r
 976         public List<Unique_stmtContext> unique_stmt() {\r
 977             return getRuleContexts(Unique_stmtContext.class);\r
 978         }\r
 979 \r
 980         public Max_elements_stmtContext max_elements_stmt(int i) {\r
 981             return getRuleContext(Max_elements_stmtContext.class, i);\r
 982         }\r
 983 \r
 984         public Unique_stmtContext unique_stmt(int i) {\r
 985             return getRuleContext(Unique_stmtContext.class, i);\r
 986         }\r
 987 \r
 988         public Deviate_add_stmtContext(ParserRuleContext parent,\r
 989                 int invokingState) {\r
 990             super(parent, invokingState);\r
 991         }\r
 992 \r
 993         @Override\r
 994         public int getRuleIndex() {\r
 995             return RULE_deviate_add_stmt;\r
 996         }\r
 997 \r
 998         @Override\r
 999         public void enterRule(ParseTreeListener listener) {\r
1000             if (listener instanceof YangParserListener)\r
1001                 ((YangParserListener) listener).enterDeviate_add_stmt(this);\r
1002         }\r
1003 \r
1004         @Override\r
1005         public void exitRule(ParseTreeListener listener) {\r
1006             if (listener instanceof YangParserListener)\r
1007                 ((YangParserListener) listener).exitDeviate_add_stmt(this);\r
1008         }\r
1009 \r
1010         @Override\r
1011         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
1012             if (visitor instanceof YangParserVisitor)\r
1013                 return ((YangParserVisitor<? extends T>) visitor)\r
1014                         .visitDeviate_add_stmt(this);\r
1015             else\r
1016                 return visitor.visitChildren(this);\r
1017         }\r
1018     }\r
1019 \r
1020     public final Deviate_add_stmtContext deviate_add_stmt()\r
1021             throws RecognitionException {\r
1022         Deviate_add_stmtContext _localctx = new Deviate_add_stmtContext(_ctx,\r
1023                 getState());\r
1024         enterRule(_localctx, 12, RULE_deviate_add_stmt);\r
1025         int _la;\r
1026         try {\r
1027             enterOuterAlt(_localctx, 1);\r
1028             {\r
1029                 setState(276);\r
1030                 match(DEVIATE_KEYWORD);\r
1031                 setState(277);\r
1032                 string();\r
1033                 setState(294);\r
1034                 switch (_input.LA(1)) {\r
1035                 case SEMICOLON: {\r
1036                     setState(278);\r
1037                     match(SEMICOLON);\r
1038                 }\r
1039                     break;\r
1040                 case LEFT_BRACE: {\r
1041                     {\r
1042                         setState(279);\r
1043                         match(LEFT_BRACE);\r
1044                         setState(290);\r
1045                         _errHandler.sync(this);\r
1046                         _la = _input.LA(1);\r
1047                         while (((((_la - 13)) & ~0x3f) == 0 && ((1L << (_la - 13)) & ((1L << (UNITS_KEYWORD - 13))\r
1048                                 | (1L << (UNIQUE_KEYWORD - 13))\r
1049                                 | (1L << (MUST_KEYWORD - 13))\r
1050                                 | (1L << (MIN_ELEMENTS_KEYWORD - 13))\r
1051                                 | (1L << (MAX_ELEMENTS_KEYWORD - 13))\r
1052                                 | (1L << (MANDATORY_KEYWORD - 13))\r
1053                                 | (1L << (DEFAULT_KEYWORD - 13)) | (1L << (CONFIG_KEYWORD - 13)))) != 0)) {\r
1054                             {\r
1055                                 setState(288);\r
1056                                 switch (_input.LA(1)) {\r
1057                                 case UNITS_KEYWORD: {\r
1058                                     setState(280);\r
1059                                     units_stmt();\r
1060                                 }\r
1061                                     break;\r
1062                                 case MUST_KEYWORD: {\r
1063                                     setState(281);\r
1064                                     must_stmt();\r
1065                                 }\r
1066                                     break;\r
1067                                 case UNIQUE_KEYWORD: {\r
1068                                     setState(282);\r
1069                                     unique_stmt();\r
1070                                 }\r
1071                                     break;\r
1072                                 case DEFAULT_KEYWORD: {\r
1073                                     setState(283);\r
1074                                     default_stmt();\r
1075                                 }\r
1076                                     break;\r
1077                                 case CONFIG_KEYWORD: {\r
1078                                     setState(284);\r
1079                                     config_stmt();\r
1080                                 }\r
1081                                     break;\r
1082                                 case MANDATORY_KEYWORD: {\r
1083                                     setState(285);\r
1084                                     mandatory_stmt();\r
1085                                 }\r
1086                                     break;\r
1087                                 case MIN_ELEMENTS_KEYWORD: {\r
1088                                     setState(286);\r
1089                                     min_elements_stmt();\r
1090                                 }\r
1091                                     break;\r
1092                                 case MAX_ELEMENTS_KEYWORD: {\r
1093                                     setState(287);\r
1094                                     max_elements_stmt();\r
1095                                 }\r
1096                                     break;\r
1097                                 default:\r
1098                                     throw new NoViableAltException(this);\r
1099                                 }\r
1100                             }\r
1101                             setState(292);\r
1102                             _errHandler.sync(this);\r
1103                             _la = _input.LA(1);\r
1104                         }\r
1105                         setState(293);\r
1106                         match(RIGHT_BRACE);\r
1107                     }\r
1108                 }\r
1109                     break;\r
1110                 default:\r
1111                     throw new NoViableAltException(this);\r
1112                 }\r
1113             }\r
1114         } catch (RecognitionException re) {\r
1115             _localctx.exception = re;\r
1116             _errHandler.reportError(this, re);\r
1117             _errHandler.recover(this, re);\r
1118         } finally {\r
1119             exitRule();\r
1120         }\r
1121         return _localctx;\r
1122     }\r
1123 \r
1124     public static class Deviate_not_supported_stmtContext extends\r
1125             ParserRuleContext {\r
1126         public TerminalNode RIGHT_BRACE() {\r
1127             return getToken(YangParser.RIGHT_BRACE, 0);\r
1128         }\r
1129 \r
1130         public TerminalNode SEMICOLON() {\r
1131             return getToken(YangParser.SEMICOLON, 0);\r
1132         }\r
1133 \r
1134         public Identifier_stmtContext identifier_stmt() {\r
1135             return getRuleContext(Identifier_stmtContext.class, 0);\r
1136         }\r
1137 \r
1138         public StringContext string() {\r
1139             return getRuleContext(StringContext.class, 0);\r
1140         }\r
1141 \r
1142         public TerminalNode DEVIATE_KEYWORD() {\r
1143             return getToken(YangParser.DEVIATE_KEYWORD, 0);\r
1144         }\r
1145 \r
1146         public TerminalNode LEFT_BRACE() {\r
1147             return getToken(YangParser.LEFT_BRACE, 0);\r
1148         }\r
1149 \r
1150         public Deviate_not_supported_stmtContext(ParserRuleContext parent,\r
1151                 int invokingState) {\r
1152             super(parent, invokingState);\r
1153         }\r
1154 \r
1155         @Override\r
1156         public int getRuleIndex() {\r
1157             return RULE_deviate_not_supported_stmt;\r
1158         }\r
1159 \r
1160         @Override\r
1161         public void enterRule(ParseTreeListener listener) {\r
1162             if (listener instanceof YangParserListener)\r
1163                 ((YangParserListener) listener)\r
1164                         .enterDeviate_not_supported_stmt(this);\r
1165         }\r
1166 \r
1167         @Override\r
1168         public void exitRule(ParseTreeListener listener) {\r
1169             if (listener instanceof YangParserListener)\r
1170                 ((YangParserListener) listener)\r
1171                         .exitDeviate_not_supported_stmt(this);\r
1172         }\r
1173 \r
1174         @Override\r
1175         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
1176             if (visitor instanceof YangParserVisitor)\r
1177                 return ((YangParserVisitor<? extends T>) visitor)\r
1178                         .visitDeviate_not_supported_stmt(this);\r
1179             else\r
1180                 return visitor.visitChildren(this);\r
1181         }\r
1182     }\r
1183 \r
1184     public final Deviate_not_supported_stmtContext deviate_not_supported_stmt()\r
1185             throws RecognitionException {\r
1186         Deviate_not_supported_stmtContext _localctx = new Deviate_not_supported_stmtContext(\r
1187                 _ctx, getState());\r
1188         enterRule(_localctx, 14, RULE_deviate_not_supported_stmt);\r
1189         int _la;\r
1190         try {\r
1191             enterOuterAlt(_localctx, 1);\r
1192             {\r
1193                 setState(296);\r
1194                 match(DEVIATE_KEYWORD);\r
1195                 setState(297);\r
1196                 string();\r
1197                 setState(304);\r
1198                 switch (_input.LA(1)) {\r
1199                 case SEMICOLON: {\r
1200                     setState(298);\r
1201                     match(SEMICOLON);\r
1202                 }\r
1203                     break;\r
1204                 case LEFT_BRACE: {\r
1205                     {\r
1206                         setState(299);\r
1207                         match(LEFT_BRACE);\r
1208                         setState(301);\r
1209                         _la = _input.LA(1);\r
1210                         if (_la == IDENTIFIER) {\r
1211                             {\r
1212                                 setState(300);\r
1213                                 identifier_stmt();\r
1214                             }\r
1215                         }\r
1216 \r
1217                         setState(303);\r
1218                         match(RIGHT_BRACE);\r
1219                     }\r
1220                 }\r
1221                     break;\r
1222                 default:\r
1223                     throw new NoViableAltException(this);\r
1224                 }\r
1225             }\r
1226         } catch (RecognitionException re) {\r
1227             _localctx.exception = re;\r
1228             _errHandler.reportError(this, re);\r
1229             _errHandler.recover(this, re);\r
1230         } finally {\r
1231             exitRule();\r
1232         }\r
1233         return _localctx;\r
1234     }\r
1235 \r
1236     public static class Deviation_stmtContext extends ParserRuleContext {\r
1237         public TerminalNode RIGHT_BRACE() {\r
1238             return getToken(YangParser.RIGHT_BRACE, 0);\r
1239         }\r
1240 \r
1241         public List<Reference_stmtContext> reference_stmt() {\r
1242             return getRuleContexts(Reference_stmtContext.class);\r
1243         }\r
1244 \r
1245         public Description_stmtContext description_stmt(int i) {\r
1246             return getRuleContext(Description_stmtContext.class, i);\r
1247         }\r
1248 \r
1249         public TerminalNode DEVIATION_KEYWORD() {\r
1250             return getToken(YangParser.DEVIATION_KEYWORD, 0);\r
1251         }\r
1252 \r
1253         public Deviate_replace_stmtContext deviate_replace_stmt(int i) {\r
1254             return getRuleContext(Deviate_replace_stmtContext.class, i);\r
1255         }\r
1256 \r
1257         public TerminalNode LEFT_BRACE() {\r
1258             return getToken(YangParser.LEFT_BRACE, 0);\r
1259         }\r
1260 \r
1261         public Deviate_delete_stmtContext deviate_delete_stmt(int i) {\r
1262             return getRuleContext(Deviate_delete_stmtContext.class, i);\r
1263         }\r
1264 \r
1265         public List<Deviate_delete_stmtContext> deviate_delete_stmt() {\r
1266             return getRuleContexts(Deviate_delete_stmtContext.class);\r
1267         }\r
1268 \r
1269         public Deviate_add_stmtContext deviate_add_stmt(int i) {\r
1270             return getRuleContext(Deviate_add_stmtContext.class, i);\r
1271         }\r
1272 \r
1273         public List<Deviate_add_stmtContext> deviate_add_stmt() {\r
1274             return getRuleContexts(Deviate_add_stmtContext.class);\r
1275         }\r
1276 \r
1277         public StringContext string() {\r
1278             return getRuleContext(StringContext.class, 0);\r
1279         }\r
1280 \r
1281         public List<Deviate_replace_stmtContext> deviate_replace_stmt() {\r
1282             return getRuleContexts(Deviate_replace_stmtContext.class);\r
1283         }\r
1284 \r
1285         public List<Description_stmtContext> description_stmt() {\r
1286             return getRuleContexts(Description_stmtContext.class);\r
1287         }\r
1288 \r
1289         public List<Deviate_not_supported_stmtContext> deviate_not_supported_stmt() {\r
1290             return getRuleContexts(Deviate_not_supported_stmtContext.class);\r
1291         }\r
1292 \r
1293         public Deviate_not_supported_stmtContext deviate_not_supported_stmt(\r
1294                 int i) {\r
1295             return getRuleContext(Deviate_not_supported_stmtContext.class, i);\r
1296         }\r
1297 \r
1298         public Reference_stmtContext reference_stmt(int i) {\r
1299             return getRuleContext(Reference_stmtContext.class, i);\r
1300         }\r
1301 \r
1302         public Deviation_stmtContext(ParserRuleContext parent, int invokingState) {\r
1303             super(parent, invokingState);\r
1304         }\r
1305 \r
1306         @Override\r
1307         public int getRuleIndex() {\r
1308             return RULE_deviation_stmt;\r
1309         }\r
1310 \r
1311         @Override\r
1312         public void enterRule(ParseTreeListener listener) {\r
1313             if (listener instanceof YangParserListener)\r
1314                 ((YangParserListener) listener).enterDeviation_stmt(this);\r
1315         }\r
1316 \r
1317         @Override\r
1318         public void exitRule(ParseTreeListener listener) {\r
1319             if (listener instanceof YangParserListener)\r
1320                 ((YangParserListener) listener).exitDeviation_stmt(this);\r
1321         }\r
1322 \r
1323         @Override\r
1324         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
1325             if (visitor instanceof YangParserVisitor)\r
1326                 return ((YangParserVisitor<? extends T>) visitor)\r
1327                         .visitDeviation_stmt(this);\r
1328             else\r
1329                 return visitor.visitChildren(this);\r
1330         }\r
1331     }\r
1332 \r
1333     public final Deviation_stmtContext deviation_stmt()\r
1334             throws RecognitionException {\r
1335         Deviation_stmtContext _localctx = new Deviation_stmtContext(_ctx,\r
1336                 getState());\r
1337         enterRule(_localctx, 16, RULE_deviation_stmt);\r
1338         int _la;\r
1339         try {\r
1340             enterOuterAlt(_localctx, 1);\r
1341             {\r
1342                 setState(306);\r
1343                 match(DEVIATION_KEYWORD);\r
1344                 setState(307);\r
1345                 string();\r
1346                 setState(308);\r
1347                 match(LEFT_BRACE);\r
1348                 setState(315);\r
1349                 _errHandler.sync(this);\r
1350                 _la = _input.LA(1);\r
1351                 do {\r
1352                     {\r
1353                         setState(315);\r
1354                         switch (getInterpreter().adaptivePredict(_input, 17,\r
1355                                 _ctx)) {\r
1356                         case 1: {\r
1357                             setState(309);\r
1358                             description_stmt();\r
1359                         }\r
1360                             break;\r
1361 \r
1362                         case 2: {\r
1363                             setState(310);\r
1364                             reference_stmt();\r
1365                         }\r
1366                             break;\r
1367 \r
1368                         case 3: {\r
1369                             setState(311);\r
1370                             deviate_not_supported_stmt();\r
1371                         }\r
1372                             break;\r
1373 \r
1374                         case 4: {\r
1375                             setState(312);\r
1376                             deviate_add_stmt();\r
1377                         }\r
1378                             break;\r
1379 \r
1380                         case 5: {\r
1381                             setState(313);\r
1382                             deviate_replace_stmt();\r
1383                         }\r
1384                             break;\r
1385 \r
1386                         case 6: {\r
1387                             setState(314);\r
1388                             deviate_delete_stmt();\r
1389                         }\r
1390                             break;\r
1391                         }\r
1392                     }\r
1393                     setState(317);\r
1394                     _errHandler.sync(this);\r
1395                     _la = _input.LA(1);\r
1396                 } while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << REFERENCE_KEYWORD)\r
1397                         | (1L << DEVIATE_KEYWORD) | (1L << DESCRIPTION_KEYWORD))) != 0));\r
1398                 setState(319);\r
1399                 match(RIGHT_BRACE);\r
1400             }\r
1401         } catch (RecognitionException re) {\r
1402             _localctx.exception = re;\r
1403             _errHandler.reportError(this, re);\r
1404             _errHandler.recover(this, re);\r
1405         } finally {\r
1406             exitRule();\r
1407         }\r
1408         return _localctx;\r
1409     }\r
1410 \r
1411     public static class Notification_stmtContext extends ParserRuleContext {\r
1412         public List<Grouping_stmtContext> grouping_stmt() {\r
1413             return getRuleContexts(Grouping_stmtContext.class);\r
1414         }\r
1415 \r
1416         public TerminalNode RIGHT_BRACE() {\r
1417             return getToken(YangParser.RIGHT_BRACE, 0);\r
1418         }\r
1419 \r
1420         public List<Reference_stmtContext> reference_stmt() {\r
1421             return getRuleContexts(Reference_stmtContext.class);\r
1422         }\r
1423 \r
1424         public Typedef_stmtContext typedef_stmt(int i) {\r
1425             return getRuleContext(Typedef_stmtContext.class, i);\r
1426         }\r
1427 \r
1428         public Description_stmtContext description_stmt(int i) {\r
1429             return getRuleContext(Description_stmtContext.class, i);\r
1430         }\r
1431 \r
1432         public Grouping_stmtContext grouping_stmt(int i) {\r
1433             return getRuleContext(Grouping_stmtContext.class, i);\r
1434         }\r
1435 \r
1436         public If_feature_stmtContext if_feature_stmt(int i) {\r
1437             return getRuleContext(If_feature_stmtContext.class, i);\r
1438         }\r
1439 \r
1440         public TerminalNode LEFT_BRACE() {\r
1441             return getToken(YangParser.LEFT_BRACE, 0);\r
1442         }\r
1443 \r
1444         public Data_def_stmtContext data_def_stmt(int i) {\r
1445             return getRuleContext(Data_def_stmtContext.class, i);\r
1446         }\r
1447 \r
1448         public List<Typedef_stmtContext> typedef_stmt() {\r
1449             return getRuleContexts(Typedef_stmtContext.class);\r
1450         }\r
1451 \r
1452         public Status_stmtContext status_stmt(int i) {\r
1453             return getRuleContext(Status_stmtContext.class, i);\r
1454         }\r
1455 \r
1456         public List<If_feature_stmtContext> if_feature_stmt() {\r
1457             return getRuleContexts(If_feature_stmtContext.class);\r
1458         }\r
1459 \r
1460         public List<Data_def_stmtContext> data_def_stmt() {\r
1461             return getRuleContexts(Data_def_stmtContext.class);\r
1462         }\r
1463 \r
1464         public TerminalNode SEMICOLON() {\r
1465             return getToken(YangParser.SEMICOLON, 0);\r
1466         }\r
1467 \r
1468         public List<Status_stmtContext> status_stmt() {\r
1469             return getRuleContexts(Status_stmtContext.class);\r
1470         }\r
1471 \r
1472         public StringContext string() {\r
1473             return getRuleContext(StringContext.class, 0);\r
1474         }\r
1475 \r
1476         public List<Description_stmtContext> description_stmt() {\r
1477             return getRuleContexts(Description_stmtContext.class);\r
1478         }\r
1479 \r
1480         public Reference_stmtContext reference_stmt(int i) {\r
1481             return getRuleContext(Reference_stmtContext.class, i);\r
1482         }\r
1483 \r
1484         public TerminalNode NOTIFICATION_KEYWORD() {\r
1485             return getToken(YangParser.NOTIFICATION_KEYWORD, 0);\r
1486         }\r
1487 \r
1488         public Notification_stmtContext(ParserRuleContext parent,\r
1489                 int invokingState) {\r
1490             super(parent, invokingState);\r
1491         }\r
1492 \r
1493         @Override\r
1494         public int getRuleIndex() {\r
1495             return RULE_notification_stmt;\r
1496         }\r
1497 \r
1498         @Override\r
1499         public void enterRule(ParseTreeListener listener) {\r
1500             if (listener instanceof YangParserListener)\r
1501                 ((YangParserListener) listener).enterNotification_stmt(this);\r
1502         }\r
1503 \r
1504         @Override\r
1505         public void exitRule(ParseTreeListener listener) {\r
1506             if (listener instanceof YangParserListener)\r
1507                 ((YangParserListener) listener).exitNotification_stmt(this);\r
1508         }\r
1509 \r
1510         @Override\r
1511         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
1512             if (visitor instanceof YangParserVisitor)\r
1513                 return ((YangParserVisitor<? extends T>) visitor)\r
1514                         .visitNotification_stmt(this);\r
1515             else\r
1516                 return visitor.visitChildren(this);\r
1517         }\r
1518     }\r
1519 \r
1520     public final Notification_stmtContext notification_stmt()\r
1521             throws RecognitionException {\r
1522         Notification_stmtContext _localctx = new Notification_stmtContext(_ctx,\r
1523                 getState());\r
1524         enterRule(_localctx, 18, RULE_notification_stmt);\r
1525         int _la;\r
1526         try {\r
1527             enterOuterAlt(_localctx, 1);\r
1528             {\r
1529                 setState(321);\r
1530                 match(NOTIFICATION_KEYWORD);\r
1531                 setState(322);\r
1532                 string();\r
1533                 setState(338);\r
1534                 switch (_input.LA(1)) {\r
1535                 case SEMICOLON: {\r
1536                     setState(323);\r
1537                     match(SEMICOLON);\r
1538                 }\r
1539                     break;\r
1540                 case LEFT_BRACE: {\r
1541                     {\r
1542                         setState(324);\r
1543                         match(LEFT_BRACE);\r
1544                         setState(334);\r
1545                         _errHandler.sync(this);\r
1546                         _la = _input.LA(1);\r
1547                         while (((((_la - 12)) & ~0x3f) == 0 && ((1L << (_la - 12)) & ((1L << (USES_KEYWORD - 12))\r
1548                                 | (1L << (TYPEDEF_KEYWORD - 12))\r
1549                                 | (1L << (STATUS_KEYWORD - 12))\r
1550                                 | (1L << (REFERENCE_KEYWORD - 12))\r
1551                                 | (1L << (LIST_KEYWORD - 12))\r
1552                                 | (1L << (LEAF_LIST_KEYWORD - 12))\r
1553                                 | (1L << (LEAF_KEYWORD - 12))\r
1554                                 | (1L << (IF_FEATURE_KEYWORD - 12))\r
1555                                 | (1L << (GROUPING_KEYWORD - 12))\r
1556                                 | (1L << (DESCRIPTION_KEYWORD - 12))\r
1557                                 | (1L << (CONTAINER_KEYWORD - 12))\r
1558                                 | (1L << (CHOICE_KEYWORD - 12)) | (1L << (ANYXML_KEYWORD - 12)))) != 0)) {\r
1559                             {\r
1560                                 setState(332);\r
1561                                 switch (_input.LA(1)) {\r
1562                                 case IF_FEATURE_KEYWORD: {\r
1563                                     setState(325);\r
1564                                     if_feature_stmt();\r
1565                                 }\r
1566                                     break;\r
1567                                 case STATUS_KEYWORD: {\r
1568                                     setState(326);\r
1569                                     status_stmt();\r
1570                                 }\r
1571                                     break;\r
1572                                 case DESCRIPTION_KEYWORD: {\r
1573                                     setState(327);\r
1574                                     description_stmt();\r
1575                                 }\r
1576                                     break;\r
1577                                 case REFERENCE_KEYWORD: {\r
1578                                     setState(328);\r
1579                                     reference_stmt();\r
1580                                 }\r
1581                                     break;\r
1582                                 case TYPEDEF_KEYWORD: {\r
1583                                     setState(329);\r
1584                                     typedef_stmt();\r
1585                                 }\r
1586                                     break;\r
1587                                 case GROUPING_KEYWORD: {\r
1588                                     setState(330);\r
1589                                     grouping_stmt();\r
1590                                 }\r
1591                                     break;\r
1592                                 case USES_KEYWORD:\r
1593                                 case LIST_KEYWORD:\r
1594                                 case LEAF_LIST_KEYWORD:\r
1595                                 case LEAF_KEYWORD:\r
1596                                 case CONTAINER_KEYWORD:\r
1597                                 case CHOICE_KEYWORD:\r
1598                                 case ANYXML_KEYWORD: {\r
1599                                     setState(331);\r
1600                                     data_def_stmt();\r
1601                                 }\r
1602                                     break;\r
1603                                 default:\r
1604                                     throw new NoViableAltException(this);\r
1605                                 }\r
1606                             }\r
1607                             setState(336);\r
1608                             _errHandler.sync(this);\r
1609                             _la = _input.LA(1);\r
1610                         }\r
1611                         setState(337);\r
1612                         match(RIGHT_BRACE);\r
1613                     }\r
1614                 }\r
1615                     break;\r
1616                 default:\r
1617                     throw new NoViableAltException(this);\r
1618                 }\r
1619             }\r
1620         } catch (RecognitionException re) {\r
1621             _localctx.exception = re;\r
1622             _errHandler.reportError(this, re);\r
1623             _errHandler.recover(this, re);\r
1624         } finally {\r
1625             exitRule();\r
1626         }\r
1627         return _localctx;\r
1628     }\r
1629 \r
1630     public static class Output_stmtContext extends ParserRuleContext {\r
1631         public List<Grouping_stmtContext> grouping_stmt() {\r
1632             return getRuleContexts(Grouping_stmtContext.class);\r
1633         }\r
1634 \r
1635         public TerminalNode RIGHT_BRACE() {\r
1636             return getToken(YangParser.RIGHT_BRACE, 0);\r
1637         }\r
1638 \r
1639         public Typedef_stmtContext typedef_stmt(int i) {\r
1640             return getRuleContext(Typedef_stmtContext.class, i);\r
1641         }\r
1642 \r
1643         public List<Data_def_stmtContext> data_def_stmt() {\r
1644             return getRuleContexts(Data_def_stmtContext.class);\r
1645         }\r
1646 \r
1647         public Grouping_stmtContext grouping_stmt(int i) {\r
1648             return getRuleContext(Grouping_stmtContext.class, i);\r
1649         }\r
1650 \r
1651         public TerminalNode OUTPUT_KEYWORD() {\r
1652             return getToken(YangParser.OUTPUT_KEYWORD, 0);\r
1653         }\r
1654 \r
1655         public TerminalNode LEFT_BRACE() {\r
1656             return getToken(YangParser.LEFT_BRACE, 0);\r
1657         }\r
1658 \r
1659         public Data_def_stmtContext data_def_stmt(int i) {\r
1660             return getRuleContext(Data_def_stmtContext.class, i);\r
1661         }\r
1662 \r
1663         public List<Typedef_stmtContext> typedef_stmt() {\r
1664             return getRuleContexts(Typedef_stmtContext.class);\r
1665         }\r
1666 \r
1667         public Output_stmtContext(ParserRuleContext parent, int invokingState) {\r
1668             super(parent, invokingState);\r
1669         }\r
1670 \r
1671         @Override\r
1672         public int getRuleIndex() {\r
1673             return RULE_output_stmt;\r
1674         }\r
1675 \r
1676         @Override\r
1677         public void enterRule(ParseTreeListener listener) {\r
1678             if (listener instanceof YangParserListener)\r
1679                 ((YangParserListener) listener).enterOutput_stmt(this);\r
1680         }\r
1681 \r
1682         @Override\r
1683         public void exitRule(ParseTreeListener listener) {\r
1684             if (listener instanceof YangParserListener)\r
1685                 ((YangParserListener) listener).exitOutput_stmt(this);\r
1686         }\r
1687 \r
1688         @Override\r
1689         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
1690             if (visitor instanceof YangParserVisitor)\r
1691                 return ((YangParserVisitor<? extends T>) visitor)\r
1692                         .visitOutput_stmt(this);\r
1693             else\r
1694                 return visitor.visitChildren(this);\r
1695         }\r
1696     }\r
1697 \r
1698     public final Output_stmtContext output_stmt() throws RecognitionException {\r
1699         Output_stmtContext _localctx = new Output_stmtContext(_ctx, getState());\r
1700         enterRule(_localctx, 20, RULE_output_stmt);\r
1701         int _la;\r
1702         try {\r
1703             enterOuterAlt(_localctx, 1);\r
1704             {\r
1705                 setState(340);\r
1706                 match(OUTPUT_KEYWORD);\r
1707                 setState(341);\r
1708                 match(LEFT_BRACE);\r
1709                 setState(345);\r
1710                 _errHandler.sync(this);\r
1711                 _la = _input.LA(1);\r
1712                 do {\r
1713                     {\r
1714                         setState(345);\r
1715                         switch (_input.LA(1)) {\r
1716                         case TYPEDEF_KEYWORD: {\r
1717                             setState(342);\r
1718                             typedef_stmt();\r
1719                         }\r
1720                             break;\r
1721                         case GROUPING_KEYWORD: {\r
1722                             setState(343);\r
1723                             grouping_stmt();\r
1724                         }\r
1725                             break;\r
1726                         case USES_KEYWORD:\r
1727                         case LIST_KEYWORD:\r
1728                         case LEAF_LIST_KEYWORD:\r
1729                         case LEAF_KEYWORD:\r
1730                         case CONTAINER_KEYWORD:\r
1731                         case CHOICE_KEYWORD:\r
1732                         case ANYXML_KEYWORD: {\r
1733                             setState(344);\r
1734                             data_def_stmt();\r
1735                         }\r
1736                             break;\r
1737                         default:\r
1738                             throw new NoViableAltException(this);\r
1739                         }\r
1740                     }\r
1741                     setState(347);\r
1742                     _errHandler.sync(this);\r
1743                     _la = _input.LA(1);\r
1744                 } while (((((_la - 12)) & ~0x3f) == 0 && ((1L << (_la - 12)) & ((1L << (USES_KEYWORD - 12))\r
1745                         | (1L << (TYPEDEF_KEYWORD - 12))\r
1746                         | (1L << (LIST_KEYWORD - 12))\r
1747                         | (1L << (LEAF_LIST_KEYWORD - 12))\r
1748                         | (1L << (LEAF_KEYWORD - 12))\r
1749                         | (1L << (GROUPING_KEYWORD - 12))\r
1750                         | (1L << (CONTAINER_KEYWORD - 12))\r
1751                         | (1L << (CHOICE_KEYWORD - 12)) | (1L << (ANYXML_KEYWORD - 12)))) != 0));\r
1752                 setState(349);\r
1753                 match(RIGHT_BRACE);\r
1754             }\r
1755         } catch (RecognitionException re) {\r
1756             _localctx.exception = re;\r
1757             _errHandler.reportError(this, re);\r
1758             _errHandler.recover(this, re);\r
1759         } finally {\r
1760             exitRule();\r
1761         }\r
1762         return _localctx;\r
1763     }\r
1764 \r
1765     public static class Input_stmtContext extends ParserRuleContext {\r
1766         public List<Grouping_stmtContext> grouping_stmt() {\r
1767             return getRuleContexts(Grouping_stmtContext.class);\r
1768         }\r
1769 \r
1770         public TerminalNode RIGHT_BRACE() {\r
1771             return getToken(YangParser.RIGHT_BRACE, 0);\r
1772         }\r
1773 \r
1774         public Typedef_stmtContext typedef_stmt(int i) {\r
1775             return getRuleContext(Typedef_stmtContext.class, i);\r
1776         }\r
1777 \r
1778         public TerminalNode INPUT_KEYWORD() {\r
1779             return getToken(YangParser.INPUT_KEYWORD, 0);\r
1780         }\r
1781 \r
1782         public List<Data_def_stmtContext> data_def_stmt() {\r
1783             return getRuleContexts(Data_def_stmtContext.class);\r
1784         }\r
1785 \r
1786         public Grouping_stmtContext grouping_stmt(int i) {\r
1787             return getRuleContext(Grouping_stmtContext.class, i);\r
1788         }\r
1789 \r
1790         public TerminalNode LEFT_BRACE() {\r
1791             return getToken(YangParser.LEFT_BRACE, 0);\r
1792         }\r
1793 \r
1794         public Data_def_stmtContext data_def_stmt(int i) {\r
1795             return getRuleContext(Data_def_stmtContext.class, i);\r
1796         }\r
1797 \r
1798         public List<Typedef_stmtContext> typedef_stmt() {\r
1799             return getRuleContexts(Typedef_stmtContext.class);\r
1800         }\r
1801 \r
1802         public Input_stmtContext(ParserRuleContext parent, int invokingState) {\r
1803             super(parent, invokingState);\r
1804         }\r
1805 \r
1806         @Override\r
1807         public int getRuleIndex() {\r
1808             return RULE_input_stmt;\r
1809         }\r
1810 \r
1811         @Override\r
1812         public void enterRule(ParseTreeListener listener) {\r
1813             if (listener instanceof YangParserListener)\r
1814                 ((YangParserListener) listener).enterInput_stmt(this);\r
1815         }\r
1816 \r
1817         @Override\r
1818         public void exitRule(ParseTreeListener listener) {\r
1819             if (listener instanceof YangParserListener)\r
1820                 ((YangParserListener) listener).exitInput_stmt(this);\r
1821         }\r
1822 \r
1823         @Override\r
1824         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
1825             if (visitor instanceof YangParserVisitor)\r
1826                 return ((YangParserVisitor<? extends T>) visitor)\r
1827                         .visitInput_stmt(this);\r
1828             else\r
1829                 return visitor.visitChildren(this);\r
1830         }\r
1831     }\r
1832 \r
1833     public final Input_stmtContext input_stmt() throws RecognitionException {\r
1834         Input_stmtContext _localctx = new Input_stmtContext(_ctx, getState());\r
1835         enterRule(_localctx, 22, RULE_input_stmt);\r
1836         int _la;\r
1837         try {\r
1838             enterOuterAlt(_localctx, 1);\r
1839             {\r
1840                 setState(351);\r
1841                 match(INPUT_KEYWORD);\r
1842                 setState(352);\r
1843                 match(LEFT_BRACE);\r
1844                 setState(356);\r
1845                 _errHandler.sync(this);\r
1846                 _la = _input.LA(1);\r
1847                 do {\r
1848                     {\r
1849                         setState(356);\r
1850                         switch (_input.LA(1)) {\r
1851                         case TYPEDEF_KEYWORD: {\r
1852                             setState(353);\r
1853                             typedef_stmt();\r
1854                         }\r
1855                             break;\r
1856                         case GROUPING_KEYWORD: {\r
1857                             setState(354);\r
1858                             grouping_stmt();\r
1859                         }\r
1860                             break;\r
1861                         case USES_KEYWORD:\r
1862                         case LIST_KEYWORD:\r
1863                         case LEAF_LIST_KEYWORD:\r
1864                         case LEAF_KEYWORD:\r
1865                         case CONTAINER_KEYWORD:\r
1866                         case CHOICE_KEYWORD:\r
1867                         case ANYXML_KEYWORD: {\r
1868                             setState(355);\r
1869                             data_def_stmt();\r
1870                         }\r
1871                             break;\r
1872                         default:\r
1873                             throw new NoViableAltException(this);\r
1874                         }\r
1875                     }\r
1876                     setState(358);\r
1877                     _errHandler.sync(this);\r
1878                     _la = _input.LA(1);\r
1879                 } while (((((_la - 12)) & ~0x3f) == 0 && ((1L << (_la - 12)) & ((1L << (USES_KEYWORD - 12))\r
1880                         | (1L << (TYPEDEF_KEYWORD - 12))\r
1881                         | (1L << (LIST_KEYWORD - 12))\r
1882                         | (1L << (LEAF_LIST_KEYWORD - 12))\r
1883                         | (1L << (LEAF_KEYWORD - 12))\r
1884                         | (1L << (GROUPING_KEYWORD - 12))\r
1885                         | (1L << (CONTAINER_KEYWORD - 12))\r
1886                         | (1L << (CHOICE_KEYWORD - 12)) | (1L << (ANYXML_KEYWORD - 12)))) != 0));\r
1887                 setState(360);\r
1888                 match(RIGHT_BRACE);\r
1889             }\r
1890         } catch (RecognitionException re) {\r
1891             _localctx.exception = re;\r
1892             _errHandler.reportError(this, re);\r
1893             _errHandler.recover(this, re);\r
1894         } finally {\r
1895             exitRule();\r
1896         }\r
1897         return _localctx;\r
1898     }\r
1899 \r
1900     public static class Rpc_stmtContext extends ParserRuleContext {\r
1901         public List<Grouping_stmtContext> grouping_stmt() {\r
1902             return getRuleContexts(Grouping_stmtContext.class);\r
1903         }\r
1904 \r
1905         public TerminalNode RIGHT_BRACE() {\r
1906             return getToken(YangParser.RIGHT_BRACE, 0);\r
1907         }\r
1908 \r
1909         public Output_stmtContext output_stmt(int i) {\r
1910             return getRuleContext(Output_stmtContext.class, i);\r
1911         }\r
1912 \r
1913         public List<Reference_stmtContext> reference_stmt() {\r
1914             return getRuleContexts(Reference_stmtContext.class);\r
1915         }\r
1916 \r
1917         public Typedef_stmtContext typedef_stmt(int i) {\r
1918             return getRuleContext(Typedef_stmtContext.class, i);\r
1919         }\r
1920 \r
1921         public Description_stmtContext description_stmt(int i) {\r
1922             return getRuleContext(Description_stmtContext.class, i);\r
1923         }\r
1924 \r
1925         public Grouping_stmtContext grouping_stmt(int i) {\r
1926             return getRuleContext(Grouping_stmtContext.class, i);\r
1927         }\r
1928 \r
1929         public Input_stmtContext input_stmt(int i) {\r
1930             return getRuleContext(Input_stmtContext.class, i);\r
1931         }\r
1932 \r
1933         public List<Input_stmtContext> input_stmt() {\r
1934             return getRuleContexts(Input_stmtContext.class);\r
1935         }\r
1936 \r
1937         public If_feature_stmtContext if_feature_stmt(int i) {\r
1938             return getRuleContext(If_feature_stmtContext.class, i);\r
1939         }\r
1940 \r
1941         public TerminalNode LEFT_BRACE() {\r
1942             return getToken(YangParser.LEFT_BRACE, 0);\r
1943         }\r
1944 \r
1945         public List<Typedef_stmtContext> typedef_stmt() {\r
1946             return getRuleContexts(Typedef_stmtContext.class);\r
1947         }\r
1948 \r
1949         public Status_stmtContext status_stmt(int i) {\r
1950             return getRuleContext(Status_stmtContext.class, i);\r
1951         }\r
1952 \r
1953         public List<If_feature_stmtContext> if_feature_stmt() {\r
1954             return getRuleContexts(If_feature_stmtContext.class);\r
1955         }\r
1956 \r
1957         public TerminalNode SEMICOLON() {\r
1958             return getToken(YangParser.SEMICOLON, 0);\r
1959         }\r
1960 \r
1961         public List<Status_stmtContext> status_stmt() {\r
1962             return getRuleContexts(Status_stmtContext.class);\r
1963         }\r
1964 \r
1965         public StringContext string() {\r
1966             return getRuleContext(StringContext.class, 0);\r
1967         }\r
1968 \r
1969         public List<Description_stmtContext> description_stmt() {\r
1970             return getRuleContexts(Description_stmtContext.class);\r
1971         }\r
1972 \r
1973         public Reference_stmtContext reference_stmt(int i) {\r
1974             return getRuleContext(Reference_stmtContext.class, i);\r
1975         }\r
1976 \r
1977         public List<Output_stmtContext> output_stmt() {\r
1978             return getRuleContexts(Output_stmtContext.class);\r
1979         }\r
1980 \r
1981         public TerminalNode RPC_KEYWORD() {\r
1982             return getToken(YangParser.RPC_KEYWORD, 0);\r
1983         }\r
1984 \r
1985         public Rpc_stmtContext(ParserRuleContext parent, int invokingState) {\r
1986             super(parent, invokingState);\r
1987         }\r
1988 \r
1989         @Override\r
1990         public int getRuleIndex() {\r
1991             return RULE_rpc_stmt;\r
1992         }\r
1993 \r
1994         @Override\r
1995         public void enterRule(ParseTreeListener listener) {\r
1996             if (listener instanceof YangParserListener)\r
1997                 ((YangParserListener) listener).enterRpc_stmt(this);\r
1998         }\r
1999 \r
2000         @Override\r
2001         public void exitRule(ParseTreeListener listener) {\r
2002             if (listener instanceof YangParserListener)\r
2003                 ((YangParserListener) listener).exitRpc_stmt(this);\r
2004         }\r
2005 \r
2006         @Override\r
2007         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
2008             if (visitor instanceof YangParserVisitor)\r
2009                 return ((YangParserVisitor<? extends T>) visitor)\r
2010                         .visitRpc_stmt(this);\r
2011             else\r
2012                 return visitor.visitChildren(this);\r
2013         }\r
2014     }\r
2015 \r
2016     public final Rpc_stmtContext rpc_stmt() throws RecognitionException {\r
2017         Rpc_stmtContext _localctx = new Rpc_stmtContext(_ctx, getState());\r
2018         enterRule(_localctx, 24, RULE_rpc_stmt);\r
2019         int _la;\r
2020         try {\r
2021             enterOuterAlt(_localctx, 1);\r
2022             {\r
2023                 setState(362);\r
2024                 match(RPC_KEYWORD);\r
2025                 setState(363);\r
2026                 string();\r
2027                 setState(380);\r
2028                 switch (_input.LA(1)) {\r
2029                 case SEMICOLON: {\r
2030                     setState(364);\r
2031                     match(SEMICOLON);\r
2032                 }\r
2033                     break;\r
2034                 case LEFT_BRACE: {\r
2035                     {\r
2036                         setState(365);\r
2037                         match(LEFT_BRACE);\r
2038                         setState(376);\r
2039                         _errHandler.sync(this);\r
2040                         _la = _input.LA(1);\r
2041                         while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << TYPEDEF_KEYWORD)\r
2042                                 | (1L << STATUS_KEYWORD)\r
2043                                 | (1L << REFERENCE_KEYWORD)\r
2044                                 | (1L << OUTPUT_KEYWORD)\r
2045                                 | (1L << INPUT_KEYWORD)\r
2046                                 | (1L << IF_FEATURE_KEYWORD)\r
2047                                 | (1L << GROUPING_KEYWORD) | (1L << DESCRIPTION_KEYWORD))) != 0)) {\r
2048                             {\r
2049                                 setState(374);\r
2050                                 switch (_input.LA(1)) {\r
2051                                 case IF_FEATURE_KEYWORD: {\r
2052                                     setState(366);\r
2053                                     if_feature_stmt();\r
2054                                 }\r
2055                                     break;\r
2056                                 case STATUS_KEYWORD: {\r
2057                                     setState(367);\r
2058                                     status_stmt();\r
2059                                 }\r
2060                                     break;\r
2061                                 case DESCRIPTION_KEYWORD: {\r
2062                                     setState(368);\r
2063                                     description_stmt();\r
2064                                 }\r
2065                                     break;\r
2066                                 case REFERENCE_KEYWORD: {\r
2067                                     setState(369);\r
2068                                     reference_stmt();\r
2069                                 }\r
2070                                     break;\r
2071                                 case TYPEDEF_KEYWORD: {\r
2072                                     setState(370);\r
2073                                     typedef_stmt();\r
2074                                 }\r
2075                                     break;\r
2076                                 case GROUPING_KEYWORD: {\r
2077                                     setState(371);\r
2078                                     grouping_stmt();\r
2079                                 }\r
2080                                     break;\r
2081                                 case INPUT_KEYWORD: {\r
2082                                     setState(372);\r
2083                                     input_stmt();\r
2084                                 }\r
2085                                     break;\r
2086                                 case OUTPUT_KEYWORD: {\r
2087                                     setState(373);\r
2088                                     output_stmt();\r
2089                                 }\r
2090                                     break;\r
2091                                 default:\r
2092                                     throw new NoViableAltException(this);\r
2093                                 }\r
2094                             }\r
2095                             setState(378);\r
2096                             _errHandler.sync(this);\r
2097                             _la = _input.LA(1);\r
2098                         }\r
2099                         setState(379);\r
2100                         match(RIGHT_BRACE);\r
2101                     }\r
2102                 }\r
2103                     break;\r
2104                 default:\r
2105                     throw new NoViableAltException(this);\r
2106                 }\r
2107             }\r
2108         } catch (RecognitionException re) {\r
2109             _localctx.exception = re;\r
2110             _errHandler.reportError(this, re);\r
2111             _errHandler.recover(this, re);\r
2112         } finally {\r
2113             exitRule();\r
2114         }\r
2115         return _localctx;\r
2116     }\r
2117 \r
2118     public static class When_stmtContext extends ParserRuleContext {\r
2119         public TerminalNode RIGHT_BRACE() {\r
2120             return getToken(YangParser.RIGHT_BRACE, 0);\r
2121         }\r
2122 \r
2123         public List<Reference_stmtContext> reference_stmt() {\r
2124             return getRuleContexts(Reference_stmtContext.class);\r
2125         }\r
2126 \r
2127         public Description_stmtContext description_stmt(int i) {\r
2128             return getRuleContext(Description_stmtContext.class, i);\r
2129         }\r
2130 \r
2131         public TerminalNode WHEN_KEYWORD() {\r
2132             return getToken(YangParser.WHEN_KEYWORD, 0);\r
2133         }\r
2134 \r
2135         public TerminalNode SEMICOLON() {\r
2136             return getToken(YangParser.SEMICOLON, 0);\r
2137         }\r
2138 \r
2139         public StringContext string() {\r
2140             return getRuleContext(StringContext.class, 0);\r
2141         }\r
2142 \r
2143         public List<Description_stmtContext> description_stmt() {\r
2144             return getRuleContexts(Description_stmtContext.class);\r
2145         }\r
2146 \r
2147         public TerminalNode LEFT_BRACE() {\r
2148             return getToken(YangParser.LEFT_BRACE, 0);\r
2149         }\r
2150 \r
2151         public Reference_stmtContext reference_stmt(int i) {\r
2152             return getRuleContext(Reference_stmtContext.class, i);\r
2153         }\r
2154 \r
2155         public When_stmtContext(ParserRuleContext parent, int invokingState) {\r
2156             super(parent, invokingState);\r
2157         }\r
2158 \r
2159         @Override\r
2160         public int getRuleIndex() {\r
2161             return RULE_when_stmt;\r
2162         }\r
2163 \r
2164         @Override\r
2165         public void enterRule(ParseTreeListener listener) {\r
2166             if (listener instanceof YangParserListener)\r
2167                 ((YangParserListener) listener).enterWhen_stmt(this);\r
2168         }\r
2169 \r
2170         @Override\r
2171         public void exitRule(ParseTreeListener listener) {\r
2172             if (listener instanceof YangParserListener)\r
2173                 ((YangParserListener) listener).exitWhen_stmt(this);\r
2174         }\r
2175 \r
2176         @Override\r
2177         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
2178             if (visitor instanceof YangParserVisitor)\r
2179                 return ((YangParserVisitor<? extends T>) visitor)\r
2180                         .visitWhen_stmt(this);\r
2181             else\r
2182                 return visitor.visitChildren(this);\r
2183         }\r
2184     }\r
2185 \r
2186     public final When_stmtContext when_stmt() throws RecognitionException {\r
2187         When_stmtContext _localctx = new When_stmtContext(_ctx, getState());\r
2188         enterRule(_localctx, 26, RULE_when_stmt);\r
2189         int _la;\r
2190         try {\r
2191             enterOuterAlt(_localctx, 1);\r
2192             {\r
2193                 setState(382);\r
2194                 match(WHEN_KEYWORD);\r
2195                 setState(383);\r
2196                 string();\r
2197                 setState(394);\r
2198                 switch (_input.LA(1)) {\r
2199                 case SEMICOLON: {\r
2200                     setState(384);\r
2201                     match(SEMICOLON);\r
2202                 }\r
2203                     break;\r
2204                 case LEFT_BRACE: {\r
2205                     {\r
2206                         setState(385);\r
2207                         match(LEFT_BRACE);\r
2208                         setState(390);\r
2209                         _errHandler.sync(this);\r
2210                         _la = _input.LA(1);\r
2211                         while (_la == REFERENCE_KEYWORD\r
2212                                 || _la == DESCRIPTION_KEYWORD) {\r
2213                             {\r
2214                                 setState(388);\r
2215                                 switch (_input.LA(1)) {\r
2216                                 case DESCRIPTION_KEYWORD: {\r
2217                                     setState(386);\r
2218                                     description_stmt();\r
2219                                 }\r
2220                                     break;\r
2221                                 case REFERENCE_KEYWORD: {\r
2222                                     setState(387);\r
2223                                     reference_stmt();\r
2224                                 }\r
2225                                     break;\r
2226                                 default:\r
2227                                     throw new NoViableAltException(this);\r
2228                                 }\r
2229                             }\r
2230                             setState(392);\r
2231                             _errHandler.sync(this);\r
2232                             _la = _input.LA(1);\r
2233                         }\r
2234                         setState(393);\r
2235                         match(RIGHT_BRACE);\r
2236                     }\r
2237                 }\r
2238                     break;\r
2239                 default:\r
2240                     throw new NoViableAltException(this);\r
2241                 }\r
2242             }\r
2243         } catch (RecognitionException re) {\r
2244             _localctx.exception = re;\r
2245             _errHandler.reportError(this, re);\r
2246             _errHandler.recover(this, re);\r
2247         } finally {\r
2248             exitRule();\r
2249         }\r
2250         return _localctx;\r
2251     }\r
2252 \r
2253     public static class Augment_stmtContext extends ParserRuleContext {\r
2254         public TerminalNode RIGHT_BRACE() {\r
2255             return getToken(YangParser.RIGHT_BRACE, 0);\r
2256         }\r
2257 \r
2258         public List<Reference_stmtContext> reference_stmt() {\r
2259             return getRuleContexts(Reference_stmtContext.class);\r
2260         }\r
2261 \r
2262         public Description_stmtContext description_stmt(int i) {\r
2263             return getRuleContext(Description_stmtContext.class, i);\r
2264         }\r
2265 \r
2266         public List<When_stmtContext> when_stmt() {\r
2267             return getRuleContexts(When_stmtContext.class);\r
2268         }\r
2269 \r
2270         public List<Case_stmtContext> case_stmt() {\r
2271             return getRuleContexts(Case_stmtContext.class);\r
2272         }\r
2273 \r
2274         public TerminalNode AUGMENT_KEYWORD() {\r
2275             return getToken(YangParser.AUGMENT_KEYWORD, 0);\r
2276         }\r
2277 \r
2278         public If_feature_stmtContext if_feature_stmt(int i) {\r
2279             return getRuleContext(If_feature_stmtContext.class, i);\r
2280         }\r
2281 \r
2282         public TerminalNode LEFT_BRACE() {\r
2283             return getToken(YangParser.LEFT_BRACE, 0);\r
2284         }\r
2285 \r
2286         public Data_def_stmtContext data_def_stmt(int i) {\r
2287             return getRuleContext(Data_def_stmtContext.class, i);\r
2288         }\r
2289 \r
2290         public Status_stmtContext status_stmt(int i) {\r
2291             return getRuleContext(Status_stmtContext.class, i);\r
2292         }\r
2293 \r
2294         public List<If_feature_stmtContext> if_feature_stmt() {\r
2295             return getRuleContexts(If_feature_stmtContext.class);\r
2296         }\r
2297 \r
2298         public Identifier_stmtContext identifier_stmt(int i) {\r
2299             return getRuleContext(Identifier_stmtContext.class, i);\r
2300         }\r
2301 \r
2302         public List<Data_def_stmtContext> data_def_stmt() {\r
2303             return getRuleContexts(Data_def_stmtContext.class);\r
2304         }\r
2305 \r
2306         public List<Status_stmtContext> status_stmt() {\r
2307             return getRuleContexts(Status_stmtContext.class);\r
2308         }\r
2309 \r
2310         public StringContext string() {\r
2311             return getRuleContext(StringContext.class, 0);\r
2312         }\r
2313 \r
2314         public List<Identifier_stmtContext> identifier_stmt() {\r
2315             return getRuleContexts(Identifier_stmtContext.class);\r
2316         }\r
2317 \r
2318         public List<Description_stmtContext> description_stmt() {\r
2319             return getRuleContexts(Description_stmtContext.class);\r
2320         }\r
2321 \r
2322         public Reference_stmtContext reference_stmt(int i) {\r
2323             return getRuleContext(Reference_stmtContext.class, i);\r
2324         }\r
2325 \r
2326         public When_stmtContext when_stmt(int i) {\r
2327             return getRuleContext(When_stmtContext.class, i);\r
2328         }\r
2329 \r
2330         public Case_stmtContext case_stmt(int i) {\r
2331             return getRuleContext(Case_stmtContext.class, i);\r
2332         }\r
2333 \r
2334         public Augment_stmtContext(ParserRuleContext parent, int invokingState) {\r
2335             super(parent, invokingState);\r
2336         }\r
2337 \r
2338         @Override\r
2339         public int getRuleIndex() {\r
2340             return RULE_augment_stmt;\r
2341         }\r
2342 \r
2343         @Override\r
2344         public void enterRule(ParseTreeListener listener) {\r
2345             if (listener instanceof YangParserListener)\r
2346                 ((YangParserListener) listener).enterAugment_stmt(this);\r
2347         }\r
2348 \r
2349         @Override\r
2350         public void exitRule(ParseTreeListener listener) {\r
2351             if (listener instanceof YangParserListener)\r
2352                 ((YangParserListener) listener).exitAugment_stmt(this);\r
2353         }\r
2354 \r
2355         @Override\r
2356         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
2357             if (visitor instanceof YangParserVisitor)\r
2358                 return ((YangParserVisitor<? extends T>) visitor)\r
2359                         .visitAugment_stmt(this);\r
2360             else\r
2361                 return visitor.visitChildren(this);\r
2362         }\r
2363     }\r
2364 \r
2365     public final Augment_stmtContext augment_stmt() throws RecognitionException {\r
2366         Augment_stmtContext _localctx = new Augment_stmtContext(_ctx,\r
2367                 getState());\r
2368         enterRule(_localctx, 28, RULE_augment_stmt);\r
2369         int _la;\r
2370         try {\r
2371             enterOuterAlt(_localctx, 1);\r
2372             {\r
2373                 setState(396);\r
2374                 match(AUGMENT_KEYWORD);\r
2375                 setState(397);\r
2376                 string();\r
2377                 setState(398);\r
2378                 match(LEFT_BRACE);\r
2379                 setState(407);\r
2380                 _errHandler.sync(this);\r
2381                 _la = _input.LA(1);\r
2382                 do {\r
2383                     {\r
2384                         setState(407);\r
2385                         switch (_input.LA(1)) {\r
2386                         case IDENTIFIER: {\r
2387                             setState(399);\r
2388                             identifier_stmt();\r
2389                         }\r
2390                             break;\r
2391                         case WHEN_KEYWORD: {\r
2392                             setState(400);\r
2393                             when_stmt();\r
2394                         }\r
2395                             break;\r
2396                         case IF_FEATURE_KEYWORD: {\r
2397                             setState(401);\r
2398                             if_feature_stmt();\r
2399                         }\r
2400                             break;\r
2401                         case STATUS_KEYWORD: {\r
2402                             setState(402);\r
2403                             status_stmt();\r
2404                         }\r
2405                             break;\r
2406                         case DESCRIPTION_KEYWORD: {\r
2407                             setState(403);\r
2408                             description_stmt();\r
2409                         }\r
2410                             break;\r
2411                         case REFERENCE_KEYWORD: {\r
2412                             setState(404);\r
2413                             reference_stmt();\r
2414                         }\r
2415                             break;\r
2416                         case USES_KEYWORD:\r
2417                         case LIST_KEYWORD:\r
2418                         case LEAF_LIST_KEYWORD:\r
2419                         case LEAF_KEYWORD:\r
2420                         case CONTAINER_KEYWORD:\r
2421                         case CHOICE_KEYWORD:\r
2422                         case ANYXML_KEYWORD: {\r
2423                             setState(405);\r
2424                             data_def_stmt();\r
2425                         }\r
2426                             break;\r
2427                         case CASE_KEYWORD: {\r
2428                             setState(406);\r
2429                             case_stmt();\r
2430                         }\r
2431                             break;\r
2432                         default:\r
2433                             throw new NoViableAltException(this);\r
2434                         }\r
2435                     }\r
2436                     setState(409);\r
2437                     _errHandler.sync(this);\r
2438                     _la = _input.LA(1);\r
2439                 } while (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (WHEN_KEYWORD - 10))\r
2440                         | (1L << (USES_KEYWORD - 10))\r
2441                         | (1L << (STATUS_KEYWORD - 10))\r
2442                         | (1L << (REFERENCE_KEYWORD - 10))\r
2443                         | (1L << (LIST_KEYWORD - 10))\r
2444                         | (1L << (LEAF_LIST_KEYWORD - 10))\r
2445                         | (1L << (LEAF_KEYWORD - 10))\r
2446                         | (1L << (IF_FEATURE_KEYWORD - 10))\r
2447                         | (1L << (DESCRIPTION_KEYWORD - 10))\r
2448                         | (1L << (CONTAINER_KEYWORD - 10))\r
2449                         | (1L << (CHOICE_KEYWORD - 10))\r
2450                         | (1L << (CASE_KEYWORD - 10))\r
2451                         | (1L << (ANYXML_KEYWORD - 10)) | (1L << (IDENTIFIER - 10)))) != 0));\r
2452                 setState(411);\r
2453                 match(RIGHT_BRACE);\r
2454             }\r
2455         } catch (RecognitionException re) {\r
2456             _localctx.exception = re;\r
2457             _errHandler.reportError(this, re);\r
2458             _errHandler.recover(this, re);\r
2459         } finally {\r
2460             exitRule();\r
2461         }\r
2462         return _localctx;\r
2463     }\r
2464 \r
2465     public static class Uses_augment_stmtContext extends ParserRuleContext {\r
2466         public TerminalNode RIGHT_BRACE() {\r
2467             return getToken(YangParser.RIGHT_BRACE, 0);\r
2468         }\r
2469 \r
2470         public List<Reference_stmtContext> reference_stmt() {\r
2471             return getRuleContexts(Reference_stmtContext.class);\r
2472         }\r
2473 \r
2474         public Description_stmtContext description_stmt(int i) {\r
2475             return getRuleContext(Description_stmtContext.class, i);\r
2476         }\r
2477 \r
2478         public List<When_stmtContext> when_stmt() {\r
2479             return getRuleContexts(When_stmtContext.class);\r
2480         }\r
2481 \r
2482         public List<Case_stmtContext> case_stmt() {\r
2483             return getRuleContexts(Case_stmtContext.class);\r
2484         }\r
2485 \r
2486         public TerminalNode AUGMENT_KEYWORD() {\r
2487             return getToken(YangParser.AUGMENT_KEYWORD, 0);\r
2488         }\r
2489 \r
2490         public If_feature_stmtContext if_feature_stmt(int i) {\r
2491             return getRuleContext(If_feature_stmtContext.class, i);\r
2492         }\r
2493 \r
2494         public TerminalNode LEFT_BRACE() {\r
2495             return getToken(YangParser.LEFT_BRACE, 0);\r
2496         }\r
2497 \r
2498         public Data_def_stmtContext data_def_stmt(int i) {\r
2499             return getRuleContext(Data_def_stmtContext.class, i);\r
2500         }\r
2501 \r
2502         public Status_stmtContext status_stmt(int i) {\r
2503             return getRuleContext(Status_stmtContext.class, i);\r
2504         }\r
2505 \r
2506         public List<If_feature_stmtContext> if_feature_stmt() {\r
2507             return getRuleContexts(If_feature_stmtContext.class);\r
2508         }\r
2509 \r
2510         public Identifier_stmtContext identifier_stmt(int i) {\r
2511             return getRuleContext(Identifier_stmtContext.class, i);\r
2512         }\r
2513 \r
2514         public List<Data_def_stmtContext> data_def_stmt() {\r
2515             return getRuleContexts(Data_def_stmtContext.class);\r
2516         }\r
2517 \r
2518         public List<Status_stmtContext> status_stmt() {\r
2519             return getRuleContexts(Status_stmtContext.class);\r
2520         }\r
2521 \r
2522         public StringContext string() {\r
2523             return getRuleContext(StringContext.class, 0);\r
2524         }\r
2525 \r
2526         public List<Identifier_stmtContext> identifier_stmt() {\r
2527             return getRuleContexts(Identifier_stmtContext.class);\r
2528         }\r
2529 \r
2530         public List<Description_stmtContext> description_stmt() {\r
2531             return getRuleContexts(Description_stmtContext.class);\r
2532         }\r
2533 \r
2534         public Reference_stmtContext reference_stmt(int i) {\r
2535             return getRuleContext(Reference_stmtContext.class, i);\r
2536         }\r
2537 \r
2538         public When_stmtContext when_stmt(int i) {\r
2539             return getRuleContext(When_stmtContext.class, i);\r
2540         }\r
2541 \r
2542         public Case_stmtContext case_stmt(int i) {\r
2543             return getRuleContext(Case_stmtContext.class, i);\r
2544         }\r
2545 \r
2546         public Uses_augment_stmtContext(ParserRuleContext parent,\r
2547                 int invokingState) {\r
2548             super(parent, invokingState);\r
2549         }\r
2550 \r
2551         @Override\r
2552         public int getRuleIndex() {\r
2553             return RULE_uses_augment_stmt;\r
2554         }\r
2555 \r
2556         @Override\r
2557         public void enterRule(ParseTreeListener listener) {\r
2558             if (listener instanceof YangParserListener)\r
2559                 ((YangParserListener) listener).enterUses_augment_stmt(this);\r
2560         }\r
2561 \r
2562         @Override\r
2563         public void exitRule(ParseTreeListener listener) {\r
2564             if (listener instanceof YangParserListener)\r
2565                 ((YangParserListener) listener).exitUses_augment_stmt(this);\r
2566         }\r
2567 \r
2568         @Override\r
2569         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
2570             if (visitor instanceof YangParserVisitor)\r
2571                 return ((YangParserVisitor<? extends T>) visitor)\r
2572                         .visitUses_augment_stmt(this);\r
2573             else\r
2574                 return visitor.visitChildren(this);\r
2575         }\r
2576     }\r
2577 \r
2578     public final Uses_augment_stmtContext uses_augment_stmt()\r
2579             throws RecognitionException {\r
2580         Uses_augment_stmtContext _localctx = new Uses_augment_stmtContext(_ctx,\r
2581                 getState());\r
2582         enterRule(_localctx, 30, RULE_uses_augment_stmt);\r
2583         int _la;\r
2584         try {\r
2585             enterOuterAlt(_localctx, 1);\r
2586             {\r
2587                 setState(413);\r
2588                 match(AUGMENT_KEYWORD);\r
2589                 setState(414);\r
2590                 string();\r
2591                 setState(415);\r
2592                 match(LEFT_BRACE);\r
2593                 setState(424);\r
2594                 _errHandler.sync(this);\r
2595                 _la = _input.LA(1);\r
2596                 do {\r
2597                     {\r
2598                         setState(424);\r
2599                         switch (_input.LA(1)) {\r
2600                         case IDENTIFIER: {\r
2601                             setState(416);\r
2602                             identifier_stmt();\r
2603                         }\r
2604                             break;\r
2605                         case WHEN_KEYWORD: {\r
2606                             setState(417);\r
2607                             when_stmt();\r
2608                         }\r
2609                             break;\r
2610                         case IF_FEATURE_KEYWORD: {\r
2611                             setState(418);\r
2612                             if_feature_stmt();\r
2613                         }\r
2614                             break;\r
2615                         case STATUS_KEYWORD: {\r
2616                             setState(419);\r
2617                             status_stmt();\r
2618                         }\r
2619                             break;\r
2620                         case DESCRIPTION_KEYWORD: {\r
2621                             setState(420);\r
2622                             description_stmt();\r
2623                         }\r
2624                             break;\r
2625                         case REFERENCE_KEYWORD: {\r
2626                             setState(421);\r
2627                             reference_stmt();\r
2628                         }\r
2629                             break;\r
2630                         case USES_KEYWORD:\r
2631                         case LIST_KEYWORD:\r
2632                         case LEAF_LIST_KEYWORD:\r
2633                         case LEAF_KEYWORD:\r
2634                         case CONTAINER_KEYWORD:\r
2635                         case CHOICE_KEYWORD:\r
2636                         case ANYXML_KEYWORD: {\r
2637                             setState(422);\r
2638                             data_def_stmt();\r
2639                         }\r
2640                             break;\r
2641                         case CASE_KEYWORD: {\r
2642                             setState(423);\r
2643                             case_stmt();\r
2644                         }\r
2645                             break;\r
2646                         default:\r
2647                             throw new NoViableAltException(this);\r
2648                         }\r
2649                     }\r
2650                     setState(426);\r
2651                     _errHandler.sync(this);\r
2652                     _la = _input.LA(1);\r
2653                 } while (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (WHEN_KEYWORD - 10))\r
2654                         | (1L << (USES_KEYWORD - 10))\r
2655                         | (1L << (STATUS_KEYWORD - 10))\r
2656                         | (1L << (REFERENCE_KEYWORD - 10))\r
2657                         | (1L << (LIST_KEYWORD - 10))\r
2658                         | (1L << (LEAF_LIST_KEYWORD - 10))\r
2659                         | (1L << (LEAF_KEYWORD - 10))\r
2660                         | (1L << (IF_FEATURE_KEYWORD - 10))\r
2661                         | (1L << (DESCRIPTION_KEYWORD - 10))\r
2662                         | (1L << (CONTAINER_KEYWORD - 10))\r
2663                         | (1L << (CHOICE_KEYWORD - 10))\r
2664                         | (1L << (CASE_KEYWORD - 10))\r
2665                         | (1L << (ANYXML_KEYWORD - 10)) | (1L << (IDENTIFIER - 10)))) != 0));\r
2666                 setState(428);\r
2667                 match(RIGHT_BRACE);\r
2668             }\r
2669         } catch (RecognitionException re) {\r
2670             _localctx.exception = re;\r
2671             _errHandler.reportError(this, re);\r
2672             _errHandler.recover(this, re);\r
2673         } finally {\r
2674             exitRule();\r
2675         }\r
2676         return _localctx;\r
2677     }\r
2678 \r
2679     public static class Refine_anyxml_stmtsContext extends ParserRuleContext {\r
2680         public List<Reference_stmtContext> reference_stmt() {\r
2681             return getRuleContexts(Reference_stmtContext.class);\r
2682         }\r
2683 \r
2684         public Description_stmtContext description_stmt(int i) {\r
2685             return getRuleContext(Description_stmtContext.class, i);\r
2686         }\r
2687 \r
2688         public Mandatory_stmtContext mandatory_stmt(int i) {\r
2689             return getRuleContext(Mandatory_stmtContext.class, i);\r
2690         }\r
2691 \r
2692         public Config_stmtContext config_stmt(int i) {\r
2693             return getRuleContext(Config_stmtContext.class, i);\r
2694         }\r
2695 \r
2696         public List<Config_stmtContext> config_stmt() {\r
2697             return getRuleContexts(Config_stmtContext.class);\r
2698         }\r
2699 \r
2700         public List<Must_stmtContext> must_stmt() {\r
2701             return getRuleContexts(Must_stmtContext.class);\r
2702         }\r
2703 \r
2704         public List<Description_stmtContext> description_stmt() {\r
2705             return getRuleContexts(Description_stmtContext.class);\r
2706         }\r
2707 \r
2708         public Reference_stmtContext reference_stmt(int i) {\r
2709             return getRuleContext(Reference_stmtContext.class, i);\r
2710         }\r
2711 \r
2712         public List<Mandatory_stmtContext> mandatory_stmt() {\r
2713             return getRuleContexts(Mandatory_stmtContext.class);\r
2714         }\r
2715 \r
2716         public Must_stmtContext must_stmt(int i) {\r
2717             return getRuleContext(Must_stmtContext.class, i);\r
2718         }\r
2719 \r
2720         public Refine_anyxml_stmtsContext(ParserRuleContext parent,\r
2721                 int invokingState) {\r
2722             super(parent, invokingState);\r
2723         }\r
2724 \r
2725         @Override\r
2726         public int getRuleIndex() {\r
2727             return RULE_refine_anyxml_stmts;\r
2728         }\r
2729 \r
2730         @Override\r
2731         public void enterRule(ParseTreeListener listener) {\r
2732             if (listener instanceof YangParserListener)\r
2733                 ((YangParserListener) listener).enterRefine_anyxml_stmts(this);\r
2734         }\r
2735 \r
2736         @Override\r
2737         public void exitRule(ParseTreeListener listener) {\r
2738             if (listener instanceof YangParserListener)\r
2739                 ((YangParserListener) listener).exitRefine_anyxml_stmts(this);\r
2740         }\r
2741 \r
2742         @Override\r
2743         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
2744             if (visitor instanceof YangParserVisitor)\r
2745                 return ((YangParserVisitor<? extends T>) visitor)\r
2746                         .visitRefine_anyxml_stmts(this);\r
2747             else\r
2748                 return visitor.visitChildren(this);\r
2749         }\r
2750     }\r
2751 \r
2752     public final Refine_anyxml_stmtsContext refine_anyxml_stmts()\r
2753             throws RecognitionException {\r
2754         Refine_anyxml_stmtsContext _localctx = new Refine_anyxml_stmtsContext(\r
2755                 _ctx, getState());\r
2756         enterRule(_localctx, 32, RULE_refine_anyxml_stmts);\r
2757         try {\r
2758             int _alt;\r
2759             enterOuterAlt(_localctx, 1);\r
2760             {\r
2761                 setState(437);\r
2762                 _errHandler.sync(this);\r
2763                 _alt = getInterpreter().adaptivePredict(_input, 37, _ctx);\r
2764                 while (_alt != 2 && _alt != -1) {\r
2765                     if (_alt == 1) {\r
2766                         {\r
2767                             setState(435);\r
2768                             switch (_input.LA(1)) {\r
2769                             case MUST_KEYWORD: {\r
2770                                 setState(430);\r
2771                                 must_stmt();\r
2772                             }\r
2773                                 break;\r
2774                             case CONFIG_KEYWORD: {\r
2775                                 setState(431);\r
2776                                 config_stmt();\r
2777                             }\r
2778                                 break;\r
2779                             case MANDATORY_KEYWORD: {\r
2780                                 setState(432);\r
2781                                 mandatory_stmt();\r
2782                             }\r
2783                                 break;\r
2784                             case DESCRIPTION_KEYWORD: {\r
2785                                 setState(433);\r
2786                                 description_stmt();\r
2787                             }\r
2788                                 break;\r
2789                             case REFERENCE_KEYWORD: {\r
2790                                 setState(434);\r
2791                                 reference_stmt();\r
2792                             }\r
2793                                 break;\r
2794                             default:\r
2795                                 throw new NoViableAltException(this);\r
2796                             }\r
2797                         }\r
2798                     }\r
2799                     setState(439);\r
2800                     _errHandler.sync(this);\r
2801                     _alt = getInterpreter().adaptivePredict(_input, 37, _ctx);\r
2802                 }\r
2803             }\r
2804         } catch (RecognitionException re) {\r
2805             _localctx.exception = re;\r
2806             _errHandler.reportError(this, re);\r
2807             _errHandler.recover(this, re);\r
2808         } finally {\r
2809             exitRule();\r
2810         }\r
2811         return _localctx;\r
2812     }\r
2813 \r
2814     public static class Refine_case_stmtsContext extends ParserRuleContext {\r
2815         public List<Reference_stmtContext> reference_stmt() {\r
2816             return getRuleContexts(Reference_stmtContext.class);\r
2817         }\r
2818 \r
2819         public Description_stmtContext description_stmt(int i) {\r
2820             return getRuleContext(Description_stmtContext.class, i);\r
2821         }\r
2822 \r
2823         public List<Description_stmtContext> description_stmt() {\r
2824             return getRuleContexts(Description_stmtContext.class);\r
2825         }\r
2826 \r
2827         public Reference_stmtContext reference_stmt(int i) {\r
2828             return getRuleContext(Reference_stmtContext.class, i);\r
2829         }\r
2830 \r
2831         public Refine_case_stmtsContext(ParserRuleContext parent,\r
2832                 int invokingState) {\r
2833             super(parent, invokingState);\r
2834         }\r
2835 \r
2836         @Override\r
2837         public int getRuleIndex() {\r
2838             return RULE_refine_case_stmts;\r
2839         }\r
2840 \r
2841         @Override\r
2842         public void enterRule(ParseTreeListener listener) {\r
2843             if (listener instanceof YangParserListener)\r
2844                 ((YangParserListener) listener).enterRefine_case_stmts(this);\r
2845         }\r
2846 \r
2847         @Override\r
2848         public void exitRule(ParseTreeListener listener) {\r
2849             if (listener instanceof YangParserListener)\r
2850                 ((YangParserListener) listener).exitRefine_case_stmts(this);\r
2851         }\r
2852 \r
2853         @Override\r
2854         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
2855             if (visitor instanceof YangParserVisitor)\r
2856                 return ((YangParserVisitor<? extends T>) visitor)\r
2857                         .visitRefine_case_stmts(this);\r
2858             else\r
2859                 return visitor.visitChildren(this);\r
2860         }\r
2861     }\r
2862 \r
2863     public final Refine_case_stmtsContext refine_case_stmts()\r
2864             throws RecognitionException {\r
2865         Refine_case_stmtsContext _localctx = new Refine_case_stmtsContext(_ctx,\r
2866                 getState());\r
2867         enterRule(_localctx, 34, RULE_refine_case_stmts);\r
2868         try {\r
2869             int _alt;\r
2870             enterOuterAlt(_localctx, 1);\r
2871             {\r
2872                 setState(444);\r
2873                 _errHandler.sync(this);\r
2874                 _alt = getInterpreter().adaptivePredict(_input, 39, _ctx);\r
2875                 while (_alt != 2 && _alt != -1) {\r
2876                     if (_alt == 1) {\r
2877                         {\r
2878                             setState(442);\r
2879                             switch (_input.LA(1)) {\r
2880                             case DESCRIPTION_KEYWORD: {\r
2881                                 setState(440);\r
2882                                 description_stmt();\r
2883                             }\r
2884                                 break;\r
2885                             case REFERENCE_KEYWORD: {\r
2886                                 setState(441);\r
2887                                 reference_stmt();\r
2888                             }\r
2889                                 break;\r
2890                             default:\r
2891                                 throw new NoViableAltException(this);\r
2892                             }\r
2893                         }\r
2894                     }\r
2895                     setState(446);\r
2896                     _errHandler.sync(this);\r
2897                     _alt = getInterpreter().adaptivePredict(_input, 39, _ctx);\r
2898                 }\r
2899             }\r
2900         } catch (RecognitionException re) {\r
2901             _localctx.exception = re;\r
2902             _errHandler.reportError(this, re);\r
2903             _errHandler.recover(this, re);\r
2904         } finally {\r
2905             exitRule();\r
2906         }\r
2907         return _localctx;\r
2908     }\r
2909 \r
2910     public static class Refine_choice_stmtsContext extends ParserRuleContext {\r
2911         public List<Reference_stmtContext> reference_stmt() {\r
2912             return getRuleContexts(Reference_stmtContext.class);\r
2913         }\r
2914 \r
2915         public List<Default_stmtContext> default_stmt() {\r
2916             return getRuleContexts(Default_stmtContext.class);\r
2917         }\r
2918 \r
2919         public Description_stmtContext description_stmt(int i) {\r
2920             return getRuleContext(Description_stmtContext.class, i);\r
2921         }\r
2922 \r
2923         public Default_stmtContext default_stmt(int i) {\r
2924             return getRuleContext(Default_stmtContext.class, i);\r
2925         }\r
2926 \r
2927         public Mandatory_stmtContext mandatory_stmt(int i) {\r
2928             return getRuleContext(Mandatory_stmtContext.class, i);\r
2929         }\r
2930 \r
2931         public Config_stmtContext config_stmt(int i) {\r
2932             return getRuleContext(Config_stmtContext.class, i);\r
2933         }\r
2934 \r
2935         public List<Config_stmtContext> config_stmt() {\r
2936             return getRuleContexts(Config_stmtContext.class);\r
2937         }\r
2938 \r
2939         public List<Description_stmtContext> description_stmt() {\r
2940             return getRuleContexts(Description_stmtContext.class);\r
2941         }\r
2942 \r
2943         public Reference_stmtContext reference_stmt(int i) {\r
2944             return getRuleContext(Reference_stmtContext.class, i);\r
2945         }\r
2946 \r
2947         public List<Mandatory_stmtContext> mandatory_stmt() {\r
2948             return getRuleContexts(Mandatory_stmtContext.class);\r
2949         }\r
2950 \r
2951         public Refine_choice_stmtsContext(ParserRuleContext parent,\r
2952                 int invokingState) {\r
2953             super(parent, invokingState);\r
2954         }\r
2955 \r
2956         @Override\r
2957         public int getRuleIndex() {\r
2958             return RULE_refine_choice_stmts;\r
2959         }\r
2960 \r
2961         @Override\r
2962         public void enterRule(ParseTreeListener listener) {\r
2963             if (listener instanceof YangParserListener)\r
2964                 ((YangParserListener) listener).enterRefine_choice_stmts(this);\r
2965         }\r
2966 \r
2967         @Override\r
2968         public void exitRule(ParseTreeListener listener) {\r
2969             if (listener instanceof YangParserListener)\r
2970                 ((YangParserListener) listener).exitRefine_choice_stmts(this);\r
2971         }\r
2972 \r
2973         @Override\r
2974         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
2975             if (visitor instanceof YangParserVisitor)\r
2976                 return ((YangParserVisitor<? extends T>) visitor)\r
2977                         .visitRefine_choice_stmts(this);\r
2978             else\r
2979                 return visitor.visitChildren(this);\r
2980         }\r
2981     }\r
2982 \r
2983     public final Refine_choice_stmtsContext refine_choice_stmts()\r
2984             throws RecognitionException {\r
2985         Refine_choice_stmtsContext _localctx = new Refine_choice_stmtsContext(\r
2986                 _ctx, getState());\r
2987         enterRule(_localctx, 36, RULE_refine_choice_stmts);\r
2988         try {\r
2989             int _alt;\r
2990             enterOuterAlt(_localctx, 1);\r
2991             {\r
2992                 setState(454);\r
2993                 _errHandler.sync(this);\r
2994                 _alt = getInterpreter().adaptivePredict(_input, 41, _ctx);\r
2995                 while (_alt != 2 && _alt != -1) {\r
2996                     if (_alt == 1) {\r
2997                         {\r
2998                             setState(452);\r
2999                             switch (_input.LA(1)) {\r
3000                             case DEFAULT_KEYWORD: {\r
3001                                 setState(447);\r
3002                                 default_stmt();\r
3003                             }\r
3004                                 break;\r
3005                             case CONFIG_KEYWORD: {\r
3006                                 setState(448);\r
3007                                 config_stmt();\r
3008                             }\r
3009                                 break;\r
3010                             case MANDATORY_KEYWORD: {\r
3011                                 setState(449);\r
3012                                 mandatory_stmt();\r
3013                             }\r
3014                                 break;\r
3015                             case DESCRIPTION_KEYWORD: {\r
3016                                 setState(450);\r
3017                                 description_stmt();\r
3018                             }\r
3019                                 break;\r
3020                             case REFERENCE_KEYWORD: {\r
3021                                 setState(451);\r
3022                                 reference_stmt();\r
3023                             }\r
3024                                 break;\r
3025                             default:\r
3026                                 throw new NoViableAltException(this);\r
3027                             }\r
3028                         }\r
3029                     }\r
3030                     setState(456);\r
3031                     _errHandler.sync(this);\r
3032                     _alt = getInterpreter().adaptivePredict(_input, 41, _ctx);\r
3033                 }\r
3034             }\r
3035         } catch (RecognitionException re) {\r
3036             _localctx.exception = re;\r
3037             _errHandler.reportError(this, re);\r
3038             _errHandler.recover(this, re);\r
3039         } finally {\r
3040             exitRule();\r
3041         }\r
3042         return _localctx;\r
3043     }\r
3044 \r
3045     public static class Refine_list_stmtsContext extends ParserRuleContext {\r
3046         public List<Reference_stmtContext> reference_stmt() {\r
3047             return getRuleContexts(Reference_stmtContext.class);\r
3048         }\r
3049 \r
3050         public Description_stmtContext description_stmt(int i) {\r
3051             return getRuleContext(Description_stmtContext.class, i);\r
3052         }\r
3053 \r
3054         public Config_stmtContext config_stmt(int i) {\r
3055             return getRuleContext(Config_stmtContext.class, i);\r
3056         }\r
3057 \r
3058         public List<Min_elements_stmtContext> min_elements_stmt() {\r
3059             return getRuleContexts(Min_elements_stmtContext.class);\r
3060         }\r
3061 \r
3062         public List<Max_elements_stmtContext> max_elements_stmt() {\r
3063             return getRuleContexts(Max_elements_stmtContext.class);\r
3064         }\r
3065 \r
3066         public List<Config_stmtContext> config_stmt() {\r
3067             return getRuleContexts(Config_stmtContext.class);\r
3068         }\r
3069 \r
3070         public List<Must_stmtContext> must_stmt() {\r
3071             return getRuleContexts(Must_stmtContext.class);\r
3072         }\r
3073 \r
3074         public Max_elements_stmtContext max_elements_stmt(int i) {\r
3075             return getRuleContext(Max_elements_stmtContext.class, i);\r
3076         }\r
3077 \r
3078         public List<Description_stmtContext> description_stmt() {\r
3079             return getRuleContexts(Description_stmtContext.class);\r
3080         }\r
3081 \r
3082         public Reference_stmtContext reference_stmt(int i) {\r
3083             return getRuleContext(Reference_stmtContext.class, i);\r
3084         }\r
3085 \r
3086         public Must_stmtContext must_stmt(int i) {\r
3087             return getRuleContext(Must_stmtContext.class, i);\r
3088         }\r
3089 \r
3090         public Min_elements_stmtContext min_elements_stmt(int i) {\r
3091             return getRuleContext(Min_elements_stmtContext.class, i);\r
3092         }\r
3093 \r
3094         public Refine_list_stmtsContext(ParserRuleContext parent,\r
3095                 int invokingState) {\r
3096             super(parent, invokingState);\r
3097         }\r
3098 \r
3099         @Override\r
3100         public int getRuleIndex() {\r
3101             return RULE_refine_list_stmts;\r
3102         }\r
3103 \r
3104         @Override\r
3105         public void enterRule(ParseTreeListener listener) {\r
3106             if (listener instanceof YangParserListener)\r
3107                 ((YangParserListener) listener).enterRefine_list_stmts(this);\r
3108         }\r
3109 \r
3110         @Override\r
3111         public void exitRule(ParseTreeListener listener) {\r
3112             if (listener instanceof YangParserListener)\r
3113                 ((YangParserListener) listener).exitRefine_list_stmts(this);\r
3114         }\r
3115 \r
3116         @Override\r
3117         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
3118             if (visitor instanceof YangParserVisitor)\r
3119                 return ((YangParserVisitor<? extends T>) visitor)\r
3120                         .visitRefine_list_stmts(this);\r
3121             else\r
3122                 return visitor.visitChildren(this);\r
3123         }\r
3124     }\r
3125 \r
3126     public final Refine_list_stmtsContext refine_list_stmts()\r
3127             throws RecognitionException {\r
3128         Refine_list_stmtsContext _localctx = new Refine_list_stmtsContext(_ctx,\r
3129                 getState());\r
3130         enterRule(_localctx, 38, RULE_refine_list_stmts);\r
3131         try {\r
3132             int _alt;\r
3133             enterOuterAlt(_localctx, 1);\r
3134             {\r
3135                 setState(465);\r
3136                 _errHandler.sync(this);\r
3137                 _alt = getInterpreter().adaptivePredict(_input, 43, _ctx);\r
3138                 while (_alt != 2 && _alt != -1) {\r
3139                     if (_alt == 1) {\r
3140                         {\r
3141                             setState(463);\r
3142                             switch (_input.LA(1)) {\r
3143                             case MUST_KEYWORD: {\r
3144                                 setState(457);\r
3145                                 must_stmt();\r
3146                             }\r
3147                                 break;\r
3148                             case CONFIG_KEYWORD: {\r
3149                                 setState(458);\r
3150                                 config_stmt();\r
3151                             }\r
3152                                 break;\r
3153                             case MIN_ELEMENTS_KEYWORD: {\r
3154                                 setState(459);\r
3155                                 min_elements_stmt();\r
3156                             }\r
3157                                 break;\r
3158                             case MAX_ELEMENTS_KEYWORD: {\r
3159                                 setState(460);\r
3160                                 max_elements_stmt();\r
3161                             }\r
3162                                 break;\r
3163                             case DESCRIPTION_KEYWORD: {\r
3164                                 setState(461);\r
3165                                 description_stmt();\r
3166                             }\r
3167                                 break;\r
3168                             case REFERENCE_KEYWORD: {\r
3169                                 setState(462);\r
3170                                 reference_stmt();\r
3171                             }\r
3172                                 break;\r
3173                             default:\r
3174                                 throw new NoViableAltException(this);\r
3175                             }\r
3176                         }\r
3177                     }\r
3178                     setState(467);\r
3179                     _errHandler.sync(this);\r
3180                     _alt = getInterpreter().adaptivePredict(_input, 43, _ctx);\r
3181                 }\r
3182             }\r
3183         } catch (RecognitionException re) {\r
3184             _localctx.exception = re;\r
3185             _errHandler.reportError(this, re);\r
3186             _errHandler.recover(this, re);\r
3187         } finally {\r
3188             exitRule();\r
3189         }\r
3190         return _localctx;\r
3191     }\r
3192 \r
3193     public static class Refine_leaf_list_stmtsContext extends ParserRuleContext {\r
3194         public List<Reference_stmtContext> reference_stmt() {\r
3195             return getRuleContexts(Reference_stmtContext.class);\r
3196         }\r
3197 \r
3198         public Description_stmtContext description_stmt(int i) {\r
3199             return getRuleContext(Description_stmtContext.class, i);\r
3200         }\r
3201 \r
3202         public Config_stmtContext config_stmt(int i) {\r
3203             return getRuleContext(Config_stmtContext.class, i);\r
3204         }\r
3205 \r
3206         public List<Min_elements_stmtContext> min_elements_stmt() {\r
3207             return getRuleContexts(Min_elements_stmtContext.class);\r
3208         }\r
3209 \r
3210         public List<Max_elements_stmtContext> max_elements_stmt() {\r
3211             return getRuleContexts(Max_elements_stmtContext.class);\r
3212         }\r
3213 \r
3214         public List<Config_stmtContext> config_stmt() {\r
3215             return getRuleContexts(Config_stmtContext.class);\r
3216         }\r
3217 \r
3218         public List<Must_stmtContext> must_stmt() {\r
3219             return getRuleContexts(Must_stmtContext.class);\r
3220         }\r
3221 \r
3222         public Max_elements_stmtContext max_elements_stmt(int i) {\r
3223             return getRuleContext(Max_elements_stmtContext.class, i);\r
3224         }\r
3225 \r
3226         public List<Description_stmtContext> description_stmt() {\r
3227             return getRuleContexts(Description_stmtContext.class);\r
3228         }\r
3229 \r
3230         public Reference_stmtContext reference_stmt(int i) {\r
3231             return getRuleContext(Reference_stmtContext.class, i);\r
3232         }\r
3233 \r
3234         public Must_stmtContext must_stmt(int i) {\r
3235             return getRuleContext(Must_stmtContext.class, i);\r
3236         }\r
3237 \r
3238         public Min_elements_stmtContext min_elements_stmt(int i) {\r
3239             return getRuleContext(Min_elements_stmtContext.class, i);\r
3240         }\r
3241 \r
3242         public Refine_leaf_list_stmtsContext(ParserRuleContext parent,\r
3243                 int invokingState) {\r
3244             super(parent, invokingState);\r
3245         }\r
3246 \r
3247         @Override\r
3248         public int getRuleIndex() {\r
3249             return RULE_refine_leaf_list_stmts;\r
3250         }\r
3251 \r
3252         @Override\r
3253         public void enterRule(ParseTreeListener listener) {\r
3254             if (listener instanceof YangParserListener)\r
3255                 ((YangParserListener) listener)\r
3256                         .enterRefine_leaf_list_stmts(this);\r
3257         }\r
3258 \r
3259         @Override\r
3260         public void exitRule(ParseTreeListener listener) {\r
3261             if (listener instanceof YangParserListener)\r
3262                 ((YangParserListener) listener)\r
3263                         .exitRefine_leaf_list_stmts(this);\r
3264         }\r
3265 \r
3266         @Override\r
3267         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
3268             if (visitor instanceof YangParserVisitor)\r
3269                 return ((YangParserVisitor<? extends T>) visitor)\r
3270                         .visitRefine_leaf_list_stmts(this);\r
3271             else\r
3272                 return visitor.visitChildren(this);\r
3273         }\r
3274     }\r
3275 \r
3276     public final Refine_leaf_list_stmtsContext refine_leaf_list_stmts()\r
3277             throws RecognitionException {\r
3278         Refine_leaf_list_stmtsContext _localctx = new Refine_leaf_list_stmtsContext(\r
3279                 _ctx, getState());\r
3280         enterRule(_localctx, 40, RULE_refine_leaf_list_stmts);\r
3281         try {\r
3282             int _alt;\r
3283             enterOuterAlt(_localctx, 1);\r
3284             {\r
3285                 setState(476);\r
3286                 _errHandler.sync(this);\r
3287                 _alt = getInterpreter().adaptivePredict(_input, 45, _ctx);\r
3288                 while (_alt != 2 && _alt != -1) {\r
3289                     if (_alt == 1) {\r
3290                         {\r
3291                             setState(474);\r
3292                             switch (_input.LA(1)) {\r
3293                             case MUST_KEYWORD: {\r
3294                                 setState(468);\r
3295                                 must_stmt();\r
3296                             }\r
3297                                 break;\r
3298                             case CONFIG_KEYWORD: {\r
3299                                 setState(469);\r
3300                                 config_stmt();\r
3301                             }\r
3302                                 break;\r
3303                             case MIN_ELEMENTS_KEYWORD: {\r
3304                                 setState(470);\r
3305                                 min_elements_stmt();\r
3306                             }\r
3307                                 break;\r
3308                             case MAX_ELEMENTS_KEYWORD: {\r
3309                                 setState(471);\r
3310                                 max_elements_stmt();\r
3311                             }\r
3312                                 break;\r
3313                             case DESCRIPTION_KEYWORD: {\r
3314                                 setState(472);\r
3315                                 description_stmt();\r
3316                             }\r
3317                                 break;\r
3318                             case REFERENCE_KEYWORD: {\r
3319                                 setState(473);\r
3320                                 reference_stmt();\r
3321                             }\r
3322                                 break;\r
3323                             default:\r
3324                                 throw new NoViableAltException(this);\r
3325                             }\r
3326                         }\r
3327                     }\r
3328                     setState(478);\r
3329                     _errHandler.sync(this);\r
3330                     _alt = getInterpreter().adaptivePredict(_input, 45, _ctx);\r
3331                 }\r
3332             }\r
3333         } catch (RecognitionException re) {\r
3334             _localctx.exception = re;\r
3335             _errHandler.reportError(this, re);\r
3336             _errHandler.recover(this, re);\r
3337         } finally {\r
3338             exitRule();\r
3339         }\r
3340         return _localctx;\r
3341     }\r
3342 \r
3343     public static class Refine_leaf_stmtsContext extends ParserRuleContext {\r
3344         public List<Reference_stmtContext> reference_stmt() {\r
3345             return getRuleContexts(Reference_stmtContext.class);\r
3346         }\r
3347 \r
3348         public List<Default_stmtContext> default_stmt() {\r
3349             return getRuleContexts(Default_stmtContext.class);\r
3350         }\r
3351 \r
3352         public Description_stmtContext description_stmt(int i) {\r
3353             return getRuleContext(Description_stmtContext.class, i);\r
3354         }\r
3355 \r
3356         public Default_stmtContext default_stmt(int i) {\r
3357             return getRuleContext(Default_stmtContext.class, i);\r
3358         }\r
3359 \r
3360         public Mandatory_stmtContext mandatory_stmt(int i) {\r
3361             return getRuleContext(Mandatory_stmtContext.class, i);\r
3362         }\r
3363 \r
3364         public Config_stmtContext config_stmt(int i) {\r
3365             return getRuleContext(Config_stmtContext.class, i);\r
3366         }\r
3367 \r
3368         public List<Config_stmtContext> config_stmt() {\r
3369             return getRuleContexts(Config_stmtContext.class);\r
3370         }\r
3371 \r
3372         public List<Must_stmtContext> must_stmt() {\r
3373             return getRuleContexts(Must_stmtContext.class);\r
3374         }\r
3375 \r
3376         public List<Description_stmtContext> description_stmt() {\r
3377             return getRuleContexts(Description_stmtContext.class);\r
3378         }\r
3379 \r
3380         public Reference_stmtContext reference_stmt(int i) {\r
3381             return getRuleContext(Reference_stmtContext.class, i);\r
3382         }\r
3383 \r
3384         public List<Mandatory_stmtContext> mandatory_stmt() {\r
3385             return getRuleContexts(Mandatory_stmtContext.class);\r
3386         }\r
3387 \r
3388         public Must_stmtContext must_stmt(int i) {\r
3389             return getRuleContext(Must_stmtContext.class, i);\r
3390         }\r
3391 \r
3392         public Refine_leaf_stmtsContext(ParserRuleContext parent,\r
3393                 int invokingState) {\r
3394             super(parent, invokingState);\r
3395         }\r
3396 \r
3397         @Override\r
3398         public int getRuleIndex() {\r
3399             return RULE_refine_leaf_stmts;\r
3400         }\r
3401 \r
3402         @Override\r
3403         public void enterRule(ParseTreeListener listener) {\r
3404             if (listener instanceof YangParserListener)\r
3405                 ((YangParserListener) listener).enterRefine_leaf_stmts(this);\r
3406         }\r
3407 \r
3408         @Override\r
3409         public void exitRule(ParseTreeListener listener) {\r
3410             if (listener instanceof YangParserListener)\r
3411                 ((YangParserListener) listener).exitRefine_leaf_stmts(this);\r
3412         }\r
3413 \r
3414         @Override\r
3415         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
3416             if (visitor instanceof YangParserVisitor)\r
3417                 return ((YangParserVisitor<? extends T>) visitor)\r
3418                         .visitRefine_leaf_stmts(this);\r
3419             else\r
3420                 return visitor.visitChildren(this);\r
3421         }\r
3422     }\r
3423 \r
3424     public final Refine_leaf_stmtsContext refine_leaf_stmts()\r
3425             throws RecognitionException {\r
3426         Refine_leaf_stmtsContext _localctx = new Refine_leaf_stmtsContext(_ctx,\r
3427                 getState());\r
3428         enterRule(_localctx, 42, RULE_refine_leaf_stmts);\r
3429         try {\r
3430             int _alt;\r
3431             enterOuterAlt(_localctx, 1);\r
3432             {\r
3433                 setState(487);\r
3434                 _errHandler.sync(this);\r
3435                 _alt = getInterpreter().adaptivePredict(_input, 47, _ctx);\r
3436                 while (_alt != 2 && _alt != -1) {\r
3437                     if (_alt == 1) {\r
3438                         {\r
3439                             setState(485);\r
3440                             switch (_input.LA(1)) {\r
3441                             case MUST_KEYWORD: {\r
3442                                 setState(479);\r
3443                                 must_stmt();\r
3444                             }\r
3445                                 break;\r
3446                             case DEFAULT_KEYWORD: {\r
3447                                 setState(480);\r
3448                                 default_stmt();\r
3449                             }\r
3450                                 break;\r
3451                             case CONFIG_KEYWORD: {\r
3452                                 setState(481);\r
3453                                 config_stmt();\r
3454                             }\r
3455                                 break;\r
3456                             case MANDATORY_KEYWORD: {\r
3457                                 setState(482);\r
3458                                 mandatory_stmt();\r
3459                             }\r
3460                                 break;\r
3461                             case DESCRIPTION_KEYWORD: {\r
3462                                 setState(483);\r
3463                                 description_stmt();\r
3464                             }\r
3465                                 break;\r
3466                             case REFERENCE_KEYWORD: {\r
3467                                 setState(484);\r
3468                                 reference_stmt();\r
3469                             }\r
3470                                 break;\r
3471                             default:\r
3472                                 throw new NoViableAltException(this);\r
3473                             }\r
3474                         }\r
3475                     }\r
3476                     setState(489);\r
3477                     _errHandler.sync(this);\r
3478                     _alt = getInterpreter().adaptivePredict(_input, 47, _ctx);\r
3479                 }\r
3480             }\r
3481         } catch (RecognitionException re) {\r
3482             _localctx.exception = re;\r
3483             _errHandler.reportError(this, re);\r
3484             _errHandler.recover(this, re);\r
3485         } finally {\r
3486             exitRule();\r
3487         }\r
3488         return _localctx;\r
3489     }\r
3490 \r
3491     public static class Refine_container_stmtsContext extends ParserRuleContext {\r
3492         public List<Reference_stmtContext> reference_stmt() {\r
3493             return getRuleContexts(Reference_stmtContext.class);\r
3494         }\r
3495 \r
3496         public List<Presence_stmtContext> presence_stmt() {\r
3497             return getRuleContexts(Presence_stmtContext.class);\r
3498         }\r
3499 \r
3500         public Description_stmtContext description_stmt(int i) {\r
3501             return getRuleContext(Description_stmtContext.class, i);\r
3502         }\r
3503 \r
3504         public Config_stmtContext config_stmt(int i) {\r
3505             return getRuleContext(Config_stmtContext.class, i);\r
3506         }\r
3507 \r
3508         public Presence_stmtContext presence_stmt(int i) {\r
3509             return getRuleContext(Presence_stmtContext.class, i);\r
3510         }\r
3511 \r
3512         public List<Config_stmtContext> config_stmt() {\r
3513             return getRuleContexts(Config_stmtContext.class);\r
3514         }\r
3515 \r
3516         public List<Must_stmtContext> must_stmt() {\r
3517             return getRuleContexts(Must_stmtContext.class);\r
3518         }\r
3519 \r
3520         public List<Description_stmtContext> description_stmt() {\r
3521             return getRuleContexts(Description_stmtContext.class);\r
3522         }\r
3523 \r
3524         public Reference_stmtContext reference_stmt(int i) {\r
3525             return getRuleContext(Reference_stmtContext.class, i);\r
3526         }\r
3527 \r
3528         public Must_stmtContext must_stmt(int i) {\r
3529             return getRuleContext(Must_stmtContext.class, i);\r
3530         }\r
3531 \r
3532         public Refine_container_stmtsContext(ParserRuleContext parent,\r
3533                 int invokingState) {\r
3534             super(parent, invokingState);\r
3535         }\r
3536 \r
3537         @Override\r
3538         public int getRuleIndex() {\r
3539             return RULE_refine_container_stmts;\r
3540         }\r
3541 \r
3542         @Override\r
3543         public void enterRule(ParseTreeListener listener) {\r
3544             if (listener instanceof YangParserListener)\r
3545                 ((YangParserListener) listener)\r
3546                         .enterRefine_container_stmts(this);\r
3547         }\r
3548 \r
3549         @Override\r
3550         public void exitRule(ParseTreeListener listener) {\r
3551             if (listener instanceof YangParserListener)\r
3552                 ((YangParserListener) listener)\r
3553                         .exitRefine_container_stmts(this);\r
3554         }\r
3555 \r
3556         @Override\r
3557         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
3558             if (visitor instanceof YangParserVisitor)\r
3559                 return ((YangParserVisitor<? extends T>) visitor)\r
3560                         .visitRefine_container_stmts(this);\r
3561             else\r
3562                 return visitor.visitChildren(this);\r
3563         }\r
3564     }\r
3565 \r
3566     public final Refine_container_stmtsContext refine_container_stmts()\r
3567             throws RecognitionException {\r
3568         Refine_container_stmtsContext _localctx = new Refine_container_stmtsContext(\r
3569                 _ctx, getState());\r
3570         enterRule(_localctx, 44, RULE_refine_container_stmts);\r
3571         try {\r
3572             int _alt;\r
3573             enterOuterAlt(_localctx, 1);\r
3574             {\r
3575                 setState(497);\r
3576                 _errHandler.sync(this);\r
3577                 _alt = getInterpreter().adaptivePredict(_input, 49, _ctx);\r
3578                 while (_alt != 2 && _alt != -1) {\r
3579                     if (_alt == 1) {\r
3580                         {\r
3581                             setState(495);\r
3582                             switch (_input.LA(1)) {\r
3583                             case MUST_KEYWORD: {\r
3584                                 setState(490);\r
3585                                 must_stmt();\r
3586                             }\r
3587                                 break;\r
3588                             case PRESENCE_KEYWORD: {\r
3589                                 setState(491);\r
3590                                 presence_stmt();\r
3591                             }\r
3592                                 break;\r
3593                             case CONFIG_KEYWORD: {\r
3594                                 setState(492);\r
3595                                 config_stmt();\r
3596                             }\r
3597                                 break;\r
3598                             case DESCRIPTION_KEYWORD: {\r
3599                                 setState(493);\r
3600                                 description_stmt();\r
3601                             }\r
3602                                 break;\r
3603                             case REFERENCE_KEYWORD: {\r
3604                                 setState(494);\r
3605                                 reference_stmt();\r
3606                             }\r
3607                                 break;\r
3608                             default:\r
3609                                 throw new NoViableAltException(this);\r
3610                             }\r
3611                         }\r
3612                     }\r
3613                     setState(499);\r
3614                     _errHandler.sync(this);\r
3615                     _alt = getInterpreter().adaptivePredict(_input, 49, _ctx);\r
3616                 }\r
3617             }\r
3618         } catch (RecognitionException re) {\r
3619             _localctx.exception = re;\r
3620             _errHandler.reportError(this, re);\r
3621             _errHandler.recover(this, re);\r
3622         } finally {\r
3623             exitRule();\r
3624         }\r
3625         return _localctx;\r
3626     }\r
3627 \r
3628     public static class Refune_pomContext extends ParserRuleContext {\r
3629         public Refine_list_stmtsContext refine_list_stmts() {\r
3630             return getRuleContext(Refine_list_stmtsContext.class, 0);\r
3631         }\r
3632 \r
3633         public Refine_choice_stmtsContext refine_choice_stmts() {\r
3634             return getRuleContext(Refine_choice_stmtsContext.class, 0);\r
3635         }\r
3636 \r
3637         public Refine_leaf_list_stmtsContext refine_leaf_list_stmts() {\r
3638             return getRuleContext(Refine_leaf_list_stmtsContext.class, 0);\r
3639         }\r
3640 \r
3641         public Refine_case_stmtsContext refine_case_stmts() {\r
3642             return getRuleContext(Refine_case_stmtsContext.class, 0);\r
3643         }\r
3644 \r
3645         public Refine_leaf_stmtsContext refine_leaf_stmts() {\r
3646             return getRuleContext(Refine_leaf_stmtsContext.class, 0);\r
3647         }\r
3648 \r
3649         public Refine_anyxml_stmtsContext refine_anyxml_stmts() {\r
3650             return getRuleContext(Refine_anyxml_stmtsContext.class, 0);\r
3651         }\r
3652 \r
3653         public Refine_container_stmtsContext refine_container_stmts() {\r
3654             return getRuleContext(Refine_container_stmtsContext.class, 0);\r
3655         }\r
3656 \r
3657         public Refune_pomContext(ParserRuleContext parent, int invokingState) {\r
3658             super(parent, invokingState);\r
3659         }\r
3660 \r
3661         @Override\r
3662         public int getRuleIndex() {\r
3663             return RULE_refune_pom;\r
3664         }\r
3665 \r
3666         @Override\r
3667         public void enterRule(ParseTreeListener listener) {\r
3668             if (listener instanceof YangParserListener)\r
3669                 ((YangParserListener) listener).enterRefune_pom(this);\r
3670         }\r
3671 \r
3672         @Override\r
3673         public void exitRule(ParseTreeListener listener) {\r
3674             if (listener instanceof YangParserListener)\r
3675                 ((YangParserListener) listener).exitRefune_pom(this);\r
3676         }\r
3677 \r
3678         @Override\r
3679         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
3680             if (visitor instanceof YangParserVisitor)\r
3681                 return ((YangParserVisitor<? extends T>) visitor)\r
3682                         .visitRefune_pom(this);\r
3683             else\r
3684                 return visitor.visitChildren(this);\r
3685         }\r
3686     }\r
3687 \r
3688     public final Refune_pomContext refune_pom() throws RecognitionException {\r
3689         Refune_pomContext _localctx = new Refune_pomContext(_ctx, getState());\r
3690         enterRule(_localctx, 46, RULE_refune_pom);\r
3691         try {\r
3692             enterOuterAlt(_localctx, 1);\r
3693             {\r
3694                 setState(507);\r
3695                 switch (getInterpreter().adaptivePredict(_input, 50, _ctx)) {\r
3696                 case 1: {\r
3697                     setState(500);\r
3698                     refine_container_stmts();\r
3699                 }\r
3700                     break;\r
3701 \r
3702                 case 2: {\r
3703                     setState(501);\r
3704                     refine_leaf_stmts();\r
3705                 }\r
3706                     break;\r
3707 \r
3708                 case 3: {\r
3709                     setState(502);\r
3710                     refine_leaf_list_stmts();\r
3711                 }\r
3712                     break;\r
3713 \r
3714                 case 4: {\r
3715                     setState(503);\r
3716                     refine_list_stmts();\r
3717                 }\r
3718                     break;\r
3719 \r
3720                 case 5: {\r
3721                     setState(504);\r
3722                     refine_choice_stmts();\r
3723                 }\r
3724                     break;\r
3725 \r
3726                 case 6: {\r
3727                     setState(505);\r
3728                     refine_case_stmts();\r
3729                 }\r
3730                     break;\r
3731 \r
3732                 case 7: {\r
3733                     setState(506);\r
3734                     refine_anyxml_stmts();\r
3735                 }\r
3736                     break;\r
3737                 }\r
3738             }\r
3739         } catch (RecognitionException re) {\r
3740             _localctx.exception = re;\r
3741             _errHandler.reportError(this, re);\r
3742             _errHandler.recover(this, re);\r
3743         } finally {\r
3744             exitRule();\r
3745         }\r
3746         return _localctx;\r
3747     }\r
3748 \r
3749     public static class Refine_stmtContext extends ParserRuleContext {\r
3750         public List<Refune_pomContext> refune_pom() {\r
3751             return getRuleContexts(Refune_pomContext.class);\r
3752         }\r
3753 \r
3754         public TerminalNode RIGHT_BRACE() {\r
3755             return getToken(YangParser.RIGHT_BRACE, 0);\r
3756         }\r
3757 \r
3758         public TerminalNode SEMICOLON() {\r
3759             return getToken(YangParser.SEMICOLON, 0);\r
3760         }\r
3761 \r
3762         public StringContext string() {\r
3763             return getRuleContext(StringContext.class, 0);\r
3764         }\r
3765 \r
3766         public Refune_pomContext refune_pom(int i) {\r
3767             return getRuleContext(Refune_pomContext.class, i);\r
3768         }\r
3769 \r
3770         public TerminalNode LEFT_BRACE() {\r
3771             return getToken(YangParser.LEFT_BRACE, 0);\r
3772         }\r
3773 \r
3774         public TerminalNode REFINE_KEYWORD() {\r
3775             return getToken(YangParser.REFINE_KEYWORD, 0);\r
3776         }\r
3777 \r
3778         public Refine_stmtContext(ParserRuleContext parent, int invokingState) {\r
3779             super(parent, invokingState);\r
3780         }\r
3781 \r
3782         @Override\r
3783         public int getRuleIndex() {\r
3784             return RULE_refine_stmt;\r
3785         }\r
3786 \r
3787         @Override\r
3788         public void enterRule(ParseTreeListener listener) {\r
3789             if (listener instanceof YangParserListener)\r
3790                 ((YangParserListener) listener).enterRefine_stmt(this);\r
3791         }\r
3792 \r
3793         @Override\r
3794         public void exitRule(ParseTreeListener listener) {\r
3795             if (listener instanceof YangParserListener)\r
3796                 ((YangParserListener) listener).exitRefine_stmt(this);\r
3797         }\r
3798 \r
3799         @Override\r
3800         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
3801             if (visitor instanceof YangParserVisitor)\r
3802                 return ((YangParserVisitor<? extends T>) visitor)\r
3803                         .visitRefine_stmt(this);\r
3804             else\r
3805                 return visitor.visitChildren(this);\r
3806         }\r
3807     }\r
3808 \r
3809     public final Refine_stmtContext refine_stmt() throws RecognitionException {\r
3810         Refine_stmtContext _localctx = new Refine_stmtContext(_ctx, getState());\r
3811         enterRule(_localctx, 48, RULE_refine_stmt);\r
3812         try {\r
3813             int _alt;\r
3814             enterOuterAlt(_localctx, 1);\r
3815             {\r
3816                 setState(509);\r
3817                 match(REFINE_KEYWORD);\r
3818                 setState(510);\r
3819                 string();\r
3820                 setState(520);\r
3821                 switch (_input.LA(1)) {\r
3822                 case SEMICOLON: {\r
3823                     setState(511);\r
3824                     match(SEMICOLON);\r
3825                 }\r
3826                     break;\r
3827                 case LEFT_BRACE: {\r
3828                     {\r
3829                         setState(512);\r
3830                         match(LEFT_BRACE);\r
3831                         setState(514);\r
3832                         _errHandler.sync(this);\r
3833                         _alt = getInterpreter().adaptivePredict(_input, 51,\r
3834                                 _ctx);\r
3835                         do {\r
3836                             switch (_alt) {\r
3837                             case 1: {\r
3838                                 {\r
3839                                     setState(513);\r
3840                                     refune_pom();\r
3841                                 }\r
3842                             }\r
3843                                 break;\r
3844                             default:\r
3845                                 throw new NoViableAltException(this);\r
3846                             }\r
3847                             setState(516);\r
3848                             _errHandler.sync(this);\r
3849                             _alt = getInterpreter().adaptivePredict(_input, 51,\r
3850                                     _ctx);\r
3851                         } while (_alt != 2 && _alt != -1);\r
3852                         setState(518);\r
3853                         match(RIGHT_BRACE);\r
3854                     }\r
3855                 }\r
3856                     break;\r
3857                 default:\r
3858                     throw new NoViableAltException(this);\r
3859                 }\r
3860             }\r
3861         } catch (RecognitionException re) {\r
3862             _localctx.exception = re;\r
3863             _errHandler.reportError(this, re);\r
3864             _errHandler.recover(this, re);\r
3865         } finally {\r
3866             exitRule();\r
3867         }\r
3868         return _localctx;\r
3869     }\r
3870 \r
3871     public static class Uses_stmtContext extends ParserRuleContext {\r
3872         public TerminalNode RIGHT_BRACE() {\r
3873             return getToken(YangParser.RIGHT_BRACE, 0);\r
3874         }\r
3875 \r
3876         public List<Reference_stmtContext> reference_stmt() {\r
3877             return getRuleContexts(Reference_stmtContext.class);\r
3878         }\r
3879 \r
3880         public Description_stmtContext description_stmt(int i) {\r
3881             return getRuleContext(Description_stmtContext.class, i);\r
3882         }\r
3883 \r
3884         public List<When_stmtContext> when_stmt() {\r
3885             return getRuleContexts(When_stmtContext.class);\r
3886         }\r
3887 \r
3888         public List<Uses_augment_stmtContext> uses_augment_stmt() {\r
3889             return getRuleContexts(Uses_augment_stmtContext.class);\r
3890         }\r
3891 \r
3892         public If_feature_stmtContext if_feature_stmt(int i) {\r
3893             return getRuleContext(If_feature_stmtContext.class, i);\r
3894         }\r
3895 \r
3896         public TerminalNode USES_KEYWORD() {\r
3897             return getToken(YangParser.USES_KEYWORD, 0);\r
3898         }\r
3899 \r
3900         public TerminalNode LEFT_BRACE() {\r
3901             return getToken(YangParser.LEFT_BRACE, 0);\r
3902         }\r
3903 \r
3904         public Status_stmtContext status_stmt(int i) {\r
3905             return getRuleContext(Status_stmtContext.class, i);\r
3906         }\r
3907 \r
3908         public List<If_feature_stmtContext> if_feature_stmt() {\r
3909             return getRuleContexts(If_feature_stmtContext.class);\r
3910         }\r
3911 \r
3912         public Identifier_stmtContext identifier_stmt(int i) {\r
3913             return getRuleContext(Identifier_stmtContext.class, i);\r
3914         }\r
3915 \r
3916         public TerminalNode SEMICOLON() {\r
3917             return getToken(YangParser.SEMICOLON, 0);\r
3918         }\r
3919 \r
3920         public List<Status_stmtContext> status_stmt() {\r
3921             return getRuleContexts(Status_stmtContext.class);\r
3922         }\r
3923 \r
3924         public Refine_stmtContext refine_stmt(int i) {\r
3925             return getRuleContext(Refine_stmtContext.class, i);\r
3926         }\r
3927 \r
3928         public StringContext string() {\r
3929             return getRuleContext(StringContext.class, 0);\r
3930         }\r
3931 \r
3932         public List<Identifier_stmtContext> identifier_stmt() {\r
3933             return getRuleContexts(Identifier_stmtContext.class);\r
3934         }\r
3935 \r
3936         public List<Description_stmtContext> description_stmt() {\r
3937             return getRuleContexts(Description_stmtContext.class);\r
3938         }\r
3939 \r
3940         public Reference_stmtContext reference_stmt(int i) {\r
3941             return getRuleContext(Reference_stmtContext.class, i);\r
3942         }\r
3943 \r
3944         public When_stmtContext when_stmt(int i) {\r
3945             return getRuleContext(When_stmtContext.class, i);\r
3946         }\r
3947 \r
3948         public Uses_augment_stmtContext uses_augment_stmt(int i) {\r
3949             return getRuleContext(Uses_augment_stmtContext.class, i);\r
3950         }\r
3951 \r
3952         public List<Refine_stmtContext> refine_stmt() {\r
3953             return getRuleContexts(Refine_stmtContext.class);\r
3954         }\r
3955 \r
3956         public Uses_stmtContext(ParserRuleContext parent, int invokingState) {\r
3957             super(parent, invokingState);\r
3958         }\r
3959 \r
3960         @Override\r
3961         public int getRuleIndex() {\r
3962             return RULE_uses_stmt;\r
3963         }\r
3964 \r
3965         @Override\r
3966         public void enterRule(ParseTreeListener listener) {\r
3967             if (listener instanceof YangParserListener)\r
3968                 ((YangParserListener) listener).enterUses_stmt(this);\r
3969         }\r
3970 \r
3971         @Override\r
3972         public void exitRule(ParseTreeListener listener) {\r
3973             if (listener instanceof YangParserListener)\r
3974                 ((YangParserListener) listener).exitUses_stmt(this);\r
3975         }\r
3976 \r
3977         @Override\r
3978         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
3979             if (visitor instanceof YangParserVisitor)\r
3980                 return ((YangParserVisitor<? extends T>) visitor)\r
3981                         .visitUses_stmt(this);\r
3982             else\r
3983                 return visitor.visitChildren(this);\r
3984         }\r
3985     }\r
3986 \r
3987     public final Uses_stmtContext uses_stmt() throws RecognitionException {\r
3988         Uses_stmtContext _localctx = new Uses_stmtContext(_ctx, getState());\r
3989         enterRule(_localctx, 50, RULE_uses_stmt);\r
3990         int _la;\r
3991         try {\r
3992             enterOuterAlt(_localctx, 1);\r
3993             {\r
3994                 setState(522);\r
3995                 match(USES_KEYWORD);\r
3996                 setState(523);\r
3997                 string();\r
3998                 setState(540);\r
3999                 switch (_input.LA(1)) {\r
4000                 case SEMICOLON: {\r
4001                     setState(524);\r
4002                     match(SEMICOLON);\r
4003                 }\r
4004                     break;\r
4005                 case LEFT_BRACE: {\r
4006                     {\r
4007                         setState(525);\r
4008                         match(LEFT_BRACE);\r
4009                         setState(536);\r
4010                         _errHandler.sync(this);\r
4011                         _la = _input.LA(1);\r
4012                         while (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (WHEN_KEYWORD - 10))\r
4013                                 | (1L << (STATUS_KEYWORD - 10))\r
4014                                 | (1L << (REFINE_KEYWORD - 10))\r
4015                                 | (1L << (REFERENCE_KEYWORD - 10))\r
4016                                 | (1L << (IF_FEATURE_KEYWORD - 10))\r
4017                                 | (1L << (DESCRIPTION_KEYWORD - 10))\r
4018                                 | (1L << (AUGMENT_KEYWORD - 10)) | (1L << (IDENTIFIER - 10)))) != 0)) {\r
4019                             {\r
4020                                 setState(534);\r
4021                                 switch (_input.LA(1)) {\r
4022                                 case IDENTIFIER: {\r
4023                                     setState(526);\r
4024                                     identifier_stmt();\r
4025                                 }\r
4026                                     break;\r
4027                                 case WHEN_KEYWORD: {\r
4028                                     setState(527);\r
4029                                     when_stmt();\r
4030                                 }\r
4031                                     break;\r
4032                                 case IF_FEATURE_KEYWORD: {\r
4033                                     setState(528);\r
4034                                     if_feature_stmt();\r
4035                                 }\r
4036                                     break;\r
4037                                 case STATUS_KEYWORD: {\r
4038                                     setState(529);\r
4039                                     status_stmt();\r
4040                                 }\r
4041                                     break;\r
4042                                 case DESCRIPTION_KEYWORD: {\r
4043                                     setState(530);\r
4044                                     description_stmt();\r
4045                                 }\r
4046                                     break;\r
4047                                 case REFERENCE_KEYWORD: {\r
4048                                     setState(531);\r
4049                                     reference_stmt();\r
4050                                 }\r
4051                                     break;\r
4052                                 case REFINE_KEYWORD: {\r
4053                                     setState(532);\r
4054                                     refine_stmt();\r
4055                                 }\r
4056                                     break;\r
4057                                 case AUGMENT_KEYWORD: {\r
4058                                     setState(533);\r
4059                                     uses_augment_stmt();\r
4060                                 }\r
4061                                     break;\r
4062                                 default:\r
4063                                     throw new NoViableAltException(this);\r
4064                                 }\r
4065                             }\r
4066                             setState(538);\r
4067                             _errHandler.sync(this);\r
4068                             _la = _input.LA(1);\r
4069                         }\r
4070                         setState(539);\r
4071                         match(RIGHT_BRACE);\r
4072                     }\r
4073                 }\r
4074                     break;\r
4075                 default:\r
4076                     throw new NoViableAltException(this);\r
4077                 }\r
4078             }\r
4079         } catch (RecognitionException re) {\r
4080             _localctx.exception = re;\r
4081             _errHandler.reportError(this, re);\r
4082             _errHandler.recover(this, re);\r
4083         } finally {\r
4084             exitRule();\r
4085         }\r
4086         return _localctx;\r
4087     }\r
4088 \r
4089     public static class Anyxml_stmtContext extends ParserRuleContext {\r
4090         public TerminalNode RIGHT_BRACE() {\r
4091             return getToken(YangParser.RIGHT_BRACE, 0);\r
4092         }\r
4093 \r
4094         public List<Reference_stmtContext> reference_stmt() {\r
4095             return getRuleContexts(Reference_stmtContext.class);\r
4096         }\r
4097 \r
4098         public Description_stmtContext description_stmt(int i) {\r
4099             return getRuleContext(Description_stmtContext.class, i);\r
4100         }\r
4101 \r
4102         public List<When_stmtContext> when_stmt() {\r
4103             return getRuleContexts(When_stmtContext.class);\r
4104         }\r
4105 \r
4106         public TerminalNode ANYXML_KEYWORD() {\r
4107             return getToken(YangParser.ANYXML_KEYWORD, 0);\r
4108         }\r
4109 \r
4110         public If_feature_stmtContext if_feature_stmt(int i) {\r
4111             return getRuleContext(If_feature_stmtContext.class, i);\r
4112         }\r
4113 \r
4114         public TerminalNode LEFT_BRACE() {\r
4115             return getToken(YangParser.LEFT_BRACE, 0);\r
4116         }\r
4117 \r
4118         public Status_stmtContext status_stmt(int i) {\r
4119             return getRuleContext(Status_stmtContext.class, i);\r
4120         }\r
4121 \r
4122         public List<Mandatory_stmtContext> mandatory_stmt() {\r
4123             return getRuleContexts(Mandatory_stmtContext.class);\r
4124         }\r
4125 \r
4126         public Must_stmtContext must_stmt(int i) {\r
4127             return getRuleContext(Must_stmtContext.class, i);\r
4128         }\r
4129 \r
4130         public List<If_feature_stmtContext> if_feature_stmt() {\r
4131             return getRuleContexts(If_feature_stmtContext.class);\r
4132         }\r
4133 \r
4134         public Identifier_stmtContext identifier_stmt(int i) {\r
4135             return getRuleContext(Identifier_stmtContext.class, i);\r
4136         }\r
4137 \r
4138         public List<Status_stmtContext> status_stmt() {\r
4139             return getRuleContexts(Status_stmtContext.class);\r
4140         }\r
4141 \r
4142         public Mandatory_stmtContext mandatory_stmt(int i) {\r
4143             return getRuleContext(Mandatory_stmtContext.class, i);\r
4144         }\r
4145 \r
4146         public Config_stmtContext config_stmt(int i) {\r
4147             return getRuleContext(Config_stmtContext.class, i);\r
4148         }\r
4149 \r
4150         public TerminalNode SEMICOLON() {\r
4151             return getToken(YangParser.SEMICOLON, 0);\r
4152         }\r
4153 \r
4154         public List<Config_stmtContext> config_stmt() {\r
4155             return getRuleContexts(Config_stmtContext.class);\r
4156         }\r
4157 \r
4158         public StringContext string() {\r
4159             return getRuleContext(StringContext.class, 0);\r
4160         }\r
4161 \r
4162         public List<Identifier_stmtContext> identifier_stmt() {\r
4163             return getRuleContexts(Identifier_stmtContext.class);\r
4164         }\r
4165 \r
4166         public List<Must_stmtContext> must_stmt() {\r
4167             return getRuleContexts(Must_stmtContext.class);\r
4168         }\r
4169 \r
4170         public List<Description_stmtContext> description_stmt() {\r
4171             return getRuleContexts(Description_stmtContext.class);\r
4172         }\r
4173 \r
4174         public Reference_stmtContext reference_stmt(int i) {\r
4175             return getRuleContext(Reference_stmtContext.class, i);\r
4176         }\r
4177 \r
4178         public When_stmtContext when_stmt(int i) {\r
4179             return getRuleContext(When_stmtContext.class, i);\r
4180         }\r
4181 \r
4182         public Anyxml_stmtContext(ParserRuleContext parent, int invokingState) {\r
4183             super(parent, invokingState);\r
4184         }\r
4185 \r
4186         @Override\r
4187         public int getRuleIndex() {\r
4188             return RULE_anyxml_stmt;\r
4189         }\r
4190 \r
4191         @Override\r
4192         public void enterRule(ParseTreeListener listener) {\r
4193             if (listener instanceof YangParserListener)\r
4194                 ((YangParserListener) listener).enterAnyxml_stmt(this);\r
4195         }\r
4196 \r
4197         @Override\r
4198         public void exitRule(ParseTreeListener listener) {\r
4199             if (listener instanceof YangParserListener)\r
4200                 ((YangParserListener) listener).exitAnyxml_stmt(this);\r
4201         }\r
4202 \r
4203         @Override\r
4204         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
4205             if (visitor instanceof YangParserVisitor)\r
4206                 return ((YangParserVisitor<? extends T>) visitor)\r
4207                         .visitAnyxml_stmt(this);\r
4208             else\r
4209                 return visitor.visitChildren(this);\r
4210         }\r
4211     }\r
4212 \r
4213     public final Anyxml_stmtContext anyxml_stmt() throws RecognitionException {\r
4214         Anyxml_stmtContext _localctx = new Anyxml_stmtContext(_ctx, getState());\r
4215         enterRule(_localctx, 52, RULE_anyxml_stmt);\r
4216         int _la;\r
4217         try {\r
4218             enterOuterAlt(_localctx, 1);\r
4219             {\r
4220                 setState(542);\r
4221                 match(ANYXML_KEYWORD);\r
4222                 setState(543);\r
4223                 string();\r
4224                 setState(561);\r
4225                 switch (_input.LA(1)) {\r
4226                 case SEMICOLON: {\r
4227                     setState(544);\r
4228                     match(SEMICOLON);\r
4229                 }\r
4230                     break;\r
4231                 case LEFT_BRACE: {\r
4232                     {\r
4233                         setState(545);\r
4234                         match(LEFT_BRACE);\r
4235                         setState(557);\r
4236                         _errHandler.sync(this);\r
4237                         _la = _input.LA(1);\r
4238                         while (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (WHEN_KEYWORD - 10))\r
4239                                 | (1L << (STATUS_KEYWORD - 10))\r
4240                                 | (1L << (REFERENCE_KEYWORD - 10))\r
4241                                 | (1L << (MUST_KEYWORD - 10))\r
4242                                 | (1L << (MANDATORY_KEYWORD - 10))\r
4243                                 | (1L << (IF_FEATURE_KEYWORD - 10))\r
4244                                 | (1L << (DESCRIPTION_KEYWORD - 10))\r
4245                                 | (1L << (CONFIG_KEYWORD - 10)) | (1L << (IDENTIFIER - 10)))) != 0)) {\r
4246                             {\r
4247                                 setState(555);\r
4248                                 switch (_input.LA(1)) {\r
4249                                 case IDENTIFIER: {\r
4250                                     setState(546);\r
4251                                     identifier_stmt();\r
4252                                 }\r
4253                                     break;\r
4254                                 case WHEN_KEYWORD: {\r
4255                                     setState(547);\r
4256                                     when_stmt();\r
4257                                 }\r
4258                                     break;\r
4259                                 case IF_FEATURE_KEYWORD: {\r
4260                                     setState(548);\r
4261                                     if_feature_stmt();\r
4262                                 }\r
4263                                     break;\r
4264                                 case MUST_KEYWORD: {\r
4265                                     setState(549);\r
4266                                     must_stmt();\r
4267                                 }\r
4268                                     break;\r
4269                                 case CONFIG_KEYWORD: {\r
4270                                     setState(550);\r
4271                                     config_stmt();\r
4272                                 }\r
4273                                     break;\r
4274                                 case MANDATORY_KEYWORD: {\r
4275                                     setState(551);\r
4276                                     mandatory_stmt();\r
4277                                 }\r
4278                                     break;\r
4279                                 case STATUS_KEYWORD: {\r
4280                                     setState(552);\r
4281                                     status_stmt();\r
4282                                 }\r
4283                                     break;\r
4284                                 case DESCRIPTION_KEYWORD: {\r
4285                                     setState(553);\r
4286                                     description_stmt();\r
4287                                 }\r
4288                                     break;\r
4289                                 case REFERENCE_KEYWORD: {\r
4290                                     setState(554);\r
4291                                     reference_stmt();\r
4292                                 }\r
4293                                     break;\r
4294                                 default:\r
4295                                     throw new NoViableAltException(this);\r
4296                                 }\r
4297                             }\r
4298                             setState(559);\r
4299                             _errHandler.sync(this);\r
4300                             _la = _input.LA(1);\r
4301                         }\r
4302                         setState(560);\r
4303                         match(RIGHT_BRACE);\r
4304                     }\r
4305                 }\r
4306                     break;\r
4307                 default:\r
4308                     throw new NoViableAltException(this);\r
4309                 }\r
4310             }\r
4311         } catch (RecognitionException re) {\r
4312             _localctx.exception = re;\r
4313             _errHandler.reportError(this, re);\r
4314             _errHandler.recover(this, re);\r
4315         } finally {\r
4316             exitRule();\r
4317         }\r
4318         return _localctx;\r
4319     }\r
4320 \r
4321     public static class Case_stmtContext extends ParserRuleContext {\r
4322         public TerminalNode RIGHT_BRACE() {\r
4323             return getToken(YangParser.RIGHT_BRACE, 0);\r
4324         }\r
4325 \r
4326         public List<Reference_stmtContext> reference_stmt() {\r
4327             return getRuleContexts(Reference_stmtContext.class);\r
4328         }\r
4329 \r
4330         public Description_stmtContext description_stmt(int i) {\r
4331             return getRuleContext(Description_stmtContext.class, i);\r
4332         }\r
4333 \r
4334         public List<When_stmtContext> when_stmt() {\r
4335             return getRuleContexts(When_stmtContext.class);\r
4336         }\r
4337 \r
4338         public If_feature_stmtContext if_feature_stmt(int i) {\r
4339             return getRuleContext(If_feature_stmtContext.class, i);\r
4340         }\r
4341 \r
4342         public TerminalNode LEFT_BRACE() {\r
4343             return getToken(YangParser.LEFT_BRACE, 0);\r
4344         }\r
4345 \r
4346         public Data_def_stmtContext data_def_stmt(int i) {\r
4347             return getRuleContext(Data_def_stmtContext.class, i);\r
4348         }\r
4349 \r
4350         public Status_stmtContext status_stmt(int i) {\r
4351             return getRuleContext(Status_stmtContext.class, i);\r
4352         }\r
4353 \r
4354         public List<If_feature_stmtContext> if_feature_stmt() {\r
4355             return getRuleContexts(If_feature_stmtContext.class);\r
4356         }\r
4357 \r
4358         public Identifier_stmtContext identifier_stmt(int i) {\r
4359             return getRuleContext(Identifier_stmtContext.class, i);\r
4360         }\r
4361 \r
4362         public TerminalNode CASE_KEYWORD() {\r
4363             return getToken(YangParser.CASE_KEYWORD, 0);\r
4364         }\r
4365 \r
4366         public List<Data_def_stmtContext> data_def_stmt() {\r
4367             return getRuleContexts(Data_def_stmtContext.class);\r
4368         }\r
4369 \r
4370         public TerminalNode SEMICOLON() {\r
4371             return getToken(YangParser.SEMICOLON, 0);\r
4372         }\r
4373 \r
4374         public List<Status_stmtContext> status_stmt() {\r
4375             return getRuleContexts(Status_stmtContext.class);\r
4376         }\r
4377 \r
4378         public StringContext string() {\r
4379             return getRuleContext(StringContext.class, 0);\r
4380         }\r
4381 \r
4382         public List<Identifier_stmtContext> identifier_stmt() {\r
4383             return getRuleContexts(Identifier_stmtContext.class);\r
4384         }\r
4385 \r
4386         public List<Description_stmtContext> description_stmt() {\r
4387             return getRuleContexts(Description_stmtContext.class);\r
4388         }\r
4389 \r
4390         public Reference_stmtContext reference_stmt(int i) {\r
4391             return getRuleContext(Reference_stmtContext.class, i);\r
4392         }\r
4393 \r
4394         public When_stmtContext when_stmt(int i) {\r
4395             return getRuleContext(When_stmtContext.class, i);\r
4396         }\r
4397 \r
4398         public Case_stmtContext(ParserRuleContext parent, int invokingState) {\r
4399             super(parent, invokingState);\r
4400         }\r
4401 \r
4402         @Override\r
4403         public int getRuleIndex() {\r
4404             return RULE_case_stmt;\r
4405         }\r
4406 \r
4407         @Override\r
4408         public void enterRule(ParseTreeListener listener) {\r
4409             if (listener instanceof YangParserListener)\r
4410                 ((YangParserListener) listener).enterCase_stmt(this);\r
4411         }\r
4412 \r
4413         @Override\r
4414         public void exitRule(ParseTreeListener listener) {\r
4415             if (listener instanceof YangParserListener)\r
4416                 ((YangParserListener) listener).exitCase_stmt(this);\r
4417         }\r
4418 \r
4419         @Override\r
4420         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
4421             if (visitor instanceof YangParserVisitor)\r
4422                 return ((YangParserVisitor<? extends T>) visitor)\r
4423                         .visitCase_stmt(this);\r
4424             else\r
4425                 return visitor.visitChildren(this);\r
4426         }\r
4427     }\r
4428 \r
4429     public final Case_stmtContext case_stmt() throws RecognitionException {\r
4430         Case_stmtContext _localctx = new Case_stmtContext(_ctx, getState());\r
4431         enterRule(_localctx, 54, RULE_case_stmt);\r
4432         int _la;\r
4433         try {\r
4434             enterOuterAlt(_localctx, 1);\r
4435             {\r
4436                 setState(563);\r
4437                 match(CASE_KEYWORD);\r
4438                 setState(564);\r
4439                 string();\r
4440                 setState(580);\r
4441                 switch (_input.LA(1)) {\r
4442                 case SEMICOLON: {\r
4443                     setState(565);\r
4444                     match(SEMICOLON);\r
4445                 }\r
4446                     break;\r
4447                 case LEFT_BRACE: {\r
4448                     {\r
4449                         setState(566);\r
4450                         match(LEFT_BRACE);\r
4451                         setState(576);\r
4452                         _errHandler.sync(this);\r
4453                         _la = _input.LA(1);\r
4454                         while (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (WHEN_KEYWORD - 10))\r
4455                                 | (1L << (USES_KEYWORD - 10))\r
4456                                 | (1L << (STATUS_KEYWORD - 10))\r
4457                                 | (1L << (REFERENCE_KEYWORD - 10))\r
4458                                 | (1L << (LIST_KEYWORD - 10))\r
4459                                 | (1L << (LEAF_LIST_KEYWORD - 10))\r
4460                                 | (1L << (LEAF_KEYWORD - 10))\r
4461                                 | (1L << (IF_FEATURE_KEYWORD - 10))\r
4462                                 | (1L << (DESCRIPTION_KEYWORD - 10))\r
4463                                 | (1L << (CONTAINER_KEYWORD - 10))\r
4464                                 | (1L << (CHOICE_KEYWORD - 10))\r
4465                                 | (1L << (ANYXML_KEYWORD - 10)) | (1L << (IDENTIFIER - 10)))) != 0)) {\r
4466                             {\r
4467                                 setState(574);\r
4468                                 switch (_input.LA(1)) {\r
4469                                 case IDENTIFIER: {\r
4470                                     setState(567);\r
4471                                     identifier_stmt();\r
4472                                 }\r
4473                                     break;\r
4474                                 case WHEN_KEYWORD: {\r
4475                                     setState(568);\r
4476                                     when_stmt();\r
4477                                 }\r
4478                                     break;\r
4479                                 case IF_FEATURE_KEYWORD: {\r
4480                                     setState(569);\r
4481                                     if_feature_stmt();\r
4482                                 }\r
4483                                     break;\r
4484                                 case STATUS_KEYWORD: {\r
4485                                     setState(570);\r
4486                                     status_stmt();\r
4487                                 }\r
4488                                     break;\r
4489                                 case DESCRIPTION_KEYWORD: {\r
4490                                     setState(571);\r
4491                                     description_stmt();\r
4492                                 }\r
4493                                     break;\r
4494                                 case REFERENCE_KEYWORD: {\r
4495                                     setState(572);\r
4496                                     reference_stmt();\r
4497                                 }\r
4498                                     break;\r
4499                                 case USES_KEYWORD:\r
4500                                 case LIST_KEYWORD:\r
4501                                 case LEAF_LIST_KEYWORD:\r
4502                                 case LEAF_KEYWORD:\r
4503                                 case CONTAINER_KEYWORD:\r
4504                                 case CHOICE_KEYWORD:\r
4505                                 case ANYXML_KEYWORD: {\r
4506                                     setState(573);\r
4507                                     data_def_stmt();\r
4508                                 }\r
4509                                     break;\r
4510                                 default:\r
4511                                     throw new NoViableAltException(this);\r
4512                                 }\r
4513                             }\r
4514                             setState(578);\r
4515                             _errHandler.sync(this);\r
4516                             _la = _input.LA(1);\r
4517                         }\r
4518                         setState(579);\r
4519                         match(RIGHT_BRACE);\r
4520                     }\r
4521                 }\r
4522                     break;\r
4523                 default:\r
4524                     throw new NoViableAltException(this);\r
4525                 }\r
4526             }\r
4527         } catch (RecognitionException re) {\r
4528             _localctx.exception = re;\r
4529             _errHandler.reportError(this, re);\r
4530             _errHandler.recover(this, re);\r
4531         } finally {\r
4532             exitRule();\r
4533         }\r
4534         return _localctx;\r
4535     }\r
4536 \r
4537     public static class Short_case_stmtContext extends ParserRuleContext {\r
4538         public Anyxml_stmtContext anyxml_stmt() {\r
4539             return getRuleContext(Anyxml_stmtContext.class, 0);\r
4540         }\r
4541 \r
4542         public List_stmtContext list_stmt() {\r
4543             return getRuleContext(List_stmtContext.class, 0);\r
4544         }\r
4545 \r
4546         public Leaf_stmtContext leaf_stmt() {\r
4547             return getRuleContext(Leaf_stmtContext.class, 0);\r
4548         }\r
4549 \r
4550         public Container_stmtContext container_stmt() {\r
4551             return getRuleContext(Container_stmtContext.class, 0);\r
4552         }\r
4553 \r
4554         public Leaf_list_stmtContext leaf_list_stmt() {\r
4555             return getRuleContext(Leaf_list_stmtContext.class, 0);\r
4556         }\r
4557 \r
4558         public Short_case_stmtContext(ParserRuleContext parent,\r
4559                 int invokingState) {\r
4560             super(parent, invokingState);\r
4561         }\r
4562 \r
4563         @Override\r
4564         public int getRuleIndex() {\r
4565             return RULE_short_case_stmt;\r
4566         }\r
4567 \r
4568         @Override\r
4569         public void enterRule(ParseTreeListener listener) {\r
4570             if (listener instanceof YangParserListener)\r
4571                 ((YangParserListener) listener).enterShort_case_stmt(this);\r
4572         }\r
4573 \r
4574         @Override\r
4575         public void exitRule(ParseTreeListener listener) {\r
4576             if (listener instanceof YangParserListener)\r
4577                 ((YangParserListener) listener).exitShort_case_stmt(this);\r
4578         }\r
4579 \r
4580         @Override\r
4581         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
4582             if (visitor instanceof YangParserVisitor)\r
4583                 return ((YangParserVisitor<? extends T>) visitor)\r
4584                         .visitShort_case_stmt(this);\r
4585             else\r
4586                 return visitor.visitChildren(this);\r
4587         }\r
4588     }\r
4589 \r
4590     public final Short_case_stmtContext short_case_stmt()\r
4591             throws RecognitionException {\r
4592         Short_case_stmtContext _localctx = new Short_case_stmtContext(_ctx,\r
4593                 getState());\r
4594         enterRule(_localctx, 56, RULE_short_case_stmt);\r
4595         try {\r
4596             setState(587);\r
4597             switch (_input.LA(1)) {\r
4598             case CONTAINER_KEYWORD:\r
4599                 enterOuterAlt(_localctx, 1);\r
4600                 {\r
4601                     setState(582);\r
4602                     container_stmt();\r
4603                 }\r
4604                 break;\r
4605             case LEAF_KEYWORD:\r
4606                 enterOuterAlt(_localctx, 2);\r
4607                 {\r
4608                     setState(583);\r
4609                     leaf_stmt();\r
4610                 }\r
4611                 break;\r
4612             case LEAF_LIST_KEYWORD:\r
4613                 enterOuterAlt(_localctx, 3);\r
4614                 {\r
4615                     setState(584);\r
4616                     leaf_list_stmt();\r
4617                 }\r
4618                 break;\r
4619             case LIST_KEYWORD:\r
4620                 enterOuterAlt(_localctx, 4);\r
4621                 {\r
4622                     setState(585);\r
4623                     list_stmt();\r
4624                 }\r
4625                 break;\r
4626             case ANYXML_KEYWORD:\r
4627                 enterOuterAlt(_localctx, 5);\r
4628                 {\r
4629                     setState(586);\r
4630                     anyxml_stmt();\r
4631                 }\r
4632                 break;\r
4633             default:\r
4634                 throw new NoViableAltException(this);\r
4635             }\r
4636         } catch (RecognitionException re) {\r
4637             _localctx.exception = re;\r
4638             _errHandler.reportError(this, re);\r
4639             _errHandler.recover(this, re);\r
4640         } finally {\r
4641             exitRule();\r
4642         }\r
4643         return _localctx;\r
4644     }\r
4645 \r
4646     public static class Choice_stmtContext extends ParserRuleContext {\r
4647         public TerminalNode RIGHT_BRACE() {\r
4648             return getToken(YangParser.RIGHT_BRACE, 0);\r
4649         }\r
4650 \r
4651         public List<Reference_stmtContext> reference_stmt() {\r
4652             return getRuleContexts(Reference_stmtContext.class);\r
4653         }\r
4654 \r
4655         public Description_stmtContext description_stmt(int i) {\r
4656             return getRuleContext(Description_stmtContext.class, i);\r
4657         }\r
4658 \r
4659         public Default_stmtContext default_stmt(int i) {\r
4660             return getRuleContext(Default_stmtContext.class, i);\r
4661         }\r
4662 \r
4663         public TerminalNode CHOICE_KEYWORD() {\r
4664             return getToken(YangParser.CHOICE_KEYWORD, 0);\r
4665         }\r
4666 \r
4667         public List<When_stmtContext> when_stmt() {\r
4668             return getRuleContexts(When_stmtContext.class);\r
4669         }\r
4670 \r
4671         public List<Case_stmtContext> case_stmt() {\r
4672             return getRuleContexts(Case_stmtContext.class);\r
4673         }\r
4674 \r
4675         public If_feature_stmtContext if_feature_stmt(int i) {\r
4676             return getRuleContext(If_feature_stmtContext.class, i);\r
4677         }\r
4678 \r
4679         public TerminalNode LEFT_BRACE() {\r
4680             return getToken(YangParser.LEFT_BRACE, 0);\r
4681         }\r
4682 \r
4683         public Status_stmtContext status_stmt(int i) {\r
4684             return getRuleContext(Status_stmtContext.class, i);\r
4685         }\r
4686 \r
4687         public List<Mandatory_stmtContext> mandatory_stmt() {\r
4688             return getRuleContexts(Mandatory_stmtContext.class);\r
4689         }\r
4690 \r
4691         public List<If_feature_stmtContext> if_feature_stmt() {\r
4692             return getRuleContexts(If_feature_stmtContext.class);\r
4693         }\r
4694 \r
4695         public Identifier_stmtContext identifier_stmt(int i) {\r
4696             return getRuleContext(Identifier_stmtContext.class, i);\r
4697         }\r
4698 \r
4699         public List<Default_stmtContext> default_stmt() {\r
4700             return getRuleContexts(Default_stmtContext.class);\r
4701         }\r
4702 \r
4703         public List<Status_stmtContext> status_stmt() {\r
4704             return getRuleContexts(Status_stmtContext.class);\r
4705         }\r
4706 \r
4707         public Mandatory_stmtContext mandatory_stmt(int i) {\r
4708             return getRuleContext(Mandatory_stmtContext.class, i);\r
4709         }\r
4710 \r
4711         public Config_stmtContext config_stmt(int i) {\r
4712             return getRuleContext(Config_stmtContext.class, i);\r
4713         }\r
4714 \r
4715         public TerminalNode SEMICOLON() {\r
4716             return getToken(YangParser.SEMICOLON, 0);\r
4717         }\r
4718 \r
4719         public Short_case_stmtContext short_case_stmt(int i) {\r
4720             return getRuleContext(Short_case_stmtContext.class, i);\r
4721         }\r
4722 \r
4723         public List<Short_case_stmtContext> short_case_stmt() {\r
4724             return getRuleContexts(Short_case_stmtContext.class);\r
4725         }\r
4726 \r
4727         public List<Config_stmtContext> config_stmt() {\r
4728             return getRuleContexts(Config_stmtContext.class);\r
4729         }\r
4730 \r
4731         public StringContext string() {\r
4732             return getRuleContext(StringContext.class, 0);\r
4733         }\r
4734 \r
4735         public List<Identifier_stmtContext> identifier_stmt() {\r
4736             return getRuleContexts(Identifier_stmtContext.class);\r
4737         }\r
4738 \r
4739         public List<Description_stmtContext> description_stmt() {\r
4740             return getRuleContexts(Description_stmtContext.class);\r
4741         }\r
4742 \r
4743         public Reference_stmtContext reference_stmt(int i) {\r
4744             return getRuleContext(Reference_stmtContext.class, i);\r
4745         }\r
4746 \r
4747         public When_stmtContext when_stmt(int i) {\r
4748             return getRuleContext(When_stmtContext.class, i);\r
4749         }\r
4750 \r
4751         public Case_stmtContext case_stmt(int i) {\r
4752             return getRuleContext(Case_stmtContext.class, i);\r
4753         }\r
4754 \r
4755         public Choice_stmtContext(ParserRuleContext parent, int invokingState) {\r
4756             super(parent, invokingState);\r
4757         }\r
4758 \r
4759         @Override\r
4760         public int getRuleIndex() {\r
4761             return RULE_choice_stmt;\r
4762         }\r
4763 \r
4764         @Override\r
4765         public void enterRule(ParseTreeListener listener) {\r
4766             if (listener instanceof YangParserListener)\r
4767                 ((YangParserListener) listener).enterChoice_stmt(this);\r
4768         }\r
4769 \r
4770         @Override\r
4771         public void exitRule(ParseTreeListener listener) {\r
4772             if (listener instanceof YangParserListener)\r
4773                 ((YangParserListener) listener).exitChoice_stmt(this);\r
4774         }\r
4775 \r
4776         @Override\r
4777         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
4778             if (visitor instanceof YangParserVisitor)\r
4779                 return ((YangParserVisitor<? extends T>) visitor)\r
4780                         .visitChoice_stmt(this);\r
4781             else\r
4782                 return visitor.visitChildren(this);\r
4783         }\r
4784     }\r
4785 \r
4786     public final Choice_stmtContext choice_stmt() throws RecognitionException {\r
4787         Choice_stmtContext _localctx = new Choice_stmtContext(_ctx, getState());\r
4788         enterRule(_localctx, 58, RULE_choice_stmt);\r
4789         int _la;\r
4790         try {\r
4791             enterOuterAlt(_localctx, 1);\r
4792             {\r
4793                 setState(589);\r
4794                 match(CHOICE_KEYWORD);\r
4795                 setState(590);\r
4796                 string();\r
4797                 setState(610);\r
4798                 switch (_input.LA(1)) {\r
4799                 case SEMICOLON: {\r
4800                     setState(591);\r
4801                     match(SEMICOLON);\r
4802                 }\r
4803                     break;\r
4804                 case LEFT_BRACE: {\r
4805                     {\r
4806                         setState(592);\r
4807                         match(LEFT_BRACE);\r
4808                         setState(606);\r
4809                         _errHandler.sync(this);\r
4810                         _la = _input.LA(1);\r
4811                         while (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (WHEN_KEYWORD - 10))\r
4812                                 | (1L << (STATUS_KEYWORD - 10))\r
4813                                 | (1L << (REFERENCE_KEYWORD - 10))\r
4814                                 | (1L << (MANDATORY_KEYWORD - 10))\r
4815                                 | (1L << (LIST_KEYWORD - 10))\r
4816                                 | (1L << (LEAF_LIST_KEYWORD - 10))\r
4817                                 | (1L << (LEAF_KEYWORD - 10))\r
4818                                 | (1L << (IF_FEATURE_KEYWORD - 10))\r
4819                                 | (1L << (DESCRIPTION_KEYWORD - 10))\r
4820                                 | (1L << (DEFAULT_KEYWORD - 10))\r
4821                                 | (1L << (CONTAINER_KEYWORD - 10))\r
4822                                 | (1L << (CONFIG_KEYWORD - 10))\r
4823                                 | (1L << (CASE_KEYWORD - 10))\r
4824                                 | (1L << (ANYXML_KEYWORD - 10)) | (1L << (IDENTIFIER - 10)))) != 0)) {\r
4825                             {\r
4826                                 setState(604);\r
4827                                 switch (_input.LA(1)) {\r
4828                                 case IDENTIFIER: {\r
4829                                     setState(593);\r
4830                                     identifier_stmt();\r
4831                                 }\r
4832                                     break;\r
4833                                 case WHEN_KEYWORD: {\r
4834                                     setState(594);\r
4835                                     when_stmt();\r
4836                                 }\r
4837                                     break;\r
4838                                 case IF_FEATURE_KEYWORD: {\r
4839                                     setState(595);\r
4840                                     if_feature_stmt();\r
4841                                 }\r
4842                                     break;\r
4843                                 case DEFAULT_KEYWORD: {\r
4844                                     setState(596);\r
4845                                     default_stmt();\r
4846                                 }\r
4847                                     break;\r
4848                                 case CONFIG_KEYWORD: {\r
4849                                     setState(597);\r
4850                                     config_stmt();\r
4851                                 }\r
4852                                     break;\r
4853                                 case MANDATORY_KEYWORD: {\r
4854                                     setState(598);\r
4855                                     mandatory_stmt();\r
4856                                 }\r
4857                                     break;\r
4858                                 case STATUS_KEYWORD: {\r
4859                                     setState(599);\r
4860                                     status_stmt();\r
4861                                 }\r
4862                                     break;\r
4863                                 case DESCRIPTION_KEYWORD: {\r
4864                                     setState(600);\r
4865                                     description_stmt();\r
4866                                 }\r
4867                                     break;\r
4868                                 case REFERENCE_KEYWORD: {\r
4869                                     setState(601);\r
4870                                     reference_stmt();\r
4871                                 }\r
4872                                     break;\r
4873                                 case LIST_KEYWORD:\r
4874                                 case LEAF_LIST_KEYWORD:\r
4875                                 case LEAF_KEYWORD:\r
4876                                 case CONTAINER_KEYWORD:\r
4877                                 case ANYXML_KEYWORD: {\r
4878                                     setState(602);\r
4879                                     short_case_stmt();\r
4880                                 }\r
4881                                     break;\r
4882                                 case CASE_KEYWORD: {\r
4883                                     setState(603);\r
4884                                     case_stmt();\r
4885                                 }\r
4886                                     break;\r
4887                                 default:\r
4888                                     throw new NoViableAltException(this);\r
4889                                 }\r
4890                             }\r
4891                             setState(608);\r
4892                             _errHandler.sync(this);\r
4893                             _la = _input.LA(1);\r
4894                         }\r
4895                         setState(609);\r
4896                         match(RIGHT_BRACE);\r
4897                     }\r
4898                 }\r
4899                     break;\r
4900                 default:\r
4901                     throw new NoViableAltException(this);\r
4902                 }\r
4903             }\r
4904         } catch (RecognitionException re) {\r
4905             _localctx.exception = re;\r
4906             _errHandler.reportError(this, re);\r
4907             _errHandler.recover(this, re);\r
4908         } finally {\r
4909             exitRule();\r
4910         }\r
4911         return _localctx;\r
4912     }\r
4913 \r
4914     public static class Unique_stmtContext extends ParserRuleContext {\r
4915         public StringContext string() {\r
4916             return getRuleContext(StringContext.class, 0);\r
4917         }\r
4918 \r
4919         public StmtendContext stmtend() {\r
4920             return getRuleContext(StmtendContext.class, 0);\r
4921         }\r
4922 \r
4923         public TerminalNode UNIQUE_KEYWORD() {\r
4924             return getToken(YangParser.UNIQUE_KEYWORD, 0);\r
4925         }\r
4926 \r
4927         public Unique_stmtContext(ParserRuleContext parent, int invokingState) {\r
4928             super(parent, invokingState);\r
4929         }\r
4930 \r
4931         @Override\r
4932         public int getRuleIndex() {\r
4933             return RULE_unique_stmt;\r
4934         }\r
4935 \r
4936         @Override\r
4937         public void enterRule(ParseTreeListener listener) {\r
4938             if (listener instanceof YangParserListener)\r
4939                 ((YangParserListener) listener).enterUnique_stmt(this);\r
4940         }\r
4941 \r
4942         @Override\r
4943         public void exitRule(ParseTreeListener listener) {\r
4944             if (listener instanceof YangParserListener)\r
4945                 ((YangParserListener) listener).exitUnique_stmt(this);\r
4946         }\r
4947 \r
4948         @Override\r
4949         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
4950             if (visitor instanceof YangParserVisitor)\r
4951                 return ((YangParserVisitor<? extends T>) visitor)\r
4952                         .visitUnique_stmt(this);\r
4953             else\r
4954                 return visitor.visitChildren(this);\r
4955         }\r
4956     }\r
4957 \r
4958     public final Unique_stmtContext unique_stmt() throws RecognitionException {\r
4959         Unique_stmtContext _localctx = new Unique_stmtContext(_ctx, getState());\r
4960         enterRule(_localctx, 60, RULE_unique_stmt);\r
4961         try {\r
4962             enterOuterAlt(_localctx, 1);\r
4963             {\r
4964                 setState(612);\r
4965                 match(UNIQUE_KEYWORD);\r
4966                 setState(613);\r
4967                 string();\r
4968                 setState(614);\r
4969                 stmtend();\r
4970             }\r
4971         } catch (RecognitionException re) {\r
4972             _localctx.exception = re;\r
4973             _errHandler.reportError(this, re);\r
4974             _errHandler.recover(this, re);\r
4975         } finally {\r
4976             exitRule();\r
4977         }\r
4978         return _localctx;\r
4979     }\r
4980 \r
4981     public static class Key_stmtContext extends ParserRuleContext {\r
4982         public StringContext string() {\r
4983             return getRuleContext(StringContext.class, 0);\r
4984         }\r
4985 \r
4986         public StmtendContext stmtend() {\r
4987             return getRuleContext(StmtendContext.class, 0);\r
4988         }\r
4989 \r
4990         public TerminalNode KEY_KEYWORD() {\r
4991             return getToken(YangParser.KEY_KEYWORD, 0);\r
4992         }\r
4993 \r
4994         public Key_stmtContext(ParserRuleContext parent, int invokingState) {\r
4995             super(parent, invokingState);\r
4996         }\r
4997 \r
4998         @Override\r
4999         public int getRuleIndex() {\r
5000             return RULE_key_stmt;\r
5001         }\r
5002 \r
5003         @Override\r
5004         public void enterRule(ParseTreeListener listener) {\r
5005             if (listener instanceof YangParserListener)\r
5006                 ((YangParserListener) listener).enterKey_stmt(this);\r
5007         }\r
5008 \r
5009         @Override\r
5010         public void exitRule(ParseTreeListener listener) {\r
5011             if (listener instanceof YangParserListener)\r
5012                 ((YangParserListener) listener).exitKey_stmt(this);\r
5013         }\r
5014 \r
5015         @Override\r
5016         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
5017             if (visitor instanceof YangParserVisitor)\r
5018                 return ((YangParserVisitor<? extends T>) visitor)\r
5019                         .visitKey_stmt(this);\r
5020             else\r
5021                 return visitor.visitChildren(this);\r
5022         }\r
5023     }\r
5024 \r
5025     public final Key_stmtContext key_stmt() throws RecognitionException {\r
5026         Key_stmtContext _localctx = new Key_stmtContext(_ctx, getState());\r
5027         enterRule(_localctx, 62, RULE_key_stmt);\r
5028         try {\r
5029             enterOuterAlt(_localctx, 1);\r
5030             {\r
5031                 setState(616);\r
5032                 match(KEY_KEYWORD);\r
5033                 setState(617);\r
5034                 string();\r
5035                 setState(618);\r
5036                 stmtend();\r
5037             }\r
5038         } catch (RecognitionException re) {\r
5039             _localctx.exception = re;\r
5040             _errHandler.reportError(this, re);\r
5041             _errHandler.recover(this, re);\r
5042         } finally {\r
5043             exitRule();\r
5044         }\r
5045         return _localctx;\r
5046     }\r
5047 \r
5048     public static class List_stmtContext extends ParserRuleContext {\r
5049         public TerminalNode RIGHT_BRACE() {\r
5050             return getToken(YangParser.RIGHT_BRACE, 0);\r
5051         }\r
5052 \r
5053         public List<When_stmtContext> when_stmt() {\r
5054             return getRuleContexts(When_stmtContext.class);\r
5055         }\r
5056 \r
5057         public List<Max_elements_stmtContext> max_elements_stmt() {\r
5058             return getRuleContexts(Max_elements_stmtContext.class);\r
5059         }\r
5060 \r
5061         public Data_def_stmtContext data_def_stmt(int i) {\r
5062             return getRuleContext(Data_def_stmtContext.class, i);\r
5063         }\r
5064 \r
5065         public List<Typedef_stmtContext> typedef_stmt() {\r
5066             return getRuleContexts(Typedef_stmtContext.class);\r
5067         }\r
5068 \r
5069         public Min_elements_stmtContext min_elements_stmt(int i) {\r
5070             return getRuleContext(Min_elements_stmtContext.class, i);\r
5071         }\r
5072 \r
5073         public List<Data_def_stmtContext> data_def_stmt() {\r
5074             return getRuleContexts(Data_def_stmtContext.class);\r
5075         }\r
5076 \r
5077         public Config_stmtContext config_stmt(int i) {\r
5078             return getRuleContext(Config_stmtContext.class, i);\r
5079         }\r
5080 \r
5081         public List<Min_elements_stmtContext> min_elements_stmt() {\r
5082             return getRuleContexts(Min_elements_stmtContext.class);\r
5083         }\r
5084 \r
5085         public List<Description_stmtContext> description_stmt() {\r
5086             return getRuleContexts(Description_stmtContext.class);\r
5087         }\r
5088 \r
5089         public When_stmtContext when_stmt(int i) {\r
5090             return getRuleContext(When_stmtContext.class, i);\r
5091         }\r
5092 \r
5093         public Unique_stmtContext unique_stmt(int i) {\r
5094             return getRuleContext(Unique_stmtContext.class, i);\r
5095         }\r
5096 \r
5097         public List<Grouping_stmtContext> grouping_stmt() {\r
5098             return getRuleContexts(Grouping_stmtContext.class);\r
5099         }\r
5100 \r
5101         public List<Reference_stmtContext> reference_stmt() {\r
5102             return getRuleContexts(Reference_stmtContext.class);\r
5103         }\r
5104 \r
5105         public Typedef_stmtContext typedef_stmt(int i) {\r
5106             return getRuleContext(Typedef_stmtContext.class, i);\r
5107         }\r
5108 \r
5109         public Description_stmtContext description_stmt(int i) {\r
5110             return getRuleContext(Description_stmtContext.class, i);\r
5111         }\r
5112 \r
5113         public Ordered_by_stmtContext ordered_by_stmt(int i) {\r
5114             return getRuleContext(Ordered_by_stmtContext.class, i);\r
5115         }\r
5116 \r
5117         public Grouping_stmtContext grouping_stmt(int i) {\r
5118             return getRuleContext(Grouping_stmtContext.class, i);\r
5119         }\r
5120 \r
5121         public If_feature_stmtContext if_feature_stmt(int i) {\r
5122             return getRuleContext(If_feature_stmtContext.class, i);\r
5123         }\r
5124 \r
5125         public TerminalNode LEFT_BRACE() {\r
5126             return getToken(YangParser.LEFT_BRACE, 0);\r
5127         }\r
5128 \r
5129         public Status_stmtContext status_stmt(int i) {\r
5130             return getRuleContext(Status_stmtContext.class, i);\r
5131         }\r
5132 \r
5133         public List<Ordered_by_stmtContext> ordered_by_stmt() {\r
5134             return getRuleContexts(Ordered_by_stmtContext.class);\r
5135         }\r
5136 \r
5137         public Must_stmtContext must_stmt(int i) {\r
5138             return getRuleContext(Must_stmtContext.class, i);\r
5139         }\r
5140 \r
5141         public List<If_feature_stmtContext> if_feature_stmt() {\r
5142             return getRuleContexts(If_feature_stmtContext.class);\r
5143         }\r
5144 \r
5145         public TerminalNode LIST_KEYWORD() {\r
5146             return getToken(YangParser.LIST_KEYWORD, 0);\r
5147         }\r
5148 \r
5149         public Key_stmtContext key_stmt(int i) {\r
5150             return getRuleContext(Key_stmtContext.class, i);\r
5151         }\r
5152 \r
5153         public Identifier_stmtContext identifier_stmt(int i) {\r
5154             return getRuleContext(Identifier_stmtContext.class, i);\r
5155         }\r
5156 \r
5157         public List<Status_stmtContext> status_stmt() {\r
5158             return getRuleContexts(Status_stmtContext.class);\r
5159         }\r
5160 \r
5161         public List<Must_stmtContext> must_stmt() {\r
5162             return getRuleContexts(Must_stmtContext.class);\r
5163         }\r
5164 \r
5165         public List<Identifier_stmtContext> identifier_stmt() {\r
5166             return getRuleContexts(Identifier_stmtContext.class);\r
5167         }\r
5168 \r
5169         public StringContext string() {\r
5170             return getRuleContext(StringContext.class, 0);\r
5171         }\r
5172 \r
5173         public List<Config_stmtContext> config_stmt() {\r
5174             return getRuleContexts(Config_stmtContext.class);\r
5175         }\r
5176 \r
5177         public List<Unique_stmtContext> unique_stmt() {\r
5178             return getRuleContexts(Unique_stmtContext.class);\r
5179         }\r
5180 \r
5181         public Max_elements_stmtContext max_elements_stmt(int i) {\r
5182             return getRuleContext(Max_elements_stmtContext.class, i);\r
5183         }\r
5184 \r
5185         public List<Key_stmtContext> key_stmt() {\r
5186             return getRuleContexts(Key_stmtContext.class);\r
5187         }\r
5188 \r
5189         public Reference_stmtContext reference_stmt(int i) {\r
5190             return getRuleContext(Reference_stmtContext.class, i);\r
5191         }\r
5192 \r
5193         public List_stmtContext(ParserRuleContext parent, int invokingState) {\r
5194             super(parent, invokingState);\r
5195         }\r
5196 \r
5197         @Override\r
5198         public int getRuleIndex() {\r
5199             return RULE_list_stmt;\r
5200         }\r
5201 \r
5202         @Override\r
5203         public void enterRule(ParseTreeListener listener) {\r
5204             if (listener instanceof YangParserListener)\r
5205                 ((YangParserListener) listener).enterList_stmt(this);\r
5206         }\r
5207 \r
5208         @Override\r
5209         public void exitRule(ParseTreeListener listener) {\r
5210             if (listener instanceof YangParserListener)\r
5211                 ((YangParserListener) listener).exitList_stmt(this);\r
5212         }\r
5213 \r
5214         @Override\r
5215         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
5216             if (visitor instanceof YangParserVisitor)\r
5217                 return ((YangParserVisitor<? extends T>) visitor)\r
5218                         .visitList_stmt(this);\r
5219             else\r
5220                 return visitor.visitChildren(this);\r
5221         }\r
5222     }\r
5223 \r
5224     public final List_stmtContext list_stmt() throws RecognitionException {\r
5225         List_stmtContext _localctx = new List_stmtContext(_ctx, getState());\r
5226         enterRule(_localctx, 64, RULE_list_stmt);\r
5227         int _la;\r
5228         try {\r
5229             enterOuterAlt(_localctx, 1);\r
5230             {\r
5231                 setState(620);\r
5232                 match(LIST_KEYWORD);\r
5233                 setState(621);\r
5234                 string();\r
5235                 setState(622);\r
5236                 match(LEFT_BRACE);\r
5237                 setState(639);\r
5238                 _errHandler.sync(this);\r
5239                 _la = _input.LA(1);\r
5240                 do {\r
5241                     {\r
5242                         setState(639);\r
5243                         switch (_input.LA(1)) {\r
5244                         case IDENTIFIER: {\r
5245                             setState(623);\r
5246                             identifier_stmt();\r
5247                         }\r
5248                             break;\r
5249                         case WHEN_KEYWORD: {\r
5250                             setState(624);\r
5251                             when_stmt();\r
5252                         }\r
5253                             break;\r
5254                         case IF_FEATURE_KEYWORD: {\r
5255                             setState(625);\r
5256                             if_feature_stmt();\r
5257                         }\r
5258                             break;\r
5259                         case MUST_KEYWORD: {\r
5260                             setState(626);\r
5261                             must_stmt();\r
5262                         }\r
5263                             break;\r
5264                         case KEY_KEYWORD: {\r
5265                             setState(627);\r
5266                             key_stmt();\r
5267                         }\r
5268                             break;\r
5269                         case UNIQUE_KEYWORD: {\r
5270                             setState(628);\r
5271                             unique_stmt();\r
5272                         }\r
5273                             break;\r
5274                         case CONFIG_KEYWORD: {\r
5275                             setState(629);\r
5276                             config_stmt();\r
5277                         }\r
5278                             break;\r
5279                         case MIN_ELEMENTS_KEYWORD: {\r
5280                             setState(630);\r
5281                             min_elements_stmt();\r
5282                         }\r
5283                             break;\r
5284                         case MAX_ELEMENTS_KEYWORD: {\r
5285                             setState(631);\r
5286                             max_elements_stmt();\r
5287                         }\r
5288                             break;\r
5289                         case ORDERED_BY_KEYWORD: {\r
5290                             setState(632);\r
5291                             ordered_by_stmt();\r
5292                         }\r
5293                             break;\r
5294                         case STATUS_KEYWORD: {\r
5295                             setState(633);\r
5296                             status_stmt();\r
5297                         }\r
5298                             break;\r
5299                         case DESCRIPTION_KEYWORD: {\r
5300                             setState(634);\r
5301                             description_stmt();\r
5302                         }\r
5303                             break;\r
5304                         case REFERENCE_KEYWORD: {\r
5305                             setState(635);\r
5306                             reference_stmt();\r
5307                         }\r
5308                             break;\r
5309                         case TYPEDEF_KEYWORD: {\r
5310                             setState(636);\r
5311                             typedef_stmt();\r
5312                         }\r
5313                             break;\r
5314                         case GROUPING_KEYWORD: {\r
5315                             setState(637);\r
5316                             grouping_stmt();\r
5317                         }\r
5318                             break;\r
5319                         case USES_KEYWORD:\r
5320                         case LIST_KEYWORD:\r
5321                         case LEAF_LIST_KEYWORD:\r
5322                         case LEAF_KEYWORD:\r
5323                         case CONTAINER_KEYWORD:\r
5324                         case CHOICE_KEYWORD:\r
5325                         case ANYXML_KEYWORD: {\r
5326                             setState(638);\r
5327                             data_def_stmt();\r
5328                         }\r
5329                             break;\r
5330                         default:\r
5331                             throw new NoViableAltException(this);\r
5332                         }\r
5333                     }\r
5334                     setState(641);\r
5335                     _errHandler.sync(this);\r
5336                     _la = _input.LA(1);\r
5337                 } while (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (WHEN_KEYWORD - 10))\r
5338                         | (1L << (USES_KEYWORD - 10))\r
5339                         | (1L << (UNIQUE_KEYWORD - 10))\r
5340                         | (1L << (TYPEDEF_KEYWORD - 10))\r
5341                         | (1L << (STATUS_KEYWORD - 10))\r
5342                         | (1L << (REFERENCE_KEYWORD - 10))\r
5343                         | (1L << (ORDERED_BY_KEYWORD - 10))\r
5344                         | (1L << (MUST_KEYWORD - 10))\r
5345                         | (1L << (MIN_ELEMENTS_KEYWORD - 10))\r
5346                         | (1L << (MAX_ELEMENTS_KEYWORD - 10))\r
5347                         | (1L << (LIST_KEYWORD - 10))\r
5348                         | (1L << (LEAF_LIST_KEYWORD - 10))\r
5349                         | (1L << (LEAF_KEYWORD - 10))\r
5350                         | (1L << (KEY_KEYWORD - 10))\r
5351                         | (1L << (IF_FEATURE_KEYWORD - 10))\r
5352                         | (1L << (GROUPING_KEYWORD - 10))\r
5353                         | (1L << (DESCRIPTION_KEYWORD - 10))\r
5354                         | (1L << (CONTAINER_KEYWORD - 10))\r
5355                         | (1L << (CONFIG_KEYWORD - 10))\r
5356                         | (1L << (CHOICE_KEYWORD - 10))\r
5357                         | (1L << (ANYXML_KEYWORD - 10)) | (1L << (IDENTIFIER - 10)))) != 0));\r
5358                 setState(643);\r
5359                 match(RIGHT_BRACE);\r
5360             }\r
5361         } catch (RecognitionException re) {\r
5362             _localctx.exception = re;\r
5363             _errHandler.reportError(this, re);\r
5364             _errHandler.recover(this, re);\r
5365         } finally {\r
5366             exitRule();\r
5367         }\r
5368         return _localctx;\r
5369     }\r
5370 \r
5371     public static class Leaf_list_stmtContext extends ParserRuleContext {\r
5372         public TerminalNode RIGHT_BRACE() {\r
5373             return getToken(YangParser.RIGHT_BRACE, 0);\r
5374         }\r
5375 \r
5376         public List<When_stmtContext> when_stmt() {\r
5377             return getRuleContexts(When_stmtContext.class);\r
5378         }\r
5379 \r
5380         public Type_stmtContext type_stmt(int i) {\r
5381             return getRuleContext(Type_stmtContext.class, i);\r
5382         }\r
5383 \r
5384         public List<Max_elements_stmtContext> max_elements_stmt() {\r
5385             return getRuleContexts(Max_elements_stmtContext.class);\r
5386         }\r
5387 \r
5388         public Min_elements_stmtContext min_elements_stmt(int i) {\r
5389             return getRuleContext(Min_elements_stmtContext.class, i);\r
5390         }\r
5391 \r
5392         public TerminalNode LEAF_LIST_KEYWORD() {\r
5393             return getToken(YangParser.LEAF_LIST_KEYWORD, 0);\r
5394         }\r
5395 \r
5396         public Config_stmtContext config_stmt(int i) {\r
5397             return getRuleContext(Config_stmtContext.class, i);\r
5398         }\r
5399 \r
5400         public List<Min_elements_stmtContext> min_elements_stmt() {\r
5401             return getRuleContexts(Min_elements_stmtContext.class);\r
5402         }\r
5403 \r
5404         public List<Description_stmtContext> description_stmt() {\r
5405             return getRuleContexts(Description_stmtContext.class);\r
5406         }\r
5407 \r
5408         public When_stmtContext when_stmt(int i) {\r
5409             return getRuleContext(When_stmtContext.class, i);\r
5410         }\r
5411 \r
5412         public Units_stmtContext units_stmt(int i) {\r
5413             return getRuleContext(Units_stmtContext.class, i);\r
5414         }\r
5415 \r
5416         public List<Reference_stmtContext> reference_stmt() {\r
5417             return getRuleContexts(Reference_stmtContext.class);\r
5418         }\r
5419 \r
5420         public Description_stmtContext description_stmt(int i) {\r
5421             return getRuleContext(Description_stmtContext.class, i);\r
5422         }\r
5423 \r
5424         public Ordered_by_stmtContext ordered_by_stmt(int i) {\r
5425             return getRuleContext(Ordered_by_stmtContext.class, i);\r
5426         }\r
5427 \r
5428         public List<Units_stmtContext> units_stmt() {\r
5429             return getRuleContexts(Units_stmtContext.class);\r
5430         }\r
5431 \r
5432         public If_feature_stmtContext if_feature_stmt(int i) {\r
5433             return getRuleContext(If_feature_stmtContext.class, i);\r
5434         }\r
5435 \r
5436         public TerminalNode LEFT_BRACE() {\r
5437             return getToken(YangParser.LEFT_BRACE, 0);\r
5438         }\r
5439 \r
5440         public Status_stmtContext status_stmt(int i) {\r
5441             return getRuleContext(Status_stmtContext.class, i);\r
5442         }\r
5443 \r
5444         public List<Ordered_by_stmtContext> ordered_by_stmt() {\r
5445             return getRuleContexts(Ordered_by_stmtContext.class);\r
5446         }\r
5447 \r
5448         public List<Type_stmtContext> type_stmt() {\r
5449             return getRuleContexts(Type_stmtContext.class);\r
5450         }\r
5451 \r
5452         public List<If_feature_stmtContext> if_feature_stmt() {\r
5453             return getRuleContexts(If_feature_stmtContext.class);\r
5454         }\r
5455 \r
5456         public Must_stmtContext must_stmt(int i) {\r
5457             return getRuleContext(Must_stmtContext.class, i);\r
5458         }\r
5459 \r
5460         public Identifier_stmtContext identifier_stmt(int i) {\r
5461             return getRuleContext(Identifier_stmtContext.class, i);\r
5462         }\r
5463 \r
5464         public List<Status_stmtContext> status_stmt() {\r
5465             return getRuleContexts(Status_stmtContext.class);\r
5466         }\r
5467 \r
5468         public List<Identifier_stmtContext> identifier_stmt() {\r
5469             return getRuleContexts(Identifier_stmtContext.class);\r
5470         }\r
5471 \r
5472         public StringContext string() {\r
5473             return getRuleContext(StringContext.class, 0);\r
5474         }\r
5475 \r
5476         public List<Must_stmtContext> must_stmt() {\r
5477             return getRuleContexts(Must_stmtContext.class);\r
5478         }\r
5479 \r
5480         public List<Config_stmtContext> config_stmt() {\r
5481             return getRuleContexts(Config_stmtContext.class);\r
5482         }\r
5483 \r
5484         public Max_elements_stmtContext max_elements_stmt(int i) {\r
5485             return getRuleContext(Max_elements_stmtContext.class, i);\r
5486         }\r
5487 \r
5488         public Reference_stmtContext reference_stmt(int i) {\r
5489             return getRuleContext(Reference_stmtContext.class, i);\r
5490         }\r
5491 \r
5492         public Leaf_list_stmtContext(ParserRuleContext parent, int invokingState) {\r
5493             super(parent, invokingState);\r
5494         }\r
5495 \r
5496         @Override\r
5497         public int getRuleIndex() {\r
5498             return RULE_leaf_list_stmt;\r
5499         }\r
5500 \r
5501         @Override\r
5502         public void enterRule(ParseTreeListener listener) {\r
5503             if (listener instanceof YangParserListener)\r
5504                 ((YangParserListener) listener).enterLeaf_list_stmt(this);\r
5505         }\r
5506 \r
5507         @Override\r
5508         public void exitRule(ParseTreeListener listener) {\r
5509             if (listener instanceof YangParserListener)\r
5510                 ((YangParserListener) listener).exitLeaf_list_stmt(this);\r
5511         }\r
5512 \r
5513         @Override\r
5514         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
5515             if (visitor instanceof YangParserVisitor)\r
5516                 return ((YangParserVisitor<? extends T>) visitor)\r
5517                         .visitLeaf_list_stmt(this);\r
5518             else\r
5519                 return visitor.visitChildren(this);\r
5520         }\r
5521     }\r
5522 \r
5523     public final Leaf_list_stmtContext leaf_list_stmt()\r
5524             throws RecognitionException {\r
5525         Leaf_list_stmtContext _localctx = new Leaf_list_stmtContext(_ctx,\r
5526                 getState());\r
5527         enterRule(_localctx, 66, RULE_leaf_list_stmt);\r
5528         int _la;\r
5529         try {\r
5530             enterOuterAlt(_localctx, 1);\r
5531             {\r
5532                 setState(645);\r
5533                 match(LEAF_LIST_KEYWORD);\r
5534                 setState(646);\r
5535                 string();\r
5536                 setState(647);\r
5537                 match(LEFT_BRACE);\r
5538                 setState(663);\r
5539                 _errHandler.sync(this);\r
5540                 _la = _input.LA(1);\r
5541                 while (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (WHEN_KEYWORD - 10))\r
5542                         | (1L << (UNITS_KEYWORD - 10))\r
5543                         | (1L << (TYPE_KEYWORD - 10))\r
5544                         | (1L << (STATUS_KEYWORD - 10))\r
5545                         | (1L << (REFERENCE_KEYWORD - 10))\r
5546                         | (1L << (ORDERED_BY_KEYWORD - 10))\r
5547                         | (1L << (MUST_KEYWORD - 10))\r
5548                         | (1L << (MIN_ELEMENTS_KEYWORD - 10))\r
5549                         | (1L << (MAX_ELEMENTS_KEYWORD - 10))\r
5550                         | (1L << (IF_FEATURE_KEYWORD - 10))\r
5551                         | (1L << (DESCRIPTION_KEYWORD - 10))\r
5552                         | (1L << (CONFIG_KEYWORD - 10)) | (1L << (IDENTIFIER - 10)))) != 0)) {\r
5553                     {\r
5554                         setState(661);\r
5555                         switch (_input.LA(1)) {\r
5556                         case IDENTIFIER: {\r
5557                             setState(648);\r
5558                             identifier_stmt();\r
5559                         }\r
5560                             break;\r
5561                         case WHEN_KEYWORD: {\r
5562                             setState(649);\r
5563                             when_stmt();\r
5564                         }\r
5565                             break;\r
5566                         case IF_FEATURE_KEYWORD: {\r
5567                             setState(650);\r
5568                             if_feature_stmt();\r
5569                         }\r
5570                             break;\r
5571                         case TYPE_KEYWORD: {\r
5572                             setState(651);\r
5573                             type_stmt();\r
5574                         }\r
5575                             break;\r
5576                         case UNITS_KEYWORD: {\r
5577                             setState(652);\r
5578                             units_stmt();\r
5579                         }\r
5580                             break;\r
5581                         case MUST_KEYWORD: {\r
5582                             setState(653);\r
5583                             must_stmt();\r
5584                         }\r
5585                             break;\r
5586                         case CONFIG_KEYWORD: {\r
5587                             setState(654);\r
5588                             config_stmt();\r
5589                         }\r
5590                             break;\r
5591                         case MIN_ELEMENTS_KEYWORD: {\r
5592                             setState(655);\r
5593                             min_elements_stmt();\r
5594                         }\r
5595                             break;\r
5596                         case MAX_ELEMENTS_KEYWORD: {\r
5597                             setState(656);\r
5598                             max_elements_stmt();\r
5599                         }\r
5600                             break;\r
5601                         case ORDERED_BY_KEYWORD: {\r
5602                             setState(657);\r
5603                             ordered_by_stmt();\r
5604                         }\r
5605                             break;\r
5606                         case STATUS_KEYWORD: {\r
5607                             setState(658);\r
5608                             status_stmt();\r
5609                         }\r
5610                             break;\r
5611                         case DESCRIPTION_KEYWORD: {\r
5612                             setState(659);\r
5613                             description_stmt();\r
5614                         }\r
5615                             break;\r
5616                         case REFERENCE_KEYWORD: {\r
5617                             setState(660);\r
5618                             reference_stmt();\r
5619                         }\r
5620                             break;\r
5621                         default:\r
5622                             throw new NoViableAltException(this);\r
5623                         }\r
5624                     }\r
5625                     setState(665);\r
5626                     _errHandler.sync(this);\r
5627                     _la = _input.LA(1);\r
5628                 }\r
5629                 setState(666);\r
5630                 match(RIGHT_BRACE);\r
5631             }\r
5632         } catch (RecognitionException re) {\r
5633             _localctx.exception = re;\r
5634             _errHandler.reportError(this, re);\r
5635             _errHandler.recover(this, re);\r
5636         } finally {\r
5637             exitRule();\r
5638         }\r
5639         return _localctx;\r
5640     }\r
5641 \r
5642     public static class Leaf_stmtContext extends ParserRuleContext {\r
5643         public TerminalNode RIGHT_BRACE() {\r
5644             return getToken(YangParser.RIGHT_BRACE, 0);\r
5645         }\r
5646 \r
5647         public List<When_stmtContext> when_stmt() {\r
5648             return getRuleContexts(When_stmtContext.class);\r
5649         }\r
5650 \r
5651         public Type_stmtContext type_stmt(int i) {\r
5652             return getRuleContext(Type_stmtContext.class, i);\r
5653         }\r
5654 \r
5655         public List<Mandatory_stmtContext> mandatory_stmt() {\r
5656             return getRuleContexts(Mandatory_stmtContext.class);\r
5657         }\r
5658 \r
5659         public Config_stmtContext config_stmt(int i) {\r
5660             return getRuleContext(Config_stmtContext.class, i);\r
5661         }\r
5662 \r
5663         public TerminalNode LEAF_KEYWORD() {\r
5664             return getToken(YangParser.LEAF_KEYWORD, 0);\r
5665         }\r
5666 \r
5667         public List<Description_stmtContext> description_stmt() {\r
5668             return getRuleContexts(Description_stmtContext.class);\r
5669         }\r
5670 \r
5671         public When_stmtContext when_stmt(int i) {\r
5672             return getRuleContext(When_stmtContext.class, i);\r
5673         }\r
5674 \r
5675         public Units_stmtContext units_stmt(int i) {\r
5676             return getRuleContext(Units_stmtContext.class, i);\r
5677         }\r
5678 \r
5679         public List<Reference_stmtContext> reference_stmt() {\r
5680             return getRuleContexts(Reference_stmtContext.class);\r
5681         }\r
5682 \r
5683         public Description_stmtContext description_stmt(int i) {\r
5684             return getRuleContext(Description_stmtContext.class, i);\r
5685         }\r
5686 \r
5687         public Default_stmtContext default_stmt(int i) {\r
5688             return getRuleContext(Default_stmtContext.class, i);\r
5689         }\r
5690 \r
5691         public List<Units_stmtContext> units_stmt() {\r
5692             return getRuleContexts(Units_stmtContext.class);\r
5693         }\r
5694 \r
5695         public If_feature_stmtContext if_feature_stmt(int i) {\r
5696             return getRuleContext(If_feature_stmtContext.class, i);\r
5697         }\r
5698 \r
5699         public TerminalNode LEFT_BRACE() {\r
5700             return getToken(YangParser.LEFT_BRACE, 0);\r
5701         }\r
5702 \r
5703         public Status_stmtContext status_stmt(int i) {\r
5704             return getRuleContext(Status_stmtContext.class, i);\r
5705         }\r
5706 \r
5707         public List<Type_stmtContext> type_stmt() {\r
5708             return getRuleContexts(Type_stmtContext.class);\r
5709         }\r
5710 \r
5711         public List<If_feature_stmtContext> if_feature_stmt() {\r
5712             return getRuleContexts(If_feature_stmtContext.class);\r
5713         }\r
5714 \r
5715         public Must_stmtContext must_stmt(int i) {\r
5716             return getRuleContext(Must_stmtContext.class, i);\r
5717         }\r
5718 \r
5719         public Identifier_stmtContext identifier_stmt(int i) {\r
5720             return getRuleContext(Identifier_stmtContext.class, i);\r
5721         }\r
5722 \r
5723         public List<Default_stmtContext> default_stmt() {\r
5724             return getRuleContexts(Default_stmtContext.class);\r
5725         }\r
5726 \r
5727         public Mandatory_stmtContext mandatory_stmt(int i) {\r
5728             return getRuleContext(Mandatory_stmtContext.class, i);\r
5729         }\r
5730 \r
5731         public List<Status_stmtContext> status_stmt() {\r
5732             return getRuleContexts(Status_stmtContext.class);\r
5733         }\r
5734 \r
5735         public List<Identifier_stmtContext> identifier_stmt() {\r
5736             return getRuleContexts(Identifier_stmtContext.class);\r
5737         }\r
5738 \r
5739         public StringContext string() {\r
5740             return getRuleContext(StringContext.class, 0);\r
5741         }\r
5742 \r
5743         public List<Must_stmtContext> must_stmt() {\r
5744             return getRuleContexts(Must_stmtContext.class);\r
5745         }\r
5746 \r
5747         public List<Config_stmtContext> config_stmt() {\r
5748             return getRuleContexts(Config_stmtContext.class);\r
5749         }\r
5750 \r
5751         public Reference_stmtContext reference_stmt(int i) {\r
5752             return getRuleContext(Reference_stmtContext.class, i);\r
5753         }\r
5754 \r
5755         public Leaf_stmtContext(ParserRuleContext parent, int invokingState) {\r
5756             super(parent, invokingState);\r
5757         }\r
5758 \r
5759         @Override\r
5760         public int getRuleIndex() {\r
5761             return RULE_leaf_stmt;\r
5762         }\r
5763 \r
5764         @Override\r
5765         public void enterRule(ParseTreeListener listener) {\r
5766             if (listener instanceof YangParserListener)\r
5767                 ((YangParserListener) listener).enterLeaf_stmt(this);\r
5768         }\r
5769 \r
5770         @Override\r
5771         public void exitRule(ParseTreeListener listener) {\r
5772             if (listener instanceof YangParserListener)\r
5773                 ((YangParserListener) listener).exitLeaf_stmt(this);\r
5774         }\r
5775 \r
5776         @Override\r
5777         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
5778             if (visitor instanceof YangParserVisitor)\r
5779                 return ((YangParserVisitor<? extends T>) visitor)\r
5780                         .visitLeaf_stmt(this);\r
5781             else\r
5782                 return visitor.visitChildren(this);\r
5783         }\r
5784     }\r
5785 \r
5786     public final Leaf_stmtContext leaf_stmt() throws RecognitionException {\r
5787         Leaf_stmtContext _localctx = new Leaf_stmtContext(_ctx, getState());\r
5788         enterRule(_localctx, 68, RULE_leaf_stmt);\r
5789         int _la;\r
5790         try {\r
5791             enterOuterAlt(_localctx, 1);\r
5792             {\r
5793                 setState(668);\r
5794                 match(LEAF_KEYWORD);\r
5795                 setState(669);\r
5796                 string();\r
5797                 setState(670);\r
5798                 match(LEFT_BRACE);\r
5799                 setState(685);\r
5800                 _errHandler.sync(this);\r
5801                 _la = _input.LA(1);\r
5802                 while (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (WHEN_KEYWORD - 10))\r
5803                         | (1L << (UNITS_KEYWORD - 10))\r
5804                         | (1L << (TYPE_KEYWORD - 10))\r
5805                         | (1L << (STATUS_KEYWORD - 10))\r
5806                         | (1L << (REFERENCE_KEYWORD - 10))\r
5807                         | (1L << (MUST_KEYWORD - 10))\r
5808                         | (1L << (MANDATORY_KEYWORD - 10))\r
5809                         | (1L << (IF_FEATURE_KEYWORD - 10))\r
5810                         | (1L << (DESCRIPTION_KEYWORD - 10))\r
5811                         | (1L << (DEFAULT_KEYWORD - 10))\r
5812                         | (1L << (CONFIG_KEYWORD - 10)) | (1L << (IDENTIFIER - 10)))) != 0)) {\r
5813                     {\r
5814                         setState(683);\r
5815                         switch (_input.LA(1)) {\r
5816                         case IDENTIFIER: {\r
5817                             setState(671);\r
5818                             identifier_stmt();\r
5819                         }\r
5820                             break;\r
5821                         case WHEN_KEYWORD: {\r
5822                             setState(672);\r
5823                             when_stmt();\r
5824                         }\r
5825                             break;\r
5826                         case IF_FEATURE_KEYWORD: {\r
5827                             setState(673);\r
5828                             if_feature_stmt();\r
5829                         }\r
5830                             break;\r
5831                         case TYPE_KEYWORD: {\r
5832                             setState(674);\r
5833                             type_stmt();\r
5834                         }\r
5835                             break;\r
5836                         case UNITS_KEYWORD: {\r
5837                             setState(675);\r
5838                             units_stmt();\r
5839                         }\r
5840                             break;\r
5841                         case MUST_KEYWORD: {\r
5842                             setState(676);\r
5843                             must_stmt();\r
5844                         }\r
5845                             break;\r
5846                         case DEFAULT_KEYWORD: {\r
5847                             setState(677);\r
5848                             default_stmt();\r
5849                         }\r
5850                             break;\r
5851                         case CONFIG_KEYWORD: {\r
5852                             setState(678);\r
5853                             config_stmt();\r
5854                         }\r
5855                             break;\r
5856                         case MANDATORY_KEYWORD: {\r
5857                             setState(679);\r
5858                             mandatory_stmt();\r
5859                         }\r
5860                             break;\r
5861                         case STATUS_KEYWORD: {\r
5862                             setState(680);\r
5863                             status_stmt();\r
5864                         }\r
5865                             break;\r
5866                         case DESCRIPTION_KEYWORD: {\r
5867                             setState(681);\r
5868                             description_stmt();\r
5869                         }\r
5870                             break;\r
5871                         case REFERENCE_KEYWORD: {\r
5872                             setState(682);\r
5873                             reference_stmt();\r
5874                         }\r
5875                             break;\r
5876                         default:\r
5877                             throw new NoViableAltException(this);\r
5878                         }\r
5879                     }\r
5880                     setState(687);\r
5881                     _errHandler.sync(this);\r
5882                     _la = _input.LA(1);\r
5883                 }\r
5884                 setState(688);\r
5885                 match(RIGHT_BRACE);\r
5886             }\r
5887         } catch (RecognitionException re) {\r
5888             _localctx.exception = re;\r
5889             _errHandler.reportError(this, re);\r
5890             _errHandler.recover(this, re);\r
5891         } finally {\r
5892             exitRule();\r
5893         }\r
5894         return _localctx;\r
5895     }\r
5896 \r
5897     public static class Container_stmtContext extends ParserRuleContext {\r
5898         public TerminalNode RIGHT_BRACE() {\r
5899             return getToken(YangParser.RIGHT_BRACE, 0);\r
5900         }\r
5901 \r
5902         public List<When_stmtContext> when_stmt() {\r
5903             return getRuleContexts(When_stmtContext.class);\r
5904         }\r
5905 \r
5906         public Data_def_stmtContext data_def_stmt(int i) {\r
5907             return getRuleContext(Data_def_stmtContext.class, i);\r
5908         }\r
5909 \r
5910         public List<Typedef_stmtContext> typedef_stmt() {\r
5911             return getRuleContexts(Typedef_stmtContext.class);\r
5912         }\r
5913 \r
5914         public List<Data_def_stmtContext> data_def_stmt() {\r
5915             return getRuleContexts(Data_def_stmtContext.class);\r
5916         }\r
5917 \r
5918         public TerminalNode SEMICOLON() {\r
5919             return getToken(YangParser.SEMICOLON, 0);\r
5920         }\r
5921 \r
5922         public Config_stmtContext config_stmt(int i) {\r
5923             return getRuleContext(Config_stmtContext.class, i);\r
5924         }\r
5925 \r
5926         public List<Description_stmtContext> description_stmt() {\r
5927             return getRuleContexts(Description_stmtContext.class);\r
5928         }\r
5929 \r
5930         public When_stmtContext when_stmt(int i) {\r
5931             return getRuleContext(When_stmtContext.class, i);\r
5932         }\r
5933 \r
5934         public List<Grouping_stmtContext> grouping_stmt() {\r
5935             return getRuleContexts(Grouping_stmtContext.class);\r
5936         }\r
5937 \r
5938         public TerminalNode CONTAINER_KEYWORD() {\r
5939             return getToken(YangParser.CONTAINER_KEYWORD, 0);\r
5940         }\r
5941 \r
5942         public List<Presence_stmtContext> presence_stmt() {\r
5943             return getRuleContexts(Presence_stmtContext.class);\r
5944         }\r
5945 \r
5946         public List<Reference_stmtContext> reference_stmt() {\r
5947             return getRuleContexts(Reference_stmtContext.class);\r
5948         }\r
5949 \r
5950         public Typedef_stmtContext typedef_stmt(int i) {\r
5951             return getRuleContext(Typedef_stmtContext.class, i);\r
5952         }\r
5953 \r
5954         public Description_stmtContext description_stmt(int i) {\r
5955             return getRuleContext(Description_stmtContext.class, i);\r
5956         }\r
5957 \r
5958         public Grouping_stmtContext grouping_stmt(int i) {\r
5959             return getRuleContext(Grouping_stmtContext.class, i);\r
5960         }\r
5961 \r
5962         public If_feature_stmtContext if_feature_stmt(int i) {\r
5963             return getRuleContext(If_feature_stmtContext.class, i);\r
5964         }\r
5965 \r
5966         public TerminalNode LEFT_BRACE() {\r
5967             return getToken(YangParser.LEFT_BRACE, 0);\r
5968         }\r
5969 \r
5970         public Status_stmtContext status_stmt(int i) {\r
5971             return getRuleContext(Status_stmtContext.class, i);\r
5972         }\r
5973 \r
5974         public List<If_feature_stmtContext> if_feature_stmt() {\r
5975             return getRuleContexts(If_feature_stmtContext.class);\r
5976         }\r
5977 \r
5978         public Must_stmtContext must_stmt(int i) {\r
5979             return getRuleContext(Must_stmtContext.class, i);\r
5980         }\r
5981 \r
5982         public Identifier_stmtContext identifier_stmt(int i) {\r
5983             return getRuleContext(Identifier_stmtContext.class, i);\r
5984         }\r
5985 \r
5986         public List<Status_stmtContext> status_stmt() {\r
5987             return getRuleContexts(Status_stmtContext.class);\r
5988         }\r
5989 \r
5990         public Presence_stmtContext presence_stmt(int i) {\r
5991             return getRuleContext(Presence_stmtContext.class, i);\r
5992         }\r
5993 \r
5994         public List<Must_stmtContext> must_stmt() {\r
5995             return getRuleContexts(Must_stmtContext.class);\r
5996         }\r
5997 \r
5998         public List<Identifier_stmtContext> identifier_stmt() {\r
5999             return getRuleContexts(Identifier_stmtContext.class);\r
6000         }\r
6001 \r
6002         public StringContext string() {\r
6003             return getRuleContext(StringContext.class, 0);\r
6004         }\r
6005 \r
6006         public List<Config_stmtContext> config_stmt() {\r
6007             return getRuleContexts(Config_stmtContext.class);\r
6008         }\r
6009 \r
6010         public Reference_stmtContext reference_stmt(int i) {\r
6011             return getRuleContext(Reference_stmtContext.class, i);\r
6012         }\r
6013 \r
6014         public Container_stmtContext(ParserRuleContext parent, int invokingState) {\r
6015             super(parent, invokingState);\r
6016         }\r
6017 \r
6018         @Override\r
6019         public int getRuleIndex() {\r
6020             return RULE_container_stmt;\r
6021         }\r
6022 \r
6023         @Override\r
6024         public void enterRule(ParseTreeListener listener) {\r
6025             if (listener instanceof YangParserListener)\r
6026                 ((YangParserListener) listener).enterContainer_stmt(this);\r
6027         }\r
6028 \r
6029         @Override\r
6030         public void exitRule(ParseTreeListener listener) {\r
6031             if (listener instanceof YangParserListener)\r
6032                 ((YangParserListener) listener).exitContainer_stmt(this);\r
6033         }\r
6034 \r
6035         @Override\r
6036         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
6037             if (visitor instanceof YangParserVisitor)\r
6038                 return ((YangParserVisitor<? extends T>) visitor)\r
6039                         .visitContainer_stmt(this);\r
6040             else\r
6041                 return visitor.visitChildren(this);\r
6042         }\r
6043     }\r
6044 \r
6045     public final Container_stmtContext container_stmt()\r
6046             throws RecognitionException {\r
6047         Container_stmtContext _localctx = new Container_stmtContext(_ctx,\r
6048                 getState());\r
6049         enterRule(_localctx, 70, RULE_container_stmt);\r
6050         int _la;\r
6051         try {\r
6052             enterOuterAlt(_localctx, 1);\r
6053             {\r
6054                 setState(690);\r
6055                 match(CONTAINER_KEYWORD);\r
6056                 setState(691);\r
6057                 string();\r
6058                 setState(712);\r
6059                 switch (_input.LA(1)) {\r
6060                 case SEMICOLON: {\r
6061                     setState(692);\r
6062                     match(SEMICOLON);\r
6063                 }\r
6064                     break;\r
6065                 case LEFT_BRACE: {\r
6066                     {\r
6067                         setState(693);\r
6068                         match(LEFT_BRACE);\r
6069                         setState(708);\r
6070                         _errHandler.sync(this);\r
6071                         _la = _input.LA(1);\r
6072                         while (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (WHEN_KEYWORD - 10))\r
6073                                 | (1L << (USES_KEYWORD - 10))\r
6074                                 | (1L << (TYPEDEF_KEYWORD - 10))\r
6075                                 | (1L << (STATUS_KEYWORD - 10))\r
6076                                 | (1L << (REFERENCE_KEYWORD - 10))\r
6077                                 | (1L << (PRESENCE_KEYWORD - 10))\r
6078                                 | (1L << (MUST_KEYWORD - 10))\r
6079                                 | (1L << (LIST_KEYWORD - 10))\r
6080                                 | (1L << (LEAF_LIST_KEYWORD - 10))\r
6081                                 | (1L << (LEAF_KEYWORD - 10))\r
6082                                 | (1L << (IF_FEATURE_KEYWORD - 10))\r
6083                                 | (1L << (GROUPING_KEYWORD - 10))\r
6084                                 | (1L << (DESCRIPTION_KEYWORD - 10))\r
6085                                 | (1L << (CONTAINER_KEYWORD - 10))\r
6086                                 | (1L << (CONFIG_KEYWORD - 10))\r
6087                                 | (1L << (CHOICE_KEYWORD - 10))\r
6088                                 | (1L << (ANYXML_KEYWORD - 10)) | (1L << (IDENTIFIER - 10)))) != 0)) {\r
6089                             {\r
6090                                 setState(706);\r
6091                                 switch (_input.LA(1)) {\r
6092                                 case IDENTIFIER: {\r
6093                                     setState(694);\r
6094                                     identifier_stmt();\r
6095                                 }\r
6096                                     break;\r
6097                                 case WHEN_KEYWORD: {\r
6098                                     setState(695);\r
6099                                     when_stmt();\r
6100                                 }\r
6101                                     break;\r
6102                                 case IF_FEATURE_KEYWORD: {\r
6103                                     setState(696);\r
6104                                     if_feature_stmt();\r
6105                                 }\r
6106                                     break;\r
6107                                 case MUST_KEYWORD: {\r
6108                                     setState(697);\r
6109                                     must_stmt();\r
6110                                 }\r
6111                                     break;\r
6112                                 case PRESENCE_KEYWORD: {\r
6113                                     setState(698);\r
6114                                     presence_stmt();\r
6115                                 }\r
6116                                     break;\r
6117                                 case CONFIG_KEYWORD: {\r
6118                                     setState(699);\r
6119                                     config_stmt();\r
6120                                 }\r
6121                                     break;\r
6122                                 case STATUS_KEYWORD: {\r
6123                                     setState(700);\r
6124                                     status_stmt();\r
6125                                 }\r
6126                                     break;\r
6127                                 case DESCRIPTION_KEYWORD: {\r
6128                                     setState(701);\r
6129                                     description_stmt();\r
6130                                 }\r
6131                                     break;\r
6132                                 case REFERENCE_KEYWORD: {\r
6133                                     setState(702);\r
6134                                     reference_stmt();\r
6135                                 }\r
6136                                     break;\r
6137                                 case TYPEDEF_KEYWORD: {\r
6138                                     setState(703);\r
6139                                     typedef_stmt();\r
6140                                 }\r
6141                                     break;\r
6142                                 case GROUPING_KEYWORD: {\r
6143                                     setState(704);\r
6144                                     grouping_stmt();\r
6145                                 }\r
6146                                     break;\r
6147                                 case USES_KEYWORD:\r
6148                                 case LIST_KEYWORD:\r
6149                                 case LEAF_LIST_KEYWORD:\r
6150                                 case LEAF_KEYWORD:\r
6151                                 case CONTAINER_KEYWORD:\r
6152                                 case CHOICE_KEYWORD:\r
6153                                 case ANYXML_KEYWORD: {\r
6154                                     setState(705);\r
6155                                     data_def_stmt();\r
6156                                 }\r
6157                                     break;\r
6158                                 default:\r
6159                                     throw new NoViableAltException(this);\r
6160                                 }\r
6161                             }\r
6162                             setState(710);\r
6163                             _errHandler.sync(this);\r
6164                             _la = _input.LA(1);\r
6165                         }\r
6166                         setState(711);\r
6167                         match(RIGHT_BRACE);\r
6168                     }\r
6169                 }\r
6170                     break;\r
6171                 default:\r
6172                     throw new NoViableAltException(this);\r
6173                 }\r
6174             }\r
6175         } catch (RecognitionException re) {\r
6176             _localctx.exception = re;\r
6177             _errHandler.reportError(this, re);\r
6178             _errHandler.recover(this, re);\r
6179         } finally {\r
6180             exitRule();\r
6181         }\r
6182         return _localctx;\r
6183     }\r
6184 \r
6185     public static class Grouping_stmtContext extends ParserRuleContext {\r
6186         public List<Grouping_stmtContext> grouping_stmt() {\r
6187             return getRuleContexts(Grouping_stmtContext.class);\r
6188         }\r
6189 \r
6190         public TerminalNode RIGHT_BRACE() {\r
6191             return getToken(YangParser.RIGHT_BRACE, 0);\r
6192         }\r
6193 \r
6194         public List<Reference_stmtContext> reference_stmt() {\r
6195             return getRuleContexts(Reference_stmtContext.class);\r
6196         }\r
6197 \r
6198         public Typedef_stmtContext typedef_stmt(int i) {\r
6199             return getRuleContext(Typedef_stmtContext.class, i);\r
6200         }\r
6201 \r
6202         public Description_stmtContext description_stmt(int i) {\r
6203             return getRuleContext(Description_stmtContext.class, i);\r
6204         }\r
6205 \r
6206         public Grouping_stmtContext grouping_stmt(int i) {\r
6207             return getRuleContext(Grouping_stmtContext.class, i);\r
6208         }\r
6209 \r
6210         public TerminalNode LEFT_BRACE() {\r
6211             return getToken(YangParser.LEFT_BRACE, 0);\r
6212         }\r
6213 \r
6214         public Data_def_stmtContext data_def_stmt(int i) {\r
6215             return getRuleContext(Data_def_stmtContext.class, i);\r
6216         }\r
6217 \r
6218         public List<Typedef_stmtContext> typedef_stmt() {\r
6219             return getRuleContexts(Typedef_stmtContext.class);\r
6220         }\r
6221 \r
6222         public Status_stmtContext status_stmt(int i) {\r
6223             return getRuleContext(Status_stmtContext.class, i);\r
6224         }\r
6225 \r
6226         public Identifier_stmtContext identifier_stmt(int i) {\r
6227             return getRuleContext(Identifier_stmtContext.class, i);\r
6228         }\r
6229 \r
6230         public List<Data_def_stmtContext> data_def_stmt() {\r
6231             return getRuleContexts(Data_def_stmtContext.class);\r
6232         }\r
6233 \r
6234         public TerminalNode GROUPING_KEYWORD() {\r
6235             return getToken(YangParser.GROUPING_KEYWORD, 0);\r
6236         }\r
6237 \r
6238         public TerminalNode SEMICOLON() {\r
6239             return getToken(YangParser.SEMICOLON, 0);\r
6240         }\r
6241 \r
6242         public List<Status_stmtContext> status_stmt() {\r
6243             return getRuleContexts(Status_stmtContext.class);\r
6244         }\r
6245 \r
6246         public StringContext string() {\r
6247             return getRuleContext(StringContext.class, 0);\r
6248         }\r
6249 \r
6250         public List<Identifier_stmtContext> identifier_stmt() {\r
6251             return getRuleContexts(Identifier_stmtContext.class);\r
6252         }\r
6253 \r
6254         public List<Description_stmtContext> description_stmt() {\r
6255             return getRuleContexts(Description_stmtContext.class);\r
6256         }\r
6257 \r
6258         public Reference_stmtContext reference_stmt(int i) {\r
6259             return getRuleContext(Reference_stmtContext.class, i);\r
6260         }\r
6261 \r
6262         public Grouping_stmtContext(ParserRuleContext parent, int invokingState) {\r
6263             super(parent, invokingState);\r
6264         }\r
6265 \r
6266         @Override\r
6267         public int getRuleIndex() {\r
6268             return RULE_grouping_stmt;\r
6269         }\r
6270 \r
6271         @Override\r
6272         public void enterRule(ParseTreeListener listener) {\r
6273             if (listener instanceof YangParserListener)\r
6274                 ((YangParserListener) listener).enterGrouping_stmt(this);\r
6275         }\r
6276 \r
6277         @Override\r
6278         public void exitRule(ParseTreeListener listener) {\r
6279             if (listener instanceof YangParserListener)\r
6280                 ((YangParserListener) listener).exitGrouping_stmt(this);\r
6281         }\r
6282 \r
6283         @Override\r
6284         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
6285             if (visitor instanceof YangParserVisitor)\r
6286                 return ((YangParserVisitor<? extends T>) visitor)\r
6287                         .visitGrouping_stmt(this);\r
6288             else\r
6289                 return visitor.visitChildren(this);\r
6290         }\r
6291     }\r
6292 \r
6293     public final Grouping_stmtContext grouping_stmt()\r
6294             throws RecognitionException {\r
6295         Grouping_stmtContext _localctx = new Grouping_stmtContext(_ctx,\r
6296                 getState());\r
6297         enterRule(_localctx, 72, RULE_grouping_stmt);\r
6298         int _la;\r
6299         try {\r
6300             enterOuterAlt(_localctx, 1);\r
6301             {\r
6302                 setState(714);\r
6303                 match(GROUPING_KEYWORD);\r
6304                 setState(715);\r
6305                 string();\r
6306                 setState(731);\r
6307                 switch (_input.LA(1)) {\r
6308                 case SEMICOLON: {\r
6309                     setState(716);\r
6310                     match(SEMICOLON);\r
6311                 }\r
6312                     break;\r
6313                 case LEFT_BRACE: {\r
6314                     {\r
6315                         setState(717);\r
6316                         match(LEFT_BRACE);\r
6317                         setState(727);\r
6318                         _errHandler.sync(this);\r
6319                         _la = _input.LA(1);\r
6320                         while (((((_la - 12)) & ~0x3f) == 0 && ((1L << (_la - 12)) & ((1L << (USES_KEYWORD - 12))\r
6321                                 | (1L << (TYPEDEF_KEYWORD - 12))\r
6322                                 | (1L << (STATUS_KEYWORD - 12))\r
6323                                 | (1L << (REFERENCE_KEYWORD - 12))\r
6324                                 | (1L << (LIST_KEYWORD - 12))\r
6325                                 | (1L << (LEAF_LIST_KEYWORD - 12))\r
6326                                 | (1L << (LEAF_KEYWORD - 12))\r
6327                                 | (1L << (GROUPING_KEYWORD - 12))\r
6328                                 | (1L << (DESCRIPTION_KEYWORD - 12))\r
6329                                 | (1L << (CONTAINER_KEYWORD - 12))\r
6330                                 | (1L << (CHOICE_KEYWORD - 12))\r
6331                                 | (1L << (ANYXML_KEYWORD - 12)) | (1L << (IDENTIFIER - 12)))) != 0)) {\r
6332                             {\r
6333                                 setState(725);\r
6334                                 switch (_input.LA(1)) {\r
6335                                 case IDENTIFIER: {\r
6336                                     setState(718);\r
6337                                     identifier_stmt();\r
6338                                 }\r
6339                                     break;\r
6340                                 case STATUS_KEYWORD: {\r
6341                                     setState(719);\r
6342                                     status_stmt();\r
6343                                 }\r
6344                                     break;\r
6345                                 case DESCRIPTION_KEYWORD: {\r
6346                                     setState(720);\r
6347                                     description_stmt();\r
6348                                 }\r
6349                                     break;\r
6350                                 case REFERENCE_KEYWORD: {\r
6351                                     setState(721);\r
6352                                     reference_stmt();\r
6353                                 }\r
6354                                     break;\r
6355                                 case TYPEDEF_KEYWORD: {\r
6356                                     setState(722);\r
6357                                     typedef_stmt();\r
6358                                 }\r
6359                                     break;\r
6360                                 case GROUPING_KEYWORD: {\r
6361                                     setState(723);\r
6362                                     grouping_stmt();\r
6363                                 }\r
6364                                     break;\r
6365                                 case USES_KEYWORD:\r
6366                                 case LIST_KEYWORD:\r
6367                                 case LEAF_LIST_KEYWORD:\r
6368                                 case LEAF_KEYWORD:\r
6369                                 case CONTAINER_KEYWORD:\r
6370                                 case CHOICE_KEYWORD:\r
6371                                 case ANYXML_KEYWORD: {\r
6372                                     setState(724);\r
6373                                     data_def_stmt();\r
6374                                 }\r
6375                                     break;\r
6376                                 default:\r
6377                                     throw new NoViableAltException(this);\r
6378                                 }\r
6379                             }\r
6380                             setState(729);\r
6381                             _errHandler.sync(this);\r
6382                             _la = _input.LA(1);\r
6383                         }\r
6384                         setState(730);\r
6385                         match(RIGHT_BRACE);\r
6386                     }\r
6387                 }\r
6388                     break;\r
6389                 default:\r
6390                     throw new NoViableAltException(this);\r
6391                 }\r
6392             }\r
6393         } catch (RecognitionException re) {\r
6394             _localctx.exception = re;\r
6395             _errHandler.reportError(this, re);\r
6396             _errHandler.recover(this, re);\r
6397         } finally {\r
6398             exitRule();\r
6399         }\r
6400         return _localctx;\r
6401     }\r
6402 \r
6403     public static class Value_stmtContext extends ParserRuleContext {\r
6404         public StringContext string() {\r
6405             return getRuleContext(StringContext.class, 0);\r
6406         }\r
6407 \r
6408         public StmtendContext stmtend() {\r
6409             return getRuleContext(StmtendContext.class, 0);\r
6410         }\r
6411 \r
6412         public TerminalNode VALUE_KEYWORD() {\r
6413             return getToken(YangParser.VALUE_KEYWORD, 0);\r
6414         }\r
6415 \r
6416         public Value_stmtContext(ParserRuleContext parent, int invokingState) {\r
6417             super(parent, invokingState);\r
6418         }\r
6419 \r
6420         @Override\r
6421         public int getRuleIndex() {\r
6422             return RULE_value_stmt;\r
6423         }\r
6424 \r
6425         @Override\r
6426         public void enterRule(ParseTreeListener listener) {\r
6427             if (listener instanceof YangParserListener)\r
6428                 ((YangParserListener) listener).enterValue_stmt(this);\r
6429         }\r
6430 \r
6431         @Override\r
6432         public void exitRule(ParseTreeListener listener) {\r
6433             if (listener instanceof YangParserListener)\r
6434                 ((YangParserListener) listener).exitValue_stmt(this);\r
6435         }\r
6436 \r
6437         @Override\r
6438         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
6439             if (visitor instanceof YangParserVisitor)\r
6440                 return ((YangParserVisitor<? extends T>) visitor)\r
6441                         .visitValue_stmt(this);\r
6442             else\r
6443                 return visitor.visitChildren(this);\r
6444         }\r
6445     }\r
6446 \r
6447     public final Value_stmtContext value_stmt() throws RecognitionException {\r
6448         Value_stmtContext _localctx = new Value_stmtContext(_ctx, getState());\r
6449         enterRule(_localctx, 74, RULE_value_stmt);\r
6450         try {\r
6451             enterOuterAlt(_localctx, 1);\r
6452             {\r
6453                 setState(733);\r
6454                 match(VALUE_KEYWORD);\r
6455                 setState(734);\r
6456                 string();\r
6457                 setState(735);\r
6458                 stmtend();\r
6459             }\r
6460         } catch (RecognitionException re) {\r
6461             _localctx.exception = re;\r
6462             _errHandler.reportError(this, re);\r
6463             _errHandler.recover(this, re);\r
6464         } finally {\r
6465             exitRule();\r
6466         }\r
6467         return _localctx;\r
6468     }\r
6469 \r
6470     public static class Max_value_argContext extends ParserRuleContext {\r
6471         public StringContext string() {\r
6472             return getRuleContext(StringContext.class, 0);\r
6473         }\r
6474 \r
6475         public Max_value_argContext(ParserRuleContext parent, int invokingState) {\r
6476             super(parent, invokingState);\r
6477         }\r
6478 \r
6479         @Override\r
6480         public int getRuleIndex() {\r
6481             return RULE_max_value_arg;\r
6482         }\r
6483 \r
6484         @Override\r
6485         public void enterRule(ParseTreeListener listener) {\r
6486             if (listener instanceof YangParserListener)\r
6487                 ((YangParserListener) listener).enterMax_value_arg(this);\r
6488         }\r
6489 \r
6490         @Override\r
6491         public void exitRule(ParseTreeListener listener) {\r
6492             if (listener instanceof YangParserListener)\r
6493                 ((YangParserListener) listener).exitMax_value_arg(this);\r
6494         }\r
6495 \r
6496         @Override\r
6497         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
6498             if (visitor instanceof YangParserVisitor)\r
6499                 return ((YangParserVisitor<? extends T>) visitor)\r
6500                         .visitMax_value_arg(this);\r
6501             else\r
6502                 return visitor.visitChildren(this);\r
6503         }\r
6504     }\r
6505 \r
6506     public final Max_value_argContext max_value_arg()\r
6507             throws RecognitionException {\r
6508         Max_value_argContext _localctx = new Max_value_argContext(_ctx,\r
6509                 getState());\r
6510         enterRule(_localctx, 76, RULE_max_value_arg);\r
6511         try {\r
6512             enterOuterAlt(_localctx, 1);\r
6513             {\r
6514                 setState(737);\r
6515                 string();\r
6516             }\r
6517         } catch (RecognitionException re) {\r
6518             _localctx.exception = re;\r
6519             _errHandler.reportError(this, re);\r
6520             _errHandler.recover(this, re);\r
6521         } finally {\r
6522             exitRule();\r
6523         }\r
6524         return _localctx;\r
6525     }\r
6526 \r
6527     public static class Max_elements_stmtContext extends ParserRuleContext {\r
6528         public TerminalNode MAX_ELEMENTS_KEYWORD() {\r
6529             return getToken(YangParser.MAX_ELEMENTS_KEYWORD, 0);\r
6530         }\r
6531 \r
6532         public Max_value_argContext max_value_arg() {\r
6533             return getRuleContext(Max_value_argContext.class, 0);\r
6534         }\r
6535 \r
6536         public StmtendContext stmtend() {\r
6537             return getRuleContext(StmtendContext.class, 0);\r
6538         }\r
6539 \r
6540         public Max_elements_stmtContext(ParserRuleContext parent,\r
6541                 int invokingState) {\r
6542             super(parent, invokingState);\r
6543         }\r
6544 \r
6545         @Override\r
6546         public int getRuleIndex() {\r
6547             return RULE_max_elements_stmt;\r
6548         }\r
6549 \r
6550         @Override\r
6551         public void enterRule(ParseTreeListener listener) {\r
6552             if (listener instanceof YangParserListener)\r
6553                 ((YangParserListener) listener).enterMax_elements_stmt(this);\r
6554         }\r
6555 \r
6556         @Override\r
6557         public void exitRule(ParseTreeListener listener) {\r
6558             if (listener instanceof YangParserListener)\r
6559                 ((YangParserListener) listener).exitMax_elements_stmt(this);\r
6560         }\r
6561 \r
6562         @Override\r
6563         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
6564             if (visitor instanceof YangParserVisitor)\r
6565                 return ((YangParserVisitor<? extends T>) visitor)\r
6566                         .visitMax_elements_stmt(this);\r
6567             else\r
6568                 return visitor.visitChildren(this);\r
6569         }\r
6570     }\r
6571 \r
6572     public final Max_elements_stmtContext max_elements_stmt()\r
6573             throws RecognitionException {\r
6574         Max_elements_stmtContext _localctx = new Max_elements_stmtContext(_ctx,\r
6575                 getState());\r
6576         enterRule(_localctx, 78, RULE_max_elements_stmt);\r
6577         try {\r
6578             enterOuterAlt(_localctx, 1);\r
6579             {\r
6580                 setState(739);\r
6581                 match(MAX_ELEMENTS_KEYWORD);\r
6582                 setState(740);\r
6583                 max_value_arg();\r
6584                 setState(741);\r
6585                 stmtend();\r
6586             }\r
6587         } catch (RecognitionException re) {\r
6588             _localctx.exception = re;\r
6589             _errHandler.reportError(this, re);\r
6590             _errHandler.recover(this, re);\r
6591         } finally {\r
6592             exitRule();\r
6593         }\r
6594         return _localctx;\r
6595     }\r
6596 \r
6597     public static class Min_elements_stmtContext extends ParserRuleContext {\r
6598         public StringContext string() {\r
6599             return getRuleContext(StringContext.class, 0);\r
6600         }\r
6601 \r
6602         public StmtendContext stmtend() {\r
6603             return getRuleContext(StmtendContext.class, 0);\r
6604         }\r
6605 \r
6606         public TerminalNode MIN_ELEMENTS_KEYWORD() {\r
6607             return getToken(YangParser.MIN_ELEMENTS_KEYWORD, 0);\r
6608         }\r
6609 \r
6610         public Min_elements_stmtContext(ParserRuleContext parent,\r
6611                 int invokingState) {\r
6612             super(parent, invokingState);\r
6613         }\r
6614 \r
6615         @Override\r
6616         public int getRuleIndex() {\r
6617             return RULE_min_elements_stmt;\r
6618         }\r
6619 \r
6620         @Override\r
6621         public void enterRule(ParseTreeListener listener) {\r
6622             if (listener instanceof YangParserListener)\r
6623                 ((YangParserListener) listener).enterMin_elements_stmt(this);\r
6624         }\r
6625 \r
6626         @Override\r
6627         public void exitRule(ParseTreeListener listener) {\r
6628             if (listener instanceof YangParserListener)\r
6629                 ((YangParserListener) listener).exitMin_elements_stmt(this);\r
6630         }\r
6631 \r
6632         @Override\r
6633         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
6634             if (visitor instanceof YangParserVisitor)\r
6635                 return ((YangParserVisitor<? extends T>) visitor)\r
6636                         .visitMin_elements_stmt(this);\r
6637             else\r
6638                 return visitor.visitChildren(this);\r
6639         }\r
6640     }\r
6641 \r
6642     public final Min_elements_stmtContext min_elements_stmt()\r
6643             throws RecognitionException {\r
6644         Min_elements_stmtContext _localctx = new Min_elements_stmtContext(_ctx,\r
6645                 getState());\r
6646         enterRule(_localctx, 80, RULE_min_elements_stmt);\r
6647         try {\r
6648             enterOuterAlt(_localctx, 1);\r
6649             {\r
6650                 setState(743);\r
6651                 match(MIN_ELEMENTS_KEYWORD);\r
6652                 setState(744);\r
6653                 string();\r
6654                 setState(745);\r
6655                 stmtend();\r
6656             }\r
6657         } catch (RecognitionException re) {\r
6658             _localctx.exception = re;\r
6659             _errHandler.reportError(this, re);\r
6660             _errHandler.recover(this, re);\r
6661         } finally {\r
6662             exitRule();\r
6663         }\r
6664         return _localctx;\r
6665     }\r
6666 \r
6667     public static class Error_app_tag_stmtContext extends ParserRuleContext {\r
6668         public StringContext string() {\r
6669             return getRuleContext(StringContext.class, 0);\r
6670         }\r
6671 \r
6672         public TerminalNode ERROR_APP_TAG_KEYWORD() {\r
6673             return getToken(YangParser.ERROR_APP_TAG_KEYWORD, 0);\r
6674         }\r
6675 \r
6676         public StmtendContext stmtend() {\r
6677             return getRuleContext(StmtendContext.class, 0);\r
6678         }\r
6679 \r
6680         public Error_app_tag_stmtContext(ParserRuleContext parent,\r
6681                 int invokingState) {\r
6682             super(parent, invokingState);\r
6683         }\r
6684 \r
6685         @Override\r
6686         public int getRuleIndex() {\r
6687             return RULE_error_app_tag_stmt;\r
6688         }\r
6689 \r
6690         @Override\r
6691         public void enterRule(ParseTreeListener listener) {\r
6692             if (listener instanceof YangParserListener)\r
6693                 ((YangParserListener) listener).enterError_app_tag_stmt(this);\r
6694         }\r
6695 \r
6696         @Override\r
6697         public void exitRule(ParseTreeListener listener) {\r
6698             if (listener instanceof YangParserListener)\r
6699                 ((YangParserListener) listener).exitError_app_tag_stmt(this);\r
6700         }\r
6701 \r
6702         @Override\r
6703         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
6704             if (visitor instanceof YangParserVisitor)\r
6705                 return ((YangParserVisitor<? extends T>) visitor)\r
6706                         .visitError_app_tag_stmt(this);\r
6707             else\r
6708                 return visitor.visitChildren(this);\r
6709         }\r
6710     }\r
6711 \r
6712     public final Error_app_tag_stmtContext error_app_tag_stmt()\r
6713             throws RecognitionException {\r
6714         Error_app_tag_stmtContext _localctx = new Error_app_tag_stmtContext(\r
6715                 _ctx, getState());\r
6716         enterRule(_localctx, 82, RULE_error_app_tag_stmt);\r
6717         try {\r
6718             enterOuterAlt(_localctx, 1);\r
6719             {\r
6720                 setState(747);\r
6721                 match(ERROR_APP_TAG_KEYWORD);\r
6722                 setState(748);\r
6723                 string();\r
6724                 setState(749);\r
6725                 stmtend();\r
6726             }\r
6727         } catch (RecognitionException re) {\r
6728             _localctx.exception = re;\r
6729             _errHandler.reportError(this, re);\r
6730             _errHandler.recover(this, re);\r
6731         } finally {\r
6732             exitRule();\r
6733         }\r
6734         return _localctx;\r
6735     }\r
6736 \r
6737     public static class Error_message_stmtContext extends ParserRuleContext {\r
6738         public StringContext string() {\r
6739             return getRuleContext(StringContext.class, 0);\r
6740         }\r
6741 \r
6742         public TerminalNode ERROR_MESSAGE_KEYWORD() {\r
6743             return getToken(YangParser.ERROR_MESSAGE_KEYWORD, 0);\r
6744         }\r
6745 \r
6746         public StmtendContext stmtend() {\r
6747             return getRuleContext(StmtendContext.class, 0);\r
6748         }\r
6749 \r
6750         public Error_message_stmtContext(ParserRuleContext parent,\r
6751                 int invokingState) {\r
6752             super(parent, invokingState);\r
6753         }\r
6754 \r
6755         @Override\r
6756         public int getRuleIndex() {\r
6757             return RULE_error_message_stmt;\r
6758         }\r
6759 \r
6760         @Override\r
6761         public void enterRule(ParseTreeListener listener) {\r
6762             if (listener instanceof YangParserListener)\r
6763                 ((YangParserListener) listener).enterError_message_stmt(this);\r
6764         }\r
6765 \r
6766         @Override\r
6767         public void exitRule(ParseTreeListener listener) {\r
6768             if (listener instanceof YangParserListener)\r
6769                 ((YangParserListener) listener).exitError_message_stmt(this);\r
6770         }\r
6771 \r
6772         @Override\r
6773         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
6774             if (visitor instanceof YangParserVisitor)\r
6775                 return ((YangParserVisitor<? extends T>) visitor)\r
6776                         .visitError_message_stmt(this);\r
6777             else\r
6778                 return visitor.visitChildren(this);\r
6779         }\r
6780     }\r
6781 \r
6782     public final Error_message_stmtContext error_message_stmt()\r
6783             throws RecognitionException {\r
6784         Error_message_stmtContext _localctx = new Error_message_stmtContext(\r
6785                 _ctx, getState());\r
6786         enterRule(_localctx, 84, RULE_error_message_stmt);\r
6787         try {\r
6788             enterOuterAlt(_localctx, 1);\r
6789             {\r
6790                 setState(751);\r
6791                 match(ERROR_MESSAGE_KEYWORD);\r
6792                 setState(752);\r
6793                 string();\r
6794                 setState(753);\r
6795                 stmtend();\r
6796             }\r
6797         } catch (RecognitionException re) {\r
6798             _localctx.exception = re;\r
6799             _errHandler.reportError(this, re);\r
6800             _errHandler.recover(this, re);\r
6801         } finally {\r
6802             exitRule();\r
6803         }\r
6804         return _localctx;\r
6805     }\r
6806 \r
6807     public static class Must_stmtContext extends ParserRuleContext {\r
6808         public TerminalNode RIGHT_BRACE() {\r
6809             return getToken(YangParser.RIGHT_BRACE, 0);\r
6810         }\r
6811 \r
6812         public List<Reference_stmtContext> reference_stmt() {\r
6813             return getRuleContexts(Reference_stmtContext.class);\r
6814         }\r
6815 \r
6816         public Description_stmtContext description_stmt(int i) {\r
6817             return getRuleContext(Description_stmtContext.class, i);\r
6818         }\r
6819 \r
6820         public TerminalNode LEFT_BRACE() {\r
6821             return getToken(YangParser.LEFT_BRACE, 0);\r
6822         }\r
6823 \r
6824         public List<Error_app_tag_stmtContext> error_app_tag_stmt() {\r
6825             return getRuleContexts(Error_app_tag_stmtContext.class);\r
6826         }\r
6827 \r
6828         public TerminalNode MUST_KEYWORD() {\r
6829             return getToken(YangParser.MUST_KEYWORD, 0);\r
6830         }\r
6831 \r
6832         public Error_message_stmtContext error_message_stmt(int i) {\r
6833             return getRuleContext(Error_message_stmtContext.class, i);\r
6834         }\r
6835 \r
6836         public Identifier_stmtContext identifier_stmt(int i) {\r
6837             return getRuleContext(Identifier_stmtContext.class, i);\r
6838         }\r
6839 \r
6840         public TerminalNode SEMICOLON() {\r
6841             return getToken(YangParser.SEMICOLON, 0);\r
6842         }\r
6843 \r
6844         public StringContext string() {\r
6845             return getRuleContext(StringContext.class, 0);\r
6846         }\r
6847 \r
6848         public List<Identifier_stmtContext> identifier_stmt() {\r
6849             return getRuleContexts(Identifier_stmtContext.class);\r
6850         }\r
6851 \r
6852         public Error_app_tag_stmtContext error_app_tag_stmt(int i) {\r
6853             return getRuleContext(Error_app_tag_stmtContext.class, i);\r
6854         }\r
6855 \r
6856         public List<Error_message_stmtContext> error_message_stmt() {\r
6857             return getRuleContexts(Error_message_stmtContext.class);\r
6858         }\r
6859 \r
6860         public List<Description_stmtContext> description_stmt() {\r
6861             return getRuleContexts(Description_stmtContext.class);\r
6862         }\r
6863 \r
6864         public Reference_stmtContext reference_stmt(int i) {\r
6865             return getRuleContext(Reference_stmtContext.class, i);\r
6866         }\r
6867 \r
6868         public Must_stmtContext(ParserRuleContext parent, int invokingState) {\r
6869             super(parent, invokingState);\r
6870         }\r
6871 \r
6872         @Override\r
6873         public int getRuleIndex() {\r
6874             return RULE_must_stmt;\r
6875         }\r
6876 \r
6877         @Override\r
6878         public void enterRule(ParseTreeListener listener) {\r
6879             if (listener instanceof YangParserListener)\r
6880                 ((YangParserListener) listener).enterMust_stmt(this);\r
6881         }\r
6882 \r
6883         @Override\r
6884         public void exitRule(ParseTreeListener listener) {\r
6885             if (listener instanceof YangParserListener)\r
6886                 ((YangParserListener) listener).exitMust_stmt(this);\r
6887         }\r
6888 \r
6889         @Override\r
6890         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
6891             if (visitor instanceof YangParserVisitor)\r
6892                 return ((YangParserVisitor<? extends T>) visitor)\r
6893                         .visitMust_stmt(this);\r
6894             else\r
6895                 return visitor.visitChildren(this);\r
6896         }\r
6897     }\r
6898 \r
6899     public final Must_stmtContext must_stmt() throws RecognitionException {\r
6900         Must_stmtContext _localctx = new Must_stmtContext(_ctx, getState());\r
6901         enterRule(_localctx, 86, RULE_must_stmt);\r
6902         int _la;\r
6903         try {\r
6904             enterOuterAlt(_localctx, 1);\r
6905             {\r
6906                 setState(755);\r
6907                 match(MUST_KEYWORD);\r
6908                 setState(756);\r
6909                 string();\r
6910                 setState(770);\r
6911                 switch (_input.LA(1)) {\r
6912                 case SEMICOLON: {\r
6913                     setState(757);\r
6914                     match(SEMICOLON);\r
6915                 }\r
6916                     break;\r
6917                 case LEFT_BRACE: {\r
6918                     {\r
6919                         setState(758);\r
6920                         match(LEFT_BRACE);\r
6921                         setState(766);\r
6922                         _errHandler.sync(this);\r
6923                         _la = _input.LA(1);\r
6924                         while (((((_la - 24)) & ~0x3f) == 0 && ((1L << (_la - 24)) & ((1L << (REFERENCE_KEYWORD - 24))\r
6925                                 | (1L << (ERROR_MESSAGE_KEYWORD - 24))\r
6926                                 | (1L << (ERROR_APP_TAG_KEYWORD - 24))\r
6927                                 | (1L << (DESCRIPTION_KEYWORD - 24)) | (1L << (IDENTIFIER - 24)))) != 0)) {\r
6928                             {\r
6929                                 setState(764);\r
6930                                 switch (_input.LA(1)) {\r
6931                                 case IDENTIFIER: {\r
6932                                     setState(759);\r
6933                                     identifier_stmt();\r
6934                                 }\r
6935                                     break;\r
6936                                 case ERROR_MESSAGE_KEYWORD: {\r
6937                                     setState(760);\r
6938                                     error_message_stmt();\r
6939                                 }\r
6940                                     break;\r
6941                                 case ERROR_APP_TAG_KEYWORD: {\r
6942                                     setState(761);\r
6943                                     error_app_tag_stmt();\r
6944                                 }\r
6945                                     break;\r
6946                                 case DESCRIPTION_KEYWORD: {\r
6947                                     setState(762);\r
6948                                     description_stmt();\r
6949                                 }\r
6950                                     break;\r
6951                                 case REFERENCE_KEYWORD: {\r
6952                                     setState(763);\r
6953                                     reference_stmt();\r
6954                                 }\r
6955                                     break;\r
6956                                 default:\r
6957                                     throw new NoViableAltException(this);\r
6958                                 }\r
6959                             }\r
6960                             setState(768);\r
6961                             _errHandler.sync(this);\r
6962                             _la = _input.LA(1);\r
6963                         }\r
6964                         setState(769);\r
6965                         match(RIGHT_BRACE);\r
6966                     }\r
6967                 }\r
6968                     break;\r
6969                 default:\r
6970                     throw new NoViableAltException(this);\r
6971                 }\r
6972             }\r
6973         } catch (RecognitionException re) {\r
6974             _localctx.exception = re;\r
6975             _errHandler.reportError(this, re);\r
6976             _errHandler.recover(this, re);\r
6977         } finally {\r
6978             exitRule();\r
6979         }\r
6980         return _localctx;\r
6981     }\r
6982 \r
6983     public static class Ordered_by_argContext extends ParserRuleContext {\r
6984         public StringContext string() {\r
6985             return getRuleContext(StringContext.class, 0);\r
6986         }\r
6987 \r
6988         public Ordered_by_argContext(ParserRuleContext parent, int invokingState) {\r
6989             super(parent, invokingState);\r
6990         }\r
6991 \r
6992         @Override\r
6993         public int getRuleIndex() {\r
6994             return RULE_ordered_by_arg;\r
6995         }\r
6996 \r
6997         @Override\r
6998         public void enterRule(ParseTreeListener listener) {\r
6999             if (listener instanceof YangParserListener)\r
7000                 ((YangParserListener) listener).enterOrdered_by_arg(this);\r
7001         }\r
7002 \r
7003         @Override\r
7004         public void exitRule(ParseTreeListener listener) {\r
7005             if (listener instanceof YangParserListener)\r
7006                 ((YangParserListener) listener).exitOrdered_by_arg(this);\r
7007         }\r
7008 \r
7009         @Override\r
7010         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
7011             if (visitor instanceof YangParserVisitor)\r
7012                 return ((YangParserVisitor<? extends T>) visitor)\r
7013                         .visitOrdered_by_arg(this);\r
7014             else\r
7015                 return visitor.visitChildren(this);\r
7016         }\r
7017     }\r
7018 \r
7019     public final Ordered_by_argContext ordered_by_arg()\r
7020             throws RecognitionException {\r
7021         Ordered_by_argContext _localctx = new Ordered_by_argContext(_ctx,\r
7022                 getState());\r
7023         enterRule(_localctx, 88, RULE_ordered_by_arg);\r
7024         try {\r
7025             enterOuterAlt(_localctx, 1);\r
7026             {\r
7027                 setState(772);\r
7028                 string();\r
7029             }\r
7030         } catch (RecognitionException re) {\r
7031             _localctx.exception = re;\r
7032             _errHandler.reportError(this, re);\r
7033             _errHandler.recover(this, re);\r
7034         } finally {\r
7035             exitRule();\r
7036         }\r
7037         return _localctx;\r
7038     }\r
7039 \r
7040     public static class Ordered_by_stmtContext extends ParserRuleContext {\r
7041         public Ordered_by_argContext ordered_by_arg() {\r
7042             return getRuleContext(Ordered_by_argContext.class, 0);\r
7043         }\r
7044 \r
7045         public TerminalNode ORDERED_BY_KEYWORD() {\r
7046             return getToken(YangParser.ORDERED_BY_KEYWORD, 0);\r
7047         }\r
7048 \r
7049         public StmtendContext stmtend() {\r
7050             return getRuleContext(StmtendContext.class, 0);\r
7051         }\r
7052 \r
7053         public Ordered_by_stmtContext(ParserRuleContext parent,\r
7054                 int invokingState) {\r
7055             super(parent, invokingState);\r
7056         }\r
7057 \r
7058         @Override\r
7059         public int getRuleIndex() {\r
7060             return RULE_ordered_by_stmt;\r
7061         }\r
7062 \r
7063         @Override\r
7064         public void enterRule(ParseTreeListener listener) {\r
7065             if (listener instanceof YangParserListener)\r
7066                 ((YangParserListener) listener).enterOrdered_by_stmt(this);\r
7067         }\r
7068 \r
7069         @Override\r
7070         public void exitRule(ParseTreeListener listener) {\r
7071             if (listener instanceof YangParserListener)\r
7072                 ((YangParserListener) listener).exitOrdered_by_stmt(this);\r
7073         }\r
7074 \r
7075         @Override\r
7076         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
7077             if (visitor instanceof YangParserVisitor)\r
7078                 return ((YangParserVisitor<? extends T>) visitor)\r
7079                         .visitOrdered_by_stmt(this);\r
7080             else\r
7081                 return visitor.visitChildren(this);\r
7082         }\r
7083     }\r
7084 \r
7085     public final Ordered_by_stmtContext ordered_by_stmt()\r
7086             throws RecognitionException {\r
7087         Ordered_by_stmtContext _localctx = new Ordered_by_stmtContext(_ctx,\r
7088                 getState());\r
7089         enterRule(_localctx, 90, RULE_ordered_by_stmt);\r
7090         try {\r
7091             enterOuterAlt(_localctx, 1);\r
7092             {\r
7093                 setState(774);\r
7094                 match(ORDERED_BY_KEYWORD);\r
7095                 setState(775);\r
7096                 ordered_by_arg();\r
7097                 setState(776);\r
7098                 stmtend();\r
7099             }\r
7100         } catch (RecognitionException re) {\r
7101             _localctx.exception = re;\r
7102             _errHandler.reportError(this, re);\r
7103             _errHandler.recover(this, re);\r
7104         } finally {\r
7105             exitRule();\r
7106         }\r
7107         return _localctx;\r
7108     }\r
7109 \r
7110     public static class Presence_stmtContext extends ParserRuleContext {\r
7111         public StringContext string() {\r
7112             return getRuleContext(StringContext.class, 0);\r
7113         }\r
7114 \r
7115         public StmtendContext stmtend() {\r
7116             return getRuleContext(StmtendContext.class, 0);\r
7117         }\r
7118 \r
7119         public TerminalNode PRESENCE_KEYWORD() {\r
7120             return getToken(YangParser.PRESENCE_KEYWORD, 0);\r
7121         }\r
7122 \r
7123         public Presence_stmtContext(ParserRuleContext parent, int invokingState) {\r
7124             super(parent, invokingState);\r
7125         }\r
7126 \r
7127         @Override\r
7128         public int getRuleIndex() {\r
7129             return RULE_presence_stmt;\r
7130         }\r
7131 \r
7132         @Override\r
7133         public void enterRule(ParseTreeListener listener) {\r
7134             if (listener instanceof YangParserListener)\r
7135                 ((YangParserListener) listener).enterPresence_stmt(this);\r
7136         }\r
7137 \r
7138         @Override\r
7139         public void exitRule(ParseTreeListener listener) {\r
7140             if (listener instanceof YangParserListener)\r
7141                 ((YangParserListener) listener).exitPresence_stmt(this);\r
7142         }\r
7143 \r
7144         @Override\r
7145         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
7146             if (visitor instanceof YangParserVisitor)\r
7147                 return ((YangParserVisitor<? extends T>) visitor)\r
7148                         .visitPresence_stmt(this);\r
7149             else\r
7150                 return visitor.visitChildren(this);\r
7151         }\r
7152     }\r
7153 \r
7154     public final Presence_stmtContext presence_stmt()\r
7155             throws RecognitionException {\r
7156         Presence_stmtContext _localctx = new Presence_stmtContext(_ctx,\r
7157                 getState());\r
7158         enterRule(_localctx, 92, RULE_presence_stmt);\r
7159         try {\r
7160             enterOuterAlt(_localctx, 1);\r
7161             {\r
7162                 setState(778);\r
7163                 match(PRESENCE_KEYWORD);\r
7164                 setState(779);\r
7165                 string();\r
7166                 setState(780);\r
7167                 stmtend();\r
7168             }\r
7169         } catch (RecognitionException re) {\r
7170             _localctx.exception = re;\r
7171             _errHandler.reportError(this, re);\r
7172             _errHandler.recover(this, re);\r
7173         } finally {\r
7174             exitRule();\r
7175         }\r
7176         return _localctx;\r
7177     }\r
7178 \r
7179     public static class Mandatory_argContext extends ParserRuleContext {\r
7180         public StringContext string() {\r
7181             return getRuleContext(StringContext.class, 0);\r
7182         }\r
7183 \r
7184         public Mandatory_argContext(ParserRuleContext parent, int invokingState) {\r
7185             super(parent, invokingState);\r
7186         }\r
7187 \r
7188         @Override\r
7189         public int getRuleIndex() {\r
7190             return RULE_mandatory_arg;\r
7191         }\r
7192 \r
7193         @Override\r
7194         public void enterRule(ParseTreeListener listener) {\r
7195             if (listener instanceof YangParserListener)\r
7196                 ((YangParserListener) listener).enterMandatory_arg(this);\r
7197         }\r
7198 \r
7199         @Override\r
7200         public void exitRule(ParseTreeListener listener) {\r
7201             if (listener instanceof YangParserListener)\r
7202                 ((YangParserListener) listener).exitMandatory_arg(this);\r
7203         }\r
7204 \r
7205         @Override\r
7206         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
7207             if (visitor instanceof YangParserVisitor)\r
7208                 return ((YangParserVisitor<? extends T>) visitor)\r
7209                         .visitMandatory_arg(this);\r
7210             else\r
7211                 return visitor.visitChildren(this);\r
7212         }\r
7213     }\r
7214 \r
7215     public final Mandatory_argContext mandatory_arg()\r
7216             throws RecognitionException {\r
7217         Mandatory_argContext _localctx = new Mandatory_argContext(_ctx,\r
7218                 getState());\r
7219         enterRule(_localctx, 94, RULE_mandatory_arg);\r
7220         try {\r
7221             enterOuterAlt(_localctx, 1);\r
7222             {\r
7223                 setState(782);\r
7224                 string();\r
7225             }\r
7226         } catch (RecognitionException re) {\r
7227             _localctx.exception = re;\r
7228             _errHandler.reportError(this, re);\r
7229             _errHandler.recover(this, re);\r
7230         } finally {\r
7231             exitRule();\r
7232         }\r
7233         return _localctx;\r
7234     }\r
7235 \r
7236     public static class Mandatory_stmtContext extends ParserRuleContext {\r
7237         public TerminalNode MANDATORY_KEYWORD() {\r
7238             return getToken(YangParser.MANDATORY_KEYWORD, 0);\r
7239         }\r
7240 \r
7241         public Mandatory_argContext mandatory_arg() {\r
7242             return getRuleContext(Mandatory_argContext.class, 0);\r
7243         }\r
7244 \r
7245         public StmtendContext stmtend() {\r
7246             return getRuleContext(StmtendContext.class, 0);\r
7247         }\r
7248 \r
7249         public Mandatory_stmtContext(ParserRuleContext parent, int invokingState) {\r
7250             super(parent, invokingState);\r
7251         }\r
7252 \r
7253         @Override\r
7254         public int getRuleIndex() {\r
7255             return RULE_mandatory_stmt;\r
7256         }\r
7257 \r
7258         @Override\r
7259         public void enterRule(ParseTreeListener listener) {\r
7260             if (listener instanceof YangParserListener)\r
7261                 ((YangParserListener) listener).enterMandatory_stmt(this);\r
7262         }\r
7263 \r
7264         @Override\r
7265         public void exitRule(ParseTreeListener listener) {\r
7266             if (listener instanceof YangParserListener)\r
7267                 ((YangParserListener) listener).exitMandatory_stmt(this);\r
7268         }\r
7269 \r
7270         @Override\r
7271         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
7272             if (visitor instanceof YangParserVisitor)\r
7273                 return ((YangParserVisitor<? extends T>) visitor)\r
7274                         .visitMandatory_stmt(this);\r
7275             else\r
7276                 return visitor.visitChildren(this);\r
7277         }\r
7278     }\r
7279 \r
7280     public final Mandatory_stmtContext mandatory_stmt()\r
7281             throws RecognitionException {\r
7282         Mandatory_stmtContext _localctx = new Mandatory_stmtContext(_ctx,\r
7283                 getState());\r
7284         enterRule(_localctx, 96, RULE_mandatory_stmt);\r
7285         try {\r
7286             enterOuterAlt(_localctx, 1);\r
7287             {\r
7288                 setState(784);\r
7289                 match(MANDATORY_KEYWORD);\r
7290                 setState(785);\r
7291                 mandatory_arg();\r
7292                 setState(786);\r
7293                 stmtend();\r
7294             }\r
7295         } catch (RecognitionException re) {\r
7296             _localctx.exception = re;\r
7297             _errHandler.reportError(this, re);\r
7298             _errHandler.recover(this, re);\r
7299         } finally {\r
7300             exitRule();\r
7301         }\r
7302         return _localctx;\r
7303     }\r
7304 \r
7305     public static class Config_argContext extends ParserRuleContext {\r
7306         public StringContext string() {\r
7307             return getRuleContext(StringContext.class, 0);\r
7308         }\r
7309 \r
7310         public Config_argContext(ParserRuleContext parent, int invokingState) {\r
7311             super(parent, invokingState);\r
7312         }\r
7313 \r
7314         @Override\r
7315         public int getRuleIndex() {\r
7316             return RULE_config_arg;\r
7317         }\r
7318 \r
7319         @Override\r
7320         public void enterRule(ParseTreeListener listener) {\r
7321             if (listener instanceof YangParserListener)\r
7322                 ((YangParserListener) listener).enterConfig_arg(this);\r
7323         }\r
7324 \r
7325         @Override\r
7326         public void exitRule(ParseTreeListener listener) {\r
7327             if (listener instanceof YangParserListener)\r
7328                 ((YangParserListener) listener).exitConfig_arg(this);\r
7329         }\r
7330 \r
7331         @Override\r
7332         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
7333             if (visitor instanceof YangParserVisitor)\r
7334                 return ((YangParserVisitor<? extends T>) visitor)\r
7335                         .visitConfig_arg(this);\r
7336             else\r
7337                 return visitor.visitChildren(this);\r
7338         }\r
7339     }\r
7340 \r
7341     public final Config_argContext config_arg() throws RecognitionException {\r
7342         Config_argContext _localctx = new Config_argContext(_ctx, getState());\r
7343         enterRule(_localctx, 98, RULE_config_arg);\r
7344         try {\r
7345             enterOuterAlt(_localctx, 1);\r
7346             {\r
7347                 setState(788);\r
7348                 string();\r
7349             }\r
7350         } catch (RecognitionException re) {\r
7351             _localctx.exception = re;\r
7352             _errHandler.reportError(this, re);\r
7353             _errHandler.recover(this, re);\r
7354         } finally {\r
7355             exitRule();\r
7356         }\r
7357         return _localctx;\r
7358     }\r
7359 \r
7360     public static class Config_stmtContext extends ParserRuleContext {\r
7361         public Config_argContext config_arg() {\r
7362             return getRuleContext(Config_argContext.class, 0);\r
7363         }\r
7364 \r
7365         public TerminalNode CONFIG_KEYWORD() {\r
7366             return getToken(YangParser.CONFIG_KEYWORD, 0);\r
7367         }\r
7368 \r
7369         public StmtendContext stmtend() {\r
7370             return getRuleContext(StmtendContext.class, 0);\r
7371         }\r
7372 \r
7373         public Config_stmtContext(ParserRuleContext parent, int invokingState) {\r
7374             super(parent, invokingState);\r
7375         }\r
7376 \r
7377         @Override\r
7378         public int getRuleIndex() {\r
7379             return RULE_config_stmt;\r
7380         }\r
7381 \r
7382         @Override\r
7383         public void enterRule(ParseTreeListener listener) {\r
7384             if (listener instanceof YangParserListener)\r
7385                 ((YangParserListener) listener).enterConfig_stmt(this);\r
7386         }\r
7387 \r
7388         @Override\r
7389         public void exitRule(ParseTreeListener listener) {\r
7390             if (listener instanceof YangParserListener)\r
7391                 ((YangParserListener) listener).exitConfig_stmt(this);\r
7392         }\r
7393 \r
7394         @Override\r
7395         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
7396             if (visitor instanceof YangParserVisitor)\r
7397                 return ((YangParserVisitor<? extends T>) visitor)\r
7398                         .visitConfig_stmt(this);\r
7399             else\r
7400                 return visitor.visitChildren(this);\r
7401         }\r
7402     }\r
7403 \r
7404     public final Config_stmtContext config_stmt() throws RecognitionException {\r
7405         Config_stmtContext _localctx = new Config_stmtContext(_ctx, getState());\r
7406         enterRule(_localctx, 100, RULE_config_stmt);\r
7407         try {\r
7408             enterOuterAlt(_localctx, 1);\r
7409             {\r
7410                 setState(790);\r
7411                 match(CONFIG_KEYWORD);\r
7412                 setState(791);\r
7413                 config_arg();\r
7414                 setState(792);\r
7415                 stmtend();\r
7416             }\r
7417         } catch (RecognitionException re) {\r
7418             _localctx.exception = re;\r
7419             _errHandler.reportError(this, re);\r
7420             _errHandler.recover(this, re);\r
7421         } finally {\r
7422             exitRule();\r
7423         }\r
7424         return _localctx;\r
7425     }\r
7426 \r
7427     public static class Status_argContext extends ParserRuleContext {\r
7428         public StringContext string() {\r
7429             return getRuleContext(StringContext.class, 0);\r
7430         }\r
7431 \r
7432         public Status_argContext(ParserRuleContext parent, int invokingState) {\r
7433             super(parent, invokingState);\r
7434         }\r
7435 \r
7436         @Override\r
7437         public int getRuleIndex() {\r
7438             return RULE_status_arg;\r
7439         }\r
7440 \r
7441         @Override\r
7442         public void enterRule(ParseTreeListener listener) {\r
7443             if (listener instanceof YangParserListener)\r
7444                 ((YangParserListener) listener).enterStatus_arg(this);\r
7445         }\r
7446 \r
7447         @Override\r
7448         public void exitRule(ParseTreeListener listener) {\r
7449             if (listener instanceof YangParserListener)\r
7450                 ((YangParserListener) listener).exitStatus_arg(this);\r
7451         }\r
7452 \r
7453         @Override\r
7454         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
7455             if (visitor instanceof YangParserVisitor)\r
7456                 return ((YangParserVisitor<? extends T>) visitor)\r
7457                         .visitStatus_arg(this);\r
7458             else\r
7459                 return visitor.visitChildren(this);\r
7460         }\r
7461     }\r
7462 \r
7463     public final Status_argContext status_arg() throws RecognitionException {\r
7464         Status_argContext _localctx = new Status_argContext(_ctx, getState());\r
7465         enterRule(_localctx, 102, RULE_status_arg);\r
7466         try {\r
7467             enterOuterAlt(_localctx, 1);\r
7468             {\r
7469                 setState(794);\r
7470                 string();\r
7471             }\r
7472         } catch (RecognitionException re) {\r
7473             _localctx.exception = re;\r
7474             _errHandler.reportError(this, re);\r
7475             _errHandler.recover(this, re);\r
7476         } finally {\r
7477             exitRule();\r
7478         }\r
7479         return _localctx;\r
7480     }\r
7481 \r
7482     public static class Status_stmtContext extends ParserRuleContext {\r
7483         public Status_argContext status_arg() {\r
7484             return getRuleContext(Status_argContext.class, 0);\r
7485         }\r
7486 \r
7487         public TerminalNode STATUS_KEYWORD() {\r
7488             return getToken(YangParser.STATUS_KEYWORD, 0);\r
7489         }\r
7490 \r
7491         public StmtendContext stmtend() {\r
7492             return getRuleContext(StmtendContext.class, 0);\r
7493         }\r
7494 \r
7495         public Status_stmtContext(ParserRuleContext parent, int invokingState) {\r
7496             super(parent, invokingState);\r
7497         }\r
7498 \r
7499         @Override\r
7500         public int getRuleIndex() {\r
7501             return RULE_status_stmt;\r
7502         }\r
7503 \r
7504         @Override\r
7505         public void enterRule(ParseTreeListener listener) {\r
7506             if (listener instanceof YangParserListener)\r
7507                 ((YangParserListener) listener).enterStatus_stmt(this);\r
7508         }\r
7509 \r
7510         @Override\r
7511         public void exitRule(ParseTreeListener listener) {\r
7512             if (listener instanceof YangParserListener)\r
7513                 ((YangParserListener) listener).exitStatus_stmt(this);\r
7514         }\r
7515 \r
7516         @Override\r
7517         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
7518             if (visitor instanceof YangParserVisitor)\r
7519                 return ((YangParserVisitor<? extends T>) visitor)\r
7520                         .visitStatus_stmt(this);\r
7521             else\r
7522                 return visitor.visitChildren(this);\r
7523         }\r
7524     }\r
7525 \r
7526     public final Status_stmtContext status_stmt() throws RecognitionException {\r
7527         Status_stmtContext _localctx = new Status_stmtContext(_ctx, getState());\r
7528         enterRule(_localctx, 104, RULE_status_stmt);\r
7529         try {\r
7530             enterOuterAlt(_localctx, 1);\r
7531             {\r
7532                 setState(796);\r
7533                 match(STATUS_KEYWORD);\r
7534                 setState(797);\r
7535                 status_arg();\r
7536                 setState(798);\r
7537                 stmtend();\r
7538             }\r
7539         } catch (RecognitionException re) {\r
7540             _localctx.exception = re;\r
7541             _errHandler.reportError(this, re);\r
7542             _errHandler.recover(this, re);\r
7543         } finally {\r
7544             exitRule();\r
7545         }\r
7546         return _localctx;\r
7547     }\r
7548 \r
7549     public static class Position_stmtContext extends ParserRuleContext {\r
7550         public TerminalNode POSITION_KEYWORD() {\r
7551             return getToken(YangParser.POSITION_KEYWORD, 0);\r
7552         }\r
7553 \r
7554         public StringContext string() {\r
7555             return getRuleContext(StringContext.class, 0);\r
7556         }\r
7557 \r
7558         public StmtendContext stmtend() {\r
7559             return getRuleContext(StmtendContext.class, 0);\r
7560         }\r
7561 \r
7562         public Position_stmtContext(ParserRuleContext parent, int invokingState) {\r
7563             super(parent, invokingState);\r
7564         }\r
7565 \r
7566         @Override\r
7567         public int getRuleIndex() {\r
7568             return RULE_position_stmt;\r
7569         }\r
7570 \r
7571         @Override\r
7572         public void enterRule(ParseTreeListener listener) {\r
7573             if (listener instanceof YangParserListener)\r
7574                 ((YangParserListener) listener).enterPosition_stmt(this);\r
7575         }\r
7576 \r
7577         @Override\r
7578         public void exitRule(ParseTreeListener listener) {\r
7579             if (listener instanceof YangParserListener)\r
7580                 ((YangParserListener) listener).exitPosition_stmt(this);\r
7581         }\r
7582 \r
7583         @Override\r
7584         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
7585             if (visitor instanceof YangParserVisitor)\r
7586                 return ((YangParserVisitor<? extends T>) visitor)\r
7587                         .visitPosition_stmt(this);\r
7588             else\r
7589                 return visitor.visitChildren(this);\r
7590         }\r
7591     }\r
7592 \r
7593     public final Position_stmtContext position_stmt()\r
7594             throws RecognitionException {\r
7595         Position_stmtContext _localctx = new Position_stmtContext(_ctx,\r
7596                 getState());\r
7597         enterRule(_localctx, 106, RULE_position_stmt);\r
7598         try {\r
7599             enterOuterAlt(_localctx, 1);\r
7600             {\r
7601                 setState(800);\r
7602                 match(POSITION_KEYWORD);\r
7603                 setState(801);\r
7604                 string();\r
7605                 setState(802);\r
7606                 stmtend();\r
7607             }\r
7608         } catch (RecognitionException re) {\r
7609             _localctx.exception = re;\r
7610             _errHandler.reportError(this, re);\r
7611             _errHandler.recover(this, re);\r
7612         } finally {\r
7613             exitRule();\r
7614         }\r
7615         return _localctx;\r
7616     }\r
7617 \r
7618     public static class Bit_stmtContext extends ParserRuleContext {\r
7619         public TerminalNode RIGHT_BRACE() {\r
7620             return getToken(YangParser.RIGHT_BRACE, 0);\r
7621         }\r
7622 \r
7623         public List<Reference_stmtContext> reference_stmt() {\r
7624             return getRuleContexts(Reference_stmtContext.class);\r
7625         }\r
7626 \r
7627         public Position_stmtContext position_stmt(int i) {\r
7628             return getRuleContext(Position_stmtContext.class, i);\r
7629         }\r
7630 \r
7631         public Description_stmtContext description_stmt(int i) {\r
7632             return getRuleContext(Description_stmtContext.class, i);\r
7633         }\r
7634 \r
7635         public List<Position_stmtContext> position_stmt() {\r
7636             return getRuleContexts(Position_stmtContext.class);\r
7637         }\r
7638 \r
7639         public TerminalNode LEFT_BRACE() {\r
7640             return getToken(YangParser.LEFT_BRACE, 0);\r
7641         }\r
7642 \r
7643         public Status_stmtContext status_stmt(int i) {\r
7644             return getRuleContext(Status_stmtContext.class, i);\r
7645         }\r
7646 \r
7647         public Identifier_stmtContext identifier_stmt(int i) {\r
7648             return getRuleContext(Identifier_stmtContext.class, i);\r
7649         }\r
7650 \r
7651         public TerminalNode SEMICOLON() {\r
7652             return getToken(YangParser.SEMICOLON, 0);\r
7653         }\r
7654 \r
7655         public List<Status_stmtContext> status_stmt() {\r
7656             return getRuleContexts(Status_stmtContext.class);\r
7657         }\r
7658 \r
7659         public StringContext string() {\r
7660             return getRuleContext(StringContext.class, 0);\r
7661         }\r
7662 \r
7663         public List<Identifier_stmtContext> identifier_stmt() {\r
7664             return getRuleContexts(Identifier_stmtContext.class);\r
7665         }\r
7666 \r
7667         public List<Description_stmtContext> description_stmt() {\r
7668             return getRuleContexts(Description_stmtContext.class);\r
7669         }\r
7670 \r
7671         public Reference_stmtContext reference_stmt(int i) {\r
7672             return getRuleContext(Reference_stmtContext.class, i);\r
7673         }\r
7674 \r
7675         public TerminalNode BIT_KEYWORD() {\r
7676             return getToken(YangParser.BIT_KEYWORD, 0);\r
7677         }\r
7678 \r
7679         public Bit_stmtContext(ParserRuleContext parent, int invokingState) {\r
7680             super(parent, invokingState);\r
7681         }\r
7682 \r
7683         @Override\r
7684         public int getRuleIndex() {\r
7685             return RULE_bit_stmt;\r
7686         }\r
7687 \r
7688         @Override\r
7689         public void enterRule(ParseTreeListener listener) {\r
7690             if (listener instanceof YangParserListener)\r
7691                 ((YangParserListener) listener).enterBit_stmt(this);\r
7692         }\r
7693 \r
7694         @Override\r
7695         public void exitRule(ParseTreeListener listener) {\r
7696             if (listener instanceof YangParserListener)\r
7697                 ((YangParserListener) listener).exitBit_stmt(this);\r
7698         }\r
7699 \r
7700         @Override\r
7701         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
7702             if (visitor instanceof YangParserVisitor)\r
7703                 return ((YangParserVisitor<? extends T>) visitor)\r
7704                         .visitBit_stmt(this);\r
7705             else\r
7706                 return visitor.visitChildren(this);\r
7707         }\r
7708     }\r
7709 \r
7710     public final Bit_stmtContext bit_stmt() throws RecognitionException {\r
7711         Bit_stmtContext _localctx = new Bit_stmtContext(_ctx, getState());\r
7712         enterRule(_localctx, 108, RULE_bit_stmt);\r
7713         int _la;\r
7714         try {\r
7715             enterOuterAlt(_localctx, 1);\r
7716             {\r
7717                 setState(804);\r
7718                 match(BIT_KEYWORD);\r
7719                 setState(805);\r
7720                 string();\r
7721                 setState(819);\r
7722                 switch (_input.LA(1)) {\r
7723                 case SEMICOLON: {\r
7724                     setState(806);\r
7725                     match(SEMICOLON);\r
7726                 }\r
7727                     break;\r
7728                 case LEFT_BRACE: {\r
7729                     {\r
7730                         setState(807);\r
7731                         match(LEFT_BRACE);\r
7732                         setState(815);\r
7733                         _errHandler.sync(this);\r
7734                         _la = _input.LA(1);\r
7735                         while (((((_la - 18)) & ~0x3f) == 0 && ((1L << (_la - 18)) & ((1L << (STATUS_KEYWORD - 18))\r
7736                                 | (1L << (REFERENCE_KEYWORD - 18))\r
7737                                 | (1L << (POSITION_KEYWORD - 18))\r
7738                                 | (1L << (DESCRIPTION_KEYWORD - 18)) | (1L << (IDENTIFIER - 18)))) != 0)) {\r
7739                             {\r
7740                                 setState(813);\r
7741                                 switch (_input.LA(1)) {\r
7742                                 case IDENTIFIER: {\r
7743                                     setState(808);\r
7744                                     identifier_stmt();\r
7745                                 }\r
7746                                     break;\r
7747                                 case POSITION_KEYWORD: {\r
7748                                     setState(809);\r
7749                                     position_stmt();\r
7750                                 }\r
7751                                     break;\r
7752                                 case STATUS_KEYWORD: {\r
7753                                     setState(810);\r
7754                                     status_stmt();\r
7755                                 }\r
7756                                     break;\r
7757                                 case DESCRIPTION_KEYWORD: {\r
7758                                     setState(811);\r
7759                                     description_stmt();\r
7760                                 }\r
7761                                     break;\r
7762                                 case REFERENCE_KEYWORD: {\r
7763                                     setState(812);\r
7764                                     reference_stmt();\r
7765                                 }\r
7766                                     break;\r
7767                                 default:\r
7768                                     throw new NoViableAltException(this);\r
7769                                 }\r
7770                             }\r
7771                             setState(817);\r
7772                             _errHandler.sync(this);\r
7773                             _la = _input.LA(1);\r
7774                         }\r
7775                         setState(818);\r
7776                         match(RIGHT_BRACE);\r
7777                     }\r
7778                 }\r
7779                     break;\r
7780                 default:\r
7781                     throw new NoViableAltException(this);\r
7782                 }\r
7783             }\r
7784         } catch (RecognitionException re) {\r
7785             _localctx.exception = re;\r
7786             _errHandler.reportError(this, re);\r
7787             _errHandler.recover(this, re);\r
7788         } finally {\r
7789             exitRule();\r
7790         }\r
7791         return _localctx;\r
7792     }\r
7793 \r
7794     public static class Bits_specificationContext extends ParserRuleContext {\r
7795         public Bit_stmtContext bit_stmt(int i) {\r
7796             return getRuleContext(Bit_stmtContext.class, i);\r
7797         }\r
7798 \r
7799         public List<Bit_stmtContext> bit_stmt() {\r
7800             return getRuleContexts(Bit_stmtContext.class);\r
7801         }\r
7802 \r
7803         public Bits_specificationContext(ParserRuleContext parent,\r
7804                 int invokingState) {\r
7805             super(parent, invokingState);\r
7806         }\r
7807 \r
7808         @Override\r
7809         public int getRuleIndex() {\r
7810             return RULE_bits_specification;\r
7811         }\r
7812 \r
7813         @Override\r
7814         public void enterRule(ParseTreeListener listener) {\r
7815             if (listener instanceof YangParserListener)\r
7816                 ((YangParserListener) listener).enterBits_specification(this);\r
7817         }\r
7818 \r
7819         @Override\r
7820         public void exitRule(ParseTreeListener listener) {\r
7821             if (listener instanceof YangParserListener)\r
7822                 ((YangParserListener) listener).exitBits_specification(this);\r
7823         }\r
7824 \r
7825         @Override\r
7826         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
7827             if (visitor instanceof YangParserVisitor)\r
7828                 return ((YangParserVisitor<? extends T>) visitor)\r
7829                         .visitBits_specification(this);\r
7830             else\r
7831                 return visitor.visitChildren(this);\r
7832         }\r
7833     }\r
7834 \r
7835     public final Bits_specificationContext bits_specification()\r
7836             throws RecognitionException {\r
7837         Bits_specificationContext _localctx = new Bits_specificationContext(\r
7838                 _ctx, getState());\r
7839         enterRule(_localctx, 110, RULE_bits_specification);\r
7840         int _la;\r
7841         try {\r
7842             enterOuterAlt(_localctx, 1);\r
7843             {\r
7844                 setState(822);\r
7845                 _errHandler.sync(this);\r
7846                 _la = _input.LA(1);\r
7847                 do {\r
7848                     {\r
7849                         {\r
7850                             setState(821);\r
7851                             bit_stmt();\r
7852                         }\r
7853                     }\r
7854                     setState(824);\r
7855                     _errHandler.sync(this);\r
7856                     _la = _input.LA(1);\r
7857                 } while (_la == BIT_KEYWORD);\r
7858             }\r
7859         } catch (RecognitionException re) {\r
7860             _localctx.exception = re;\r
7861             _errHandler.reportError(this, re);\r
7862             _errHandler.recover(this, re);\r
7863         } finally {\r
7864             exitRule();\r
7865         }\r
7866         return _localctx;\r
7867     }\r
7868 \r
7869     public static class Union_specificationContext extends ParserRuleContext {\r
7870         public Type_stmtContext type_stmt(int i) {\r
7871             return getRuleContext(Type_stmtContext.class, i);\r
7872         }\r
7873 \r
7874         public List<Type_stmtContext> type_stmt() {\r
7875             return getRuleContexts(Type_stmtContext.class);\r
7876         }\r
7877 \r
7878         public Union_specificationContext(ParserRuleContext parent,\r
7879                 int invokingState) {\r
7880             super(parent, invokingState);\r
7881         }\r
7882 \r
7883         @Override\r
7884         public int getRuleIndex() {\r
7885             return RULE_union_specification;\r
7886         }\r
7887 \r
7888         @Override\r
7889         public void enterRule(ParseTreeListener listener) {\r
7890             if (listener instanceof YangParserListener)\r
7891                 ((YangParserListener) listener).enterUnion_specification(this);\r
7892         }\r
7893 \r
7894         @Override\r
7895         public void exitRule(ParseTreeListener listener) {\r
7896             if (listener instanceof YangParserListener)\r
7897                 ((YangParserListener) listener).exitUnion_specification(this);\r
7898         }\r
7899 \r
7900         @Override\r
7901         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
7902             if (visitor instanceof YangParserVisitor)\r
7903                 return ((YangParserVisitor<? extends T>) visitor)\r
7904                         .visitUnion_specification(this);\r
7905             else\r
7906                 return visitor.visitChildren(this);\r
7907         }\r
7908     }\r
7909 \r
7910     public final Union_specificationContext union_specification()\r
7911             throws RecognitionException {\r
7912         Union_specificationContext _localctx = new Union_specificationContext(\r
7913                 _ctx, getState());\r
7914         enterRule(_localctx, 112, RULE_union_specification);\r
7915         int _la;\r
7916         try {\r
7917             enterOuterAlt(_localctx, 1);\r
7918             {\r
7919                 setState(827);\r
7920                 _errHandler.sync(this);\r
7921                 _la = _input.LA(1);\r
7922                 do {\r
7923                     {\r
7924                         {\r
7925                             setState(826);\r
7926                             type_stmt();\r
7927                         }\r
7928                     }\r
7929                     setState(829);\r
7930                     _errHandler.sync(this);\r
7931                     _la = _input.LA(1);\r
7932                 } while (_la == TYPE_KEYWORD);\r
7933             }\r
7934         } catch (RecognitionException re) {\r
7935             _localctx.exception = re;\r
7936             _errHandler.reportError(this, re);\r
7937             _errHandler.recover(this, re);\r
7938         } finally {\r
7939             exitRule();\r
7940         }\r
7941         return _localctx;\r
7942     }\r
7943 \r
7944     public static class Identityref_specificationContext extends\r
7945             ParserRuleContext {\r
7946         public Base_stmtContext base_stmt() {\r
7947             return getRuleContext(Base_stmtContext.class, 0);\r
7948         }\r
7949 \r
7950         public Identityref_specificationContext(ParserRuleContext parent,\r
7951                 int invokingState) {\r
7952             super(parent, invokingState);\r
7953         }\r
7954 \r
7955         @Override\r
7956         public int getRuleIndex() {\r
7957             return RULE_identityref_specification;\r
7958         }\r
7959 \r
7960         @Override\r
7961         public void enterRule(ParseTreeListener listener) {\r
7962             if (listener instanceof YangParserListener)\r
7963                 ((YangParserListener) listener)\r
7964                         .enterIdentityref_specification(this);\r
7965         }\r
7966 \r
7967         @Override\r
7968         public void exitRule(ParseTreeListener listener) {\r
7969             if (listener instanceof YangParserListener)\r
7970                 ((YangParserListener) listener)\r
7971                         .exitIdentityref_specification(this);\r
7972         }\r
7973 \r
7974         @Override\r
7975         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
7976             if (visitor instanceof YangParserVisitor)\r
7977                 return ((YangParserVisitor<? extends T>) visitor)\r
7978                         .visitIdentityref_specification(this);\r
7979             else\r
7980                 return visitor.visitChildren(this);\r
7981         }\r
7982     }\r
7983 \r
7984     public final Identityref_specificationContext identityref_specification()\r
7985             throws RecognitionException {\r
7986         Identityref_specificationContext _localctx = new Identityref_specificationContext(\r
7987                 _ctx, getState());\r
7988         enterRule(_localctx, 114, RULE_identityref_specification);\r
7989         try {\r
7990             enterOuterAlt(_localctx, 1);\r
7991             {\r
7992                 setState(831);\r
7993                 base_stmt();\r
7994             }\r
7995         } catch (RecognitionException re) {\r
7996             _localctx.exception = re;\r
7997             _errHandler.reportError(this, re);\r
7998             _errHandler.recover(this, re);\r
7999         } finally {\r
8000             exitRule();\r
8001         }\r
8002         return _localctx;\r
8003     }\r
8004 \r
8005     public static class Instance_identifier_specificationContext extends\r
8006             ParserRuleContext {\r
8007         public Require_instance_stmtContext require_instance_stmt() {\r
8008             return getRuleContext(Require_instance_stmtContext.class, 0);\r
8009         }\r
8010 \r
8011         public Instance_identifier_specificationContext(\r
8012                 ParserRuleContext parent, int invokingState) {\r
8013             super(parent, invokingState);\r
8014         }\r
8015 \r
8016         @Override\r
8017         public int getRuleIndex() {\r
8018             return RULE_instance_identifier_specification;\r
8019         }\r
8020 \r
8021         @Override\r
8022         public void enterRule(ParseTreeListener listener) {\r
8023             if (listener instanceof YangParserListener)\r
8024                 ((YangParserListener) listener)\r
8025                         .enterInstance_identifier_specification(this);\r
8026         }\r
8027 \r
8028         @Override\r
8029         public void exitRule(ParseTreeListener listener) {\r
8030             if (listener instanceof YangParserListener)\r
8031                 ((YangParserListener) listener)\r
8032                         .exitInstance_identifier_specification(this);\r
8033         }\r
8034 \r
8035         @Override\r
8036         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
8037             if (visitor instanceof YangParserVisitor)\r
8038                 return ((YangParserVisitor<? extends T>) visitor)\r
8039                         .visitInstance_identifier_specification(this);\r
8040             else\r
8041                 return visitor.visitChildren(this);\r
8042         }\r
8043     }\r
8044 \r
8045     public final Instance_identifier_specificationContext instance_identifier_specification()\r
8046             throws RecognitionException {\r
8047         Instance_identifier_specificationContext _localctx = new Instance_identifier_specificationContext(\r
8048                 _ctx, getState());\r
8049         enterRule(_localctx, 116, RULE_instance_identifier_specification);\r
8050         int _la;\r
8051         try {\r
8052             enterOuterAlt(_localctx, 1);\r
8053             {\r
8054                 setState(834);\r
8055                 _la = _input.LA(1);\r
8056                 if (_la == REQUIRE_INSTANCE_KEYWORD) {\r
8057                     {\r
8058                         setState(833);\r
8059                         require_instance_stmt();\r
8060                     }\r
8061                 }\r
8062 \r
8063             }\r
8064         } catch (RecognitionException re) {\r
8065             _localctx.exception = re;\r
8066             _errHandler.reportError(this, re);\r
8067             _errHandler.recover(this, re);\r
8068         } finally {\r
8069             exitRule();\r
8070         }\r
8071         return _localctx;\r
8072     }\r
8073 \r
8074     public static class Require_instance_argContext extends ParserRuleContext {\r
8075         public StringContext string() {\r
8076             return getRuleContext(StringContext.class, 0);\r
8077         }\r
8078 \r
8079         public Require_instance_argContext(ParserRuleContext parent,\r
8080                 int invokingState) {\r
8081             super(parent, invokingState);\r
8082         }\r
8083 \r
8084         @Override\r
8085         public int getRuleIndex() {\r
8086             return RULE_require_instance_arg;\r
8087         }\r
8088 \r
8089         @Override\r
8090         public void enterRule(ParseTreeListener listener) {\r
8091             if (listener instanceof YangParserListener)\r
8092                 ((YangParserListener) listener).enterRequire_instance_arg(this);\r
8093         }\r
8094 \r
8095         @Override\r
8096         public void exitRule(ParseTreeListener listener) {\r
8097             if (listener instanceof YangParserListener)\r
8098                 ((YangParserListener) listener).exitRequire_instance_arg(this);\r
8099         }\r
8100 \r
8101         @Override\r
8102         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
8103             if (visitor instanceof YangParserVisitor)\r
8104                 return ((YangParserVisitor<? extends T>) visitor)\r
8105                         .visitRequire_instance_arg(this);\r
8106             else\r
8107                 return visitor.visitChildren(this);\r
8108         }\r
8109     }\r
8110 \r
8111     public final Require_instance_argContext require_instance_arg()\r
8112             throws RecognitionException {\r
8113         Require_instance_argContext _localctx = new Require_instance_argContext(\r
8114                 _ctx, getState());\r
8115         enterRule(_localctx, 118, RULE_require_instance_arg);\r
8116         try {\r
8117             enterOuterAlt(_localctx, 1);\r
8118             {\r
8119                 setState(836);\r
8120                 string();\r
8121             }\r
8122         } catch (RecognitionException re) {\r
8123             _localctx.exception = re;\r
8124             _errHandler.reportError(this, re);\r
8125             _errHandler.recover(this, re);\r
8126         } finally {\r
8127             exitRule();\r
8128         }\r
8129         return _localctx;\r
8130     }\r
8131 \r
8132     public static class Require_instance_stmtContext extends ParserRuleContext {\r
8133         public Require_instance_argContext require_instance_arg() {\r
8134             return getRuleContext(Require_instance_argContext.class, 0);\r
8135         }\r
8136 \r
8137         public TerminalNode REQUIRE_INSTANCE_KEYWORD() {\r
8138             return getToken(YangParser.REQUIRE_INSTANCE_KEYWORD, 0);\r
8139         }\r
8140 \r
8141         public StmtendContext stmtend() {\r
8142             return getRuleContext(StmtendContext.class, 0);\r
8143         }\r
8144 \r
8145         public Require_instance_stmtContext(ParserRuleContext parent,\r
8146                 int invokingState) {\r
8147             super(parent, invokingState);\r
8148         }\r
8149 \r
8150         @Override\r
8151         public int getRuleIndex() {\r
8152             return RULE_require_instance_stmt;\r
8153         }\r
8154 \r
8155         @Override\r
8156         public void enterRule(ParseTreeListener listener) {\r
8157             if (listener instanceof YangParserListener)\r
8158                 ((YangParserListener) listener)\r
8159                         .enterRequire_instance_stmt(this);\r
8160         }\r
8161 \r
8162         @Override\r
8163         public void exitRule(ParseTreeListener listener) {\r
8164             if (listener instanceof YangParserListener)\r
8165                 ((YangParserListener) listener).exitRequire_instance_stmt(this);\r
8166         }\r
8167 \r
8168         @Override\r
8169         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
8170             if (visitor instanceof YangParserVisitor)\r
8171                 return ((YangParserVisitor<? extends T>) visitor)\r
8172                         .visitRequire_instance_stmt(this);\r
8173             else\r
8174                 return visitor.visitChildren(this);\r
8175         }\r
8176     }\r
8177 \r
8178     public final Require_instance_stmtContext require_instance_stmt()\r
8179             throws RecognitionException {\r
8180         Require_instance_stmtContext _localctx = new Require_instance_stmtContext(\r
8181                 _ctx, getState());\r
8182         enterRule(_localctx, 120, RULE_require_instance_stmt);\r
8183         try {\r
8184             enterOuterAlt(_localctx, 1);\r
8185             {\r
8186                 setState(838);\r
8187                 match(REQUIRE_INSTANCE_KEYWORD);\r
8188                 setState(839);\r
8189                 require_instance_arg();\r
8190                 setState(840);\r
8191                 stmtend();\r
8192             }\r
8193         } catch (RecognitionException re) {\r
8194             _localctx.exception = re;\r
8195             _errHandler.reportError(this, re);\r
8196             _errHandler.recover(this, re);\r
8197         } finally {\r
8198             exitRule();\r
8199         }\r
8200         return _localctx;\r
8201     }\r
8202 \r
8203     public static class Path_stmtContext extends ParserRuleContext {\r
8204         public TerminalNode PATH_KEYWORD() {\r
8205             return getToken(YangParser.PATH_KEYWORD, 0);\r
8206         }\r
8207 \r
8208         public StringContext string() {\r
8209             return getRuleContext(StringContext.class, 0);\r
8210         }\r
8211 \r
8212         public StmtendContext stmtend() {\r
8213             return getRuleContext(StmtendContext.class, 0);\r
8214         }\r
8215 \r
8216         public Path_stmtContext(ParserRuleContext parent, int invokingState) {\r
8217             super(parent, invokingState);\r
8218         }\r
8219 \r
8220         @Override\r
8221         public int getRuleIndex() {\r
8222             return RULE_path_stmt;\r
8223         }\r
8224 \r
8225         @Override\r
8226         public void enterRule(ParseTreeListener listener) {\r
8227             if (listener instanceof YangParserListener)\r
8228                 ((YangParserListener) listener).enterPath_stmt(this);\r
8229         }\r
8230 \r
8231         @Override\r
8232         public void exitRule(ParseTreeListener listener) {\r
8233             if (listener instanceof YangParserListener)\r
8234                 ((YangParserListener) listener).exitPath_stmt(this);\r
8235         }\r
8236 \r
8237         @Override\r
8238         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
8239             if (visitor instanceof YangParserVisitor)\r
8240                 return ((YangParserVisitor<? extends T>) visitor)\r
8241                         .visitPath_stmt(this);\r
8242             else\r
8243                 return visitor.visitChildren(this);\r
8244         }\r
8245     }\r
8246 \r
8247     public final Path_stmtContext path_stmt() throws RecognitionException {\r
8248         Path_stmtContext _localctx = new Path_stmtContext(_ctx, getState());\r
8249         enterRule(_localctx, 122, RULE_path_stmt);\r
8250         try {\r
8251             enterOuterAlt(_localctx, 1);\r
8252             {\r
8253                 setState(842);\r
8254                 match(PATH_KEYWORD);\r
8255                 setState(843);\r
8256                 string();\r
8257                 setState(844);\r
8258                 stmtend();\r
8259             }\r
8260         } catch (RecognitionException re) {\r
8261             _localctx.exception = re;\r
8262             _errHandler.reportError(this, re);\r
8263             _errHandler.recover(this, re);\r
8264         } finally {\r
8265             exitRule();\r
8266         }\r
8267         return _localctx;\r
8268     }\r
8269 \r
8270     public static class Leafref_specificationContext extends ParserRuleContext {\r
8271         public Path_stmtContext path_stmt() {\r
8272             return getRuleContext(Path_stmtContext.class, 0);\r
8273         }\r
8274 \r
8275         public Leafref_specificationContext(ParserRuleContext parent,\r
8276                 int invokingState) {\r
8277             super(parent, invokingState);\r
8278         }\r
8279 \r
8280         @Override\r
8281         public int getRuleIndex() {\r
8282             return RULE_leafref_specification;\r
8283         }\r
8284 \r
8285         @Override\r
8286         public void enterRule(ParseTreeListener listener) {\r
8287             if (listener instanceof YangParserListener)\r
8288                 ((YangParserListener) listener)\r
8289                         .enterLeafref_specification(this);\r
8290         }\r
8291 \r
8292         @Override\r
8293         public void exitRule(ParseTreeListener listener) {\r
8294             if (listener instanceof YangParserListener)\r
8295                 ((YangParserListener) listener).exitLeafref_specification(this);\r
8296         }\r
8297 \r
8298         @Override\r
8299         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
8300             if (visitor instanceof YangParserVisitor)\r
8301                 return ((YangParserVisitor<? extends T>) visitor)\r
8302                         .visitLeafref_specification(this);\r
8303             else\r
8304                 return visitor.visitChildren(this);\r
8305         }\r
8306     }\r
8307 \r
8308     public final Leafref_specificationContext leafref_specification()\r
8309             throws RecognitionException {\r
8310         Leafref_specificationContext _localctx = new Leafref_specificationContext(\r
8311                 _ctx, getState());\r
8312         enterRule(_localctx, 124, RULE_leafref_specification);\r
8313         try {\r
8314             enterOuterAlt(_localctx, 1);\r
8315             {\r
8316                 setState(846);\r
8317                 path_stmt();\r
8318             }\r
8319         } catch (RecognitionException re) {\r
8320             _localctx.exception = re;\r
8321             _errHandler.reportError(this, re);\r
8322             _errHandler.recover(this, re);\r
8323         } finally {\r
8324             exitRule();\r
8325         }\r
8326         return _localctx;\r
8327     }\r
8328 \r
8329     public static class Enum_stmtContext extends ParserRuleContext {\r
8330         public TerminalNode RIGHT_BRACE() {\r
8331             return getToken(YangParser.RIGHT_BRACE, 0);\r
8332         }\r
8333 \r
8334         public List<Reference_stmtContext> reference_stmt() {\r
8335             return getRuleContexts(Reference_stmtContext.class);\r
8336         }\r
8337 \r
8338         public Description_stmtContext description_stmt(int i) {\r
8339             return getRuleContext(Description_stmtContext.class, i);\r
8340         }\r
8341 \r
8342         public TerminalNode LEFT_BRACE() {\r
8343             return getToken(YangParser.LEFT_BRACE, 0);\r
8344         }\r
8345 \r
8346         public Status_stmtContext status_stmt(int i) {\r
8347             return getRuleContext(Status_stmtContext.class, i);\r
8348         }\r
8349 \r
8350         public Value_stmtContext value_stmt(int i) {\r
8351             return getRuleContext(Value_stmtContext.class, i);\r
8352         }\r
8353 \r
8354         public List<Value_stmtContext> value_stmt() {\r
8355             return getRuleContexts(Value_stmtContext.class);\r
8356         }\r
8357 \r
8358         public TerminalNode ENUM_KEYWORD() {\r
8359             return getToken(YangParser.ENUM_KEYWORD, 0);\r
8360         }\r
8361 \r
8362         public Identifier_stmtContext identifier_stmt(int i) {\r
8363             return getRuleContext(Identifier_stmtContext.class, i);\r
8364         }\r
8365 \r
8366         public TerminalNode SEMICOLON() {\r
8367             return getToken(YangParser.SEMICOLON, 0);\r
8368         }\r
8369 \r
8370         public List<Status_stmtContext> status_stmt() {\r
8371             return getRuleContexts(Status_stmtContext.class);\r
8372         }\r
8373 \r
8374         public StringContext string() {\r
8375             return getRuleContext(StringContext.class, 0);\r
8376         }\r
8377 \r
8378         public List<Identifier_stmtContext> identifier_stmt() {\r
8379             return getRuleContexts(Identifier_stmtContext.class);\r
8380         }\r
8381 \r
8382         public List<Description_stmtContext> description_stmt() {\r
8383             return getRuleContexts(Description_stmtContext.class);\r
8384         }\r
8385 \r
8386         public Reference_stmtContext reference_stmt(int i) {\r
8387             return getRuleContext(Reference_stmtContext.class, i);\r
8388         }\r
8389 \r
8390         public Enum_stmtContext(ParserRuleContext parent, int invokingState) {\r
8391             super(parent, invokingState);\r
8392         }\r
8393 \r
8394         @Override\r
8395         public int getRuleIndex() {\r
8396             return RULE_enum_stmt;\r
8397         }\r
8398 \r
8399         @Override\r
8400         public void enterRule(ParseTreeListener listener) {\r
8401             if (listener instanceof YangParserListener)\r
8402                 ((YangParserListener) listener).enterEnum_stmt(this);\r
8403         }\r
8404 \r
8405         @Override\r
8406         public void exitRule(ParseTreeListener listener) {\r
8407             if (listener instanceof YangParserListener)\r
8408                 ((YangParserListener) listener).exitEnum_stmt(this);\r
8409         }\r
8410 \r
8411         @Override\r
8412         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
8413             if (visitor instanceof YangParserVisitor)\r
8414                 return ((YangParserVisitor<? extends T>) visitor)\r
8415                         .visitEnum_stmt(this);\r
8416             else\r
8417                 return visitor.visitChildren(this);\r
8418         }\r
8419     }\r
8420 \r
8421     public final Enum_stmtContext enum_stmt() throws RecognitionException {\r
8422         Enum_stmtContext _localctx = new Enum_stmtContext(_ctx, getState());\r
8423         enterRule(_localctx, 126, RULE_enum_stmt);\r
8424         int _la;\r
8425         try {\r
8426             enterOuterAlt(_localctx, 1);\r
8427             {\r
8428                 setState(848);\r
8429                 match(ENUM_KEYWORD);\r
8430                 setState(849);\r
8431                 string();\r
8432                 setState(863);\r
8433                 switch (_input.LA(1)) {\r
8434                 case SEMICOLON: {\r
8435                     setState(850);\r
8436                     match(SEMICOLON);\r
8437                 }\r
8438                     break;\r
8439                 case LEFT_BRACE: {\r
8440                     {\r
8441                         setState(851);\r
8442                         match(LEFT_BRACE);\r
8443                         setState(859);\r
8444                         _errHandler.sync(this);\r
8445                         _la = _input.LA(1);\r
8446                         while (((((_la - 11)) & ~0x3f) == 0 && ((1L << (_la - 11)) & ((1L << (VALUE_KEYWORD - 11))\r
8447                                 | (1L << (STATUS_KEYWORD - 11))\r
8448                                 | (1L << (REFERENCE_KEYWORD - 11))\r
8449                                 | (1L << (DESCRIPTION_KEYWORD - 11)) | (1L << (IDENTIFIER - 11)))) != 0)) {\r
8450                             {\r
8451                                 setState(857);\r
8452                                 switch (_input.LA(1)) {\r
8453                                 case IDENTIFIER: {\r
8454                                     setState(852);\r
8455                                     identifier_stmt();\r
8456                                 }\r
8457                                     break;\r
8458                                 case VALUE_KEYWORD: {\r
8459                                     setState(853);\r
8460                                     value_stmt();\r
8461                                 }\r
8462                                     break;\r
8463                                 case STATUS_KEYWORD: {\r
8464                                     setState(854);\r
8465                                     status_stmt();\r
8466                                 }\r
8467                                     break;\r
8468                                 case DESCRIPTION_KEYWORD: {\r
8469                                     setState(855);\r
8470                                     description_stmt();\r
8471                                 }\r
8472                                     break;\r
8473                                 case REFERENCE_KEYWORD: {\r
8474                                     setState(856);\r
8475                                     reference_stmt();\r
8476                                 }\r
8477                                     break;\r
8478                                 default:\r
8479                                     throw new NoViableAltException(this);\r
8480                                 }\r
8481                             }\r
8482                             setState(861);\r
8483                             _errHandler.sync(this);\r
8484                             _la = _input.LA(1);\r
8485                         }\r
8486                         setState(862);\r
8487                         match(RIGHT_BRACE);\r
8488                     }\r
8489                 }\r
8490                     break;\r
8491                 default:\r
8492                     throw new NoViableAltException(this);\r
8493                 }\r
8494             }\r
8495         } catch (RecognitionException re) {\r
8496             _localctx.exception = re;\r
8497             _errHandler.reportError(this, re);\r
8498             _errHandler.recover(this, re);\r
8499         } finally {\r
8500             exitRule();\r
8501         }\r
8502         return _localctx;\r
8503     }\r
8504 \r
8505     public static class Enum_specificationContext extends ParserRuleContext {\r
8506         public List<Enum_stmtContext> enum_stmt() {\r
8507             return getRuleContexts(Enum_stmtContext.class);\r
8508         }\r
8509 \r
8510         public Enum_stmtContext enum_stmt(int i) {\r
8511             return getRuleContext(Enum_stmtContext.class, i);\r
8512         }\r
8513 \r
8514         public Enum_specificationContext(ParserRuleContext parent,\r
8515                 int invokingState) {\r
8516             super(parent, invokingState);\r
8517         }\r
8518 \r
8519         @Override\r
8520         public int getRuleIndex() {\r
8521             return RULE_enum_specification;\r
8522         }\r
8523 \r
8524         @Override\r
8525         public void enterRule(ParseTreeListener listener) {\r
8526             if (listener instanceof YangParserListener)\r
8527                 ((YangParserListener) listener).enterEnum_specification(this);\r
8528         }\r
8529 \r
8530         @Override\r
8531         public void exitRule(ParseTreeListener listener) {\r
8532             if (listener instanceof YangParserListener)\r
8533                 ((YangParserListener) listener).exitEnum_specification(this);\r
8534         }\r
8535 \r
8536         @Override\r
8537         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
8538             if (visitor instanceof YangParserVisitor)\r
8539                 return ((YangParserVisitor<? extends T>) visitor)\r
8540                         .visitEnum_specification(this);\r
8541             else\r
8542                 return visitor.visitChildren(this);\r
8543         }\r
8544     }\r
8545 \r
8546     public final Enum_specificationContext enum_specification()\r
8547             throws RecognitionException {\r
8548         Enum_specificationContext _localctx = new Enum_specificationContext(\r
8549                 _ctx, getState());\r
8550         enterRule(_localctx, 128, RULE_enum_specification);\r
8551         int _la;\r
8552         try {\r
8553             enterOuterAlt(_localctx, 1);\r
8554             {\r
8555                 setState(866);\r
8556                 _errHandler.sync(this);\r
8557                 _la = _input.LA(1);\r
8558                 do {\r
8559                     {\r
8560                         {\r
8561                             setState(865);\r
8562                             enum_stmt();\r
8563                         }\r
8564                     }\r
8565                     setState(868);\r
8566                     _errHandler.sync(this);\r
8567                     _la = _input.LA(1);\r
8568                 } while (_la == ENUM_KEYWORD);\r
8569             }\r
8570         } catch (RecognitionException re) {\r
8571             _localctx.exception = re;\r
8572             _errHandler.reportError(this, re);\r
8573             _errHandler.recover(this, re);\r
8574         } finally {\r
8575             exitRule();\r
8576         }\r
8577         return _localctx;\r
8578     }\r
8579 \r
8580     public static class Default_stmtContext extends ParserRuleContext {\r
8581         public StringContext string() {\r
8582             return getRuleContext(StringContext.class, 0);\r
8583         }\r
8584 \r
8585         public StmtendContext stmtend() {\r
8586             return getRuleContext(StmtendContext.class, 0);\r
8587         }\r
8588 \r
8589         public TerminalNode DEFAULT_KEYWORD() {\r
8590             return getToken(YangParser.DEFAULT_KEYWORD, 0);\r
8591         }\r
8592 \r
8593         public Default_stmtContext(ParserRuleContext parent, int invokingState) {\r
8594             super(parent, invokingState);\r
8595         }\r
8596 \r
8597         @Override\r
8598         public int getRuleIndex() {\r
8599             return RULE_default_stmt;\r
8600         }\r
8601 \r
8602         @Override\r
8603         public void enterRule(ParseTreeListener listener) {\r
8604             if (listener instanceof YangParserListener)\r
8605                 ((YangParserListener) listener).enterDefault_stmt(this);\r
8606         }\r
8607 \r
8608         @Override\r
8609         public void exitRule(ParseTreeListener listener) {\r
8610             if (listener instanceof YangParserListener)\r
8611                 ((YangParserListener) listener).exitDefault_stmt(this);\r
8612         }\r
8613 \r
8614         @Override\r
8615         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
8616             if (visitor instanceof YangParserVisitor)\r
8617                 return ((YangParserVisitor<? extends T>) visitor)\r
8618                         .visitDefault_stmt(this);\r
8619             else\r
8620                 return visitor.visitChildren(this);\r
8621         }\r
8622     }\r
8623 \r
8624     public final Default_stmtContext default_stmt() throws RecognitionException {\r
8625         Default_stmtContext _localctx = new Default_stmtContext(_ctx,\r
8626                 getState());\r
8627         enterRule(_localctx, 130, RULE_default_stmt);\r
8628         try {\r
8629             enterOuterAlt(_localctx, 1);\r
8630             {\r
8631                 setState(870);\r
8632                 match(DEFAULT_KEYWORD);\r
8633                 setState(871);\r
8634                 string();\r
8635                 setState(872);\r
8636                 stmtend();\r
8637             }\r
8638         } catch (RecognitionException re) {\r
8639             _localctx.exception = re;\r
8640             _errHandler.reportError(this, re);\r
8641             _errHandler.recover(this, re);\r
8642         } finally {\r
8643             exitRule();\r
8644         }\r
8645         return _localctx;\r
8646     }\r
8647 \r
8648     public static class Pattern_stmtContext extends ParserRuleContext {\r
8649         public TerminalNode RIGHT_BRACE() {\r
8650             return getToken(YangParser.RIGHT_BRACE, 0);\r
8651         }\r
8652 \r
8653         public List<Reference_stmtContext> reference_stmt() {\r
8654             return getRuleContexts(Reference_stmtContext.class);\r
8655         }\r
8656 \r
8657         public Description_stmtContext description_stmt(int i) {\r
8658             return getRuleContext(Description_stmtContext.class, i);\r
8659         }\r
8660 \r
8661         public TerminalNode LEFT_BRACE() {\r
8662             return getToken(YangParser.LEFT_BRACE, 0);\r
8663         }\r
8664 \r
8665         public List<Error_app_tag_stmtContext> error_app_tag_stmt() {\r
8666             return getRuleContexts(Error_app_tag_stmtContext.class);\r
8667         }\r
8668 \r
8669         public Error_message_stmtContext error_message_stmt(int i) {\r
8670             return getRuleContext(Error_message_stmtContext.class, i);\r
8671         }\r
8672 \r
8673         public Identifier_stmtContext identifier_stmt(int i) {\r
8674             return getRuleContext(Identifier_stmtContext.class, i);\r
8675         }\r
8676 \r
8677         public TerminalNode PATTERN_KEYWORD() {\r
8678             return getToken(YangParser.PATTERN_KEYWORD, 0);\r
8679         }\r
8680 \r
8681         public TerminalNode SEMICOLON() {\r
8682             return getToken(YangParser.SEMICOLON, 0);\r
8683         }\r
8684 \r
8685         public StringContext string() {\r
8686             return getRuleContext(StringContext.class, 0);\r
8687         }\r
8688 \r
8689         public List<Identifier_stmtContext> identifier_stmt() {\r
8690             return getRuleContexts(Identifier_stmtContext.class);\r
8691         }\r
8692 \r
8693         public Error_app_tag_stmtContext error_app_tag_stmt(int i) {\r
8694             return getRuleContext(Error_app_tag_stmtContext.class, i);\r
8695         }\r
8696 \r
8697         public List<Error_message_stmtContext> error_message_stmt() {\r
8698             return getRuleContexts(Error_message_stmtContext.class);\r
8699         }\r
8700 \r
8701         public List<Description_stmtContext> description_stmt() {\r
8702             return getRuleContexts(Description_stmtContext.class);\r
8703         }\r
8704 \r
8705         public Reference_stmtContext reference_stmt(int i) {\r
8706             return getRuleContext(Reference_stmtContext.class, i);\r
8707         }\r
8708 \r
8709         public Pattern_stmtContext(ParserRuleContext parent, int invokingState) {\r
8710             super(parent, invokingState);\r
8711         }\r
8712 \r
8713         @Override\r
8714         public int getRuleIndex() {\r
8715             return RULE_pattern_stmt;\r
8716         }\r
8717 \r
8718         @Override\r
8719         public void enterRule(ParseTreeListener listener) {\r
8720             if (listener instanceof YangParserListener)\r
8721                 ((YangParserListener) listener).enterPattern_stmt(this);\r
8722         }\r
8723 \r
8724         @Override\r
8725         public void exitRule(ParseTreeListener listener) {\r
8726             if (listener instanceof YangParserListener)\r
8727                 ((YangParserListener) listener).exitPattern_stmt(this);\r
8728         }\r
8729 \r
8730         @Override\r
8731         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
8732             if (visitor instanceof YangParserVisitor)\r
8733                 return ((YangParserVisitor<? extends T>) visitor)\r
8734                         .visitPattern_stmt(this);\r
8735             else\r
8736                 return visitor.visitChildren(this);\r
8737         }\r
8738     }\r
8739 \r
8740     public final Pattern_stmtContext pattern_stmt() throws RecognitionException {\r
8741         Pattern_stmtContext _localctx = new Pattern_stmtContext(_ctx,\r
8742                 getState());\r
8743         enterRule(_localctx, 132, RULE_pattern_stmt);\r
8744         int _la;\r
8745         try {\r
8746             enterOuterAlt(_localctx, 1);\r
8747             {\r
8748                 setState(874);\r
8749                 match(PATTERN_KEYWORD);\r
8750                 setState(875);\r
8751                 string();\r
8752                 setState(889);\r
8753                 switch (_input.LA(1)) {\r
8754                 case SEMICOLON: {\r
8755                     setState(876);\r
8756                     match(SEMICOLON);\r
8757                 }\r
8758                     break;\r
8759                 case LEFT_BRACE: {\r
8760                     {\r
8761                         setState(877);\r
8762                         match(LEFT_BRACE);\r
8763                         setState(885);\r
8764                         _errHandler.sync(this);\r
8765                         _la = _input.LA(1);\r
8766                         while (((((_la - 24)) & ~0x3f) == 0 && ((1L << (_la - 24)) & ((1L << (REFERENCE_KEYWORD - 24))\r
8767                                 | (1L << (ERROR_MESSAGE_KEYWORD - 24))\r
8768                                 | (1L << (ERROR_APP_TAG_KEYWORD - 24))\r
8769                                 | (1L << (DESCRIPTION_KEYWORD - 24)) | (1L << (IDENTIFIER - 24)))) != 0)) {\r
8770                             {\r
8771                                 setState(883);\r
8772                                 switch (_input.LA(1)) {\r
8773                                 case IDENTIFIER: {\r
8774                                     setState(878);\r
8775                                     identifier_stmt();\r
8776                                 }\r
8777                                     break;\r
8778                                 case ERROR_MESSAGE_KEYWORD: {\r
8779                                     setState(879);\r
8780                                     error_message_stmt();\r
8781                                 }\r
8782                                     break;\r
8783                                 case ERROR_APP_TAG_KEYWORD: {\r
8784                                     setState(880);\r
8785                                     error_app_tag_stmt();\r
8786                                 }\r
8787                                     break;\r
8788                                 case DESCRIPTION_KEYWORD: {\r
8789                                     setState(881);\r
8790                                     description_stmt();\r
8791                                 }\r
8792                                     break;\r
8793                                 case REFERENCE_KEYWORD: {\r
8794                                     setState(882);\r
8795                                     reference_stmt();\r
8796                                 }\r
8797                                     break;\r
8798                                 default:\r
8799                                     throw new NoViableAltException(this);\r
8800                                 }\r
8801                             }\r
8802                             setState(887);\r
8803                             _errHandler.sync(this);\r
8804                             _la = _input.LA(1);\r
8805                         }\r
8806                         setState(888);\r
8807                         match(RIGHT_BRACE);\r
8808                     }\r
8809                 }\r
8810                     break;\r
8811                 default:\r
8812                     throw new NoViableAltException(this);\r
8813                 }\r
8814             }\r
8815         } catch (RecognitionException re) {\r
8816             _localctx.exception = re;\r
8817             _errHandler.reportError(this, re);\r
8818             _errHandler.recover(this, re);\r
8819         } finally {\r
8820             exitRule();\r
8821         }\r
8822         return _localctx;\r
8823     }\r
8824 \r
8825     public static class Length_stmtContext extends ParserRuleContext {\r
8826         public TerminalNode RIGHT_BRACE() {\r
8827             return getToken(YangParser.RIGHT_BRACE, 0);\r
8828         }\r
8829 \r
8830         public List<Reference_stmtContext> reference_stmt() {\r
8831             return getRuleContexts(Reference_stmtContext.class);\r
8832         }\r
8833 \r
8834         public Description_stmtContext description_stmt(int i) {\r
8835             return getRuleContext(Description_stmtContext.class, i);\r
8836         }\r
8837 \r
8838         public TerminalNode LEFT_BRACE() {\r
8839             return getToken(YangParser.LEFT_BRACE, 0);\r
8840         }\r
8841 \r
8842         public List<Error_app_tag_stmtContext> error_app_tag_stmt() {\r
8843             return getRuleContexts(Error_app_tag_stmtContext.class);\r
8844         }\r
8845 \r
8846         public Error_message_stmtContext error_message_stmt(int i) {\r
8847             return getRuleContext(Error_message_stmtContext.class, i);\r
8848         }\r
8849 \r
8850         public Identifier_stmtContext identifier_stmt(int i) {\r
8851             return getRuleContext(Identifier_stmtContext.class, i);\r
8852         }\r
8853 \r
8854         public TerminalNode SEMICOLON() {\r
8855             return getToken(YangParser.SEMICOLON, 0);\r
8856         }\r
8857 \r
8858         public StringContext string() {\r
8859             return getRuleContext(StringContext.class, 0);\r
8860         }\r
8861 \r
8862         public List<Identifier_stmtContext> identifier_stmt() {\r
8863             return getRuleContexts(Identifier_stmtContext.class);\r
8864         }\r
8865 \r
8866         public TerminalNode LENGTH_KEYWORD() {\r
8867             return getToken(YangParser.LENGTH_KEYWORD, 0);\r
8868         }\r
8869 \r
8870         public Error_app_tag_stmtContext error_app_tag_stmt(int i) {\r
8871             return getRuleContext(Error_app_tag_stmtContext.class, i);\r
8872         }\r
8873 \r
8874         public List<Error_message_stmtContext> error_message_stmt() {\r
8875             return getRuleContexts(Error_message_stmtContext.class);\r
8876         }\r
8877 \r
8878         public List<Description_stmtContext> description_stmt() {\r
8879             return getRuleContexts(Description_stmtContext.class);\r
8880         }\r
8881 \r
8882         public Reference_stmtContext reference_stmt(int i) {\r
8883             return getRuleContext(Reference_stmtContext.class, i);\r
8884         }\r
8885 \r
8886         public Length_stmtContext(ParserRuleContext parent, int invokingState) {\r
8887             super(parent, invokingState);\r
8888         }\r
8889 \r
8890         @Override\r
8891         public int getRuleIndex() {\r
8892             return RULE_length_stmt;\r
8893         }\r
8894 \r
8895         @Override\r
8896         public void enterRule(ParseTreeListener listener) {\r
8897             if (listener instanceof YangParserListener)\r
8898                 ((YangParserListener) listener).enterLength_stmt(this);\r
8899         }\r
8900 \r
8901         @Override\r
8902         public void exitRule(ParseTreeListener listener) {\r
8903             if (listener instanceof YangParserListener)\r
8904                 ((YangParserListener) listener).exitLength_stmt(this);\r
8905         }\r
8906 \r
8907         @Override\r
8908         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
8909             if (visitor instanceof YangParserVisitor)\r
8910                 return ((YangParserVisitor<? extends T>) visitor)\r
8911                         .visitLength_stmt(this);\r
8912             else\r
8913                 return visitor.visitChildren(this);\r
8914         }\r
8915     }\r
8916 \r
8917     public final Length_stmtContext length_stmt() throws RecognitionException {\r
8918         Length_stmtContext _localctx = new Length_stmtContext(_ctx, getState());\r
8919         enterRule(_localctx, 134, RULE_length_stmt);\r
8920         int _la;\r
8921         try {\r
8922             enterOuterAlt(_localctx, 1);\r
8923             {\r
8924                 setState(891);\r
8925                 match(LENGTH_KEYWORD);\r
8926                 setState(892);\r
8927                 string();\r
8928                 setState(906);\r
8929                 switch (_input.LA(1)) {\r
8930                 case SEMICOLON: {\r
8931                     setState(893);\r
8932                     match(SEMICOLON);\r
8933                 }\r
8934                     break;\r
8935                 case LEFT_BRACE: {\r
8936                     {\r
8937                         setState(894);\r
8938                         match(LEFT_BRACE);\r
8939                         setState(902);\r
8940                         _errHandler.sync(this);\r
8941                         _la = _input.LA(1);\r
8942                         while (((((_la - 24)) & ~0x3f) == 0 && ((1L << (_la - 24)) & ((1L << (REFERENCE_KEYWORD - 24))\r
8943                                 | (1L << (ERROR_MESSAGE_KEYWORD - 24))\r
8944                                 | (1L << (ERROR_APP_TAG_KEYWORD - 24))\r
8945                                 | (1L << (DESCRIPTION_KEYWORD - 24)) | (1L << (IDENTIFIER - 24)))) != 0)) {\r
8946                             {\r
8947                                 setState(900);\r
8948                                 switch (_input.LA(1)) {\r
8949                                 case IDENTIFIER: {\r
8950                                     setState(895);\r
8951                                     identifier_stmt();\r
8952                                 }\r
8953                                     break;\r
8954                                 case ERROR_MESSAGE_KEYWORD: {\r
8955                                     setState(896);\r
8956                                     error_message_stmt();\r
8957                                 }\r
8958                                     break;\r
8959                                 case ERROR_APP_TAG_KEYWORD: {\r
8960                                     setState(897);\r
8961                                     error_app_tag_stmt();\r
8962                                 }\r
8963                                     break;\r
8964                                 case DESCRIPTION_KEYWORD: {\r
8965                                     setState(898);\r
8966                                     description_stmt();\r
8967                                 }\r
8968                                     break;\r
8969                                 case REFERENCE_KEYWORD: {\r
8970                                     setState(899);\r
8971                                     reference_stmt();\r
8972                                 }\r
8973                                     break;\r
8974                                 default:\r
8975                                     throw new NoViableAltException(this);\r
8976                                 }\r
8977                             }\r
8978                             setState(904);\r
8979                             _errHandler.sync(this);\r
8980                             _la = _input.LA(1);\r
8981                         }\r
8982                         setState(905);\r
8983                         match(RIGHT_BRACE);\r
8984                     }\r
8985                 }\r
8986                     break;\r
8987                 default:\r
8988                     throw new NoViableAltException(this);\r
8989                 }\r
8990             }\r
8991         } catch (RecognitionException re) {\r
8992             _localctx.exception = re;\r
8993             _errHandler.reportError(this, re);\r
8994             _errHandler.recover(this, re);\r
8995         } finally {\r
8996             exitRule();\r
8997         }\r
8998         return _localctx;\r
8999     }\r
9000 \r
9001     public static class String_restrictionsContext extends ParserRuleContext {\r
9002         public Length_stmtContext length_stmt(int i) {\r
9003             return getRuleContext(Length_stmtContext.class, i);\r
9004         }\r
9005 \r
9006         public List<Pattern_stmtContext> pattern_stmt() {\r
9007             return getRuleContexts(Pattern_stmtContext.class);\r
9008         }\r
9009 \r
9010         public List<Length_stmtContext> length_stmt() {\r
9011             return getRuleContexts(Length_stmtContext.class);\r
9012         }\r
9013 \r
9014         public Pattern_stmtContext pattern_stmt(int i) {\r
9015             return getRuleContext(Pattern_stmtContext.class, i);\r
9016         }\r
9017 \r
9018         public String_restrictionsContext(ParserRuleContext parent,\r
9019                 int invokingState) {\r
9020             super(parent, invokingState);\r
9021         }\r
9022 \r
9023         @Override\r
9024         public int getRuleIndex() {\r
9025             return RULE_string_restrictions;\r
9026         }\r
9027 \r
9028         @Override\r
9029         public void enterRule(ParseTreeListener listener) {\r
9030             if (listener instanceof YangParserListener)\r
9031                 ((YangParserListener) listener).enterString_restrictions(this);\r
9032         }\r
9033 \r
9034         @Override\r
9035         public void exitRule(ParseTreeListener listener) {\r
9036             if (listener instanceof YangParserListener)\r
9037                 ((YangParserListener) listener).exitString_restrictions(this);\r
9038         }\r
9039 \r
9040         @Override\r
9041         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
9042             if (visitor instanceof YangParserVisitor)\r
9043                 return ((YangParserVisitor<? extends T>) visitor)\r
9044                         .visitString_restrictions(this);\r
9045             else\r
9046                 return visitor.visitChildren(this);\r
9047         }\r
9048     }\r
9049 \r
9050     public final String_restrictionsContext string_restrictions()\r
9051             throws RecognitionException {\r
9052         String_restrictionsContext _localctx = new String_restrictionsContext(\r
9053                 _ctx, getState());\r
9054         enterRule(_localctx, 136, RULE_string_restrictions);\r
9055         int _la;\r
9056         try {\r
9057             enterOuterAlt(_localctx, 1);\r
9058             {\r
9059                 setState(912);\r
9060                 _errHandler.sync(this);\r
9061                 _la = _input.LA(1);\r
9062                 while (_la == PATTERN_KEYWORD || _la == LENGTH_KEYWORD) {\r
9063                     {\r
9064                         setState(910);\r
9065                         switch (_input.LA(1)) {\r
9066                         case LENGTH_KEYWORD: {\r
9067                             setState(908);\r
9068                             length_stmt();\r
9069                         }\r
9070                             break;\r
9071                         case PATTERN_KEYWORD: {\r
9072                             setState(909);\r
9073                             pattern_stmt();\r
9074                         }\r
9075                             break;\r
9076                         default:\r
9077                             throw new NoViableAltException(this);\r
9078                         }\r
9079                     }\r
9080                     setState(914);\r
9081                     _errHandler.sync(this);\r
9082                     _la = _input.LA(1);\r
9083                 }\r
9084             }\r
9085         } catch (RecognitionException re) {\r
9086             _localctx.exception = re;\r
9087             _errHandler.reportError(this, re);\r
9088             _errHandler.recover(this, re);\r
9089         } finally {\r
9090             exitRule();\r
9091         }\r
9092         return _localctx;\r
9093     }\r
9094 \r
9095     public static class Fraction_digits_stmtContext extends ParserRuleContext {\r
9096         public StringContext string() {\r
9097             return getRuleContext(StringContext.class, 0);\r
9098         }\r
9099 \r
9100         public TerminalNode FRACTION_DIGITS_KEYWORD() {\r
9101             return getToken(YangParser.FRACTION_DIGITS_KEYWORD, 0);\r
9102         }\r
9103 \r
9104         public StmtendContext stmtend() {\r
9105             return getRuleContext(StmtendContext.class, 0);\r
9106         }\r
9107 \r
9108         public Fraction_digits_stmtContext(ParserRuleContext parent,\r
9109                 int invokingState) {\r
9110             super(parent, invokingState);\r
9111         }\r
9112 \r
9113         @Override\r
9114         public int getRuleIndex() {\r
9115             return RULE_fraction_digits_stmt;\r
9116         }\r
9117 \r
9118         @Override\r
9119         public void enterRule(ParseTreeListener listener) {\r
9120             if (listener instanceof YangParserListener)\r
9121                 ((YangParserListener) listener).enterFraction_digits_stmt(this);\r
9122         }\r
9123 \r
9124         @Override\r
9125         public void exitRule(ParseTreeListener listener) {\r
9126             if (listener instanceof YangParserListener)\r
9127                 ((YangParserListener) listener).exitFraction_digits_stmt(this);\r
9128         }\r
9129 \r
9130         @Override\r
9131         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
9132             if (visitor instanceof YangParserVisitor)\r
9133                 return ((YangParserVisitor<? extends T>) visitor)\r
9134                         .visitFraction_digits_stmt(this);\r
9135             else\r
9136                 return visitor.visitChildren(this);\r
9137         }\r
9138     }\r
9139 \r
9140     public final Fraction_digits_stmtContext fraction_digits_stmt()\r
9141             throws RecognitionException {\r
9142         Fraction_digits_stmtContext _localctx = new Fraction_digits_stmtContext(\r
9143                 _ctx, getState());\r
9144         enterRule(_localctx, 138, RULE_fraction_digits_stmt);\r
9145         try {\r
9146             enterOuterAlt(_localctx, 1);\r
9147             {\r
9148                 setState(915);\r
9149                 match(FRACTION_DIGITS_KEYWORD);\r
9150                 setState(916);\r
9151                 string();\r
9152                 setState(917);\r
9153                 stmtend();\r
9154             }\r
9155         } catch (RecognitionException re) {\r
9156             _localctx.exception = re;\r
9157             _errHandler.reportError(this, re);\r
9158             _errHandler.recover(this, re);\r
9159         } finally {\r
9160             exitRule();\r
9161         }\r
9162         return _localctx;\r
9163     }\r
9164 \r
9165     public static class Decimal64_specificationContext extends\r
9166             ParserRuleContext {\r
9167         public Fraction_digits_stmtContext fraction_digits_stmt() {\r
9168             return getRuleContext(Fraction_digits_stmtContext.class, 0);\r
9169         }\r
9170 \r
9171         public Numerical_restrictionsContext numerical_restrictions() {\r
9172             return getRuleContext(Numerical_restrictionsContext.class, 0);\r
9173         }\r
9174 \r
9175         public Decimal64_specificationContext(ParserRuleContext parent,\r
9176                 int invokingState) {\r
9177             super(parent, invokingState);\r
9178         }\r
9179 \r
9180         @Override\r
9181         public int getRuleIndex() {\r
9182             return RULE_decimal64_specification;\r
9183         }\r
9184 \r
9185         @Override\r
9186         public void enterRule(ParseTreeListener listener) {\r
9187             if (listener instanceof YangParserListener)\r
9188                 ((YangParserListener) listener)\r
9189                         .enterDecimal64_specification(this);\r
9190         }\r
9191 \r
9192         @Override\r
9193         public void exitRule(ParseTreeListener listener) {\r
9194             if (listener instanceof YangParserListener)\r
9195                 ((YangParserListener) listener)\r
9196                         .exitDecimal64_specification(this);\r
9197         }\r
9198 \r
9199         @Override\r
9200         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
9201             if (visitor instanceof YangParserVisitor)\r
9202                 return ((YangParserVisitor<? extends T>) visitor)\r
9203                         .visitDecimal64_specification(this);\r
9204             else\r
9205                 return visitor.visitChildren(this);\r
9206         }\r
9207     }\r
9208 \r
9209     public final Decimal64_specificationContext decimal64_specification()\r
9210             throws RecognitionException {\r
9211         Decimal64_specificationContext _localctx = new Decimal64_specificationContext(\r
9212                 _ctx, getState());\r
9213         enterRule(_localctx, 140, RULE_decimal64_specification);\r
9214         int _la;\r
9215         try {\r
9216             setState(927);\r
9217             switch (getInterpreter().adaptivePredict(_input, 101, _ctx)) {\r
9218             case 1:\r
9219                 enterOuterAlt(_localctx, 1);\r
9220                 {\r
9221                     setState(920);\r
9222                     _la = _input.LA(1);\r
9223                     if (_la == RANGE_KEYWORD) {\r
9224                         {\r
9225                             setState(919);\r
9226                             numerical_restrictions();\r
9227                         }\r
9228                     }\r
9229 \r
9230                     setState(922);\r
9231                     fraction_digits_stmt();\r
9232                 }\r
9233                 break;\r
9234 \r
9235             case 2:\r
9236                 enterOuterAlt(_localctx, 2);\r
9237                 {\r
9238                     setState(923);\r
9239                     fraction_digits_stmt();\r
9240                     setState(925);\r
9241                     _la = _input.LA(1);\r
9242                     if (_la == RANGE_KEYWORD) {\r
9243                         {\r
9244                             setState(924);\r
9245                             numerical_restrictions();\r
9246                         }\r
9247                     }\r
9248 \r
9249                 }\r
9250                 break;\r
9251             }\r
9252         } catch (RecognitionException re) {\r
9253             _localctx.exception = re;\r
9254             _errHandler.reportError(this, re);\r
9255             _errHandler.recover(this, re);\r
9256         } finally {\r
9257             exitRule();\r
9258         }\r
9259         return _localctx;\r
9260     }\r
9261 \r
9262     public static class Range_stmtContext extends ParserRuleContext {\r
9263         public TerminalNode RIGHT_BRACE() {\r
9264             return getToken(YangParser.RIGHT_BRACE, 0);\r
9265         }\r
9266 \r
9267         public List<Reference_stmtContext> reference_stmt() {\r
9268             return getRuleContexts(Reference_stmtContext.class);\r
9269         }\r
9270 \r
9271         public Description_stmtContext description_stmt(int i) {\r
9272             return getRuleContext(Description_stmtContext.class, i);\r
9273         }\r
9274 \r
9275         public TerminalNode LEFT_BRACE() {\r
9276             return getToken(YangParser.LEFT_BRACE, 0);\r
9277         }\r
9278 \r
9279         public List<Error_app_tag_stmtContext> error_app_tag_stmt() {\r
9280             return getRuleContexts(Error_app_tag_stmtContext.class);\r
9281         }\r
9282 \r
9283         public Error_message_stmtContext error_message_stmt(int i) {\r
9284             return getRuleContext(Error_message_stmtContext.class, i);\r
9285         }\r
9286 \r
9287         public Identifier_stmtContext identifier_stmt(int i) {\r
9288             return getRuleContext(Identifier_stmtContext.class, i);\r
9289         }\r
9290 \r
9291         public TerminalNode SEMICOLON() {\r
9292             return getToken(YangParser.SEMICOLON, 0);\r
9293         }\r
9294 \r
9295         public TerminalNode RANGE_KEYWORD() {\r
9296             return getToken(YangParser.RANGE_KEYWORD, 0);\r
9297         }\r
9298 \r
9299         public StringContext string() {\r
9300             return getRuleContext(StringContext.class, 0);\r
9301         }\r
9302 \r
9303         public List<Identifier_stmtContext> identifier_stmt() {\r
9304             return getRuleContexts(Identifier_stmtContext.class);\r
9305         }\r
9306 \r
9307         public Error_app_tag_stmtContext error_app_tag_stmt(int i) {\r
9308             return getRuleContext(Error_app_tag_stmtContext.class, i);\r
9309         }\r
9310 \r
9311         public List<Error_message_stmtContext> error_message_stmt() {\r
9312             return getRuleContexts(Error_message_stmtContext.class);\r
9313         }\r
9314 \r
9315         public List<Description_stmtContext> description_stmt() {\r
9316             return getRuleContexts(Description_stmtContext.class);\r
9317         }\r
9318 \r
9319         public Reference_stmtContext reference_stmt(int i) {\r
9320             return getRuleContext(Reference_stmtContext.class, i);\r
9321         }\r
9322 \r
9323         public Range_stmtContext(ParserRuleContext parent, int invokingState) {\r
9324             super(parent, invokingState);\r
9325         }\r
9326 \r
9327         @Override\r
9328         public int getRuleIndex() {\r
9329             return RULE_range_stmt;\r
9330         }\r
9331 \r
9332         @Override\r
9333         public void enterRule(ParseTreeListener listener) {\r
9334             if (listener instanceof YangParserListener)\r
9335                 ((YangParserListener) listener).enterRange_stmt(this);\r
9336         }\r
9337 \r
9338         @Override\r
9339         public void exitRule(ParseTreeListener listener) {\r
9340             if (listener instanceof YangParserListener)\r
9341                 ((YangParserListener) listener).exitRange_stmt(this);\r
9342         }\r
9343 \r
9344         @Override\r
9345         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
9346             if (visitor instanceof YangParserVisitor)\r
9347                 return ((YangParserVisitor<? extends T>) visitor)\r
9348                         .visitRange_stmt(this);\r
9349             else\r
9350                 return visitor.visitChildren(this);\r
9351         }\r
9352     }\r
9353 \r
9354     public final Range_stmtContext range_stmt() throws RecognitionException {\r
9355         Range_stmtContext _localctx = new Range_stmtContext(_ctx, getState());\r
9356         enterRule(_localctx, 142, RULE_range_stmt);\r
9357         int _la;\r
9358         try {\r
9359             enterOuterAlt(_localctx, 1);\r
9360             {\r
9361                 setState(929);\r
9362                 match(RANGE_KEYWORD);\r
9363                 setState(930);\r
9364                 string();\r
9365                 setState(944);\r
9366                 switch (_input.LA(1)) {\r
9367                 case SEMICOLON: {\r
9368                     setState(931);\r
9369                     match(SEMICOLON);\r
9370                 }\r
9371                     break;\r
9372                 case LEFT_BRACE: {\r
9373                     {\r
9374                         setState(932);\r
9375                         match(LEFT_BRACE);\r
9376                         setState(940);\r
9377                         _errHandler.sync(this);\r
9378                         _la = _input.LA(1);\r
9379                         while (((((_la - 24)) & ~0x3f) == 0 && ((1L << (_la - 24)) & ((1L << (REFERENCE_KEYWORD - 24))\r
9380                                 | (1L << (ERROR_MESSAGE_KEYWORD - 24))\r
9381                                 | (1L << (ERROR_APP_TAG_KEYWORD - 24))\r
9382                                 | (1L << (DESCRIPTION_KEYWORD - 24)) | (1L << (IDENTIFIER - 24)))) != 0)) {\r
9383                             {\r
9384                                 setState(938);\r
9385                                 switch (_input.LA(1)) {\r
9386                                 case IDENTIFIER: {\r
9387                                     setState(933);\r
9388                                     identifier_stmt();\r
9389                                 }\r
9390                                     break;\r
9391                                 case ERROR_MESSAGE_KEYWORD: {\r
9392                                     setState(934);\r
9393                                     error_message_stmt();\r
9394                                 }\r
9395                                     break;\r
9396                                 case ERROR_APP_TAG_KEYWORD: {\r
9397                                     setState(935);\r
9398                                     error_app_tag_stmt();\r
9399                                 }\r
9400                                     break;\r
9401                                 case DESCRIPTION_KEYWORD: {\r
9402                                     setState(936);\r
9403                                     description_stmt();\r
9404                                 }\r
9405                                     break;\r
9406                                 case REFERENCE_KEYWORD: {\r
9407                                     setState(937);\r
9408                                     reference_stmt();\r
9409                                 }\r
9410                                     break;\r
9411                                 default:\r
9412                                     throw new NoViableAltException(this);\r
9413                                 }\r
9414                             }\r
9415                             setState(942);\r
9416                             _errHandler.sync(this);\r
9417                             _la = _input.LA(1);\r
9418                         }\r
9419                         setState(943);\r
9420                         match(RIGHT_BRACE);\r
9421                     }\r
9422                 }\r
9423                     break;\r
9424                 default:\r
9425                     throw new NoViableAltException(this);\r
9426                 }\r
9427             }\r
9428         } catch (RecognitionException re) {\r
9429             _localctx.exception = re;\r
9430             _errHandler.reportError(this, re);\r
9431             _errHandler.recover(this, re);\r
9432         } finally {\r
9433             exitRule();\r
9434         }\r
9435         return _localctx;\r
9436     }\r
9437 \r
9438     public static class Numerical_restrictionsContext extends ParserRuleContext {\r
9439         public Range_stmtContext range_stmt() {\r
9440             return getRuleContext(Range_stmtContext.class, 0);\r
9441         }\r
9442 \r
9443         public Numerical_restrictionsContext(ParserRuleContext parent,\r
9444                 int invokingState) {\r
9445             super(parent, invokingState);\r
9446         }\r
9447 \r
9448         @Override\r
9449         public int getRuleIndex() {\r
9450             return RULE_numerical_restrictions;\r
9451         }\r
9452 \r
9453         @Override\r
9454         public void enterRule(ParseTreeListener listener) {\r
9455             if (listener instanceof YangParserListener)\r
9456                 ((YangParserListener) listener)\r
9457                         .enterNumerical_restrictions(this);\r
9458         }\r
9459 \r
9460         @Override\r
9461         public void exitRule(ParseTreeListener listener) {\r
9462             if (listener instanceof YangParserListener)\r
9463                 ((YangParserListener) listener)\r
9464                         .exitNumerical_restrictions(this);\r
9465         }\r
9466 \r
9467         @Override\r
9468         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
9469             if (visitor instanceof YangParserVisitor)\r
9470                 return ((YangParserVisitor<? extends T>) visitor)\r
9471                         .visitNumerical_restrictions(this);\r
9472             else\r
9473                 return visitor.visitChildren(this);\r
9474         }\r
9475     }\r
9476 \r
9477     public final Numerical_restrictionsContext numerical_restrictions()\r
9478             throws RecognitionException {\r
9479         Numerical_restrictionsContext _localctx = new Numerical_restrictionsContext(\r
9480                 _ctx, getState());\r
9481         enterRule(_localctx, 144, RULE_numerical_restrictions);\r
9482         try {\r
9483             enterOuterAlt(_localctx, 1);\r
9484             {\r
9485                 setState(946);\r
9486                 range_stmt();\r
9487             }\r
9488         } catch (RecognitionException re) {\r
9489             _localctx.exception = re;\r
9490             _errHandler.reportError(this, re);\r
9491             _errHandler.recover(this, re);\r
9492         } finally {\r
9493             exitRule();\r
9494         }\r
9495         return _localctx;\r
9496     }\r
9497 \r
9498     public static class Type_body_stmtsContext extends ParserRuleContext {\r
9499         public Bits_specificationContext bits_specification() {\r
9500             return getRuleContext(Bits_specificationContext.class, 0);\r
9501         }\r
9502 \r
9503         public Identityref_specificationContext identityref_specification() {\r
9504             return getRuleContext(Identityref_specificationContext.class, 0);\r
9505         }\r
9506 \r
9507         public Enum_specificationContext enum_specification() {\r
9508             return getRuleContext(Enum_specificationContext.class, 0);\r
9509         }\r
9510 \r
9511         public Numerical_restrictionsContext numerical_restrictions() {\r
9512             return getRuleContext(Numerical_restrictionsContext.class, 0);\r
9513         }\r
9514 \r
9515         public String_restrictionsContext string_restrictions() {\r
9516             return getRuleContext(String_restrictionsContext.class, 0);\r
9517         }\r
9518 \r
9519         public Leafref_specificationContext leafref_specification() {\r
9520             return getRuleContext(Leafref_specificationContext.class, 0);\r
9521         }\r
9522 \r
9523         public Decimal64_specificationContext decimal64_specification() {\r
9524             return getRuleContext(Decimal64_specificationContext.class, 0);\r
9525         }\r
9526 \r
9527         public Union_specificationContext union_specification() {\r
9528             return getRuleContext(Union_specificationContext.class, 0);\r
9529         }\r
9530 \r
9531         public Instance_identifier_specificationContext instance_identifier_specification() {\r
9532             return getRuleContext(\r
9533                     Instance_identifier_specificationContext.class, 0);\r
9534         }\r
9535 \r
9536         public Type_body_stmtsContext(ParserRuleContext parent,\r
9537                 int invokingState) {\r
9538             super(parent, invokingState);\r
9539         }\r
9540 \r
9541         @Override\r
9542         public int getRuleIndex() {\r
9543             return RULE_type_body_stmts;\r
9544         }\r
9545 \r
9546         @Override\r
9547         public void enterRule(ParseTreeListener listener) {\r
9548             if (listener instanceof YangParserListener)\r
9549                 ((YangParserListener) listener).enterType_body_stmts(this);\r
9550         }\r
9551 \r
9552         @Override\r
9553         public void exitRule(ParseTreeListener listener) {\r
9554             if (listener instanceof YangParserListener)\r
9555                 ((YangParserListener) listener).exitType_body_stmts(this);\r
9556         }\r
9557 \r
9558         @Override\r
9559         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
9560             if (visitor instanceof YangParserVisitor)\r
9561                 return ((YangParserVisitor<? extends T>) visitor)\r
9562                         .visitType_body_stmts(this);\r
9563             else\r
9564                 return visitor.visitChildren(this);\r
9565         }\r
9566     }\r
9567 \r
9568     public final Type_body_stmtsContext type_body_stmts()\r
9569             throws RecognitionException {\r
9570         Type_body_stmtsContext _localctx = new Type_body_stmtsContext(_ctx,\r
9571                 getState());\r
9572         enterRule(_localctx, 146, RULE_type_body_stmts);\r
9573         try {\r
9574             setState(957);\r
9575             switch (getInterpreter().adaptivePredict(_input, 105, _ctx)) {\r
9576             case 1:\r
9577                 enterOuterAlt(_localctx, 1);\r
9578                 {\r
9579                     setState(948);\r
9580                     numerical_restrictions();\r
9581                 }\r
9582                 break;\r
9583 \r
9584             case 2:\r
9585                 enterOuterAlt(_localctx, 2);\r
9586                 {\r
9587                     setState(949);\r
9588                     decimal64_specification();\r
9589                 }\r
9590                 break;\r
9591 \r
9592             case 3:\r
9593                 enterOuterAlt(_localctx, 3);\r
9594                 {\r
9595                     setState(950);\r
9596                     string_restrictions();\r
9597                 }\r
9598                 break;\r
9599 \r
9600             case 4:\r
9601                 enterOuterAlt(_localctx, 4);\r
9602                 {\r
9603                     setState(951);\r
9604                     enum_specification();\r
9605                 }\r
9606                 break;\r
9607 \r
9608             case 5:\r
9609                 enterOuterAlt(_localctx, 5);\r
9610                 {\r
9611                     setState(952);\r
9612                     leafref_specification();\r
9613                 }\r
9614                 break;\r
9615 \r
9616             case 6:\r
9617                 enterOuterAlt(_localctx, 6);\r
9618                 {\r
9619                     setState(953);\r
9620                     identityref_specification();\r
9621                 }\r
9622                 break;\r
9623 \r
9624             case 7:\r
9625                 enterOuterAlt(_localctx, 7);\r
9626                 {\r
9627                     setState(954);\r
9628                     instance_identifier_specification();\r
9629                 }\r
9630                 break;\r
9631 \r
9632             case 8:\r
9633                 enterOuterAlt(_localctx, 8);\r
9634                 {\r
9635                     setState(955);\r
9636                     bits_specification();\r
9637                 }\r
9638                 break;\r
9639 \r
9640             case 9:\r
9641                 enterOuterAlt(_localctx, 9);\r
9642                 {\r
9643                     setState(956);\r
9644                     union_specification();\r
9645                 }\r
9646                 break;\r
9647             }\r
9648         } catch (RecognitionException re) {\r
9649             _localctx.exception = re;\r
9650             _errHandler.reportError(this, re);\r
9651             _errHandler.recover(this, re);\r
9652         } finally {\r
9653             exitRule();\r
9654         }\r
9655         return _localctx;\r
9656     }\r
9657 \r
9658     public static class Type_stmtContext extends ParserRuleContext {\r
9659         public TerminalNode RIGHT_BRACE() {\r
9660             return getToken(YangParser.RIGHT_BRACE, 0);\r
9661         }\r
9662 \r
9663         public TerminalNode TYPE_KEYWORD() {\r
9664             return getToken(YangParser.TYPE_KEYWORD, 0);\r
9665         }\r
9666 \r
9667         public TerminalNode SEMICOLON() {\r
9668             return getToken(YangParser.SEMICOLON, 0);\r
9669         }\r
9670 \r
9671         public StringContext string() {\r
9672             return getRuleContext(StringContext.class, 0);\r
9673         }\r
9674 \r
9675         public TerminalNode LEFT_BRACE() {\r
9676             return getToken(YangParser.LEFT_BRACE, 0);\r
9677         }\r
9678 \r
9679         public Type_body_stmtsContext type_body_stmts() {\r
9680             return getRuleContext(Type_body_stmtsContext.class, 0);\r
9681         }\r
9682 \r
9683         public Type_stmtContext(ParserRuleContext parent, int invokingState) {\r
9684             super(parent, invokingState);\r
9685         }\r
9686 \r
9687         @Override\r
9688         public int getRuleIndex() {\r
9689             return RULE_type_stmt;\r
9690         }\r
9691 \r
9692         @Override\r
9693         public void enterRule(ParseTreeListener listener) {\r
9694             if (listener instanceof YangParserListener)\r
9695                 ((YangParserListener) listener).enterType_stmt(this);\r
9696         }\r
9697 \r
9698         @Override\r
9699         public void exitRule(ParseTreeListener listener) {\r
9700             if (listener instanceof YangParserListener)\r
9701                 ((YangParserListener) listener).exitType_stmt(this);\r
9702         }\r
9703 \r
9704         @Override\r
9705         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
9706             if (visitor instanceof YangParserVisitor)\r
9707                 return ((YangParserVisitor<? extends T>) visitor)\r
9708                         .visitType_stmt(this);\r
9709             else\r
9710                 return visitor.visitChildren(this);\r
9711         }\r
9712     }\r
9713 \r
9714     public final Type_stmtContext type_stmt() throws RecognitionException {\r
9715         Type_stmtContext _localctx = new Type_stmtContext(_ctx, getState());\r
9716         enterRule(_localctx, 148, RULE_type_stmt);\r
9717         try {\r
9718             enterOuterAlt(_localctx, 1);\r
9719             {\r
9720                 setState(959);\r
9721                 match(TYPE_KEYWORD);\r
9722                 setState(960);\r
9723                 string();\r
9724                 setState(966);\r
9725                 switch (_input.LA(1)) {\r
9726                 case SEMICOLON: {\r
9727                     setState(961);\r
9728                     match(SEMICOLON);\r
9729                 }\r
9730                     break;\r
9731                 case LEFT_BRACE: {\r
9732                     {\r
9733                         setState(962);\r
9734                         match(LEFT_BRACE);\r
9735                         setState(963);\r
9736                         type_body_stmts();\r
9737                         setState(964);\r
9738                         match(RIGHT_BRACE);\r
9739                     }\r
9740                 }\r
9741                     break;\r
9742                 default:\r
9743                     throw new NoViableAltException(this);\r
9744                 }\r
9745             }\r
9746         } catch (RecognitionException re) {\r
9747             _localctx.exception = re;\r
9748             _errHandler.reportError(this, re);\r
9749             _errHandler.recover(this, re);\r
9750         } finally {\r
9751             exitRule();\r
9752         }\r
9753         return _localctx;\r
9754     }\r
9755 \r
9756     public static class Typedef_stmtContext extends ParserRuleContext {\r
9757         public TerminalNode RIGHT_BRACE() {\r
9758             return getToken(YangParser.RIGHT_BRACE, 0);\r
9759         }\r
9760 \r
9761         public Units_stmtContext units_stmt(int i) {\r
9762             return getRuleContext(Units_stmtContext.class, i);\r
9763         }\r
9764 \r
9765         public List<Reference_stmtContext> reference_stmt() {\r
9766             return getRuleContexts(Reference_stmtContext.class);\r
9767         }\r
9768 \r
9769         public Description_stmtContext description_stmt(int i) {\r
9770             return getRuleContext(Description_stmtContext.class, i);\r
9771         }\r
9772 \r
9773         public Default_stmtContext default_stmt(int i) {\r
9774             return getRuleContext(Default_stmtContext.class, i);\r
9775         }\r
9776 \r
9777         public List<Units_stmtContext> units_stmt() {\r
9778             return getRuleContexts(Units_stmtContext.class);\r
9779         }\r
9780 \r
9781         public Type_stmtContext type_stmt(int i) {\r
9782             return getRuleContext(Type_stmtContext.class, i);\r
9783         }\r
9784 \r
9785         public TerminalNode LEFT_BRACE() {\r
9786             return getToken(YangParser.LEFT_BRACE, 0);\r
9787         }\r
9788 \r
9789         public Status_stmtContext status_stmt(int i) {\r
9790             return getRuleContext(Status_stmtContext.class, i);\r
9791         }\r
9792 \r
9793         public List<Type_stmtContext> type_stmt() {\r
9794             return getRuleContexts(Type_stmtContext.class);\r
9795         }\r
9796 \r
9797         public TerminalNode TYPEDEF_KEYWORD() {\r
9798             return getToken(YangParser.TYPEDEF_KEYWORD, 0);\r
9799         }\r
9800 \r
9801         public List<Default_stmtContext> default_stmt() {\r
9802             return getRuleContexts(Default_stmtContext.class);\r
9803         }\r
9804 \r
9805         public List<Status_stmtContext> status_stmt() {\r
9806             return getRuleContexts(Status_stmtContext.class);\r
9807         }\r
9808 \r
9809         public StringContext string() {\r
9810             return getRuleContext(StringContext.class, 0);\r
9811         }\r
9812 \r
9813         public List<Description_stmtContext> description_stmt() {\r
9814             return getRuleContexts(Description_stmtContext.class);\r
9815         }\r
9816 \r
9817         public Reference_stmtContext reference_stmt(int i) {\r
9818             return getRuleContext(Reference_stmtContext.class, i);\r
9819         }\r
9820 \r
9821         public Typedef_stmtContext(ParserRuleContext parent, int invokingState) {\r
9822             super(parent, invokingState);\r
9823         }\r
9824 \r
9825         @Override\r
9826         public int getRuleIndex() {\r
9827             return RULE_typedef_stmt;\r
9828         }\r
9829 \r
9830         @Override\r
9831         public void enterRule(ParseTreeListener listener) {\r
9832             if (listener instanceof YangParserListener)\r
9833                 ((YangParserListener) listener).enterTypedef_stmt(this);\r
9834         }\r
9835 \r
9836         @Override\r
9837         public void exitRule(ParseTreeListener listener) {\r
9838             if (listener instanceof YangParserListener)\r
9839                 ((YangParserListener) listener).exitTypedef_stmt(this);\r
9840         }\r
9841 \r
9842         @Override\r
9843         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
9844             if (visitor instanceof YangParserVisitor)\r
9845                 return ((YangParserVisitor<? extends T>) visitor)\r
9846                         .visitTypedef_stmt(this);\r
9847             else\r
9848                 return visitor.visitChildren(this);\r
9849         }\r
9850     }\r
9851 \r
9852     public final Typedef_stmtContext typedef_stmt() throws RecognitionException {\r
9853         Typedef_stmtContext _localctx = new Typedef_stmtContext(_ctx,\r
9854                 getState());\r
9855         enterRule(_localctx, 150, RULE_typedef_stmt);\r
9856         int _la;\r
9857         try {\r
9858             enterOuterAlt(_localctx, 1);\r
9859             {\r
9860                 setState(968);\r
9861                 match(TYPEDEF_KEYWORD);\r
9862                 setState(969);\r
9863                 string();\r
9864                 setState(970);\r
9865                 match(LEFT_BRACE);\r
9866                 setState(977);\r
9867                 _errHandler.sync(this);\r
9868                 _la = _input.LA(1);\r
9869                 do {\r
9870                     {\r
9871                         setState(977);\r
9872                         switch (_input.LA(1)) {\r
9873                         case TYPE_KEYWORD: {\r
9874                             setState(971);\r
9875                             type_stmt();\r
9876                         }\r
9877                             break;\r
9878                         case UNITS_KEYWORD: {\r
9879                             setState(972);\r
9880                             units_stmt();\r
9881                         }\r
9882                             break;\r
9883                         case DEFAULT_KEYWORD: {\r
9884                             setState(973);\r
9885                             default_stmt();\r
9886                         }\r
9887                             break;\r
9888                         case STATUS_KEYWORD: {\r
9889                             setState(974);\r
9890                             status_stmt();\r
9891                         }\r
9892                             break;\r
9893                         case DESCRIPTION_KEYWORD: {\r
9894                             setState(975);\r
9895                             description_stmt();\r
9896                         }\r
9897                             break;\r
9898                         case REFERENCE_KEYWORD: {\r
9899                             setState(976);\r
9900                             reference_stmt();\r
9901                         }\r
9902                             break;\r
9903                         default:\r
9904                             throw new NoViableAltException(this);\r
9905                         }\r
9906                     }\r
9907                     setState(979);\r
9908                     _errHandler.sync(this);\r
9909                     _la = _input.LA(1);\r
9910                 } while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << UNITS_KEYWORD)\r
9911                         | (1L << TYPE_KEYWORD)\r
9912                         | (1L << STATUS_KEYWORD)\r
9913                         | (1L << REFERENCE_KEYWORD)\r
9914                         | (1L << DESCRIPTION_KEYWORD) | (1L << DEFAULT_KEYWORD))) != 0));\r
9915                 setState(981);\r
9916                 match(RIGHT_BRACE);\r
9917             }\r
9918         } catch (RecognitionException re) {\r
9919             _localctx.exception = re;\r
9920             _errHandler.reportError(this, re);\r
9921             _errHandler.recover(this, re);\r
9922         } finally {\r
9923             exitRule();\r
9924         }\r
9925         return _localctx;\r
9926     }\r
9927 \r
9928     public static class If_feature_stmtContext extends ParserRuleContext {\r
9929         public TerminalNode IF_FEATURE_KEYWORD() {\r
9930             return getToken(YangParser.IF_FEATURE_KEYWORD, 0);\r
9931         }\r
9932 \r
9933         public StringContext string() {\r
9934             return getRuleContext(StringContext.class, 0);\r
9935         }\r
9936 \r
9937         public StmtendContext stmtend() {\r
9938             return getRuleContext(StmtendContext.class, 0);\r
9939         }\r
9940 \r
9941         public If_feature_stmtContext(ParserRuleContext parent,\r
9942                 int invokingState) {\r
9943             super(parent, invokingState);\r
9944         }\r
9945 \r
9946         @Override\r
9947         public int getRuleIndex() {\r
9948             return RULE_if_feature_stmt;\r
9949         }\r
9950 \r
9951         @Override\r
9952         public void enterRule(ParseTreeListener listener) {\r
9953             if (listener instanceof YangParserListener)\r
9954                 ((YangParserListener) listener).enterIf_feature_stmt(this);\r
9955         }\r
9956 \r
9957         @Override\r
9958         public void exitRule(ParseTreeListener listener) {\r
9959             if (listener instanceof YangParserListener)\r
9960                 ((YangParserListener) listener).exitIf_feature_stmt(this);\r
9961         }\r
9962 \r
9963         @Override\r
9964         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
9965             if (visitor instanceof YangParserVisitor)\r
9966                 return ((YangParserVisitor<? extends T>) visitor)\r
9967                         .visitIf_feature_stmt(this);\r
9968             else\r
9969                 return visitor.visitChildren(this);\r
9970         }\r
9971     }\r
9972 \r
9973     public final If_feature_stmtContext if_feature_stmt()\r
9974             throws RecognitionException {\r
9975         If_feature_stmtContext _localctx = new If_feature_stmtContext(_ctx,\r
9976                 getState());\r
9977         enterRule(_localctx, 152, RULE_if_feature_stmt);\r
9978         try {\r
9979             enterOuterAlt(_localctx, 1);\r
9980             {\r
9981                 setState(983);\r
9982                 match(IF_FEATURE_KEYWORD);\r
9983                 setState(984);\r
9984                 string();\r
9985                 setState(985);\r
9986                 stmtend();\r
9987             }\r
9988         } catch (RecognitionException re) {\r
9989             _localctx.exception = re;\r
9990             _errHandler.reportError(this, re);\r
9991             _errHandler.recover(this, re);\r
9992         } finally {\r
9993             exitRule();\r
9994         }\r
9995         return _localctx;\r
9996     }\r
9997 \r
9998     public static class Feature_stmtContext extends ParserRuleContext {\r
9999         public TerminalNode RIGHT_BRACE() {\r
10000             return getToken(YangParser.RIGHT_BRACE, 0);\r
10001         }\r
10002 \r
10003         public List<Reference_stmtContext> reference_stmt() {\r
10004             return getRuleContexts(Reference_stmtContext.class);\r
10005         }\r
10006 \r
10007         public Description_stmtContext description_stmt(int i) {\r
10008             return getRuleContext(Description_stmtContext.class, i);\r
10009         }\r
10010 \r
10011         public If_feature_stmtContext if_feature_stmt(int i) {\r
10012             return getRuleContext(If_feature_stmtContext.class, i);\r
10013         }\r
10014 \r
10015         public TerminalNode LEFT_BRACE() {\r
10016             return getToken(YangParser.LEFT_BRACE, 0);\r
10017         }\r
10018 \r
10019         public Status_stmtContext status_stmt(int i) {\r
10020             return getRuleContext(Status_stmtContext.class, i);\r
10021         }\r
10022 \r
10023         public List<If_feature_stmtContext> if_feature_stmt() {\r
10024             return getRuleContexts(If_feature_stmtContext.class);\r
10025         }\r
10026 \r
10027         public TerminalNode SEMICOLON() {\r
10028             return getToken(YangParser.SEMICOLON, 0);\r
10029         }\r
10030 \r
10031         public List<Status_stmtContext> status_stmt() {\r
10032             return getRuleContexts(Status_stmtContext.class);\r
10033         }\r
10034 \r
10035         public StringContext string() {\r
10036             return getRuleContext(StringContext.class, 0);\r
10037         }\r
10038 \r
10039         public TerminalNode FEATURE_KEYWORD() {\r
10040             return getToken(YangParser.FEATURE_KEYWORD, 0);\r
10041         }\r
10042 \r
10043         public List<Description_stmtContext> description_stmt() {\r
10044             return getRuleContexts(Description_stmtContext.class);\r
10045         }\r
10046 \r
10047         public Reference_stmtContext reference_stmt(int i) {\r
10048             return getRuleContext(Reference_stmtContext.class, i);\r
10049         }\r
10050 \r
10051         public Feature_stmtContext(ParserRuleContext parent, int invokingState) {\r
10052             super(parent, invokingState);\r
10053         }\r
10054 \r
10055         @Override\r
10056         public int getRuleIndex() {\r
10057             return RULE_feature_stmt;\r
10058         }\r
10059 \r
10060         @Override\r
10061         public void enterRule(ParseTreeListener listener) {\r
10062             if (listener instanceof YangParserListener)\r
10063                 ((YangParserListener) listener).enterFeature_stmt(this);\r
10064         }\r
10065 \r
10066         @Override\r
10067         public void exitRule(ParseTreeListener listener) {\r
10068             if (listener instanceof YangParserListener)\r
10069                 ((YangParserListener) listener).exitFeature_stmt(this);\r
10070         }\r
10071 \r
10072         @Override\r
10073         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
10074             if (visitor instanceof YangParserVisitor)\r
10075                 return ((YangParserVisitor<? extends T>) visitor)\r
10076                         .visitFeature_stmt(this);\r
10077             else\r
10078                 return visitor.visitChildren(this);\r
10079         }\r
10080     }\r
10081 \r
10082     public final Feature_stmtContext feature_stmt() throws RecognitionException {\r
10083         Feature_stmtContext _localctx = new Feature_stmtContext(_ctx,\r
10084                 getState());\r
10085         enterRule(_localctx, 154, RULE_feature_stmt);\r
10086         int _la;\r
10087         try {\r
10088             enterOuterAlt(_localctx, 1);\r
10089             {\r
10090                 setState(987);\r
10091                 match(FEATURE_KEYWORD);\r
10092                 setState(988);\r
10093                 string();\r
10094                 setState(1001);\r
10095                 switch (_input.LA(1)) {\r
10096                 case SEMICOLON: {\r
10097                     setState(989);\r
10098                     match(SEMICOLON);\r
10099                 }\r
10100                     break;\r
10101                 case LEFT_BRACE: {\r
10102                     {\r
10103                         setState(990);\r
10104                         match(LEFT_BRACE);\r
10105                         setState(997);\r
10106                         _errHandler.sync(this);\r
10107                         _la = _input.LA(1);\r
10108                         while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STATUS_KEYWORD)\r
10109                                 | (1L << REFERENCE_KEYWORD)\r
10110                                 | (1L << IF_FEATURE_KEYWORD) | (1L << DESCRIPTION_KEYWORD))) != 0)) {\r
10111                             {\r
10112                                 setState(995);\r
10113                                 switch (_input.LA(1)) {\r
10114                                 case IF_FEATURE_KEYWORD: {\r
10115                                     setState(991);\r
10116                                     if_feature_stmt();\r
10117                                 }\r
10118                                     break;\r
10119                                 case STATUS_KEYWORD: {\r
10120                                     setState(992);\r
10121                                     status_stmt();\r
10122                                 }\r
10123                                     break;\r
10124                                 case DESCRIPTION_KEYWORD: {\r
10125                                     setState(993);\r
10126                                     description_stmt();\r
10127                                 }\r
10128                                     break;\r
10129                                 case REFERENCE_KEYWORD: {\r
10130                                     setState(994);\r
10131                                     reference_stmt();\r
10132                                 }\r
10133                                     break;\r
10134                                 default:\r
10135                                     throw new NoViableAltException(this);\r
10136                                 }\r
10137                             }\r
10138                             setState(999);\r
10139                             _errHandler.sync(this);\r
10140                             _la = _input.LA(1);\r
10141                         }\r
10142                         setState(1000);\r
10143                         match(RIGHT_BRACE);\r
10144                     }\r
10145                 }\r
10146                     break;\r
10147                 default:\r
10148                     throw new NoViableAltException(this);\r
10149                 }\r
10150             }\r
10151         } catch (RecognitionException re) {\r
10152             _localctx.exception = re;\r
10153             _errHandler.reportError(this, re);\r
10154             _errHandler.recover(this, re);\r
10155         } finally {\r
10156             exitRule();\r
10157         }\r
10158         return _localctx;\r
10159     }\r
10160 \r
10161     public static class Base_stmtContext extends ParserRuleContext {\r
10162         public TerminalNode BASE_KEYWORD() {\r
10163             return getToken(YangParser.BASE_KEYWORD, 0);\r
10164         }\r
10165 \r
10166         public StringContext string() {\r
10167             return getRuleContext(StringContext.class, 0);\r
10168         }\r
10169 \r
10170         public StmtendContext stmtend() {\r
10171             return getRuleContext(StmtendContext.class, 0);\r
10172         }\r
10173 \r
10174         public Base_stmtContext(ParserRuleContext parent, int invokingState) {\r
10175             super(parent, invokingState);\r
10176         }\r
10177 \r
10178         @Override\r
10179         public int getRuleIndex() {\r
10180             return RULE_base_stmt;\r
10181         }\r
10182 \r
10183         @Override\r
10184         public void enterRule(ParseTreeListener listener) {\r
10185             if (listener instanceof YangParserListener)\r
10186                 ((YangParserListener) listener).enterBase_stmt(this);\r
10187         }\r
10188 \r
10189         @Override\r
10190         public void exitRule(ParseTreeListener listener) {\r
10191             if (listener instanceof YangParserListener)\r
10192                 ((YangParserListener) listener).exitBase_stmt(this);\r
10193         }\r
10194 \r
10195         @Override\r
10196         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
10197             if (visitor instanceof YangParserVisitor)\r
10198                 return ((YangParserVisitor<? extends T>) visitor)\r
10199                         .visitBase_stmt(this);\r
10200             else\r
10201                 return visitor.visitChildren(this);\r
10202         }\r
10203     }\r
10204 \r
10205     public final Base_stmtContext base_stmt() throws RecognitionException {\r
10206         Base_stmtContext _localctx = new Base_stmtContext(_ctx, getState());\r
10207         enterRule(_localctx, 156, RULE_base_stmt);\r
10208         try {\r
10209             enterOuterAlt(_localctx, 1);\r
10210             {\r
10211                 setState(1003);\r
10212                 match(BASE_KEYWORD);\r
10213                 setState(1004);\r
10214                 string();\r
10215                 setState(1005);\r
10216                 stmtend();\r
10217             }\r
10218         } catch (RecognitionException re) {\r
10219             _localctx.exception = re;\r
10220             _errHandler.reportError(this, re);\r
10221             _errHandler.recover(this, re);\r
10222         } finally {\r
10223             exitRule();\r
10224         }\r
10225         return _localctx;\r
10226     }\r
10227 \r
10228     public static class Identity_stmtContext extends ParserRuleContext {\r
10229         public TerminalNode RIGHT_BRACE() {\r
10230             return getToken(YangParser.RIGHT_BRACE, 0);\r
10231         }\r
10232 \r
10233         public List<Reference_stmtContext> reference_stmt() {\r
10234             return getRuleContexts(Reference_stmtContext.class);\r
10235         }\r
10236 \r
10237         public Description_stmtContext description_stmt(int i) {\r
10238             return getRuleContext(Description_stmtContext.class, i);\r
10239         }\r
10240 \r
10241         public Base_stmtContext base_stmt(int i) {\r
10242             return getRuleContext(Base_stmtContext.class, i);\r
10243         }\r
10244 \r
10245         public TerminalNode IDENTITY_KEYWORD() {\r
10246             return getToken(YangParser.IDENTITY_KEYWORD, 0);\r
10247         }\r
10248 \r
10249         public TerminalNode LEFT_BRACE() {\r
10250             return getToken(YangParser.LEFT_BRACE, 0);\r
10251         }\r
10252 \r
10253         public Status_stmtContext status_stmt(int i) {\r
10254             return getRuleContext(Status_stmtContext.class, i);\r
10255         }\r
10256 \r
10257         public TerminalNode SEMICOLON() {\r
10258             return getToken(YangParser.SEMICOLON, 0);\r
10259         }\r
10260 \r
10261         public List<Status_stmtContext> status_stmt() {\r
10262             return getRuleContexts(Status_stmtContext.class);\r
10263         }\r
10264 \r
10265         public StringContext string() {\r
10266             return getRuleContext(StringContext.class, 0);\r
10267         }\r
10268 \r
10269         public List<Base_stmtContext> base_stmt() {\r
10270             return getRuleContexts(Base_stmtContext.class);\r
10271         }\r
10272 \r
10273         public List<Description_stmtContext> description_stmt() {\r
10274             return getRuleContexts(Description_stmtContext.class);\r
10275         }\r
10276 \r
10277         public Reference_stmtContext reference_stmt(int i) {\r
10278             return getRuleContext(Reference_stmtContext.class, i);\r
10279         }\r
10280 \r
10281         public Identity_stmtContext(ParserRuleContext parent, int invokingState) {\r
10282             super(parent, invokingState);\r
10283         }\r
10284 \r
10285         @Override\r
10286         public int getRuleIndex() {\r
10287             return RULE_identity_stmt;\r
10288         }\r
10289 \r
10290         @Override\r
10291         public void enterRule(ParseTreeListener listener) {\r
10292             if (listener instanceof YangParserListener)\r
10293                 ((YangParserListener) listener).enterIdentity_stmt(this);\r
10294         }\r
10295 \r
10296         @Override\r
10297         public void exitRule(ParseTreeListener listener) {\r
10298             if (listener instanceof YangParserListener)\r
10299                 ((YangParserListener) listener).exitIdentity_stmt(this);\r
10300         }\r
10301 \r
10302         @Override\r
10303         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
10304             if (visitor instanceof YangParserVisitor)\r
10305                 return ((YangParserVisitor<? extends T>) visitor)\r
10306                         .visitIdentity_stmt(this);\r
10307             else\r
10308                 return visitor.visitChildren(this);\r
10309         }\r
10310     }\r
10311 \r
10312     public final Identity_stmtContext identity_stmt()\r
10313             throws RecognitionException {\r
10314         Identity_stmtContext _localctx = new Identity_stmtContext(_ctx,\r
10315                 getState());\r
10316         enterRule(_localctx, 158, RULE_identity_stmt);\r
10317         int _la;\r
10318         try {\r
10319             enterOuterAlt(_localctx, 1);\r
10320             {\r
10321                 setState(1007);\r
10322                 match(IDENTITY_KEYWORD);\r
10323                 setState(1008);\r
10324                 string();\r
10325                 setState(1021);\r
10326                 switch (_input.LA(1)) {\r
10327                 case SEMICOLON: {\r
10328                     setState(1009);\r
10329                     match(SEMICOLON);\r
10330                 }\r
10331                     break;\r
10332                 case LEFT_BRACE: {\r
10333                     {\r
10334                         setState(1010);\r
10335                         match(LEFT_BRACE);\r
10336                         setState(1017);\r
10337                         _errHandler.sync(this);\r
10338                         _la = _input.LA(1);\r
10339                         while (((((_la - 18)) & ~0x3f) == 0 && ((1L << (_la - 18)) & ((1L << (STATUS_KEYWORD - 18))\r
10340                                 | (1L << (REFERENCE_KEYWORD - 18))\r
10341                                 | (1L << (DESCRIPTION_KEYWORD - 18)) | (1L << (BASE_KEYWORD - 18)))) != 0)) {\r
10342                             {\r
10343                                 setState(1015);\r
10344                                 switch (_input.LA(1)) {\r
10345                                 case BASE_KEYWORD: {\r
10346                                     setState(1011);\r
10347                                     base_stmt();\r
10348                                 }\r
10349                                     break;\r
10350                                 case STATUS_KEYWORD: {\r
10351                                     setState(1012);\r
10352                                     status_stmt();\r
10353                                 }\r
10354                                     break;\r
10355                                 case DESCRIPTION_KEYWORD: {\r
10356                                     setState(1013);\r
10357                                     description_stmt();\r
10358                                 }\r
10359                                     break;\r
10360                                 case REFERENCE_KEYWORD: {\r
10361                                     setState(1014);\r
10362                                     reference_stmt();\r
10363                                 }\r
10364                                     break;\r
10365                                 default:\r
10366                                     throw new NoViableAltException(this);\r
10367                                 }\r
10368                             }\r
10369                             setState(1019);\r
10370                             _errHandler.sync(this);\r
10371                             _la = _input.LA(1);\r
10372                         }\r
10373                         setState(1020);\r
10374                         match(RIGHT_BRACE);\r
10375                     }\r
10376                 }\r
10377                     break;\r
10378                 default:\r
10379                     throw new NoViableAltException(this);\r
10380                 }\r
10381             }\r
10382         } catch (RecognitionException re) {\r
10383             _localctx.exception = re;\r
10384             _errHandler.reportError(this, re);\r
10385             _errHandler.recover(this, re);\r
10386         } finally {\r
10387             exitRule();\r
10388         }\r
10389         return _localctx;\r
10390     }\r
10391 \r
10392     public static class Yin_element_argContext extends ParserRuleContext {\r
10393         public StringContext string() {\r
10394             return getRuleContext(StringContext.class, 0);\r
10395         }\r
10396 \r
10397         public Yin_element_argContext(ParserRuleContext parent,\r
10398                 int invokingState) {\r
10399             super(parent, invokingState);\r
10400         }\r
10401 \r
10402         @Override\r
10403         public int getRuleIndex() {\r
10404             return RULE_yin_element_arg;\r
10405         }\r
10406 \r
10407         @Override\r
10408         public void enterRule(ParseTreeListener listener) {\r
10409             if (listener instanceof YangParserListener)\r
10410                 ((YangParserListener) listener).enterYin_element_arg(this);\r
10411         }\r
10412 \r
10413         @Override\r
10414         public void exitRule(ParseTreeListener listener) {\r
10415             if (listener instanceof YangParserListener)\r
10416                 ((YangParserListener) listener).exitYin_element_arg(this);\r
10417         }\r
10418 \r
10419         @Override\r
10420         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
10421             if (visitor instanceof YangParserVisitor)\r
10422                 return ((YangParserVisitor<? extends T>) visitor)\r
10423                         .visitYin_element_arg(this);\r
10424             else\r
10425                 return visitor.visitChildren(this);\r
10426         }\r
10427     }\r
10428 \r
10429     public final Yin_element_argContext yin_element_arg()\r
10430             throws RecognitionException {\r
10431         Yin_element_argContext _localctx = new Yin_element_argContext(_ctx,\r
10432                 getState());\r
10433         enterRule(_localctx, 160, RULE_yin_element_arg);\r
10434         try {\r
10435             enterOuterAlt(_localctx, 1);\r
10436             {\r
10437                 setState(1023);\r
10438                 string();\r
10439             }\r
10440         } catch (RecognitionException re) {\r
10441             _localctx.exception = re;\r
10442             _errHandler.reportError(this, re);\r
10443             _errHandler.recover(this, re);\r
10444         } finally {\r
10445             exitRule();\r
10446         }\r
10447         return _localctx;\r
10448     }\r
10449 \r
10450     public static class Yin_element_stmtContext extends ParserRuleContext {\r
10451         public TerminalNode YIN_ELEMENT_KEYWORD() {\r
10452             return getToken(YangParser.YIN_ELEMENT_KEYWORD, 0);\r
10453         }\r
10454 \r
10455         public Yin_element_argContext yin_element_arg() {\r
10456             return getRuleContext(Yin_element_argContext.class, 0);\r
10457         }\r
10458 \r
10459         public StmtendContext stmtend() {\r
10460             return getRuleContext(StmtendContext.class, 0);\r
10461         }\r
10462 \r
10463         public Yin_element_stmtContext(ParserRuleContext parent,\r
10464                 int invokingState) {\r
10465             super(parent, invokingState);\r
10466         }\r
10467 \r
10468         @Override\r
10469         public int getRuleIndex() {\r
10470             return RULE_yin_element_stmt;\r
10471         }\r
10472 \r
10473         @Override\r
10474         public void enterRule(ParseTreeListener listener) {\r
10475             if (listener instanceof YangParserListener)\r
10476                 ((YangParserListener) listener).enterYin_element_stmt(this);\r
10477         }\r
10478 \r
10479         @Override\r
10480         public void exitRule(ParseTreeListener listener) {\r
10481             if (listener instanceof YangParserListener)\r
10482                 ((YangParserListener) listener).exitYin_element_stmt(this);\r
10483         }\r
10484 \r
10485         @Override\r
10486         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
10487             if (visitor instanceof YangParserVisitor)\r
10488                 return ((YangParserVisitor<? extends T>) visitor)\r
10489                         .visitYin_element_stmt(this);\r
10490             else\r
10491                 return visitor.visitChildren(this);\r
10492         }\r
10493     }\r
10494 \r
10495     public final Yin_element_stmtContext yin_element_stmt()\r
10496             throws RecognitionException {\r
10497         Yin_element_stmtContext _localctx = new Yin_element_stmtContext(_ctx,\r
10498                 getState());\r
10499         enterRule(_localctx, 162, RULE_yin_element_stmt);\r
10500         try {\r
10501             enterOuterAlt(_localctx, 1);\r
10502             {\r
10503                 setState(1025);\r
10504                 match(YIN_ELEMENT_KEYWORD);\r
10505                 setState(1026);\r
10506                 yin_element_arg();\r
10507                 setState(1027);\r
10508                 stmtend();\r
10509             }\r
10510         } catch (RecognitionException re) {\r
10511             _localctx.exception = re;\r
10512             _errHandler.reportError(this, re);\r
10513             _errHandler.recover(this, re);\r
10514         } finally {\r
10515             exitRule();\r
10516         }\r
10517         return _localctx;\r
10518     }\r
10519 \r
10520     public static class Argument_stmtContext extends ParserRuleContext {\r
10521         public TerminalNode RIGHT_BRACE() {\r
10522             return getToken(YangParser.RIGHT_BRACE, 0);\r
10523         }\r
10524 \r
10525         public Yin_element_stmtContext yin_element_stmt() {\r
10526             return getRuleContext(Yin_element_stmtContext.class, 0);\r
10527         }\r
10528 \r
10529         public TerminalNode SEMICOLON() {\r
10530             return getToken(YangParser.SEMICOLON, 0);\r
10531         }\r
10532 \r
10533         public StringContext string() {\r
10534             return getRuleContext(StringContext.class, 0);\r
10535         }\r
10536 \r
10537         public TerminalNode LEFT_BRACE() {\r
10538             return getToken(YangParser.LEFT_BRACE, 0);\r
10539         }\r
10540 \r
10541         public TerminalNode ARGUMENT_KEYWORD() {\r
10542             return getToken(YangParser.ARGUMENT_KEYWORD, 0);\r
10543         }\r
10544 \r
10545         public Argument_stmtContext(ParserRuleContext parent, int invokingState) {\r
10546             super(parent, invokingState);\r
10547         }\r
10548 \r
10549         @Override\r
10550         public int getRuleIndex() {\r
10551             return RULE_argument_stmt;\r
10552         }\r
10553 \r
10554         @Override\r
10555         public void enterRule(ParseTreeListener listener) {\r
10556             if (listener instanceof YangParserListener)\r
10557                 ((YangParserListener) listener).enterArgument_stmt(this);\r
10558         }\r
10559 \r
10560         @Override\r
10561         public void exitRule(ParseTreeListener listener) {\r
10562             if (listener instanceof YangParserListener)\r
10563                 ((YangParserListener) listener).exitArgument_stmt(this);\r
10564         }\r
10565 \r
10566         @Override\r
10567         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
10568             if (visitor instanceof YangParserVisitor)\r
10569                 return ((YangParserVisitor<? extends T>) visitor)\r
10570                         .visitArgument_stmt(this);\r
10571             else\r
10572                 return visitor.visitChildren(this);\r
10573         }\r
10574     }\r
10575 \r
10576     public final Argument_stmtContext argument_stmt()\r
10577             throws RecognitionException {\r
10578         Argument_stmtContext _localctx = new Argument_stmtContext(_ctx,\r
10579                 getState());\r
10580         enterRule(_localctx, 164, RULE_argument_stmt);\r
10581         int _la;\r
10582         try {\r
10583             enterOuterAlt(_localctx, 1);\r
10584             {\r
10585                 setState(1029);\r
10586                 match(ARGUMENT_KEYWORD);\r
10587                 setState(1030);\r
10588                 string();\r
10589                 setState(1037);\r
10590                 switch (_input.LA(1)) {\r
10591                 case SEMICOLON: {\r
10592                     setState(1031);\r
10593                     match(SEMICOLON);\r
10594                 }\r
10595                     break;\r
10596                 case LEFT_BRACE: {\r
10597                     {\r
10598                         setState(1032);\r
10599                         match(LEFT_BRACE);\r
10600                         setState(1034);\r
10601                         _la = _input.LA(1);\r
10602                         if (_la == YIN_ELEMENT_KEYWORD) {\r
10603                             {\r
10604                                 setState(1033);\r
10605                                 yin_element_stmt();\r
10606                             }\r
10607                         }\r
10608 \r
10609                         setState(1036);\r
10610                         match(RIGHT_BRACE);\r
10611                     }\r
10612                 }\r
10613                     break;\r
10614                 default:\r
10615                     throw new NoViableAltException(this);\r
10616                 }\r
10617             }\r
10618         } catch (RecognitionException re) {\r
10619             _localctx.exception = re;\r
10620             _errHandler.reportError(this, re);\r
10621             _errHandler.recover(this, re);\r
10622         } finally {\r
10623             exitRule();\r
10624         }\r
10625         return _localctx;\r
10626     }\r
10627 \r
10628     public static class Extension_stmtContext extends ParserRuleContext {\r
10629         public TerminalNode RIGHT_BRACE() {\r
10630             return getToken(YangParser.RIGHT_BRACE, 0);\r
10631         }\r
10632 \r
10633         public TerminalNode EXTENSION_KEYWORD() {\r
10634             return getToken(YangParser.EXTENSION_KEYWORD, 0);\r
10635         }\r
10636 \r
10637         public List<Reference_stmtContext> reference_stmt() {\r
10638             return getRuleContexts(Reference_stmtContext.class);\r
10639         }\r
10640 \r
10641         public Description_stmtContext description_stmt(int i) {\r
10642             return getRuleContext(Description_stmtContext.class, i);\r
10643         }\r
10644 \r
10645         public List<Argument_stmtContext> argument_stmt() {\r
10646             return getRuleContexts(Argument_stmtContext.class);\r
10647         }\r
10648 \r
10649         public TerminalNode LEFT_BRACE() {\r
10650             return getToken(YangParser.LEFT_BRACE, 0);\r
10651         }\r
10652 \r
10653         public Status_stmtContext status_stmt(int i) {\r
10654             return getRuleContext(Status_stmtContext.class, i);\r
10655         }\r
10656 \r
10657         public TerminalNode SEMICOLON() {\r
10658             return getToken(YangParser.SEMICOLON, 0);\r
10659         }\r
10660 \r
10661         public List<Status_stmtContext> status_stmt() {\r
10662             return getRuleContexts(Status_stmtContext.class);\r
10663         }\r
10664 \r
10665         public StringContext string() {\r
10666             return getRuleContext(StringContext.class, 0);\r
10667         }\r
10668 \r
10669         public List<Description_stmtContext> description_stmt() {\r
10670             return getRuleContexts(Description_stmtContext.class);\r
10671         }\r
10672 \r
10673         public Reference_stmtContext reference_stmt(int i) {\r
10674             return getRuleContext(Reference_stmtContext.class, i);\r
10675         }\r
10676 \r
10677         public Argument_stmtContext argument_stmt(int i) {\r
10678             return getRuleContext(Argument_stmtContext.class, i);\r
10679         }\r
10680 \r
10681         public Extension_stmtContext(ParserRuleContext parent, int invokingState) {\r
10682             super(parent, invokingState);\r
10683         }\r
10684 \r
10685         @Override\r
10686         public int getRuleIndex() {\r
10687             return RULE_extension_stmt;\r
10688         }\r
10689 \r
10690         @Override\r
10691         public void enterRule(ParseTreeListener listener) {\r
10692             if (listener instanceof YangParserListener)\r
10693                 ((YangParserListener) listener).enterExtension_stmt(this);\r
10694         }\r
10695 \r
10696         @Override\r
10697         public void exitRule(ParseTreeListener listener) {\r
10698             if (listener instanceof YangParserListener)\r
10699                 ((YangParserListener) listener).exitExtension_stmt(this);\r
10700         }\r
10701 \r
10702         @Override\r
10703         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
10704             if (visitor instanceof YangParserVisitor)\r
10705                 return ((YangParserVisitor<? extends T>) visitor)\r
10706                         .visitExtension_stmt(this);\r
10707             else\r
10708                 return visitor.visitChildren(this);\r
10709         }\r
10710     }\r
10711 \r
10712     public final Extension_stmtContext extension_stmt()\r
10713             throws RecognitionException {\r
10714         Extension_stmtContext _localctx = new Extension_stmtContext(_ctx,\r
10715                 getState());\r
10716         enterRule(_localctx, 166, RULE_extension_stmt);\r
10717         int _la;\r
10718         try {\r
10719             enterOuterAlt(_localctx, 1);\r
10720             {\r
10721                 setState(1039);\r
10722                 match(EXTENSION_KEYWORD);\r
10723                 setState(1040);\r
10724                 string();\r
10725                 setState(1053);\r
10726                 switch (_input.LA(1)) {\r
10727                 case SEMICOLON: {\r
10728                     setState(1041);\r
10729                     match(SEMICOLON);\r
10730                 }\r
10731                     break;\r
10732                 case LEFT_BRACE: {\r
10733                     {\r
10734                         setState(1042);\r
10735                         match(LEFT_BRACE);\r
10736                         setState(1049);\r
10737                         _errHandler.sync(this);\r
10738                         _la = _input.LA(1);\r
10739                         while (((((_la - 18)) & ~0x3f) == 0 && ((1L << (_la - 18)) & ((1L << (STATUS_KEYWORD - 18))\r
10740                                 | (1L << (REFERENCE_KEYWORD - 18))\r
10741                                 | (1L << (DESCRIPTION_KEYWORD - 18)) | (1L << (ARGUMENT_KEYWORD - 18)))) != 0)) {\r
10742                             {\r
10743                                 setState(1047);\r
10744                                 switch (_input.LA(1)) {\r
10745                                 case ARGUMENT_KEYWORD: {\r
10746                                     setState(1043);\r
10747                                     argument_stmt();\r
10748                                 }\r
10749                                     break;\r
10750                                 case STATUS_KEYWORD: {\r
10751                                     setState(1044);\r
10752                                     status_stmt();\r
10753                                 }\r
10754                                     break;\r
10755                                 case DESCRIPTION_KEYWORD: {\r
10756                                     setState(1045);\r
10757                                     description_stmt();\r
10758                                 }\r
10759                                     break;\r
10760                                 case REFERENCE_KEYWORD: {\r
10761                                     setState(1046);\r
10762                                     reference_stmt();\r
10763                                 }\r
10764                                     break;\r
10765                                 default:\r
10766                                     throw new NoViableAltException(this);\r
10767                                 }\r
10768                             }\r
10769                             setState(1051);\r
10770                             _errHandler.sync(this);\r
10771                             _la = _input.LA(1);\r
10772                         }\r
10773                         setState(1052);\r
10774                         match(RIGHT_BRACE);\r
10775                     }\r
10776                 }\r
10777                     break;\r
10778                 default:\r
10779                     throw new NoViableAltException(this);\r
10780                 }\r
10781             }\r
10782         } catch (RecognitionException re) {\r
10783             _localctx.exception = re;\r
10784             _errHandler.reportError(this, re);\r
10785             _errHandler.recover(this, re);\r
10786         } finally {\r
10787             exitRule();\r
10788         }\r
10789         return _localctx;\r
10790     }\r
10791 \r
10792     public static class Revision_date_stmtContext extends ParserRuleContext {\r
10793         public TerminalNode REVISION_DATE_KEYWORD() {\r
10794             return getToken(YangParser.REVISION_DATE_KEYWORD, 0);\r
10795         }\r
10796 \r
10797         public StringContext string() {\r
10798             return getRuleContext(StringContext.class, 0);\r
10799         }\r
10800 \r
10801         public StmtendContext stmtend() {\r
10802             return getRuleContext(StmtendContext.class, 0);\r
10803         }\r
10804 \r
10805         public Revision_date_stmtContext(ParserRuleContext parent,\r
10806                 int invokingState) {\r
10807             super(parent, invokingState);\r
10808         }\r
10809 \r
10810         @Override\r
10811         public int getRuleIndex() {\r
10812             return RULE_revision_date_stmt;\r
10813         }\r
10814 \r
10815         @Override\r
10816         public void enterRule(ParseTreeListener listener) {\r
10817             if (listener instanceof YangParserListener)\r
10818                 ((YangParserListener) listener).enterRevision_date_stmt(this);\r
10819         }\r
10820 \r
10821         @Override\r
10822         public void exitRule(ParseTreeListener listener) {\r
10823             if (listener instanceof YangParserListener)\r
10824                 ((YangParserListener) listener).exitRevision_date_stmt(this);\r
10825         }\r
10826 \r
10827         @Override\r
10828         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
10829             if (visitor instanceof YangParserVisitor)\r
10830                 return ((YangParserVisitor<? extends T>) visitor)\r
10831                         .visitRevision_date_stmt(this);\r
10832             else\r
10833                 return visitor.visitChildren(this);\r
10834         }\r
10835     }\r
10836 \r
10837     public final Revision_date_stmtContext revision_date_stmt()\r
10838             throws RecognitionException {\r
10839         Revision_date_stmtContext _localctx = new Revision_date_stmtContext(\r
10840                 _ctx, getState());\r
10841         enterRule(_localctx, 168, RULE_revision_date_stmt);\r
10842         try {\r
10843             enterOuterAlt(_localctx, 1);\r
10844             {\r
10845                 setState(1055);\r
10846                 match(REVISION_DATE_KEYWORD);\r
10847                 setState(1056);\r
10848                 string();\r
10849                 setState(1057);\r
10850                 stmtend();\r
10851             }\r
10852         } catch (RecognitionException re) {\r
10853             _localctx.exception = re;\r
10854             _errHandler.reportError(this, re);\r
10855             _errHandler.recover(this, re);\r
10856         } finally {\r
10857             exitRule();\r
10858         }\r
10859         return _localctx;\r
10860     }\r
10861 \r
10862     public static class Revision_stmtContext extends ParserRuleContext {\r
10863         public TerminalNode RIGHT_BRACE() {\r
10864             return getToken(YangParser.RIGHT_BRACE, 0);\r
10865         }\r
10866 \r
10867         public Reference_stmtContext reference_stmt() {\r
10868             return getRuleContext(Reference_stmtContext.class, 0);\r
10869         }\r
10870 \r
10871         public TerminalNode SEMICOLON() {\r
10872             return getToken(YangParser.SEMICOLON, 0);\r
10873         }\r
10874 \r
10875         public TerminalNode REVISION_KEYWORD() {\r
10876             return getToken(YangParser.REVISION_KEYWORD, 0);\r
10877         }\r
10878 \r
10879         public StringContext string() {\r
10880             return getRuleContext(StringContext.class, 0);\r
10881         }\r
10882 \r
10883         public Description_stmtContext description_stmt() {\r
10884             return getRuleContext(Description_stmtContext.class, 0);\r
10885         }\r
10886 \r
10887         public TerminalNode LEFT_BRACE() {\r
10888             return getToken(YangParser.LEFT_BRACE, 0);\r
10889         }\r
10890 \r
10891         public Revision_stmtContext(ParserRuleContext parent, int invokingState) {\r
10892             super(parent, invokingState);\r
10893         }\r
10894 \r
10895         @Override\r
10896         public int getRuleIndex() {\r
10897             return RULE_revision_stmt;\r
10898         }\r
10899 \r
10900         @Override\r
10901         public void enterRule(ParseTreeListener listener) {\r
10902             if (listener instanceof YangParserListener)\r
10903                 ((YangParserListener) listener).enterRevision_stmt(this);\r
10904         }\r
10905 \r
10906         @Override\r
10907         public void exitRule(ParseTreeListener listener) {\r
10908             if (listener instanceof YangParserListener)\r
10909                 ((YangParserListener) listener).exitRevision_stmt(this);\r
10910         }\r
10911 \r
10912         @Override\r
10913         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
10914             if (visitor instanceof YangParserVisitor)\r
10915                 return ((YangParserVisitor<? extends T>) visitor)\r
10916                         .visitRevision_stmt(this);\r
10917             else\r
10918                 return visitor.visitChildren(this);\r
10919         }\r
10920     }\r
10921 \r
10922     public final Revision_stmtContext revision_stmt()\r
10923             throws RecognitionException {\r
10924         Revision_stmtContext _localctx = new Revision_stmtContext(_ctx,\r
10925                 getState());\r
10926         enterRule(_localctx, 170, RULE_revision_stmt);\r
10927         int _la;\r
10928         try {\r
10929             enterOuterAlt(_localctx, 1);\r
10930             {\r
10931                 setState(1059);\r
10932                 match(REVISION_KEYWORD);\r
10933                 setState(1060);\r
10934                 string();\r
10935                 setState(1070);\r
10936                 switch (_input.LA(1)) {\r
10937                 case SEMICOLON: {\r
10938                     setState(1061);\r
10939                     match(SEMICOLON);\r
10940                 }\r
10941                     break;\r
10942                 case LEFT_BRACE: {\r
10943                     {\r
10944                         setState(1062);\r
10945                         match(LEFT_BRACE);\r
10946                         setState(1064);\r
10947                         _la = _input.LA(1);\r
10948                         if (_la == DESCRIPTION_KEYWORD) {\r
10949                             {\r
10950                                 setState(1063);\r
10951                                 description_stmt();\r
10952                             }\r
10953                         }\r
10954 \r
10955                         setState(1067);\r
10956                         _la = _input.LA(1);\r
10957                         if (_la == REFERENCE_KEYWORD) {\r
10958                             {\r
10959                                 setState(1066);\r
10960                                 reference_stmt();\r
10961                             }\r
10962                         }\r
10963 \r
10964                         setState(1069);\r
10965                         match(RIGHT_BRACE);\r
10966                     }\r
10967                 }\r
10968                     break;\r
10969                 default:\r
10970                     throw new NoViableAltException(this);\r
10971                 }\r
10972             }\r
10973         } catch (RecognitionException re) {\r
10974             _localctx.exception = re;\r
10975             _errHandler.reportError(this, re);\r
10976             _errHandler.recover(this, re);\r
10977         } finally {\r
10978             exitRule();\r
10979         }\r
10980         return _localctx;\r
10981     }\r
10982 \r
10983     public static class Units_stmtContext extends ParserRuleContext {\r
10984         public TerminalNode UNITS_KEYWORD() {\r
10985             return getToken(YangParser.UNITS_KEYWORD, 0);\r
10986         }\r
10987 \r
10988         public StringContext string() {\r
10989             return getRuleContext(StringContext.class, 0);\r
10990         }\r
10991 \r
10992         public StmtendContext stmtend() {\r
10993             return getRuleContext(StmtendContext.class, 0);\r
10994         }\r
10995 \r
10996         public Units_stmtContext(ParserRuleContext parent, int invokingState) {\r
10997             super(parent, invokingState);\r
10998         }\r
10999 \r
11000         @Override\r
11001         public int getRuleIndex() {\r
11002             return RULE_units_stmt;\r
11003         }\r
11004 \r
11005         @Override\r
11006         public void enterRule(ParseTreeListener listener) {\r
11007             if (listener instanceof YangParserListener)\r
11008                 ((YangParserListener) listener).enterUnits_stmt(this);\r
11009         }\r
11010 \r
11011         @Override\r
11012         public void exitRule(ParseTreeListener listener) {\r
11013             if (listener instanceof YangParserListener)\r
11014                 ((YangParserListener) listener).exitUnits_stmt(this);\r
11015         }\r
11016 \r
11017         @Override\r
11018         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
11019             if (visitor instanceof YangParserVisitor)\r
11020                 return ((YangParserVisitor<? extends T>) visitor)\r
11021                         .visitUnits_stmt(this);\r
11022             else\r
11023                 return visitor.visitChildren(this);\r
11024         }\r
11025     }\r
11026 \r
11027     public final Units_stmtContext units_stmt() throws RecognitionException {\r
11028         Units_stmtContext _localctx = new Units_stmtContext(_ctx, getState());\r
11029         enterRule(_localctx, 172, RULE_units_stmt);\r
11030         try {\r
11031             enterOuterAlt(_localctx, 1);\r
11032             {\r
11033                 setState(1072);\r
11034                 match(UNITS_KEYWORD);\r
11035                 setState(1073);\r
11036                 string();\r
11037                 setState(1074);\r
11038                 stmtend();\r
11039             }\r
11040         } catch (RecognitionException re) {\r
11041             _localctx.exception = re;\r
11042             _errHandler.reportError(this, re);\r
11043             _errHandler.recover(this, re);\r
11044         } finally {\r
11045             exitRule();\r
11046         }\r
11047         return _localctx;\r
11048     }\r
11049 \r
11050     public static class Reference_stmtContext extends ParserRuleContext {\r
11051         public StringContext string() {\r
11052             return getRuleContext(StringContext.class, 0);\r
11053         }\r
11054 \r
11055         public StmtendContext stmtend() {\r
11056             return getRuleContext(StmtendContext.class, 0);\r
11057         }\r
11058 \r
11059         public TerminalNode REFERENCE_KEYWORD() {\r
11060             return getToken(YangParser.REFERENCE_KEYWORD, 0);\r
11061         }\r
11062 \r
11063         public Reference_stmtContext(ParserRuleContext parent, int invokingState) {\r
11064             super(parent, invokingState);\r
11065         }\r
11066 \r
11067         @Override\r
11068         public int getRuleIndex() {\r
11069             return RULE_reference_stmt;\r
11070         }\r
11071 \r
11072         @Override\r
11073         public void enterRule(ParseTreeListener listener) {\r
11074             if (listener instanceof YangParserListener)\r
11075                 ((YangParserListener) listener).enterReference_stmt(this);\r
11076         }\r
11077 \r
11078         @Override\r
11079         public void exitRule(ParseTreeListener listener) {\r
11080             if (listener instanceof YangParserListener)\r
11081                 ((YangParserListener) listener).exitReference_stmt(this);\r
11082         }\r
11083 \r
11084         @Override\r
11085         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
11086             if (visitor instanceof YangParserVisitor)\r
11087                 return ((YangParserVisitor<? extends T>) visitor)\r
11088                         .visitReference_stmt(this);\r
11089             else\r
11090                 return visitor.visitChildren(this);\r
11091         }\r
11092     }\r
11093 \r
11094     public final Reference_stmtContext reference_stmt()\r
11095             throws RecognitionException {\r
11096         Reference_stmtContext _localctx = new Reference_stmtContext(_ctx,\r
11097                 getState());\r
11098         enterRule(_localctx, 174, RULE_reference_stmt);\r
11099         try {\r
11100             enterOuterAlt(_localctx, 1);\r
11101             {\r
11102                 setState(1076);\r
11103                 match(REFERENCE_KEYWORD);\r
11104                 setState(1077);\r
11105                 string();\r
11106                 setState(1078);\r
11107                 stmtend();\r
11108             }\r
11109         } catch (RecognitionException re) {\r
11110             _localctx.exception = re;\r
11111             _errHandler.reportError(this, re);\r
11112             _errHandler.recover(this, re);\r
11113         } finally {\r
11114             exitRule();\r
11115         }\r
11116         return _localctx;\r
11117     }\r
11118 \r
11119     public static class Description_stmtContext extends ParserRuleContext {\r
11120         public StringContext string() {\r
11121             return getRuleContext(StringContext.class, 0);\r
11122         }\r
11123 \r
11124         public TerminalNode DESCRIPTION_KEYWORD() {\r
11125             return getToken(YangParser.DESCRIPTION_KEYWORD, 0);\r
11126         }\r
11127 \r
11128         public StmtendContext stmtend() {\r
11129             return getRuleContext(StmtendContext.class, 0);\r
11130         }\r
11131 \r
11132         public Description_stmtContext(ParserRuleContext parent,\r
11133                 int invokingState) {\r
11134             super(parent, invokingState);\r
11135         }\r
11136 \r
11137         @Override\r
11138         public int getRuleIndex() {\r
11139             return RULE_description_stmt;\r
11140         }\r
11141 \r
11142         @Override\r
11143         public void enterRule(ParseTreeListener listener) {\r
11144             if (listener instanceof YangParserListener)\r
11145                 ((YangParserListener) listener).enterDescription_stmt(this);\r
11146         }\r
11147 \r
11148         @Override\r
11149         public void exitRule(ParseTreeListener listener) {\r
11150             if (listener instanceof YangParserListener)\r
11151                 ((YangParserListener) listener).exitDescription_stmt(this);\r
11152         }\r
11153 \r
11154         @Override\r
11155         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
11156             if (visitor instanceof YangParserVisitor)\r
11157                 return ((YangParserVisitor<? extends T>) visitor)\r
11158                         .visitDescription_stmt(this);\r
11159             else\r
11160                 return visitor.visitChildren(this);\r
11161         }\r
11162     }\r
11163 \r
11164     public final Description_stmtContext description_stmt()\r
11165             throws RecognitionException {\r
11166         Description_stmtContext _localctx = new Description_stmtContext(_ctx,\r
11167                 getState());\r
11168         enterRule(_localctx, 176, RULE_description_stmt);\r
11169         try {\r
11170             enterOuterAlt(_localctx, 1);\r
11171             {\r
11172                 setState(1080);\r
11173                 match(DESCRIPTION_KEYWORD);\r
11174                 setState(1081);\r
11175                 string();\r
11176                 setState(1082);\r
11177                 stmtend();\r
11178             }\r
11179         } catch (RecognitionException re) {\r
11180             _localctx.exception = re;\r
11181             _errHandler.reportError(this, re);\r
11182             _errHandler.recover(this, re);\r
11183         } finally {\r
11184             exitRule();\r
11185         }\r
11186         return _localctx;\r
11187     }\r
11188 \r
11189     public static class Contact_stmtContext extends ParserRuleContext {\r
11190         public TerminalNode CONTACT_KEYWORD() {\r
11191             return getToken(YangParser.CONTACT_KEYWORD, 0);\r
11192         }\r
11193 \r
11194         public StringContext string() {\r
11195             return getRuleContext(StringContext.class, 0);\r
11196         }\r
11197 \r
11198         public StmtendContext stmtend() {\r
11199             return getRuleContext(StmtendContext.class, 0);\r
11200         }\r
11201 \r
11202         public Contact_stmtContext(ParserRuleContext parent, int invokingState) {\r
11203             super(parent, invokingState);\r
11204         }\r
11205 \r
11206         @Override\r
11207         public int getRuleIndex() {\r
11208             return RULE_contact_stmt;\r
11209         }\r
11210 \r
11211         @Override\r
11212         public void enterRule(ParseTreeListener listener) {\r
11213             if (listener instanceof YangParserListener)\r
11214                 ((YangParserListener) listener).enterContact_stmt(this);\r
11215         }\r
11216 \r
11217         @Override\r
11218         public void exitRule(ParseTreeListener listener) {\r
11219             if (listener instanceof YangParserListener)\r
11220                 ((YangParserListener) listener).exitContact_stmt(this);\r
11221         }\r
11222 \r
11223         @Override\r
11224         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
11225             if (visitor instanceof YangParserVisitor)\r
11226                 return ((YangParserVisitor<? extends T>) visitor)\r
11227                         .visitContact_stmt(this);\r
11228             else\r
11229                 return visitor.visitChildren(this);\r
11230         }\r
11231     }\r
11232 \r
11233     public final Contact_stmtContext contact_stmt() throws RecognitionException {\r
11234         Contact_stmtContext _localctx = new Contact_stmtContext(_ctx,\r
11235                 getState());\r
11236         enterRule(_localctx, 178, RULE_contact_stmt);\r
11237         try {\r
11238             enterOuterAlt(_localctx, 1);\r
11239             {\r
11240                 setState(1084);\r
11241                 match(CONTACT_KEYWORD);\r
11242                 setState(1085);\r
11243                 string();\r
11244                 setState(1086);\r
11245                 stmtend();\r
11246             }\r
11247         } catch (RecognitionException re) {\r
11248             _localctx.exception = re;\r
11249             _errHandler.reportError(this, re);\r
11250             _errHandler.recover(this, re);\r
11251         } finally {\r
11252             exitRule();\r
11253         }\r
11254         return _localctx;\r
11255     }\r
11256 \r
11257     public static class Organization_stmtContext extends ParserRuleContext {\r
11258         public StringContext string() {\r
11259             return getRuleContext(StringContext.class, 0);\r
11260         }\r
11261 \r
11262         public StmtendContext stmtend() {\r
11263             return getRuleContext(StmtendContext.class, 0);\r
11264         }\r
11265 \r
11266         public TerminalNode ORGANIZATION_KEYWORD() {\r
11267             return getToken(YangParser.ORGANIZATION_KEYWORD, 0);\r
11268         }\r
11269 \r
11270         public Organization_stmtContext(ParserRuleContext parent,\r
11271                 int invokingState) {\r
11272             super(parent, invokingState);\r
11273         }\r
11274 \r
11275         @Override\r
11276         public int getRuleIndex() {\r
11277             return RULE_organization_stmt;\r
11278         }\r
11279 \r
11280         @Override\r
11281         public void enterRule(ParseTreeListener listener) {\r
11282             if (listener instanceof YangParserListener)\r
11283                 ((YangParserListener) listener).enterOrganization_stmt(this);\r
11284         }\r
11285 \r
11286         @Override\r
11287         public void exitRule(ParseTreeListener listener) {\r
11288             if (listener instanceof YangParserListener)\r
11289                 ((YangParserListener) listener).exitOrganization_stmt(this);\r
11290         }\r
11291 \r
11292         @Override\r
11293         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
11294             if (visitor instanceof YangParserVisitor)\r
11295                 return ((YangParserVisitor<? extends T>) visitor)\r
11296                         .visitOrganization_stmt(this);\r
11297             else\r
11298                 return visitor.visitChildren(this);\r
11299         }\r
11300     }\r
11301 \r
11302     public final Organization_stmtContext organization_stmt()\r
11303             throws RecognitionException {\r
11304         Organization_stmtContext _localctx = new Organization_stmtContext(_ctx,\r
11305                 getState());\r
11306         enterRule(_localctx, 180, RULE_organization_stmt);\r
11307         try {\r
11308             enterOuterAlt(_localctx, 1);\r
11309             {\r
11310                 setState(1088);\r
11311                 match(ORGANIZATION_KEYWORD);\r
11312                 setState(1089);\r
11313                 string();\r
11314                 setState(1090);\r
11315                 stmtend();\r
11316             }\r
11317         } catch (RecognitionException re) {\r
11318             _localctx.exception = re;\r
11319             _errHandler.reportError(this, re);\r
11320             _errHandler.recover(this, re);\r
11321         } finally {\r
11322             exitRule();\r
11323         }\r
11324         return _localctx;\r
11325     }\r
11326 \r
11327     public static class Belongs_to_stmtContext extends ParserRuleContext {\r
11328         public TerminalNode RIGHT_BRACE() {\r
11329             return getToken(YangParser.RIGHT_BRACE, 0);\r
11330         }\r
11331 \r
11332         public StringContext string() {\r
11333             return getRuleContext(StringContext.class, 0);\r
11334         }\r
11335 \r
11336         public TerminalNode BELONGS_TO_KEYWORD() {\r
11337             return getToken(YangParser.BELONGS_TO_KEYWORD, 0);\r
11338         }\r
11339 \r
11340         public TerminalNode LEFT_BRACE() {\r
11341             return getToken(YangParser.LEFT_BRACE, 0);\r
11342         }\r
11343 \r
11344         public Prefix_stmtContext prefix_stmt() {\r
11345             return getRuleContext(Prefix_stmtContext.class, 0);\r
11346         }\r
11347 \r
11348         public Belongs_to_stmtContext(ParserRuleContext parent,\r
11349                 int invokingState) {\r
11350             super(parent, invokingState);\r
11351         }\r
11352 \r
11353         @Override\r
11354         public int getRuleIndex() {\r
11355             return RULE_belongs_to_stmt;\r
11356         }\r
11357 \r
11358         @Override\r
11359         public void enterRule(ParseTreeListener listener) {\r
11360             if (listener instanceof YangParserListener)\r
11361                 ((YangParserListener) listener).enterBelongs_to_stmt(this);\r
11362         }\r
11363 \r
11364         @Override\r
11365         public void exitRule(ParseTreeListener listener) {\r
11366             if (listener instanceof YangParserListener)\r
11367                 ((YangParserListener) listener).exitBelongs_to_stmt(this);\r
11368         }\r
11369 \r
11370         @Override\r
11371         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
11372             if (visitor instanceof YangParserVisitor)\r
11373                 return ((YangParserVisitor<? extends T>) visitor)\r
11374                         .visitBelongs_to_stmt(this);\r
11375             else\r
11376                 return visitor.visitChildren(this);\r
11377         }\r
11378     }\r
11379 \r
11380     public final Belongs_to_stmtContext belongs_to_stmt()\r
11381             throws RecognitionException {\r
11382         Belongs_to_stmtContext _localctx = new Belongs_to_stmtContext(_ctx,\r
11383                 getState());\r
11384         enterRule(_localctx, 182, RULE_belongs_to_stmt);\r
11385         try {\r
11386             enterOuterAlt(_localctx, 1);\r
11387             {\r
11388                 setState(1092);\r
11389                 match(BELONGS_TO_KEYWORD);\r
11390                 setState(1093);\r
11391                 string();\r
11392                 setState(1094);\r
11393                 match(LEFT_BRACE);\r
11394                 setState(1095);\r
11395                 prefix_stmt();\r
11396                 setState(1096);\r
11397                 match(RIGHT_BRACE);\r
11398             }\r
11399         } catch (RecognitionException re) {\r
11400             _localctx.exception = re;\r
11401             _errHandler.reportError(this, re);\r
11402             _errHandler.recover(this, re);\r
11403         } finally {\r
11404             exitRule();\r
11405         }\r
11406         return _localctx;\r
11407     }\r
11408 \r
11409     public static class Prefix_stmtContext extends ParserRuleContext {\r
11410         public StringContext string() {\r
11411             return getRuleContext(StringContext.class, 0);\r
11412         }\r
11413 \r
11414         public StmtendContext stmtend() {\r
11415             return getRuleContext(StmtendContext.class, 0);\r
11416         }\r
11417 \r
11418         public TerminalNode PREFIX_KEYWORD() {\r
11419             return getToken(YangParser.PREFIX_KEYWORD, 0);\r
11420         }\r
11421 \r
11422         public Prefix_stmtContext(ParserRuleContext parent, int invokingState) {\r
11423             super(parent, invokingState);\r
11424         }\r
11425 \r
11426         @Override\r
11427         public int getRuleIndex() {\r
11428             return RULE_prefix_stmt;\r
11429         }\r
11430 \r
11431         @Override\r
11432         public void enterRule(ParseTreeListener listener) {\r
11433             if (listener instanceof YangParserListener)\r
11434                 ((YangParserListener) listener).enterPrefix_stmt(this);\r
11435         }\r
11436 \r
11437         @Override\r
11438         public void exitRule(ParseTreeListener listener) {\r
11439             if (listener instanceof YangParserListener)\r
11440                 ((YangParserListener) listener).exitPrefix_stmt(this);\r
11441         }\r
11442 \r
11443         @Override\r
11444         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
11445             if (visitor instanceof YangParserVisitor)\r
11446                 return ((YangParserVisitor<? extends T>) visitor)\r
11447                         .visitPrefix_stmt(this);\r
11448             else\r
11449                 return visitor.visitChildren(this);\r
11450         }\r
11451     }\r
11452 \r
11453     public final Prefix_stmtContext prefix_stmt() throws RecognitionException {\r
11454         Prefix_stmtContext _localctx = new Prefix_stmtContext(_ctx, getState());\r
11455         enterRule(_localctx, 184, RULE_prefix_stmt);\r
11456         try {\r
11457             enterOuterAlt(_localctx, 1);\r
11458             {\r
11459                 setState(1098);\r
11460                 match(PREFIX_KEYWORD);\r
11461                 setState(1099);\r
11462                 string();\r
11463                 setState(1100);\r
11464                 stmtend();\r
11465             }\r
11466         } catch (RecognitionException re) {\r
11467             _localctx.exception = re;\r
11468             _errHandler.reportError(this, re);\r
11469             _errHandler.recover(this, re);\r
11470         } finally {\r
11471             exitRule();\r
11472         }\r
11473         return _localctx;\r
11474     }\r
11475 \r
11476     public static class Namespace_stmtContext extends ParserRuleContext {\r
11477         public StringContext string() {\r
11478             return getRuleContext(StringContext.class, 0);\r
11479         }\r
11480 \r
11481         public TerminalNode NAMESPACE_KEYWORD() {\r
11482             return getToken(YangParser.NAMESPACE_KEYWORD, 0);\r
11483         }\r
11484 \r
11485         public StmtendContext stmtend() {\r
11486             return getRuleContext(StmtendContext.class, 0);\r
11487         }\r
11488 \r
11489         public Namespace_stmtContext(ParserRuleContext parent, int invokingState) {\r
11490             super(parent, invokingState);\r
11491         }\r
11492 \r
11493         @Override\r
11494         public int getRuleIndex() {\r
11495             return RULE_namespace_stmt;\r
11496         }\r
11497 \r
11498         @Override\r
11499         public void enterRule(ParseTreeListener listener) {\r
11500             if (listener instanceof YangParserListener)\r
11501                 ((YangParserListener) listener).enterNamespace_stmt(this);\r
11502         }\r
11503 \r
11504         @Override\r
11505         public void exitRule(ParseTreeListener listener) {\r
11506             if (listener instanceof YangParserListener)\r
11507                 ((YangParserListener) listener).exitNamespace_stmt(this);\r
11508         }\r
11509 \r
11510         @Override\r
11511         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
11512             if (visitor instanceof YangParserVisitor)\r
11513                 return ((YangParserVisitor<? extends T>) visitor)\r
11514                         .visitNamespace_stmt(this);\r
11515             else\r
11516                 return visitor.visitChildren(this);\r
11517         }\r
11518     }\r
11519 \r
11520     public final Namespace_stmtContext namespace_stmt()\r
11521             throws RecognitionException {\r
11522         Namespace_stmtContext _localctx = new Namespace_stmtContext(_ctx,\r
11523                 getState());\r
11524         enterRule(_localctx, 186, RULE_namespace_stmt);\r
11525         try {\r
11526             enterOuterAlt(_localctx, 1);\r
11527             {\r
11528                 setState(1102);\r
11529                 match(NAMESPACE_KEYWORD);\r
11530                 setState(1103);\r
11531                 string();\r
11532                 setState(1104);\r
11533                 stmtend();\r
11534             }\r
11535         } catch (RecognitionException re) {\r
11536             _localctx.exception = re;\r
11537             _errHandler.reportError(this, re);\r
11538             _errHandler.recover(this, re);\r
11539         } finally {\r
11540             exitRule();\r
11541         }\r
11542         return _localctx;\r
11543     }\r
11544 \r
11545     public static class Include_stmtContext extends ParserRuleContext {\r
11546         public TerminalNode RIGHT_BRACE() {\r
11547             return getToken(YangParser.RIGHT_BRACE, 0);\r
11548         }\r
11549 \r
11550         public TerminalNode SEMICOLON() {\r
11551             return getToken(YangParser.SEMICOLON, 0);\r
11552         }\r
11553 \r
11554         public StringContext string() {\r
11555             return getRuleContext(StringContext.class, 0);\r
11556         }\r
11557 \r
11558         public TerminalNode INCLUDE_KEYWORD() {\r
11559             return getToken(YangParser.INCLUDE_KEYWORD, 0);\r
11560         }\r
11561 \r
11562         public TerminalNode LEFT_BRACE() {\r
11563             return getToken(YangParser.LEFT_BRACE, 0);\r
11564         }\r
11565 \r
11566         public Revision_date_stmtContext revision_date_stmt() {\r
11567             return getRuleContext(Revision_date_stmtContext.class, 0);\r
11568         }\r
11569 \r
11570         public Include_stmtContext(ParserRuleContext parent, int invokingState) {\r
11571             super(parent, invokingState);\r
11572         }\r
11573 \r
11574         @Override\r
11575         public int getRuleIndex() {\r
11576             return RULE_include_stmt;\r
11577         }\r
11578 \r
11579         @Override\r
11580         public void enterRule(ParseTreeListener listener) {\r
11581             if (listener instanceof YangParserListener)\r
11582                 ((YangParserListener) listener).enterInclude_stmt(this);\r
11583         }\r
11584 \r
11585         @Override\r
11586         public void exitRule(ParseTreeListener listener) {\r
11587             if (listener instanceof YangParserListener)\r
11588                 ((YangParserListener) listener).exitInclude_stmt(this);\r
11589         }\r
11590 \r
11591         @Override\r
11592         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
11593             if (visitor instanceof YangParserVisitor)\r
11594                 return ((YangParserVisitor<? extends T>) visitor)\r
11595                         .visitInclude_stmt(this);\r
11596             else\r
11597                 return visitor.visitChildren(this);\r
11598         }\r
11599     }\r
11600 \r
11601     public final Include_stmtContext include_stmt() throws RecognitionException {\r
11602         Include_stmtContext _localctx = new Include_stmtContext(_ctx,\r
11603                 getState());\r
11604         enterRule(_localctx, 188, RULE_include_stmt);\r
11605         int _la;\r
11606         try {\r
11607             enterOuterAlt(_localctx, 1);\r
11608             {\r
11609                 setState(1106);\r
11610                 match(INCLUDE_KEYWORD);\r
11611                 setState(1107);\r
11612                 string();\r
11613                 setState(1114);\r
11614                 switch (_input.LA(1)) {\r
11615                 case SEMICOLON: {\r
11616                     setState(1108);\r
11617                     match(SEMICOLON);\r
11618                 }\r
11619                     break;\r
11620                 case LEFT_BRACE: {\r
11621                     {\r
11622                         setState(1109);\r
11623                         match(LEFT_BRACE);\r
11624                         setState(1111);\r
11625                         _la = _input.LA(1);\r
11626                         if (_la == REVISION_DATE_KEYWORD) {\r
11627                             {\r
11628                                 setState(1110);\r
11629                                 revision_date_stmt();\r
11630                             }\r
11631                         }\r
11632 \r
11633                         setState(1113);\r
11634                         match(RIGHT_BRACE);\r
11635                     }\r
11636                 }\r
11637                     break;\r
11638                 default:\r
11639                     throw new NoViableAltException(this);\r
11640                 }\r
11641             }\r
11642         } catch (RecognitionException re) {\r
11643             _localctx.exception = re;\r
11644             _errHandler.reportError(this, re);\r
11645             _errHandler.recover(this, re);\r
11646         } finally {\r
11647             exitRule();\r
11648         }\r
11649         return _localctx;\r
11650     }\r
11651 \r
11652     public static class Import_stmtContext extends ParserRuleContext {\r
11653         public TerminalNode RIGHT_BRACE() {\r
11654             return getToken(YangParser.RIGHT_BRACE, 0);\r
11655         }\r
11656 \r
11657         public StringContext string() {\r
11658             return getRuleContext(StringContext.class, 0);\r
11659         }\r
11660 \r
11661         public TerminalNode LEFT_BRACE() {\r
11662             return getToken(YangParser.LEFT_BRACE, 0);\r
11663         }\r
11664 \r
11665         public Prefix_stmtContext prefix_stmt() {\r
11666             return getRuleContext(Prefix_stmtContext.class, 0);\r
11667         }\r
11668 \r
11669         public Revision_date_stmtContext revision_date_stmt() {\r
11670             return getRuleContext(Revision_date_stmtContext.class, 0);\r
11671         }\r
11672 \r
11673         public TerminalNode IMPORT_KEYWORD() {\r
11674             return getToken(YangParser.IMPORT_KEYWORD, 0);\r
11675         }\r
11676 \r
11677         public Import_stmtContext(ParserRuleContext parent, int invokingState) {\r
11678             super(parent, invokingState);\r
11679         }\r
11680 \r
11681         @Override\r
11682         public int getRuleIndex() {\r
11683             return RULE_import_stmt;\r
11684         }\r
11685 \r
11686         @Override\r
11687         public void enterRule(ParseTreeListener listener) {\r
11688             if (listener instanceof YangParserListener)\r
11689                 ((YangParserListener) listener).enterImport_stmt(this);\r
11690         }\r
11691 \r
11692         @Override\r
11693         public void exitRule(ParseTreeListener listener) {\r
11694             if (listener instanceof YangParserListener)\r
11695                 ((YangParserListener) listener).exitImport_stmt(this);\r
11696         }\r
11697 \r
11698         @Override\r
11699         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
11700             if (visitor instanceof YangParserVisitor)\r
11701                 return ((YangParserVisitor<? extends T>) visitor)\r
11702                         .visitImport_stmt(this);\r
11703             else\r
11704                 return visitor.visitChildren(this);\r
11705         }\r
11706     }\r
11707 \r
11708     public final Import_stmtContext import_stmt() throws RecognitionException {\r
11709         Import_stmtContext _localctx = new Import_stmtContext(_ctx, getState());\r
11710         enterRule(_localctx, 190, RULE_import_stmt);\r
11711         int _la;\r
11712         try {\r
11713             enterOuterAlt(_localctx, 1);\r
11714             {\r
11715                 setState(1116);\r
11716                 match(IMPORT_KEYWORD);\r
11717                 setState(1117);\r
11718                 string();\r
11719                 setState(1118);\r
11720                 match(LEFT_BRACE);\r
11721                 setState(1119);\r
11722                 prefix_stmt();\r
11723                 setState(1121);\r
11724                 _la = _input.LA(1);\r
11725                 if (_la == REVISION_DATE_KEYWORD) {\r
11726                     {\r
11727                         setState(1120);\r
11728                         revision_date_stmt();\r
11729                     }\r
11730                 }\r
11731 \r
11732                 setState(1123);\r
11733                 match(RIGHT_BRACE);\r
11734             }\r
11735         } catch (RecognitionException re) {\r
11736             _localctx.exception = re;\r
11737             _errHandler.reportError(this, re);\r
11738             _errHandler.recover(this, re);\r
11739         } finally {\r
11740             exitRule();\r
11741         }\r
11742         return _localctx;\r
11743     }\r
11744 \r
11745     public static class Yang_version_stmtContext extends ParserRuleContext {\r
11746         public StringContext string() {\r
11747             return getRuleContext(StringContext.class, 0);\r
11748         }\r
11749 \r
11750         public StmtendContext stmtend() {\r
11751             return getRuleContext(StmtendContext.class, 0);\r
11752         }\r
11753 \r
11754         public TerminalNode YANG_VERSION_KEYWORD() {\r
11755             return getToken(YangParser.YANG_VERSION_KEYWORD, 0);\r
11756         }\r
11757 \r
11758         public Yang_version_stmtContext(ParserRuleContext parent,\r
11759                 int invokingState) {\r
11760             super(parent, invokingState);\r
11761         }\r
11762 \r
11763         @Override\r
11764         public int getRuleIndex() {\r
11765             return RULE_yang_version_stmt;\r
11766         }\r
11767 \r
11768         @Override\r
11769         public void enterRule(ParseTreeListener listener) {\r
11770             if (listener instanceof YangParserListener)\r
11771                 ((YangParserListener) listener).enterYang_version_stmt(this);\r
11772         }\r
11773 \r
11774         @Override\r
11775         public void exitRule(ParseTreeListener listener) {\r
11776             if (listener instanceof YangParserListener)\r
11777                 ((YangParserListener) listener).exitYang_version_stmt(this);\r
11778         }\r
11779 \r
11780         @Override\r
11781         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
11782             if (visitor instanceof YangParserVisitor)\r
11783                 return ((YangParserVisitor<? extends T>) visitor)\r
11784                         .visitYang_version_stmt(this);\r
11785             else\r
11786                 return visitor.visitChildren(this);\r
11787         }\r
11788     }\r
11789 \r
11790     public final Yang_version_stmtContext yang_version_stmt()\r
11791             throws RecognitionException {\r
11792         Yang_version_stmtContext _localctx = new Yang_version_stmtContext(_ctx,\r
11793                 getState());\r
11794         enterRule(_localctx, 192, RULE_yang_version_stmt);\r
11795         try {\r
11796             enterOuterAlt(_localctx, 1);\r
11797             {\r
11798                 setState(1125);\r
11799                 match(YANG_VERSION_KEYWORD);\r
11800                 setState(1126);\r
11801                 string();\r
11802                 setState(1127);\r
11803                 stmtend();\r
11804             }\r
11805         } catch (RecognitionException re) {\r
11806             _localctx.exception = re;\r
11807             _errHandler.reportError(this, re);\r
11808             _errHandler.recover(this, re);\r
11809         } finally {\r
11810             exitRule();\r
11811         }\r
11812         return _localctx;\r
11813     }\r
11814 \r
11815     public static class Data_def_stmtContext extends ParserRuleContext {\r
11816         public Uses_stmtContext uses_stmt() {\r
11817             return getRuleContext(Uses_stmtContext.class, 0);\r
11818         }\r
11819 \r
11820         public Anyxml_stmtContext anyxml_stmt() {\r
11821             return getRuleContext(Anyxml_stmtContext.class, 0);\r
11822         }\r
11823 \r
11824         public List_stmtContext list_stmt() {\r
11825             return getRuleContext(List_stmtContext.class, 0);\r
11826         }\r
11827 \r
11828         public Leaf_stmtContext leaf_stmt() {\r
11829             return getRuleContext(Leaf_stmtContext.class, 0);\r
11830         }\r
11831 \r
11832         public Container_stmtContext container_stmt() {\r
11833             return getRuleContext(Container_stmtContext.class, 0);\r
11834         }\r
11835 \r
11836         public Choice_stmtContext choice_stmt() {\r
11837             return getRuleContext(Choice_stmtContext.class, 0);\r
11838         }\r
11839 \r
11840         public Leaf_list_stmtContext leaf_list_stmt() {\r
11841             return getRuleContext(Leaf_list_stmtContext.class, 0);\r
11842         }\r
11843 \r
11844         public Data_def_stmtContext(ParserRuleContext parent, int invokingState) {\r
11845             super(parent, invokingState);\r
11846         }\r
11847 \r
11848         @Override\r
11849         public int getRuleIndex() {\r
11850             return RULE_data_def_stmt;\r
11851         }\r
11852 \r
11853         @Override\r
11854         public void enterRule(ParseTreeListener listener) {\r
11855             if (listener instanceof YangParserListener)\r
11856                 ((YangParserListener) listener).enterData_def_stmt(this);\r
11857         }\r
11858 \r
11859         @Override\r
11860         public void exitRule(ParseTreeListener listener) {\r
11861             if (listener instanceof YangParserListener)\r
11862                 ((YangParserListener) listener).exitData_def_stmt(this);\r
11863         }\r
11864 \r
11865         @Override\r
11866         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
11867             if (visitor instanceof YangParserVisitor)\r
11868                 return ((YangParserVisitor<? extends T>) visitor)\r
11869                         .visitData_def_stmt(this);\r
11870             else\r
11871                 return visitor.visitChildren(this);\r
11872         }\r
11873     }\r
11874 \r
11875     public final Data_def_stmtContext data_def_stmt()\r
11876             throws RecognitionException {\r
11877         Data_def_stmtContext _localctx = new Data_def_stmtContext(_ctx,\r
11878                 getState());\r
11879         enterRule(_localctx, 194, RULE_data_def_stmt);\r
11880         try {\r
11881             setState(1136);\r
11882             switch (_input.LA(1)) {\r
11883             case CONTAINER_KEYWORD:\r
11884                 enterOuterAlt(_localctx, 1);\r
11885                 {\r
11886                     setState(1129);\r
11887                     container_stmt();\r
11888                 }\r
11889                 break;\r
11890             case LEAF_KEYWORD:\r
11891                 enterOuterAlt(_localctx, 2);\r
11892                 {\r
11893                     setState(1130);\r
11894                     leaf_stmt();\r
11895                 }\r
11896                 break;\r
11897             case LEAF_LIST_KEYWORD:\r
11898                 enterOuterAlt(_localctx, 3);\r
11899                 {\r
11900                     setState(1131);\r
11901                     leaf_list_stmt();\r
11902                 }\r
11903                 break;\r
11904             case LIST_KEYWORD:\r
11905                 enterOuterAlt(_localctx, 4);\r
11906                 {\r
11907                     setState(1132);\r
11908                     list_stmt();\r
11909                 }\r
11910                 break;\r
11911             case CHOICE_KEYWORD:\r
11912                 enterOuterAlt(_localctx, 5);\r
11913                 {\r
11914                     setState(1133);\r
11915                     choice_stmt();\r
11916                 }\r
11917                 break;\r
11918             case ANYXML_KEYWORD:\r
11919                 enterOuterAlt(_localctx, 6);\r
11920                 {\r
11921                     setState(1134);\r
11922                     anyxml_stmt();\r
11923                 }\r
11924                 break;\r
11925             case USES_KEYWORD:\r
11926                 enterOuterAlt(_localctx, 7);\r
11927                 {\r
11928                     setState(1135);\r
11929                     uses_stmt();\r
11930                 }\r
11931                 break;\r
11932             default:\r
11933                 throw new NoViableAltException(this);\r
11934             }\r
11935         } catch (RecognitionException re) {\r
11936             _localctx.exception = re;\r
11937             _errHandler.reportError(this, re);\r
11938             _errHandler.recover(this, re);\r
11939         } finally {\r
11940             exitRule();\r
11941         }\r
11942         return _localctx;\r
11943     }\r
11944 \r
11945     public static class Body_stmtsContext extends ParserRuleContext {\r
11946         public List<Grouping_stmtContext> grouping_stmt() {\r
11947             return getRuleContexts(Grouping_stmtContext.class);\r
11948         }\r
11949 \r
11950         public List<Feature_stmtContext> feature_stmt() {\r
11951             return getRuleContexts(Feature_stmtContext.class);\r
11952         }\r
11953 \r
11954         public Identity_stmtContext identity_stmt(int i) {\r
11955             return getRuleContext(Identity_stmtContext.class, i);\r
11956         }\r
11957 \r
11958         public Typedef_stmtContext typedef_stmt(int i) {\r
11959             return getRuleContext(Typedef_stmtContext.class, i);\r
11960         }\r
11961 \r
11962         public List<Notification_stmtContext> notification_stmt() {\r
11963             return getRuleContexts(Notification_stmtContext.class);\r
11964         }\r
11965 \r
11966         public Grouping_stmtContext grouping_stmt(int i) {\r
11967             return getRuleContext(Grouping_stmtContext.class, i);\r
11968         }\r
11969 \r
11970         public Deviation_stmtContext deviation_stmt(int i) {\r
11971             return getRuleContext(Deviation_stmtContext.class, i);\r
11972         }\r
11973 \r
11974         public Rpc_stmtContext rpc_stmt(int i) {\r
11975             return getRuleContext(Rpc_stmtContext.class, i);\r
11976         }\r
11977 \r
11978         public Feature_stmtContext feature_stmt(int i) {\r
11979             return getRuleContext(Feature_stmtContext.class, i);\r
11980         }\r
11981 \r
11982         public List<Augment_stmtContext> augment_stmt() {\r
11983             return getRuleContexts(Augment_stmtContext.class);\r
11984         }\r
11985 \r
11986         public List<Rpc_stmtContext> rpc_stmt() {\r
11987             return getRuleContexts(Rpc_stmtContext.class);\r
11988         }\r
11989 \r
11990         public List<Typedef_stmtContext> typedef_stmt() {\r
11991             return getRuleContexts(Typedef_stmtContext.class);\r
11992         }\r
11993 \r
11994         public Data_def_stmtContext data_def_stmt(int i) {\r
11995             return getRuleContext(Data_def_stmtContext.class, i);\r
11996         }\r
11997 \r
11998         public List<Extension_stmtContext> extension_stmt() {\r
11999             return getRuleContexts(Extension_stmtContext.class);\r
12000         }\r
12001 \r
12002         public Extension_stmtContext extension_stmt(int i) {\r
12003             return getRuleContext(Extension_stmtContext.class, i);\r
12004         }\r
12005 \r
12006         public List<Data_def_stmtContext> data_def_stmt() {\r
12007             return getRuleContexts(Data_def_stmtContext.class);\r
12008         }\r
12009 \r
12010         public List<Identity_stmtContext> identity_stmt() {\r
12011             return getRuleContexts(Identity_stmtContext.class);\r
12012         }\r
12013 \r
12014         public List<Deviation_stmtContext> deviation_stmt() {\r
12015             return getRuleContexts(Deviation_stmtContext.class);\r
12016         }\r
12017 \r
12018         public Augment_stmtContext augment_stmt(int i) {\r
12019             return getRuleContext(Augment_stmtContext.class, i);\r
12020         }\r
12021 \r
12022         public Notification_stmtContext notification_stmt(int i) {\r
12023             return getRuleContext(Notification_stmtContext.class, i);\r
12024         }\r
12025 \r
12026         public Body_stmtsContext(ParserRuleContext parent, int invokingState) {\r
12027             super(parent, invokingState);\r
12028         }\r
12029 \r
12030         @Override\r
12031         public int getRuleIndex() {\r
12032             return RULE_body_stmts;\r
12033         }\r
12034 \r
12035         @Override\r
12036         public void enterRule(ParseTreeListener listener) {\r
12037             if (listener instanceof YangParserListener)\r
12038                 ((YangParserListener) listener).enterBody_stmts(this);\r
12039         }\r
12040 \r
12041         @Override\r
12042         public void exitRule(ParseTreeListener listener) {\r
12043             if (listener instanceof YangParserListener)\r
12044                 ((YangParserListener) listener).exitBody_stmts(this);\r
12045         }\r
12046 \r
12047         @Override\r
12048         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
12049             if (visitor instanceof YangParserVisitor)\r
12050                 return ((YangParserVisitor<? extends T>) visitor)\r
12051                         .visitBody_stmts(this);\r
12052             else\r
12053                 return visitor.visitChildren(this);\r
12054         }\r
12055     }\r
12056 \r
12057     public final Body_stmtsContext body_stmts() throws RecognitionException {\r
12058         Body_stmtsContext _localctx = new Body_stmtsContext(_ctx, getState());\r
12059         enterRule(_localctx, 196, RULE_body_stmts);\r
12060         int _la;\r
12061         try {\r
12062             enterOuterAlt(_localctx, 1);\r
12063             {\r
12064                 setState(1152);\r
12065                 _errHandler.sync(this);\r
12066                 _la = _input.LA(1);\r
12067                 while (((((_la - 12)) & ~0x3f) == 0 && ((1L << (_la - 12)) & ((1L << (USES_KEYWORD - 12))\r
12068                         | (1L << (TYPEDEF_KEYWORD - 12))\r
12069                         | (1L << (RPC_KEYWORD - 12))\r
12070                         | (1L << (NOTIFICATION_KEYWORD - 12))\r
12071                         | (1L << (LIST_KEYWORD - 12))\r
12072                         | (1L << (LEAF_LIST_KEYWORD - 12))\r
12073                         | (1L << (LEAF_KEYWORD - 12))\r
12074                         | (1L << (IDENTITY_KEYWORD - 12))\r
12075                         | (1L << (GROUPING_KEYWORD - 12))\r
12076                         | (1L << (FEATURE_KEYWORD - 12))\r
12077                         | (1L << (DEVIATION_KEYWORD - 12))\r
12078                         | (1L << (EXTENSION_KEYWORD - 12))\r
12079                         | (1L << (CONTAINER_KEYWORD - 12))\r
12080                         | (1L << (CHOICE_KEYWORD - 12))\r
12081                         | (1L << (AUGMENT_KEYWORD - 12)) | (1L << (ANYXML_KEYWORD - 12)))) != 0)) {\r
12082                     {\r
12083                         {\r
12084                             setState(1148);\r
12085                             switch (_input.LA(1)) {\r
12086                             case EXTENSION_KEYWORD: {\r
12087                                 setState(1138);\r
12088                                 extension_stmt();\r
12089                             }\r
12090                                 break;\r
12091                             case FEATURE_KEYWORD: {\r
12092                                 setState(1139);\r
12093                                 feature_stmt();\r
12094                             }\r
12095                                 break;\r
12096                             case IDENTITY_KEYWORD: {\r
12097                                 setState(1140);\r
12098                                 identity_stmt();\r
12099                             }\r
12100                                 break;\r
12101                             case TYPEDEF_KEYWORD: {\r
12102                                 setState(1141);\r
12103                                 typedef_stmt();\r
12104                             }\r
12105                                 break;\r
12106                             case GROUPING_KEYWORD: {\r
12107                                 setState(1142);\r
12108                                 grouping_stmt();\r
12109                             }\r
12110                                 break;\r
12111                             case USES_KEYWORD:\r
12112                             case LIST_KEYWORD:\r
12113                             case LEAF_LIST_KEYWORD:\r
12114                             case LEAF_KEYWORD:\r
12115                             case CONTAINER_KEYWORD:\r
12116                             case CHOICE_KEYWORD:\r
12117                             case ANYXML_KEYWORD: {\r
12118                                 setState(1143);\r
12119                                 data_def_stmt();\r
12120                             }\r
12121                                 break;\r
12122                             case AUGMENT_KEYWORD: {\r
12123                                 setState(1144);\r
12124                                 augment_stmt();\r
12125                             }\r
12126                                 break;\r
12127                             case RPC_KEYWORD: {\r
12128                                 setState(1145);\r
12129                                 rpc_stmt();\r
12130                             }\r
12131                                 break;\r
12132                             case NOTIFICATION_KEYWORD: {\r
12133                                 setState(1146);\r
12134                                 notification_stmt();\r
12135                             }\r
12136                                 break;\r
12137                             case DEVIATION_KEYWORD: {\r
12138                                 setState(1147);\r
12139                                 deviation_stmt();\r
12140                             }\r
12141                                 break;\r
12142                             default:\r
12143                                 throw new NoViableAltException(this);\r
12144                             }\r
12145                         }\r
12146                     }\r
12147                     setState(1154);\r
12148                     _errHandler.sync(this);\r
12149                     _la = _input.LA(1);\r
12150                 }\r
12151             }\r
12152         } catch (RecognitionException re) {\r
12153             _localctx.exception = re;\r
12154             _errHandler.reportError(this, re);\r
12155             _errHandler.recover(this, re);\r
12156         } finally {\r
12157             exitRule();\r
12158         }\r
12159         return _localctx;\r
12160     }\r
12161 \r
12162     public static class Revision_stmtsContext extends ParserRuleContext {\r
12163         public List<Revision_stmtContext> revision_stmt() {\r
12164             return getRuleContexts(Revision_stmtContext.class);\r
12165         }\r
12166 \r
12167         public Revision_stmtContext revision_stmt(int i) {\r
12168             return getRuleContext(Revision_stmtContext.class, i);\r
12169         }\r
12170 \r
12171         public Revision_stmtsContext(ParserRuleContext parent, int invokingState) {\r
12172             super(parent, invokingState);\r
12173         }\r
12174 \r
12175         @Override\r
12176         public int getRuleIndex() {\r
12177             return RULE_revision_stmts;\r
12178         }\r
12179 \r
12180         @Override\r
12181         public void enterRule(ParseTreeListener listener) {\r
12182             if (listener instanceof YangParserListener)\r
12183                 ((YangParserListener) listener).enterRevision_stmts(this);\r
12184         }\r
12185 \r
12186         @Override\r
12187         public void exitRule(ParseTreeListener listener) {\r
12188             if (listener instanceof YangParserListener)\r
12189                 ((YangParserListener) listener).exitRevision_stmts(this);\r
12190         }\r
12191 \r
12192         @Override\r
12193         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
12194             if (visitor instanceof YangParserVisitor)\r
12195                 return ((YangParserVisitor<? extends T>) visitor)\r
12196                         .visitRevision_stmts(this);\r
12197             else\r
12198                 return visitor.visitChildren(this);\r
12199         }\r
12200     }\r
12201 \r
12202     public final Revision_stmtsContext revision_stmts()\r
12203             throws RecognitionException {\r
12204         Revision_stmtsContext _localctx = new Revision_stmtsContext(_ctx,\r
12205                 getState());\r
12206         enterRule(_localctx, 198, RULE_revision_stmts);\r
12207         int _la;\r
12208         try {\r
12209             enterOuterAlt(_localctx, 1);\r
12210             {\r
12211                 setState(1158);\r
12212                 _errHandler.sync(this);\r
12213                 _la = _input.LA(1);\r
12214                 while (_la == REVISION_KEYWORD) {\r
12215                     {\r
12216                         {\r
12217                             setState(1155);\r
12218                             revision_stmt();\r
12219                         }\r
12220                     }\r
12221                     setState(1160);\r
12222                     _errHandler.sync(this);\r
12223                     _la = _input.LA(1);\r
12224                 }\r
12225             }\r
12226         } catch (RecognitionException re) {\r
12227             _localctx.exception = re;\r
12228             _errHandler.reportError(this, re);\r
12229             _errHandler.recover(this, re);\r
12230         } finally {\r
12231             exitRule();\r
12232         }\r
12233         return _localctx;\r
12234     }\r
12235 \r
12236     public static class Linkage_stmtsContext extends ParserRuleContext {\r
12237         public List<Include_stmtContext> include_stmt() {\r
12238             return getRuleContexts(Include_stmtContext.class);\r
12239         }\r
12240 \r
12241         public Import_stmtContext import_stmt(int i) {\r
12242             return getRuleContext(Import_stmtContext.class, i);\r
12243         }\r
12244 \r
12245         public Include_stmtContext include_stmt(int i) {\r
12246             return getRuleContext(Include_stmtContext.class, i);\r
12247         }\r
12248 \r
12249         public List<Import_stmtContext> import_stmt() {\r
12250             return getRuleContexts(Import_stmtContext.class);\r
12251         }\r
12252 \r
12253         public Linkage_stmtsContext(ParserRuleContext parent, int invokingState) {\r
12254             super(parent, invokingState);\r
12255         }\r
12256 \r
12257         @Override\r
12258         public int getRuleIndex() {\r
12259             return RULE_linkage_stmts;\r
12260         }\r
12261 \r
12262         @Override\r
12263         public void enterRule(ParseTreeListener listener) {\r
12264             if (listener instanceof YangParserListener)\r
12265                 ((YangParserListener) listener).enterLinkage_stmts(this);\r
12266         }\r
12267 \r
12268         @Override\r
12269         public void exitRule(ParseTreeListener listener) {\r
12270             if (listener instanceof YangParserListener)\r
12271                 ((YangParserListener) listener).exitLinkage_stmts(this);\r
12272         }\r
12273 \r
12274         @Override\r
12275         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
12276             if (visitor instanceof YangParserVisitor)\r
12277                 return ((YangParserVisitor<? extends T>) visitor)\r
12278                         .visitLinkage_stmts(this);\r
12279             else\r
12280                 return visitor.visitChildren(this);\r
12281         }\r
12282     }\r
12283 \r
12284     public final Linkage_stmtsContext linkage_stmts()\r
12285             throws RecognitionException {\r
12286         Linkage_stmtsContext _localctx = new Linkage_stmtsContext(_ctx,\r
12287                 getState());\r
12288         enterRule(_localctx, 200, RULE_linkage_stmts);\r
12289         int _la;\r
12290         try {\r
12291             enterOuterAlt(_localctx, 1);\r
12292             {\r
12293                 setState(1165);\r
12294                 _errHandler.sync(this);\r
12295                 _la = _input.LA(1);\r
12296                 while (_la == INCLUDE_KEYWORD || _la == IMPORT_KEYWORD) {\r
12297                     {\r
12298                         setState(1163);\r
12299                         switch (_input.LA(1)) {\r
12300                         case IMPORT_KEYWORD: {\r
12301                             setState(1161);\r
12302                             import_stmt();\r
12303                         }\r
12304                             break;\r
12305                         case INCLUDE_KEYWORD: {\r
12306                             setState(1162);\r
12307                             include_stmt();\r
12308                         }\r
12309                             break;\r
12310                         default:\r
12311                             throw new NoViableAltException(this);\r
12312                         }\r
12313                     }\r
12314                     setState(1167);\r
12315                     _errHandler.sync(this);\r
12316                     _la = _input.LA(1);\r
12317                 }\r
12318             }\r
12319         } catch (RecognitionException re) {\r
12320             _localctx.exception = re;\r
12321             _errHandler.reportError(this, re);\r
12322             _errHandler.recover(this, re);\r
12323         } finally {\r
12324             exitRule();\r
12325         }\r
12326         return _localctx;\r
12327     }\r
12328 \r
12329     public static class Meta_stmtsContext extends ParserRuleContext {\r
12330         public List<Reference_stmtContext> reference_stmt() {\r
12331             return getRuleContexts(Reference_stmtContext.class);\r
12332         }\r
12333 \r
12334         public Description_stmtContext description_stmt(int i) {\r
12335             return getRuleContext(Description_stmtContext.class, i);\r
12336         }\r
12337 \r
12338         public Organization_stmtContext organization_stmt(int i) {\r
12339             return getRuleContext(Organization_stmtContext.class, i);\r
12340         }\r
12341 \r
12342         public Contact_stmtContext contact_stmt(int i) {\r
12343             return getRuleContext(Contact_stmtContext.class, i);\r
12344         }\r
12345 \r
12346         public List<Contact_stmtContext> contact_stmt() {\r
12347             return getRuleContexts(Contact_stmtContext.class);\r
12348         }\r
12349 \r
12350         public List<Organization_stmtContext> organization_stmt() {\r
12351             return getRuleContexts(Organization_stmtContext.class);\r
12352         }\r
12353 \r
12354         public List<Description_stmtContext> description_stmt() {\r
12355             return getRuleContexts(Description_stmtContext.class);\r
12356         }\r
12357 \r
12358         public Reference_stmtContext reference_stmt(int i) {\r
12359             return getRuleContext(Reference_stmtContext.class, i);\r
12360         }\r
12361 \r
12362         public Meta_stmtsContext(ParserRuleContext parent, int invokingState) {\r
12363             super(parent, invokingState);\r
12364         }\r
12365 \r
12366         @Override\r
12367         public int getRuleIndex() {\r
12368             return RULE_meta_stmts;\r
12369         }\r
12370 \r
12371         @Override\r
12372         public void enterRule(ParseTreeListener listener) {\r
12373             if (listener instanceof YangParserListener)\r
12374                 ((YangParserListener) listener).enterMeta_stmts(this);\r
12375         }\r
12376 \r
12377         @Override\r
12378         public void exitRule(ParseTreeListener listener) {\r
12379             if (listener instanceof YangParserListener)\r
12380                 ((YangParserListener) listener).exitMeta_stmts(this);\r
12381         }\r
12382 \r
12383         @Override\r
12384         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
12385             if (visitor instanceof YangParserVisitor)\r
12386                 return ((YangParserVisitor<? extends T>) visitor)\r
12387                         .visitMeta_stmts(this);\r
12388             else\r
12389                 return visitor.visitChildren(this);\r
12390         }\r
12391     }\r
12392 \r
12393     public final Meta_stmtsContext meta_stmts() throws RecognitionException {\r
12394         Meta_stmtsContext _localctx = new Meta_stmtsContext(_ctx, getState());\r
12395         enterRule(_localctx, 202, RULE_meta_stmts);\r
12396         int _la;\r
12397         try {\r
12398             enterOuterAlt(_localctx, 1);\r
12399             {\r
12400                 setState(1174);\r
12401                 _errHandler.sync(this);\r
12402                 _la = _input.LA(1);\r
12403                 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << REFERENCE_KEYWORD)\r
12404                         | (1L << ORGANIZATION_KEYWORD)\r
12405                         | (1L << DESCRIPTION_KEYWORD) | (1L << CONTACT_KEYWORD))) != 0)) {\r
12406                     {\r
12407                         setState(1172);\r
12408                         switch (_input.LA(1)) {\r
12409                         case ORGANIZATION_KEYWORD: {\r
12410                             setState(1168);\r
12411                             organization_stmt();\r
12412                         }\r
12413                             break;\r
12414                         case CONTACT_KEYWORD: {\r
12415                             setState(1169);\r
12416                             contact_stmt();\r
12417                         }\r
12418                             break;\r
12419                         case DESCRIPTION_KEYWORD: {\r
12420                             setState(1170);\r
12421                             description_stmt();\r
12422                         }\r
12423                             break;\r
12424                         case REFERENCE_KEYWORD: {\r
12425                             setState(1171);\r
12426                             reference_stmt();\r
12427                         }\r
12428                             break;\r
12429                         default:\r
12430                             throw new NoViableAltException(this);\r
12431                         }\r
12432                     }\r
12433                     setState(1176);\r
12434                     _errHandler.sync(this);\r
12435                     _la = _input.LA(1);\r
12436                 }\r
12437             }\r
12438         } catch (RecognitionException re) {\r
12439             _localctx.exception = re;\r
12440             _errHandler.reportError(this, re);\r
12441             _errHandler.recover(this, re);\r
12442         } finally {\r
12443             exitRule();\r
12444         }\r
12445         return _localctx;\r
12446     }\r
12447 \r
12448     public static class Submodule_header_stmtsContext extends ParserRuleContext {\r
12449         public Belongs_to_stmtContext belongs_to_stmt(int i) {\r
12450             return getRuleContext(Belongs_to_stmtContext.class, i);\r
12451         }\r
12452 \r
12453         public List<Belongs_to_stmtContext> belongs_to_stmt() {\r
12454             return getRuleContexts(Belongs_to_stmtContext.class);\r
12455         }\r
12456 \r
12457         public Yang_version_stmtContext yang_version_stmt(int i) {\r
12458             return getRuleContext(Yang_version_stmtContext.class, i);\r
12459         }\r
12460 \r
12461         public List<Yang_version_stmtContext> yang_version_stmt() {\r
12462             return getRuleContexts(Yang_version_stmtContext.class);\r
12463         }\r
12464 \r
12465         public Submodule_header_stmtsContext(ParserRuleContext parent,\r
12466                 int invokingState) {\r
12467             super(parent, invokingState);\r
12468         }\r
12469 \r
12470         @Override\r
12471         public int getRuleIndex() {\r
12472             return RULE_submodule_header_stmts;\r
12473         }\r
12474 \r
12475         @Override\r
12476         public void enterRule(ParseTreeListener listener) {\r
12477             if (listener instanceof YangParserListener)\r
12478                 ((YangParserListener) listener)\r
12479                         .enterSubmodule_header_stmts(this);\r
12480         }\r
12481 \r
12482         @Override\r
12483         public void exitRule(ParseTreeListener listener) {\r
12484             if (listener instanceof YangParserListener)\r
12485                 ((YangParserListener) listener)\r
12486                         .exitSubmodule_header_stmts(this);\r
12487         }\r
12488 \r
12489         @Override\r
12490         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
12491             if (visitor instanceof YangParserVisitor)\r
12492                 return ((YangParserVisitor<? extends T>) visitor)\r
12493                         .visitSubmodule_header_stmts(this);\r
12494             else\r
12495                 return visitor.visitChildren(this);\r
12496         }\r
12497     }\r
12498 \r
12499     public final Submodule_header_stmtsContext submodule_header_stmts()\r
12500             throws RecognitionException {\r
12501         Submodule_header_stmtsContext _localctx = new Submodule_header_stmtsContext(\r
12502                 _ctx, getState());\r
12503         enterRule(_localctx, 204, RULE_submodule_header_stmts);\r
12504         int _la;\r
12505         try {\r
12506             enterOuterAlt(_localctx, 1);\r
12507             {\r
12508                 setState(1179);\r
12509                 _errHandler.sync(this);\r
12510                 _la = _input.LA(1);\r
12511                 do {\r
12512                     {\r
12513                         setState(1179);\r
12514                         switch (_input.LA(1)) {\r
12515                         case YANG_VERSION_KEYWORD: {\r
12516                             setState(1177);\r
12517                             yang_version_stmt();\r
12518                         }\r
12519                             break;\r
12520                         case BELONGS_TO_KEYWORD: {\r
12521                             setState(1178);\r
12522                             belongs_to_stmt();\r
12523                         }\r
12524                             break;\r
12525                         default:\r
12526                             throw new NoViableAltException(this);\r
12527                         }\r
12528                     }\r
12529                     setState(1181);\r
12530                     _errHandler.sync(this);\r
12531                     _la = _input.LA(1);\r
12532                 } while (_la == YANG_VERSION_KEYWORD\r
12533                         || _la == BELONGS_TO_KEYWORD);\r
12534             }\r
12535         } catch (RecognitionException re) {\r
12536             _localctx.exception = re;\r
12537             _errHandler.reportError(this, re);\r
12538             _errHandler.recover(this, re);\r
12539         } finally {\r
12540             exitRule();\r
12541         }\r
12542         return _localctx;\r
12543     }\r
12544 \r
12545     public static class Module_header_stmtsContext extends ParserRuleContext {\r
12546         public List<Namespace_stmtContext> namespace_stmt() {\r
12547             return getRuleContexts(Namespace_stmtContext.class);\r
12548         }\r
12549 \r
12550         public Namespace_stmtContext namespace_stmt(int i) {\r
12551             return getRuleContext(Namespace_stmtContext.class, i);\r
12552         }\r
12553 \r
12554         public Yang_version_stmtContext yang_version_stmt(int i) {\r
12555             return getRuleContext(Yang_version_stmtContext.class, i);\r
12556         }\r
12557 \r
12558         public Prefix_stmtContext prefix_stmt(int i) {\r
12559             return getRuleContext(Prefix_stmtContext.class, i);\r
12560         }\r
12561 \r
12562         public List<Prefix_stmtContext> prefix_stmt() {\r
12563             return getRuleContexts(Prefix_stmtContext.class);\r
12564         }\r
12565 \r
12566         public List<Yang_version_stmtContext> yang_version_stmt() {\r
12567             return getRuleContexts(Yang_version_stmtContext.class);\r
12568         }\r
12569 \r
12570         public Module_header_stmtsContext(ParserRuleContext parent,\r
12571                 int invokingState) {\r
12572             super(parent, invokingState);\r
12573         }\r
12574 \r
12575         @Override\r
12576         public int getRuleIndex() {\r
12577             return RULE_module_header_stmts;\r
12578         }\r
12579 \r
12580         @Override\r
12581         public void enterRule(ParseTreeListener listener) {\r
12582             if (listener instanceof YangParserListener)\r
12583                 ((YangParserListener) listener).enterModule_header_stmts(this);\r
12584         }\r
12585 \r
12586         @Override\r
12587         public void exitRule(ParseTreeListener listener) {\r
12588             if (listener instanceof YangParserListener)\r
12589                 ((YangParserListener) listener).exitModule_header_stmts(this);\r
12590         }\r
12591 \r
12592         @Override\r
12593         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
12594             if (visitor instanceof YangParserVisitor)\r
12595                 return ((YangParserVisitor<? extends T>) visitor)\r
12596                         .visitModule_header_stmts(this);\r
12597             else\r
12598                 return visitor.visitChildren(this);\r
12599         }\r
12600     }\r
12601 \r
12602     public final Module_header_stmtsContext module_header_stmts()\r
12603             throws RecognitionException {\r
12604         Module_header_stmtsContext _localctx = new Module_header_stmtsContext(\r
12605                 _ctx, getState());\r
12606         enterRule(_localctx, 206, RULE_module_header_stmts);\r
12607         int _la;\r
12608         try {\r
12609             enterOuterAlt(_localctx, 1);\r
12610             {\r
12611                 setState(1186);\r
12612                 _errHandler.sync(this);\r
12613                 _la = _input.LA(1);\r
12614                 do {\r
12615                     {\r
12616                         setState(1186);\r
12617                         switch (_input.LA(1)) {\r
12618                         case YANG_VERSION_KEYWORD: {\r
12619                             setState(1183);\r
12620                             yang_version_stmt();\r
12621                         }\r
12622                             break;\r
12623                         case NAMESPACE_KEYWORD: {\r
12624                             setState(1184);\r
12625                             namespace_stmt();\r
12626                         }\r
12627                             break;\r
12628                         case PREFIX_KEYWORD: {\r
12629                             setState(1185);\r
12630                             prefix_stmt();\r
12631                         }\r
12632                             break;\r
12633                         default:\r
12634                             throw new NoViableAltException(this);\r
12635                         }\r
12636                     }\r
12637                     setState(1188);\r
12638                     _errHandler.sync(this);\r
12639                     _la = _input.LA(1);\r
12640                 } while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << YANG_VERSION_KEYWORD)\r
12641                         | (1L << PREFIX_KEYWORD) | (1L << NAMESPACE_KEYWORD))) != 0));\r
12642             }\r
12643         } catch (RecognitionException re) {\r
12644             _localctx.exception = re;\r
12645             _errHandler.reportError(this, re);\r
12646             _errHandler.recover(this, re);\r
12647         } finally {\r
12648             exitRule();\r
12649         }\r
12650         return _localctx;\r
12651     }\r
12652 \r
12653     public static class Submodule_stmtContext extends ParserRuleContext {\r
12654         public TerminalNode RIGHT_BRACE() {\r
12655             return getToken(YangParser.RIGHT_BRACE, 0);\r
12656         }\r
12657 \r
12658         public Linkage_stmtsContext linkage_stmts() {\r
12659             return getRuleContext(Linkage_stmtsContext.class, 0);\r
12660         }\r
12661 \r
12662         public Revision_stmtsContext revision_stmts() {\r
12663             return getRuleContext(Revision_stmtsContext.class, 0);\r
12664         }\r
12665 \r
12666         public StringContext string() {\r
12667             return getRuleContext(StringContext.class, 0);\r
12668         }\r
12669 \r
12670         public Body_stmtsContext body_stmts() {\r
12671             return getRuleContext(Body_stmtsContext.class, 0);\r
12672         }\r
12673 \r
12674         public TerminalNode LEFT_BRACE() {\r
12675             return getToken(YangParser.LEFT_BRACE, 0);\r
12676         }\r
12677 \r
12678         public TerminalNode SUBMODULE_KEYWORD() {\r
12679             return getToken(YangParser.SUBMODULE_KEYWORD, 0);\r
12680         }\r
12681 \r
12682         public Submodule_header_stmtsContext submodule_header_stmts() {\r
12683             return getRuleContext(Submodule_header_stmtsContext.class, 0);\r
12684         }\r
12685 \r
12686         public Meta_stmtsContext meta_stmts() {\r
12687             return getRuleContext(Meta_stmtsContext.class, 0);\r
12688         }\r
12689 \r
12690         public Submodule_stmtContext(ParserRuleContext parent, int invokingState) {\r
12691             super(parent, invokingState);\r
12692         }\r
12693 \r
12694         @Override\r
12695         public int getRuleIndex() {\r
12696             return RULE_submodule_stmt;\r
12697         }\r
12698 \r
12699         @Override\r
12700         public void enterRule(ParseTreeListener listener) {\r
12701             if (listener instanceof YangParserListener)\r
12702                 ((YangParserListener) listener).enterSubmodule_stmt(this);\r
12703         }\r
12704 \r
12705         @Override\r
12706         public void exitRule(ParseTreeListener listener) {\r
12707             if (listener instanceof YangParserListener)\r
12708                 ((YangParserListener) listener).exitSubmodule_stmt(this);\r
12709         }\r
12710 \r
12711         @Override\r
12712         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
12713             if (visitor instanceof YangParserVisitor)\r
12714                 return ((YangParserVisitor<? extends T>) visitor)\r
12715                         .visitSubmodule_stmt(this);\r
12716             else\r
12717                 return visitor.visitChildren(this);\r
12718         }\r
12719     }\r
12720 \r
12721     public final Submodule_stmtContext submodule_stmt()\r
12722             throws RecognitionException {\r
12723         Submodule_stmtContext _localctx = new Submodule_stmtContext(_ctx,\r
12724                 getState());\r
12725         enterRule(_localctx, 208, RULE_submodule_stmt);\r
12726         try {\r
12727             enterOuterAlt(_localctx, 1);\r
12728             {\r
12729                 setState(1190);\r
12730                 match(SUBMODULE_KEYWORD);\r
12731                 setState(1191);\r
12732                 string();\r
12733                 setState(1192);\r
12734                 match(LEFT_BRACE);\r
12735                 setState(1193);\r
12736                 submodule_header_stmts();\r
12737                 setState(1194);\r
12738                 linkage_stmts();\r
12739                 setState(1195);\r
12740                 meta_stmts();\r
12741                 setState(1196);\r
12742                 revision_stmts();\r
12743                 setState(1197);\r
12744                 body_stmts();\r
12745                 setState(1198);\r
12746                 match(RIGHT_BRACE);\r
12747             }\r
12748         } catch (RecognitionException re) {\r
12749             _localctx.exception = re;\r
12750             _errHandler.reportError(this, re);\r
12751             _errHandler.recover(this, re);\r
12752         } finally {\r
12753             exitRule();\r
12754         }\r
12755         return _localctx;\r
12756     }\r
12757 \r
12758     public static class Module_stmtContext extends ParserRuleContext {\r
12759         public TerminalNode RIGHT_BRACE() {\r
12760             return getToken(YangParser.RIGHT_BRACE, 0);\r
12761         }\r
12762 \r
12763         public Linkage_stmtsContext linkage_stmts() {\r
12764             return getRuleContext(Linkage_stmtsContext.class, 0);\r
12765         }\r
12766 \r
12767         public Revision_stmtsContext revision_stmts() {\r
12768             return getRuleContext(Revision_stmtsContext.class, 0);\r
12769         }\r
12770 \r
12771         public StringContext string() {\r
12772             return getRuleContext(StringContext.class, 0);\r
12773         }\r
12774 \r
12775         public Body_stmtsContext body_stmts() {\r
12776             return getRuleContext(Body_stmtsContext.class, 0);\r
12777         }\r
12778 \r
12779         public Module_header_stmtsContext module_header_stmts() {\r
12780             return getRuleContext(Module_header_stmtsContext.class, 0);\r
12781         }\r
12782 \r
12783         public TerminalNode MODULE_KEYWORD() {\r
12784             return getToken(YangParser.MODULE_KEYWORD, 0);\r
12785         }\r
12786 \r
12787         public TerminalNode LEFT_BRACE() {\r
12788             return getToken(YangParser.LEFT_BRACE, 0);\r
12789         }\r
12790 \r
12791         public Meta_stmtsContext meta_stmts() {\r
12792             return getRuleContext(Meta_stmtsContext.class, 0);\r
12793         }\r
12794 \r
12795         public Module_stmtContext(ParserRuleContext parent, int invokingState) {\r
12796             super(parent, invokingState);\r
12797         }\r
12798 \r
12799         @Override\r
12800         public int getRuleIndex() {\r
12801             return RULE_module_stmt;\r
12802         }\r
12803 \r
12804         @Override\r
12805         public void enterRule(ParseTreeListener listener) {\r
12806             if (listener instanceof YangParserListener)\r
12807                 ((YangParserListener) listener).enterModule_stmt(this);\r
12808         }\r
12809 \r
12810         @Override\r
12811         public void exitRule(ParseTreeListener listener) {\r
12812             if (listener instanceof YangParserListener)\r
12813                 ((YangParserListener) listener).exitModule_stmt(this);\r
12814         }\r
12815 \r
12816         @Override\r
12817         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
12818             if (visitor instanceof YangParserVisitor)\r
12819                 return ((YangParserVisitor<? extends T>) visitor)\r
12820                         .visitModule_stmt(this);\r
12821             else\r
12822                 return visitor.visitChildren(this);\r
12823         }\r
12824     }\r
12825 \r
12826     public final Module_stmtContext module_stmt() throws RecognitionException {\r
12827         Module_stmtContext _localctx = new Module_stmtContext(_ctx, getState());\r
12828         enterRule(_localctx, 210, RULE_module_stmt);\r
12829         try {\r
12830             enterOuterAlt(_localctx, 1);\r
12831             {\r
12832                 setState(1200);\r
12833                 match(MODULE_KEYWORD);\r
12834                 setState(1201);\r
12835                 string();\r
12836                 setState(1202);\r
12837                 match(LEFT_BRACE);\r
12838                 setState(1203);\r
12839                 module_header_stmts();\r
12840                 setState(1204);\r
12841                 linkage_stmts();\r
12842                 setState(1205);\r
12843                 meta_stmts();\r
12844                 setState(1206);\r
12845                 revision_stmts();\r
12846                 setState(1207);\r
12847                 body_stmts();\r
12848                 setState(1208);\r
12849                 match(RIGHT_BRACE);\r
12850             }\r
12851         } catch (RecognitionException re) {\r
12852             _localctx.exception = re;\r
12853             _errHandler.reportError(this, re);\r
12854             _errHandler.recover(this, re);\r
12855         } finally {\r
12856             exitRule();\r
12857         }\r
12858         return _localctx;\r
12859     }\r
12860 \r
12861     public static final String _serializedATN = "\2\3M\u04bd\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4"\r
12862             + "\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20"\r
12863             + "\4\21\t\21\4\22\t\22\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27"\r
12864             + "\4\30\t\30\4\31\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36"\r
12865             + "\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4"\r
12866             + ")\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62"\r
12867             + "\4\63\t\63\4\64\t\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4"\r
12868             + ";\t;\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\t"\r
12869             + "F\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4"\r
12870             + "R\tR\4S\tS\4T\tT\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]"\r
12871             + "\t]\4^\t^\4_\t_\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th"\r
12872             + "\4i\ti\4j\tj\4k\tk\3\2\3\2\5\2\u00d9\n\2\3\3\3\3\3\3\7\3\u00de\n\3\f\3"\r
12873             + "\16\3\u00e1\13\3\3\4\3\4\5\4\u00e5\n\4\3\4\3\4\3\5\3\5\5\5\u00eb\n\5\3"\r
12874             + "\5\3\5\5\5\u00ef\n\5\3\5\5\5\u00f2\n\5\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6"\r
12875             + "\3\6\3\6\3\6\7\6\u00ff\n\6\f\6\16\6\u0102\13\6\3\6\5\6\u0105\n\6\3\7\3"\r
12876             + "\7\3\7\3\7\3\7\3\7\3\7\3\7\7\7\u010f\n\7\f\7\16\7\u0112\13\7\3\7\5\7\u0115"\r
12877             + "\n\7\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\7\b\u0123\n\b\f\b"\r
12878             + "\16\b\u0126\13\b\3\b\5\b\u0129\n\b\3\t\3\t\3\t\3\t\3\t\5\t\u0130\n\t\3"\r
12879             + "\t\5\t\u0133\n\t\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\6\n\u013e\n\n\r\n"\r
12880             + "\16\n\u013f\3\n\3\n\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13"\r
12881             + "\3\13\7\13\u014f\n\13\f\13\16\13\u0152\13\13\3\13\5\13\u0155\n\13\3\f"\r
12882             + "\3\f\3\f\3\f\3\f\6\f\u015c\n\f\r\f\16\f\u015d\3\f\3\f\3\r\3\r\3\r\3\r"\r
12883             + "\3\r\6\r\u0167\n\r\r\r\16\r\u0168\3\r\3\r\3\16\3\16\3\16\3\16\3\16\3\16"\r
12884             + "\3\16\3\16\3\16\3\16\3\16\3\16\7\16\u0179\n\16\f\16\16\16\u017c\13\16"\r
12885             + "\3\16\5\16\u017f\n\16\3\17\3\17\3\17\3\17\3\17\3\17\7\17\u0187\n\17\f"\r
12886             + "\17\16\17\u018a\13\17\3\17\5\17\u018d\n\17\3\20\3\20\3\20\3\20\3\20\3"\r
12887             + "\20\3\20\3\20\3\20\3\20\3\20\6\20\u019a\n\20\r\20\16\20\u019b\3\20\3\20"\r
12888             + "\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\6\21\u01ab\n\21"\r
12889             + "\r\21\16\21\u01ac\3\21\3\21\3\22\3\22\3\22\3\22\3\22\7\22\u01b6\n\22\f"\r
12890             + "\22\16\22\u01b9\13\22\3\23\3\23\7\23\u01bd\n\23\f\23\16\23\u01c0\13\23"\r
12891             + "\3\24\3\24\3\24\3\24\3\24\7\24\u01c7\n\24\f\24\16\24\u01ca\13\24\3\25"\r
12892             + "\3\25\3\25\3\25\3\25\3\25\7\25\u01d2\n\25\f\25\16\25\u01d5\13\25\3\26"\r
12893             + "\3\26\3\26\3\26\3\26\3\26\7\26\u01dd\n\26\f\26\16\26\u01e0\13\26\3\27"\r
12894             + "\3\27\3\27\3\27\3\27\3\27\7\27\u01e8\n\27\f\27\16\27\u01eb\13\27\3\30"\r
12895             + "\3\30\3\30\3\30\3\30\7\30\u01f2\n\30\f\30\16\30\u01f5\13\30\3\31\3\31"\r
12896             + "\3\31\3\31\3\31\3\31\3\31\5\31\u01fe\n\31\3\32\3\32\3\32\3\32\3\32\6\32"\r
12897             + "\u0205\n\32\r\32\16\32\u0206\3\32\3\32\5\32\u020b\n\32\3\33\3\33\3\33"\r
12898             + "\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\7\33\u0219\n\33\f\33\16"\r
12899             + "\33\u021c\13\33\3\33\5\33\u021f\n\33\3\34\3\34\3\34\3\34\3\34\3\34\3\34"\r
12900             + "\3\34\3\34\3\34\3\34\3\34\3\34\7\34\u022e\n\34\f\34\16\34\u0231\13\34"\r
12901             + "\3\34\5\34\u0234\n\34\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35"\r
12902             + "\3\35\7\35\u0241\n\35\f\35\16\35\u0244\13\35\3\35\5\35\u0247\n\35\3\36"\r
12903             + "\3\36\3\36\3\36\3\36\5\36\u024e\n\36\3\37\3\37\3\37\3\37\3\37\3\37\3\37"\r
12904             + "\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\7\37\u025f\n\37\f\37\16\37\u0262"\r
12905             + "\13\37\3\37\5\37\u0265\n\37\3 \3 \3 \3 \3!\3!\3!\3!\3\"\3\"\3\"\3\"\3"\r
12906             + "\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\6\"\u0282\n"\r
12907             + "\"\r\"\16\"\u0283\3\"\3\"\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3"\r
12908             + "#\3#\7#\u0298\n#\f#\16#\u029b\13#\3#\3#\3$\3$\3$\3$\3$\3$\3$\3$\3$\3$"\r
12909             + "\3$\3$\3$\3$\3$\7$\u02ae\n$\f$\16$\u02b1\13$\3$\3$\3%\3%\3%\3%\3%\3%\3"\r
12910             + "%\3%\3%\3%\3%\3%\3%\3%\3%\3%\7%\u02c5\n%\f%\16%\u02c8\13%\3%\5%\u02cb"\r
12911             + "\n%\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\7&\u02d8\n&\f&\16&\u02db\13&\3&\5"\r
12912             + "&\u02de\n&\3\'\3\'\3\'\3\'\3(\3(\3)\3)\3)\3)\3*\3*\3*\3*\3+\3+\3+\3+\3"\r
12913             + ",\3,\3,\3,\3-\3-\3-\3-\3-\3-\3-\3-\3-\7-\u02ff\n-\f-\16-\u0302\13-\3-"\r
12914             + "\5-\u0305\n-\3.\3.\3/\3/\3/\3/\3\60\3\60\3\60\3\60\3\61\3\61\3\62\3\62"\r
12915             + "\3\62\3\62\3\63\3\63\3\64\3\64\3\64\3\64\3\65\3\65\3\66\3\66\3\66\3\66"\r
12916             + "\3\67\3\67\3\67\3\67\38\38\38\38\38\38\38\38\38\78\u0330\n8\f8\168\u0333"\r
12917             + "\138\38\58\u0336\n8\39\69\u0339\n9\r9\169\u033a\3:\6:\u033e\n:\r:\16:"\r
12918             + "\u033f\3;\3;\3<\5<\u0345\n<\3=\3=\3>\3>\3>\3>\3?\3?\3?\3?\3@\3@\3A\3A"\r
12919             + "\3A\3A\3A\3A\3A\3A\3A\7A\u035c\nA\fA\16A\u035f\13A\3A\5A\u0362\nA\3B\6"\r
12920             + "B\u0365\nB\rB\16B\u0366\3C\3C\3C\3C\3D\3D\3D\3D\3D\3D\3D\3D\3D\7D\u0376"\r
12921             + "\nD\fD\16D\u0379\13D\3D\5D\u037c\nD\3E\3E\3E\3E\3E\3E\3E\3E\3E\7E\u0387"\r
12922             + "\nE\fE\16E\u038a\13E\3E\5E\u038d\nE\3F\3F\7F\u0391\nF\fF\16F\u0394\13"\r
12923             + "F\3G\3G\3G\3G\3H\5H\u039b\nH\3H\3H\3H\5H\u03a0\nH\5H\u03a2\nH\3I\3I\3"\r
12924             + "I\3I\3I\3I\3I\3I\3I\7I\u03ad\nI\fI\16I\u03b0\13I\3I\5I\u03b3\nI\3J\3J"\r
12925             + "\3K\3K\3K\3K\3K\3K\3K\3K\3K\5K\u03c0\nK\3L\3L\3L\3L\3L\3L\3L\5L\u03c9"\r
12926             + "\nL\3M\3M\3M\3M\3M\3M\3M\3M\3M\6M\u03d4\nM\rM\16M\u03d5\3M\3M\3N\3N\3"\r
12927             + "N\3N\3O\3O\3O\3O\3O\3O\3O\3O\7O\u03e6\nO\fO\16O\u03e9\13O\3O\5O\u03ec"\r
12928             + "\nO\3P\3P\3P\3P\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\7Q\u03fa\nQ\fQ\16Q\u03fd\13Q\3"\r
12929             + "Q\5Q\u0400\nQ\3R\3R\3S\3S\3S\3S\3T\3T\3T\3T\3T\5T\u040d\nT\3T\5T\u0410"\r
12930             + "\nT\3U\3U\3U\3U\3U\3U\3U\3U\7U\u041a\nU\fU\16U\u041d\13U\3U\5U\u0420\n"\r
12931             + "U\3V\3V\3V\3V\3W\3W\3W\3W\3W\5W\u042b\nW\3W\5W\u042e\nW\3W\5W\u0431\n"\r
12932             + "W\3X\3X\3X\3X\3Y\3Y\3Y\3Y\3Z\3Z\3Z\3Z\3[\3[\3[\3[\3\\\3\\\3\\\3\\\3]\3"\r
12933             + "]\3]\3]\3]\3]\3^\3^\3^\3^\3_\3_\3_\3_\3`\3`\3`\3`\3`\5`\u045a\n`\3`\5"\r
12934             + "`\u045d\n`\3a\3a\3a\3a\3a\5a\u0464\na\3a\3a\3b\3b\3b\3b\3c\3c\3c\3c\3"\r
12935             + "c\3c\3c\5c\u0473\nc\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\5d\u047f\nd\7d\u0481"\r
12936             + "\nd\fd\16d\u0484\13d\3e\7e\u0487\ne\fe\16e\u048a\13e\3f\3f\7f\u048e\n"\r
12937             + "f\ff\16f\u0491\13f\3g\3g\3g\3g\7g\u0497\ng\fg\16g\u049a\13g\3h\3h\6h\u049e"\r
12938             + "\nh\rh\16h\u049f\3i\3i\3i\6i\u04a5\ni\ri\16i\u04a6\3j\3j\3j\3j\3j\3j\3"\r
12939             + "j\3j\3j\3j\3k\3k\3k\3k\3k\3k\3k\3k\3k\3k\3k\2l\2\4\6\b\n\f\16\20\22\24"\r
12940             + "\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtv"\r
12941             + "xz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094"\r
12942             + "\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac"\r
12943             + "\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u00be\u00c0\u00c2\u00c4"\r
12944             + "\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4\2\2\u05a3\2\u00d8\3\2"\r
12945             + "\2\2\4\u00da\3\2\2\2\6\u00e2\3\2\2\2\b\u00f1\3\2\2\2\n\u00f3\3\2\2\2\f"\r
12946             + "\u0106\3\2\2\2\16\u0116\3\2\2\2\20\u012a\3\2\2\2\22\u0134\3\2\2\2\24\u0143"\r
12947             + "\3\2\2\2\26\u0156\3\2\2\2\30\u0161\3\2\2\2\32\u016c\3\2\2\2\34\u0180\3"\r
12948             + "\2\2\2\36\u018e\3\2\2\2 \u019f\3\2\2\2\"\u01b7\3\2\2\2$\u01be\3\2\2\2"\r
12949             + "&\u01c8\3\2\2\2(\u01d3\3\2\2\2*\u01de\3\2\2\2,\u01e9\3\2\2\2.\u01f3\3"\r
12950             + "\2\2\2\60\u01fd\3\2\2\2\62\u01ff\3\2\2\2\64\u020c\3\2\2\2\66\u0220\3\2"\r
12951             + "\2\28\u0235\3\2\2\2:\u024d\3\2\2\2<\u024f\3\2\2\2>\u0266\3\2\2\2@\u026a"\r
12952             + "\3\2\2\2B\u026e\3\2\2\2D\u0287\3\2\2\2F\u029e\3\2\2\2H\u02b4\3\2\2\2J"\r
12953             + "\u02cc\3\2\2\2L\u02df\3\2\2\2N\u02e3\3\2\2\2P\u02e5\3\2\2\2R\u02e9\3\2"\r
12954             + "\2\2T\u02ed\3\2\2\2V\u02f1\3\2\2\2X\u02f5\3\2\2\2Z\u0306\3\2\2\2\\\u0308"\r
12955             + "\3\2\2\2^\u030c\3\2\2\2`\u0310\3\2\2\2b\u0312\3\2\2\2d\u0316\3\2\2\2f"\r
12956             + "\u0318\3\2\2\2h\u031c\3\2\2\2j\u031e\3\2\2\2l\u0322\3\2\2\2n\u0326\3\2"\r
12957             + "\2\2p\u0338\3\2\2\2r\u033d\3\2\2\2t\u0341\3\2\2\2v\u0344\3\2\2\2x\u0346"\r
12958             + "\3\2\2\2z\u0348\3\2\2\2|\u034c\3\2\2\2~\u0350\3\2\2\2\u0080\u0352\3\2"\r
12959             + "\2\2\u0082\u0364\3\2\2\2\u0084\u0368\3\2\2\2\u0086\u036c\3\2\2\2\u0088"\r
12960             + "\u037d\3\2\2\2\u008a\u0392\3\2\2\2\u008c\u0395\3\2\2\2\u008e\u03a1\3\2"\r
12961             + "\2\2\u0090\u03a3\3\2\2\2\u0092\u03b4\3\2\2\2\u0094\u03bf\3\2\2\2\u0096"\r
12962             + "\u03c1\3\2\2\2\u0098\u03ca\3\2\2\2\u009a\u03d9\3\2\2\2\u009c\u03dd\3\2"\r
12963             + "\2\2\u009e\u03ed\3\2\2\2\u00a0\u03f1\3\2\2\2\u00a2\u0401\3\2\2\2\u00a4"\r
12964             + "\u0403\3\2\2\2\u00a6\u0407\3\2\2\2\u00a8\u0411\3\2\2\2\u00aa\u0421\3\2"\r
12965             + "\2\2\u00ac\u0425\3\2\2\2\u00ae\u0432\3\2\2\2\u00b0\u0436\3\2\2\2\u00b2"\r
12966             + "\u043a\3\2\2\2\u00b4\u043e\3\2\2\2\u00b6\u0442\3\2\2\2\u00b8\u0446\3\2"\r
12967             + "\2\2\u00ba\u044c\3\2\2\2\u00bc\u0450\3\2\2\2\u00be\u0454\3\2\2\2\u00c0"\r
12968             + "\u045e\3\2\2\2\u00c2\u0467\3\2\2\2\u00c4\u0472\3\2\2\2\u00c6\u0482\3\2"\r
12969             + "\2\2\u00c8\u0488\3\2\2\2\u00ca\u048f\3\2\2\2\u00cc\u0498\3\2\2\2\u00ce"\r
12970             + "\u049d\3\2\2\2\u00d0\u04a4\3\2\2\2\u00d2\u04a8\3\2\2\2\u00d4\u04b2\3\2"\r
12971             + "\2\2\u00d6\u00d9\5\u00d4k\2\u00d7\u00d9\5\u00d2j\2\u00d8\u00d6\3\2\2\2"\r
12972             + "\u00d8\u00d7\3\2\2\2\u00d9\3\3\2\2\2\u00da\u00df\7L\2\2\u00db\u00dc\7"\r
12973             + "\6\2\2\u00dc\u00de\7L\2\2\u00dd\u00db\3\2\2\2\u00de\u00e1\3\2\2\2\u00df"\r
12974             + "\u00dd\3\2\2\2\u00df\u00e0\3\2\2\2\u00e0\5\3\2\2\2\u00e1\u00df\3\2\2\2"\r
12975             + "\u00e2\u00e4\7K\2\2\u00e3\u00e5\5\4\3\2\u00e4\u00e3\3\2\2\2\u00e4\u00e5"\r
12976             + "\3\2\2\2\u00e5\u00e6\3\2\2\2\u00e6\u00e7\5\b\5\2\u00e7\7\3\2\2\2\u00e8"\r
12977             + "\u00ea\7\3\2\2\u00e9\u00eb\5\6\4\2\u00ea\u00e9\3\2\2\2\u00ea\u00eb\3\2"\r
12978             + "\2\2\u00eb\u00f2\3\2\2\2\u00ec\u00ee\7\4\2\2\u00ed\u00ef\5\6\4\2\u00ee"\r
12979             + "\u00ed\3\2\2\2\u00ee\u00ef\3\2\2\2\u00ef\u00f0\3\2\2\2\u00f0\u00f2\7\5"\r
12980             + "\2\2\u00f1\u00e8\3\2\2\2\u00f1\u00ec\3\2\2\2\u00f2\t\3\2\2\2\u00f3\u00f4"\r
12981             + "\78\2\2\u00f4\u0104\5\4\3\2\u00f5\u0105\7\3\2\2\u00f6\u0100\7\4\2\2\u00f7"\r
12982             + "\u00ff\5\u0096L\2\u00f8\u00ff\5\u00aeX\2\u00f9\u00ff\5\u0084C\2\u00fa"\r
12983             + "\u00ff\5f\64\2\u00fb\u00ff\5b\62\2\u00fc\u00ff\5R*\2\u00fd\u00ff\5P)\2"\r
12984             + "\u00fe\u00f7\3\2\2\2\u00fe\u00f8\3\2\2\2\u00fe\u00f9\3\2\2\2\u00fe\u00fa"\r
12985             + "\3\2\2\2\u00fe\u00fb\3\2\2\2\u00fe\u00fc\3\2\2\2\u00fe\u00fd\3\2\2\2\u00ff"\r
12986             + "\u0102\3\2\2\2\u0100\u00fe\3\2\2\2\u0100\u0101\3\2\2\2\u0101\u0103\3\2"\r
12987             + "\2\2\u0102\u0100\3\2\2\2\u0103\u0105\7\5\2\2\u0104\u00f5\3\2\2\2\u0104"\r
12988             + "\u00f6\3\2\2\2\u0105\13\3\2\2\2\u0106\u0107\78\2\2\u0107\u0114\5\4\3\2"\r
12989             + "\u0108\u0115\7\3\2\2\u0109\u0110\7\4\2\2\u010a\u010f\5\u00aeX\2\u010b"\r
12990             + "\u010f\5X-\2\u010c\u010f\5> \2\u010d\u010f\5\u0084C\2\u010e\u010a\3\2"\r
12991             + "\2\2\u010e\u010b\3\2\2\2\u010e\u010c\3\2\2\2\u010e\u010d\3\2\2\2\u010f"\r
12992             + "\u0112\3\2\2\2\u0110\u010e\3\2\2\2\u0110\u0111\3\2\2\2\u0111\u0113\3\2"\r
12993             + "\2\2\u0112\u0110\3\2\2\2\u0113\u0115\7\5\2\2\u0114\u0108\3\2\2\2\u0114"\r
12994             + "\u0109\3\2\2\2\u0115\r\3\2\2\2\u0116\u0117\78\2\2\u0117\u0128\5\4\3\2"\r
12995             + "\u0118\u0129\7\3\2\2\u0119\u0124\7\4\2\2\u011a\u0123\5\u00aeX\2\u011b"\r
12996             + "\u0123\5X-\2\u011c\u0123\5> \2\u011d\u0123\5\u0084C\2\u011e\u0123\5f\64"\r
12997             + "\2\u011f\u0123\5b\62\2\u0120\u0123\5R*\2\u0121\u0123\5P)\2\u0122\u011a"\r
12998             + "\3\2\2\2\u0122\u011b\3\2\2\2\u0122\u011c\3\2\2\2\u0122\u011d\3\2\2\2\u0122"\r
12999             + "\u011e\3\2\2\2\u0122\u011f\3\2\2\2\u0122\u0120\3\2\2\2\u0122\u0121\3\2"\r
13000             + "\2\2\u0123\u0126\3\2\2\2\u0124\u0122\3\2\2\2\u0124\u0125\3\2\2\2\u0125"\r
13001             + "\u0127\3\2\2\2\u0126\u0124\3\2\2\2\u0127\u0129\7\5\2\2\u0128\u0118\3\2"\r
13002             + "\2\2\u0128\u0119\3\2\2\2\u0129\17\3\2\2\2\u012a\u012b\78\2\2\u012b\u0132"\r
13003             + "\5\4\3\2\u012c\u0133\7\3\2\2\u012d\u012f\7\4\2\2\u012e\u0130\5\6\4\2\u012f"\r
13004             + "\u012e\3\2\2\2\u012f\u0130\3\2\2\2\u0130\u0131\3\2\2\2\u0131\u0133\7\5"\r
13005             + "\2\2\u0132\u012c\3\2\2\2\u0132\u012d\3\2\2\2\u0133\21\3\2\2\2\u0134\u0135"\r
13006             + "\79\2\2\u0135\u0136\5\4\3\2\u0136\u013d\7\4\2\2\u0137\u013e\5\u00b2Z\2"\r
13007             + "\u0138\u013e\5\u00b0Y\2\u0139\u013e\5\20\t\2\u013a\u013e\5\16\b\2\u013b"\r
13008             + "\u013e\5\n\6\2\u013c\u013e\5\f\7\2\u013d\u0137\3\2\2\2\u013d\u0138\3\2"\r
13009             + "\2\2\u013d\u0139\3\2\2\2\u013d\u013a\3\2\2\2\u013d\u013b\3\2\2\2\u013d"\r
13010             + "\u013c\3\2\2\2\u013e\u013f\3\2\2\2\u013f\u013d\3\2\2\2\u013f\u0140\3\2"\r
13011             + "\2\2\u0140\u0141\3\2\2\2\u0141\u0142\7\5\2\2\u0142\23\3\2\2\2\u0143\u0144"\r
13012             + "\7$\2\2\u0144\u0154\5\4\3\2\u0145\u0155\7\3\2\2\u0146\u0150\7\4\2\2\u0147"\r
13013             + "\u014f\5\u009aN\2\u0148\u014f\5j\66\2\u0149\u014f\5\u00b2Z\2\u014a\u014f"\r
13014             + "\5\u00b0Y\2\u014b\u014f\5\u0098M\2\u014c\u014f\5J&\2\u014d\u014f\5\u00c4"\r
13015             + "c\2\u014e\u0147\3\2\2\2\u014e\u0148\3\2\2\2\u014e\u0149\3\2\2\2\u014e"\r
13016             + "\u014a\3\2\2\2\u014e\u014b\3\2\2\2\u014e\u014c\3\2\2\2\u014e\u014d\3\2"\r
13017             + "\2\2\u014f\u0152\3\2\2\2\u0150\u014e\3\2\2\2\u0150\u0151\3\2\2\2\u0151"\r
13018             + "\u0153\3\2\2\2\u0152\u0150\3\2\2\2\u0153\u0155\7\5\2\2\u0154\u0145\3\2"\r
13019             + "\2\2\u0154\u0146\3\2\2\2\u0155\25\3\2\2\2\u0156\u0157\7!\2\2\u0157\u015b"\r
13020             + "\7\4\2\2\u0158\u015c\5\u0098M\2\u0159\u015c\5J&\2\u015a\u015c\5\u00c4"\r
13021             + "c\2\u015b\u0158\3\2\2\2\u015b\u0159\3\2\2\2\u015b\u015a\3\2\2\2\u015c"\r
13022             + "\u015d\3\2\2\2\u015d\u015b\3\2\2\2\u015d\u015e\3\2\2\2\u015e\u015f\3\2"\r
13023             + "\2\2\u015f\u0160\7\5\2\2\u0160\27\3\2\2\2\u0161\u0162\7\60\2\2\u0162\u0166"\r
13024             + "\7\4\2\2\u0163\u0167\5\u0098M\2\u0164\u0167\5J&\2\u0165\u0167\5\u00c4"\r
13025             + "c\2\u0166\u0163\3\2\2\2\u0166\u0164\3\2\2\2\u0166\u0165\3\2\2\2\u0167"\r
13026             + "\u0168\3\2\2\2\u0168\u0166\3\2\2\2\u0168\u0169\3\2\2\2\u0169\u016a\3\2"\r
13027             + "\2\2\u016a\u016b\7\5\2\2\u016b\31\3\2\2\2\u016c\u016d\7\25\2\2\u016d\u017e"\r
13028             + "\5\4\3\2\u016e\u017f\7\3\2\2\u016f\u017a\7\4\2\2\u0170\u0179\5\u009aN"\r
13029             + "\2\u0171\u0179\5j\66\2\u0172\u0179\5\u00b2Z\2\u0173\u0179\5\u00b0Y\2\u0174"\r
13030             + "\u0179\5\u0098M\2\u0175\u0179\5J&\2\u0176\u0179\5\30\r\2\u0177\u0179\5"\r
13031             + "\26\f\2\u0178\u0170\3\2\2\2\u0178\u0171\3\2\2\2\u0178\u0172\3\2\2\2\u0178"\r
13032             + "\u0173\3\2\2\2\u0178\u0174\3\2\2\2\u0178\u0175\3\2\2\2\u0178\u0176\3\2"\r
13033             + "\2\2\u0178\u0177\3\2\2\2\u0179\u017c\3\2\2\2\u017a\u0178\3\2\2\2\u017a"\r
13034             + "\u017b\3\2\2\2\u017b\u017d\3\2\2\2\u017c\u017a\3\2\2\2\u017d\u017f\7\5"\r
13035             + "\2\2\u017e\u016e\3\2\2\2\u017e\u016f\3\2\2\2\u017f\33\3\2\2\2\u0180\u0181"\r
13036             + "\7\f\2\2\u0181\u018c\5\4\3\2\u0182\u018d\7\3\2\2\u0183\u0188\7\4\2\2\u0184"\r
13037             + "\u0187\5\u00b2Z\2\u0185\u0187\5\u00b0Y\2\u0186\u0184\3\2\2\2\u0186\u0185"\r
13038             + "\3\2\2\2\u0187\u018a\3\2\2\2\u0188\u0186\3\2\2\2\u0188\u0189\3\2\2\2\u0189"\r
13039             + "\u018b\3\2\2\2\u018a\u0188\3\2\2\2\u018b\u018d\7\5\2\2\u018c\u0182\3\2"\r
13040             + "\2\2\u018c\u0183\3\2\2\2\u018d\35\3\2\2\2\u018e\u018f\7H\2\2\u018f\u0190"\r
13041             + "\5\4\3\2\u0190\u0199\7\4\2\2\u0191\u019a\5\6\4\2\u0192\u019a\5\34\17\2"\r
13042             + "\u0193\u019a\5\u009aN\2\u0194\u019a\5j\66\2\u0195\u019a\5\u00b2Z\2\u0196"\r
13043             + "\u019a\5\u00b0Y\2\u0197\u019a\5\u00c4c\2\u0198\u019a\58\35\2\u0199\u0191"\r
13044             + "\3\2\2\2\u0199\u0192\3\2\2\2\u0199\u0193\3\2\2\2\u0199\u0194\3\2\2\2\u0199"\r
13045             + "\u0195\3\2\2\2\u0199\u0196\3\2\2\2\u0199\u0197\3\2\2\2\u0199\u0198\3\2"\r
13046             + "\2\2\u019a\u019b\3\2\2\2\u019b\u0199\3\2\2\2\u019b\u019c\3\2\2\2\u019c"\r
13047             + "\u019d\3\2\2\2\u019d\u019e\7\5\2\2\u019e\37\3\2\2\2\u019f\u01a0\7H\2\2"\r
13048             + "\u01a0\u01a1\5\4\3\2\u01a1\u01aa\7\4\2\2\u01a2\u01ab\5\6\4\2\u01a3\u01ab"\r
13049             + "\5\34\17\2\u01a4\u01ab\5\u009aN\2\u01a5\u01ab\5j\66\2\u01a6\u01ab\5\u00b2"\r
13050             + "Z\2\u01a7\u01ab\5\u00b0Y\2\u01a8\u01ab\5\u00c4c\2\u01a9\u01ab\58\35\2"\r
13051             + "\u01aa\u01a2\3\2\2\2\u01aa\u01a3\3\2\2\2\u01aa\u01a4\3\2\2\2\u01aa\u01a5"\r
13052             + "\3\2\2\2\u01aa\u01a6\3\2\2\2\u01aa\u01a7\3\2\2\2\u01aa\u01a8\3\2\2\2\u01aa"\r
13053             + "\u01a9\3\2\2\2\u01ab\u01ac\3\2\2\2\u01ac\u01aa\3\2\2\2\u01ac\u01ad\3\2"\r
13054             + "\2\2\u01ad\u01ae\3\2\2\2\u01ae\u01af\7\5\2\2\u01af!\3\2\2\2\u01b0\u01b6"\r
13055             + "\5X-\2\u01b1\u01b6\5f\64\2\u01b2\u01b6\5b\62\2\u01b3\u01b6\5\u00b2Z\2"\r
13056             + "\u01b4\u01b6\5\u00b0Y\2\u01b5\u01b0\3\2\2\2\u01b5\u01b1\3\2\2\2\u01b5"\r
13057             + "\u01b2\3\2\2\2\u01b5\u01b3\3\2\2\2\u01b5\u01b4\3\2\2\2\u01b6\u01b9\3\2"\r
13058             + "\2\2\u01b7\u01b5\3\2\2\2\u01b7\u01b8\3\2\2\2\u01b8#\3\2\2\2\u01b9\u01b7"\r
13059             + "\3\2\2\2\u01ba\u01bd\5\u00b2Z\2\u01bb\u01bd\5\u00b0Y\2\u01bc\u01ba\3\2"\r
13060             + "\2\2\u01bc\u01bb\3\2\2\2\u01bd\u01c0\3\2\2\2\u01be\u01bc\3\2\2\2\u01be"\r
13061             + "\u01bf\3\2\2\2\u01bf%\3\2\2\2\u01c0\u01be\3\2\2\2\u01c1\u01c7\5\u0084"\r
13062             + "C\2\u01c2\u01c7\5f\64\2\u01c3\u01c7\5b\62\2\u01c4\u01c7\5\u00b2Z\2\u01c5"\r
13063             + "\u01c7\5\u00b0Y\2\u01c6\u01c1\3\2\2\2\u01c6\u01c2\3\2\2\2\u01c6\u01c3"\r
13064             + "\3\2\2\2\u01c6\u01c4\3\2\2\2\u01c6\u01c5\3\2\2\2\u01c7\u01ca\3\2\2\2\u01c8"\r
13065             + "\u01c6\3\2\2\2\u01c8\u01c9\3\2\2\2\u01c9\'\3\2\2\2\u01ca\u01c8\3\2\2\2"\r
13066             + "\u01cb\u01d2\5X-\2\u01cc\u01d2\5f\64\2\u01cd\u01d2\5R*\2\u01ce\u01d2\5"\r
13067             + "P)\2\u01cf\u01d2\5\u00b2Z\2\u01d0\u01d2\5\u00b0Y\2\u01d1\u01cb\3\2\2\2"\r
13068             + "\u01d1\u01cc\3\2\2\2\u01d1\u01cd\3\2\2\2\u01d1\u01ce\3\2\2\2\u01d1\u01cf"\r
13069             + "\3\2\2\2\u01d1\u01d0\3\2\2\2\u01d2\u01d5\3\2\2\2\u01d3\u01d1\3\2\2\2\u01d3"\r
13070             + "\u01d4\3\2\2\2\u01d4)\3\2\2\2\u01d5\u01d3\3\2\2\2\u01d6\u01dd\5X-\2\u01d7"\r
13071             + "\u01dd\5f\64\2\u01d8\u01dd\5R*\2\u01d9\u01dd\5P)\2\u01da\u01dd\5\u00b2"\r
13072             + "Z\2\u01db\u01dd\5\u00b0Y\2\u01dc\u01d6\3\2\2\2\u01dc\u01d7\3\2\2\2\u01dc"\r
13073             + "\u01d8\3\2\2\2\u01dc\u01d9\3\2\2\2\u01dc\u01da\3\2\2\2\u01dc\u01db\3\2"\r
13074             + "\2\2\u01dd\u01e0\3\2\2\2\u01de\u01dc\3\2\2\2\u01de\u01df\3\2\2\2\u01df"\r
13075             + "+\3\2\2\2\u01e0\u01de\3\2\2\2\u01e1\u01e8\5X-\2\u01e2\u01e8\5\u0084C\2"\r
13076             + "\u01e3\u01e8\5f\64\2\u01e4\u01e8\5b\62\2\u01e5\u01e8\5\u00b2Z\2\u01e6"\r
13077             + "\u01e8\5\u00b0Y\2\u01e7\u01e1\3\2\2\2\u01e7\u01e2\3\2\2\2\u01e7\u01e3"\r
13078             + "\3\2\2\2\u01e7\u01e4\3\2\2\2\u01e7\u01e5\3\2\2\2\u01e7\u01e6\3\2\2\2\u01e8"\r
13079             + "\u01eb\3\2\2\2\u01e9\u01e7\3\2\2\2\u01e9\u01ea\3\2\2\2\u01ea-\3\2\2\2"\r
13080             + "\u01eb\u01e9\3\2\2\2\u01ec\u01f2\5X-\2\u01ed\u01f2\5^\60\2\u01ee\u01f2"\r
13081             + "\5f\64\2\u01ef\u01f2\5\u00b2Z\2\u01f0\u01f2\5\u00b0Y\2\u01f1\u01ec\3\2"\r
13082             + "\2\2\u01f1\u01ed\3\2\2\2\u01f1\u01ee\3\2\2\2\u01f1\u01ef\3\2\2\2\u01f1"\r
13083             + "\u01f0\3\2\2\2\u01f2\u01f5\3\2\2\2\u01f3\u01f1\3\2\2\2\u01f3\u01f4\3\2"\r
13084             + "\2\2\u01f4/\3\2\2\2\u01f5\u01f3\3\2\2\2\u01f6\u01fe\5.\30\2\u01f7\u01fe"\r
13085             + "\5,\27\2\u01f8\u01fe\5*\26\2\u01f9\u01fe\5(\25\2\u01fa\u01fe\5&\24\2\u01fb"\r
13086             + "\u01fe\5$\23\2\u01fc\u01fe\5\"\22\2\u01fd\u01f6\3\2\2\2\u01fd\u01f7\3"\r
13087             + "\2\2\2\u01fd\u01f8\3\2\2\2\u01fd\u01f9\3\2\2\2\u01fd\u01fa\3\2\2\2\u01fd"\r
13088             + "\u01fb\3\2\2\2\u01fd\u01fc\3\2\2\2\u01fe\61\3\2\2\2\u01ff\u0200\7\31\2"\r
13089             + "\2\u0200\u020a\5\4\3\2\u0201\u020b\7\3\2\2\u0202\u0204\7\4\2\2\u0203\u0205"\r
13090             + "\5\60\31\2\u0204\u0203\3\2\2\2\u0205\u0206\3\2\2\2\u0206\u0204\3\2\2\2"\r
13091             + "\u0206\u0207\3\2\2\2\u0207\u0208\3\2\2\2\u0208\u0209\7\5\2\2\u0209\u020b"\r
13092             + "\3\2\2\2\u020a\u0201\3\2\2\2\u020a\u0202\3\2\2\2\u020b\63\3\2\2\2\u020c"\r
13093             + "\u020d\7\16\2\2\u020d\u021e\5\4\3\2\u020e\u021f\7\3\2\2\u020f\u021a\7"\r
13094             + "\4\2\2\u0210\u0219\5\6\4\2\u0211\u0219\5\34\17\2\u0212\u0219\5\u009aN"\r
13095             + "\2\u0213\u0219\5j\66\2\u0214\u0219\5\u00b2Z\2\u0215\u0219\5\u00b0Y\2\u0216"\r
13096             + "\u0219\5\62\32\2\u0217\u0219\5 \21\2\u0218\u0210\3\2\2\2\u0218\u0211\3"\r
13097             + "\2\2\2\u0218\u0212\3\2\2\2\u0218\u0213\3\2\2\2\u0218\u0214\3\2\2\2\u0218"\r
13098             + "\u0215\3\2\2\2\u0218\u0216\3\2\2\2\u0218\u0217\3\2\2\2\u0219\u021c\3\2"\r
13099             + "\2\2\u021a\u0218\3\2\2\2\u021a\u021b\3\2\2\2\u021b\u021d\3\2\2\2\u021c"\r
13100             + "\u021a\3\2\2\2\u021d\u021f\7\5\2\2\u021e\u020e\3\2\2\2\u021e\u020f\3\2"\r
13101             + "\2\2\u021f\65\3\2\2\2\u0220\u0221\7J\2\2\u0221\u0233\5\4\3\2\u0222\u0234"\r
13102             + "\7\3\2\2\u0223\u022f\7\4\2\2\u0224\u022e\5\6\4\2\u0225\u022e\5\34\17\2"\r
13103             + "\u0226\u022e\5\u009aN\2\u0227\u022e\5X-\2\u0228\u022e\5f\64\2\u0229\u022e"\r
13104             + "\5b\62\2\u022a\u022e\5j\66\2\u022b\u022e\5\u00b2Z\2\u022c\u022e\5\u00b0"\r
13105             + "Y\2\u022d\u0224\3\2\2\2\u022d\u0225\3\2\2\2\u022d\u0226\3\2\2\2\u022d"\r
13106             + "\u0227\3\2\2\2\u022d\u0228\3\2\2\2\u022d\u0229\3\2\2\2\u022d\u022a\3\2"\r
13107             + "\2\2\u022d\u022b\3\2\2\2\u022d\u022c\3\2\2\2\u022e\u0231\3\2\2\2\u022f"\r
13108             + "\u022d\3\2\2\2\u022f\u0230\3\2\2\2\u0230\u0232\3\2\2\2\u0231\u022f\3\2"\r
13109             + "\2\2\u0232\u0234\7\5\2\2\u0233\u0222\3\2\2\2\u0233\u0223\3\2\2\2\u0234"\r
13110             + "\67\3\2\2\2\u0235\u0236\7D\2\2\u0236\u0246\5\4\3\2\u0237\u0247\7\3\2\2"\r
13111             + "\u0238\u0242\7\4\2\2\u0239\u0241\5\6\4\2\u023a\u0241\5\34\17\2\u023b\u0241"\r
13112             + "\5\u009aN\2\u023c\u0241\5j\66\2\u023d\u0241\5\u00b2Z\2\u023e\u0241\5\u00b0"\r
13113             + "Y\2\u023f\u0241\5\u00c4c\2\u0240\u0239\3\2\2\2\u0240\u023a\3\2\2\2\u0240"\r
13114             + "\u023b\3\2\2\2\u0240\u023c\3\2\2\2\u0240\u023d\3\2\2\2\u0240\u023e\3\2"\r
13115             + "\2\2\u0240\u023f\3\2\2\2\u0241\u0244\3\2\2\2\u0242\u0240\3\2\2\2\u0242"\r
13116             + "\u0243\3\2\2\2\u0243\u0245\3\2\2\2\u0244\u0242\3\2\2\2\u0245\u0247\7\5"\r
13117             + "\2\2\u0246\u0237\3\2\2\2\u0246\u0238\3\2\2\2\u02479\3\2\2\2\u0248\u024e"\r
13118             + "\5H%\2\u0249\u024e\5F$\2\u024a\u024e\5D#\2\u024b\u024e\5B\"\2\u024c\u024e"\r
13119             + "\5\66\34\2\u024d\u0248\3\2\2\2\u024d\u0249\3\2\2\2\u024d\u024a\3\2\2\2"\r
13120             + "\u024d\u024b\3\2\2\2\u024d\u024c\3\2\2\2\u024e;\3\2\2\2\u024f\u0250\7"\r
13121             + "C\2\2\u0250\u0264\5\4\3\2\u0251\u0265\7\3\2\2\u0252\u0260\7\4\2\2\u0253"\r
13122             + "\u025f\5\6\4\2\u0254\u025f\5\34\17\2\u0255\u025f\5\u009aN\2\u0256\u025f"\r
13123             + "\5\u0084C\2\u0257\u025f\5f\64\2\u0258\u025f\5b\62\2\u0259\u025f\5j\66"\r
13124             + "\2\u025a\u025f\5\u00b2Z\2\u025b\u025f\5\u00b0Y\2\u025c\u025f\5:\36\2\u025d"\r
13125             + "\u025f\58\35\2\u025e\u0253\3\2\2\2\u025e\u0254\3\2\2\2\u025e\u0255\3\2"\r
13126             + "\2\2\u025e\u0256\3\2\2\2\u025e\u0257\3\2\2\2\u025e\u0258\3\2\2\2\u025e"\r
13127             + "\u0259\3\2\2\2\u025e\u025a\3\2\2\2\u025e\u025b\3\2\2\2\u025e\u025c\3\2"\r
13128             + "\2\2\u025e\u025d\3\2\2\2\u025f\u0262\3\2\2\2\u0260\u025e\3\2\2\2\u0260"\r
13129             + "\u0261\3\2\2\2\u0261\u0263\3\2\2\2\u0262\u0260\3\2\2\2\u0263\u0265\7\5"\r
13130             + "\2\2\u0264\u0251\3\2\2\2\u0264\u0252\3\2\2\2\u0265=\3\2\2\2\u0266\u0267"\r
13131             + "\7\20\2\2\u0267\u0268\5\4\3\2\u0268\u0269\5\b\5\2\u0269?\3\2\2\2\u026a"\r
13132             + "\u026b\7/\2\2\u026b\u026c\5\4\3\2\u026c\u026d\5\b\5\2\u026dA\3\2\2\2\u026e"\r
13133             + "\u026f\7+\2\2\u026f\u0270\5\4\3\2\u0270\u0281\7\4\2\2\u0271\u0282\5\6"\r
13134             + "\4\2\u0272\u0282\5\34\17\2\u0273\u0282\5\u009aN\2\u0274\u0282\5X-\2\u0275"\r
13135             + "\u0282\5@!\2\u0276\u0282\5> \2\u0277\u0282\5f\64\2\u0278\u0282\5R*\2\u0279"\r
13136             + "\u0282\5P)\2\u027a\u0282\5\\/\2\u027b\u0282\5j\66\2\u027c\u0282\5\u00b2"\r
13137             + "Z\2\u027d\u0282\5\u00b0Y\2\u027e\u0282\5\u0098M\2\u027f\u0282\5J&\2\u0280"\r
13138             + "\u0282\5\u00c4c\2\u0281\u0271\3\2\2\2\u0281\u0272\3\2\2\2\u0281\u0273"\r
13139             + "\3\2\2\2\u0281\u0274\3\2\2\2\u0281\u0275\3\2\2\2\u0281\u0276\3\2\2\2\u0281"\r
13140             + "\u0277\3\2\2\2\u0281\u0278\3\2\2\2\u0281\u0279\3\2\2\2\u0281\u027a\3\2"\r
13141             + "\2\2\u0281\u027b\3\2\2\2\u0281\u027c\3\2\2\2\u0281\u027d\3\2\2\2\u0281"\r
13142             + "\u027e\3\2\2\2\u0281\u027f\3\2\2\2\u0281\u0280\3\2\2\2\u0282\u0283\3\2"\r
13143             + "\2\2\u0283\u0281\3\2\2\2\u0283\u0284\3\2\2\2\u0284\u0285\3\2\2\2\u0285"\r
13144             + "\u0286\7\5\2\2\u0286C\3\2\2\2\u0287\u0288\7-\2\2\u0288\u0289\5\4\3\2\u0289"\r
13145             + "\u0299\7\4\2\2\u028a\u0298\5\6\4\2\u028b\u0298\5\34\17\2\u028c\u0298\5"\r
13146             + "\u009aN\2\u028d\u0298\5\u0096L\2\u028e\u0298\5\u00aeX\2\u028f\u0298\5"\r
13147             + "X-\2\u0290\u0298\5f\64\2\u0291\u0298\5R*\2\u0292\u0298\5P)\2\u0293\u0298"\r
13148             + "\5\\/\2\u0294\u0298\5j\66\2\u0295\u0298\5\u00b2Z\2\u0296\u0298\5\u00b0"\r
13149             + "Y\2\u0297\u028a\3\2\2\2\u0297\u028b\3\2\2\2\u0297\u028c\3\2\2\2\u0297"\r
13150             + "\u028d\3\2\2\2\u0297\u028e\3\2\2\2\u0297\u028f\3\2\2\2\u0297\u0290\3\2"\r
13151             + "\2\2\u0297\u0291\3\2\2\2\u0297\u0292\3\2\2\2\u0297\u0293\3\2\2\2\u0297"\r
13152             + "\u0294\3\2\2\2\u0297\u0295\3\2\2\2\u0297\u0296\3\2\2\2\u0298\u029b\3\2"\r
13153             + "\2\2\u0299\u0297\3\2\2\2\u0299\u029a\3\2\2\2\u029a\u029c\3\2\2\2\u029b"\r
13154             + "\u0299\3\2\2\2\u029c\u029d\7\5\2\2\u029dE\3\2\2\2\u029e\u029f\7.\2\2\u029f"\r
13155             + "\u02a0\5\4\3\2\u02a0\u02af\7\4\2\2\u02a1\u02ae\5\6\4\2\u02a2\u02ae\5\34"\r
13156             + "\17\2\u02a3\u02ae\5\u009aN\2\u02a4\u02ae\5\u0096L\2\u02a5\u02ae\5\u00ae"\r
13157             + "X\2\u02a6\u02ae\5X-\2\u02a7\u02ae\5\u0084C\2\u02a8\u02ae\5f\64\2\u02a9"\r
13158             + "\u02ae\5b\62\2\u02aa\u02ae\5j\66\2\u02ab\u02ae\5\u00b2Z\2\u02ac\u02ae"\r
13159             + "\5\u00b0Y\2\u02ad\u02a1\3\2\2\2\u02ad\u02a2\3\2\2\2\u02ad\u02a3\3\2\2"\r
13160             + "\2\u02ad\u02a4\3\2\2\2\u02ad\u02a5\3\2\2\2\u02ad\u02a6\3\2\2\2\u02ad\u02a7"\r
13161             + "\3\2\2\2\u02ad\u02a8\3\2\2\2\u02ad\u02a9\3\2\2\2\u02ad\u02aa\3\2\2\2\u02ad"\r
13162             + "\u02ab\3\2\2\2\u02ad\u02ac\3\2\2\2\u02ae\u02b1\3\2\2\2\u02af\u02ad\3\2"\r
13163             + "\2\2\u02af\u02b0\3\2\2\2\u02b0\u02b2\3\2\2\2\u02b1\u02af\3\2\2\2\u02b2"\r
13164             + "\u02b3\7\5\2\2\u02b3G\3\2\2\2\u02b4\u02b5\7@\2\2\u02b5\u02ca\5\4\3\2\u02b6"\r
13165             + "\u02cb\7\3\2\2\u02b7\u02c6\7\4\2\2\u02b8\u02c5\5\6\4\2\u02b9\u02c5\5\34"\r
13166             + "\17\2\u02ba\u02c5\5\u009aN\2\u02bb\u02c5\5X-\2\u02bc\u02c5\5^\60\2\u02bd"\r
13167             + "\u02c5\5f\64\2\u02be\u02c5\5j\66\2\u02bf\u02c5\5\u00b2Z\2\u02c0\u02c5"\r
13168             + "\5\u00b0Y\2\u02c1\u02c5\5\u0098M\2\u02c2\u02c5\5J&\2\u02c3\u02c5\5\u00c4"\r
13169             + "c\2\u02c4\u02b8\3\2\2\2\u02c4\u02b9\3\2\2\2\u02c4\u02ba\3\2\2\2\u02c4"\r
13170             + "\u02bb\3\2\2\2\u02c4\u02bc\3\2\2\2\u02c4\u02bd\3\2\2\2\u02c4\u02be\3\2"\r
13171             + "\2\2\u02c4\u02bf\3\2\2\2\u02c4\u02c0\3\2\2\2\u02c4\u02c1\3\2\2\2\u02c4"\r
13172             + "\u02c2\3\2\2\2\u02c4\u02c3\3\2\2\2\u02c5\u02c8\3\2\2\2\u02c6\u02c4\3\2"\r
13173             + "\2\2\u02c6\u02c7\3\2\2\2\u02c7\u02c9\3\2\2\2\u02c8\u02c6\3\2\2\2\u02c9"\r
13174             + "\u02cb\7\5\2\2\u02ca\u02b6\3\2\2\2\u02ca\u02b7\3\2\2\2\u02cbI\3\2\2\2"\r
13175             + "\u02cc\u02cd\7\65\2\2\u02cd\u02dd\5\4\3\2\u02ce\u02de\7\3\2\2\u02cf\u02d9"\r
13176             + "\7\4\2\2\u02d0\u02d8\5\6\4\2\u02d1\u02d8\5j\66\2\u02d2\u02d8\5\u00b2Z"\r
13177             + "\2\u02d3\u02d8\5\u00b0Y\2\u02d4\u02d8\5\u0098M\2\u02d5\u02d8\5J&\2\u02d6"\r
13178             + "\u02d8\5\u00c4c\2\u02d7\u02d0\3\2\2\2\u02d7\u02d1\3\2\2\2\u02d7\u02d2"\r
13179             + "\3\2\2\2\u02d7\u02d3\3\2\2\2\u02d7\u02d4\3\2\2\2\u02d7\u02d5\3\2\2\2\u02d7"\r
13180             + "\u02d6\3\2\2\2\u02d8\u02db\3\2\2\2\u02d9\u02d7\3\2\2\2\u02d9\u02da\3\2"\r
13181             + "\2\2\u02da\u02dc\3\2\2\2\u02db\u02d9\3\2\2\2\u02dc\u02de\7\5\2\2\u02dd"\r
13182             + "\u02ce\3\2\2\2\u02dd\u02cf\3\2\2\2\u02deK\3\2\2\2\u02df\u02e0\7\r\2\2"\r
13183             + "\u02e0\u02e1\5\4\3\2\u02e1\u02e2\5\b\5\2\u02e2M\3\2\2\2\u02e3\u02e4\5"\r
13184             + "\4\3\2\u02e4O\3\2\2\2\u02e5\u02e6\7)\2\2\u02e6\u02e7\5N(\2\u02e7\u02e8"\r
13185             + "\5\b\5\2\u02e8Q\3\2\2\2\u02e9\u02ea\7(\2\2\u02ea\u02eb\5\4\3\2\u02eb\u02ec"\r
13186             + "\5\b\5\2\u02ecS\3\2\2\2\u02ed\u02ee\7<\2\2\u02ee\u02ef\5\4\3\2\u02ef\u02f0"\r
13187             + "\5\b\5\2\u02f0U\3\2\2\2\u02f1\u02f2\7;\2\2\u02f2\u02f3\5\4\3\2\u02f3\u02f4"\r
13188             + "\5\b\5\2\u02f4W\3\2\2\2\u02f5\u02f6\7&\2\2\u02f6\u0304\5\4\3\2\u02f7\u0305"\r
13189             + "\7\3\2\2\u02f8\u0300\7\4\2\2\u02f9\u02ff\5\6\4\2\u02fa\u02ff\5V,\2\u02fb"\r
13190             + "\u02ff\5T+\2\u02fc\u02ff\5\u00b2Z\2\u02fd\u02ff\5\u00b0Y\2\u02fe\u02f9"\r
13191             + "\3\2\2\2\u02fe\u02fa\3\2\2\2\u02fe\u02fb\3\2\2\2\u02fe\u02fc\3\2\2\2\u02fe"\r
13192             + "\u02fd\3\2\2\2\u02ff\u0302\3\2\2\2\u0300\u02fe\3\2\2\2\u0300\u0301\3\2"\r
13193             + "\2\2\u0301\u0303\3\2\2\2\u0302\u0300\3\2\2\2\u0303\u0305\7\5\2\2\u0304"\r
13194             + "\u02f7\3\2\2\2\u0304\u02f8\3\2\2\2\u0305Y\3\2\2\2\u0306\u0307\5\4\3\2"\r
13195             + "\u0307[\3\2\2\2\u0308\u0309\7#\2\2\u0309\u030a\5Z.\2\u030a\u030b\5\b\5"\r
13196             + "\2\u030b]\3\2\2\2\u030c\u030d\7\34\2\2\u030d\u030e\5\4\3\2\u030e\u030f"\r
13197             + "\5\b\5\2\u030f_\3\2\2\2\u0310\u0311\5\4\3\2\u0311a\3\2\2\2\u0312\u0313"\r
13198             + "\7*\2\2\u0313\u0314\5`\61\2\u0314\u0315\5\b\5\2\u0315c\3\2\2\2\u0316\u0317"\r
13199             + "\5\4\3\2\u0317e\3\2\2\2\u0318\u0319\7B\2\2\u0319\u031a\5d\63\2\u031a\u031b"\r
13200             + "\5\b\5\2\u031bg\3\2\2\2\u031c\u031d\5\4\3\2\u031di\3\2\2\2\u031e\u031f"\r
13201             + "\7\24\2\2\u031f\u0320\5h\65\2\u0320\u0321\5\b\5\2\u0321k\3\2\2\2\u0322"\r
13202             + "\u0323\7\36\2\2\u0323\u0324\5\4\3\2\u0324\u0325\5\b\5\2\u0325m\3\2\2\2"\r
13203             + "\u0326\u0327\7E\2\2\u0327\u0335\5\4\3\2\u0328\u0336\7\3\2\2\u0329\u0331"\r
13204             + "\7\4\2\2\u032a\u0330\5\6\4\2\u032b\u0330\5l\67\2\u032c\u0330\5j\66\2\u032d"\r
13205             + "\u0330\5\u00b2Z\2\u032e\u0330\5\u00b0Y\2\u032f\u032a\3\2\2\2\u032f\u032b"\r
13206             + "\3\2\2\2\u032f\u032c\3\2\2\2\u032f\u032d\3\2\2\2\u032f\u032e\3\2\2\2\u0330"\r
13207             + "\u0333\3\2\2\2\u0331\u032f\3\2\2\2\u0331\u0332\3\2\2\2\u0332\u0334\3\2"\r
13208             + "\2\2\u0333\u0331\3\2\2\2\u0334\u0336\7\5\2\2\u0335\u0328\3\2\2\2\u0335"\r
13209             + "\u0329\3\2\2\2\u0336o\3\2\2\2\u0337\u0339\5n8\2\u0338\u0337\3\2\2\2\u0339"\r
13210             + "\u033a\3\2\2\2\u033a\u0338\3\2\2\2\u033a\u033b\3\2\2\2\u033bq\3\2\2\2"\r
13211             + "\u033c\u033e\5\u0096L\2\u033d\u033c\3\2\2\2\u033e\u033f\3\2\2\2\u033f"\r
13212             + "\u033d\3\2\2\2\u033f\u0340\3\2\2\2\u0340s\3\2\2\2\u0341\u0342\5\u009e"\r
13213             + "P\2\u0342u\3\2\2\2\u0343\u0345\5z>\2\u0344\u0343\3\2\2\2\u0344\u0345\3"\r
13214             + "\2\2\2\u0345w\3\2\2\2\u0346\u0347\5\4\3\2\u0347y\3\2\2\2\u0348\u0349\7"\r
13215             + "\30\2\2\u0349\u034a\5x=\2\u034a\u034b\5\b\5\2\u034b{\3\2\2\2\u034c\u034d"\r
13216             + "\7 \2\2\u034d\u034e\5\4\3\2\u034e\u034f\5\b\5\2\u034f}\3\2\2\2\u0350\u0351"\r
13217             + "\5|?\2\u0351\177\3\2\2\2\u0352\u0353\7=\2\2\u0353\u0361\5\4\3\2\u0354"\r
13218             + "\u0362\7\3\2\2\u0355\u035d\7\4\2\2\u0356\u035c\5\6\4\2\u0357\u035c\5L"\r
13219             + "\'\2\u0358\u035c\5j\66\2\u0359\u035c\5\u00b2Z\2\u035a\u035c\5\u00b0Y\2"\r
13220             + "\u035b\u0356\3\2\2\2\u035b\u0357\3\2\2\2\u035b\u0358\3\2\2\2\u035b\u0359"\r
13221             + "\3\2\2\2\u035b\u035a\3\2\2\2\u035c\u035f\3\2\2\2\u035d\u035b\3\2\2\2\u035d"\r
13222             + "\u035e\3\2\2\2\u035e\u0360\3\2\2\2\u035f\u035d\3\2\2\2\u0360\u0362\7\5"\r
13223             + "\2\2\u0361\u0354\3\2\2\2\u0361\u0355\3\2\2\2\u0362\u0081\3\2\2\2\u0363"\r
13224             + "\u0365\5\u0080A\2\u0364\u0363\3\2\2\2\u0365\u0366\3\2\2\2\u0366\u0364"\r
13225             + "\3\2\2\2\u0366\u0367\3\2\2\2\u0367\u0083\3\2\2\2\u0368\u0369\7?\2\2\u0369"\r
13226             + "\u036a\5\4\3\2\u036a\u036b\5\b\5\2\u036b\u0085\3\2\2\2\u036c\u036d\7\37"\r
13227             + "\2\2\u036d\u037b\5\4\3\2\u036e\u037c\7\3\2\2\u036f\u0377\7\4\2\2\u0370"\r
13228             + "\u0376\5\6\4\2\u0371\u0376\5V,\2\u0372\u0376\5T+\2\u0373\u0376\5\u00b2"\r
13229             + "Z\2\u0374\u0376\5\u00b0Y\2\u0375\u0370\3\2\2\2\u0375\u0371\3\2\2\2\u0375"\r
13230             + "\u0372\3\2\2\2\u0375\u0373\3\2\2\2\u0375\u0374\3\2\2\2\u0376\u0379\3\2"\r
13231             + "\2\2\u0377\u0375\3\2\2\2\u0377\u0378\3\2\2\2\u0378\u037a\3\2\2\2\u0379"\r
13232             + "\u0377\3\2\2\2\u037a\u037c\7\5\2\2\u037b\u036e\3\2\2\2\u037b\u036f\3\2"\r
13233             + "\2\2\u037c\u0087\3\2\2\2\u037d\u037e\7,\2\2\u037e\u038c\5\4\3\2\u037f"\r
13234             + "\u038d\7\3\2\2\u0380\u0388\7\4\2\2\u0381\u0387\5\6\4\2\u0382\u0387\5V"\r
13235             + ",\2\u0383\u0387\5T+\2\u0384\u0387\5\u00b2Z\2\u0385\u0387\5\u00b0Y\2\u0386"\r
13236             + "\u0381\3\2\2\2\u0386\u0382\3\2\2\2\u0386\u0383\3\2\2\2\u0386\u0384\3\2"\r
13237             + "\2\2\u0386\u0385\3\2\2\2\u0387\u038a\3\2\2\2\u0388\u0386\3\2\2\2\u0388"\r
13238             + "\u0389\3\2\2\2\u0389\u038b\3\2\2\2\u038a\u0388\3\2\2\2\u038b\u038d\7\5"\r
13239             + "\2\2\u038c\u037f\3\2\2\2\u038c\u0380\3\2\2\2\u038d\u0089\3\2\2\2\u038e"\r
13240             + "\u0391\5\u0088E\2\u038f\u0391\5\u0086D\2\u0390\u038e\3\2\2\2\u0390\u038f"\r
13241             + "\3\2\2\2\u0391\u0394\3\2\2\2\u0392\u0390\3\2\2\2\u0392\u0393\3\2\2\2\u0393"\r
13242             + "\u008b\3\2\2\2\u0394\u0392\3\2\2\2\u0395\u0396\7\66\2\2\u0396\u0397\5"\r
13243             + "\4\3\2\u0397\u0398\5\b\5\2\u0398\u008d\3\2\2\2\u0399\u039b\5\u0092J\2"\r
13244             + "\u039a\u0399\3\2\2\2\u039a\u039b\3\2\2\2\u039b\u039c\3\2\2\2\u039c\u03a2"\r
13245             + "\5\u008cG\2\u039d\u039f\5\u008cG\2\u039e\u03a0\5\u0092J\2\u039f\u039e"\r
13246             + "\3\2\2\2\u039f\u03a0\3\2\2\2\u03a0\u03a2\3\2\2\2\u03a1\u039a\3\2\2\2\u03a1"\r
13247             + "\u039d\3\2\2\2\u03a2\u008f\3\2\2\2\u03a3\u03a4\7\33\2\2\u03a4\u03b2\5"\r
13248             + "\4\3\2\u03a5\u03b3\7\3\2\2\u03a6\u03ae\7\4\2\2\u03a7\u03ad\5\6\4\2\u03a8"\r
13249             + "\u03ad\5V,\2\u03a9\u03ad\5T+\2\u03aa\u03ad\5\u00b2Z\2\u03ab\u03ad\5\u00b0"\r
13250             + "Y\2\u03ac\u03a7\3\2\2\2\u03ac\u03a8\3\2\2\2\u03ac\u03a9\3\2\2\2\u03ac"\r
13251             + "\u03aa\3\2\2\2\u03ac\u03ab\3\2\2\2\u03ad\u03b0\3\2\2\2\u03ae\u03ac\3\2"\r
13252             + "\2\2\u03ae\u03af\3\2\2\2\u03af\u03b1\3\2\2\2\u03b0\u03ae\3\2\2\2\u03b1"\r
13253             + "\u03b3\7\5\2\2\u03b2\u03a5\3\2\2\2\u03b2\u03a6\3\2\2\2\u03b3\u0091\3\2"\r
13254             + "\2\2\u03b4\u03b5\5\u0090I\2\u03b5\u0093\3\2\2\2\u03b6\u03c0\5\u0092J\2"\r
13255             + "\u03b7\u03c0\5\u008eH\2\u03b8\u03c0\5\u008aF\2\u03b9\u03c0\5\u0082B\2"\r
13256             + "\u03ba\u03c0\5~@\2\u03bb\u03c0\5t;\2\u03bc\u03c0\5v<\2\u03bd\u03c0\5p"\r
13257             + "9\2\u03be\u03c0\5r:\2\u03bf\u03b6\3\2\2\2\u03bf\u03b7\3\2\2\2\u03bf\u03b8"\r
13258             + "\3\2\2\2\u03bf\u03b9\3\2\2\2\u03bf\u03ba\3\2\2\2\u03bf\u03bb\3\2\2\2\u03bf"\r
13259             + "\u03bc\3\2\2\2\u03bf\u03bd\3\2\2\2\u03bf\u03be\3\2\2\2\u03c0\u0095\3\2"\r
13260             + "\2\2\u03c1\u03c2\7\22\2\2\u03c2\u03c8\5\4\3\2\u03c3\u03c9\7\3\2\2\u03c4"\r
13261             + "\u03c5\7\4\2\2\u03c5\u03c6\5\u0094K\2\u03c6\u03c7\7\5\2\2\u03c7\u03c9"\r
13262             + "\3\2\2\2\u03c8\u03c3\3\2\2\2\u03c8\u03c4\3\2\2\2\u03c9\u0097\3\2\2\2\u03ca"\r
13263             + "\u03cb\7\21\2\2\u03cb\u03cc\5\4\3\2\u03cc\u03d3\7\4\2\2\u03cd\u03d4\5"\r
13264             + "\u0096L\2\u03ce\u03d4\5\u00aeX\2\u03cf\u03d4\5\u0084C\2\u03d0\u03d4\5"\r
13265             + "j\66\2\u03d1\u03d4\5\u00b2Z\2\u03d2\u03d4\5\u00b0Y\2\u03d3\u03cd\3\2\2"\r
13266             + "\2\u03d3\u03ce\3\2\2\2\u03d3\u03cf\3\2\2\2\u03d3\u03d0\3\2\2\2\u03d3\u03d1"\r
13267             + "\3\2\2\2\u03d3\u03d2\3\2\2\2\u03d4\u03d5\3\2\2\2\u03d5\u03d3\3\2\2\2\u03d5"\r
13268             + "\u03d6\3\2\2\2\u03d6\u03d7\3\2\2\2\u03d7\u03d8\7\5\2\2\u03d8\u0099\3\2"\r
13269             + "\2\2\u03d9\u03da\7\63\2\2\u03da\u03db\5\4\3\2\u03db\u03dc\5\b\5\2\u03dc"\r
13270             + "\u009b\3\2\2\2\u03dd\u03de\7\67\2\2\u03de\u03eb\5\4\3\2\u03df\u03ec\7"\r
13271             + "\3\2\2\u03e0\u03e7\7\4\2\2\u03e1\u03e6\5\u009aN\2\u03e2\u03e6\5j\66\2"\r
13272             + "\u03e3\u03e6\5\u00b2Z\2\u03e4\u03e6\5\u00b0Y\2\u03e5\u03e1\3\2\2\2\u03e5"\r
13273             + "\u03e2\3\2\2\2\u03e5\u03e3\3\2\2\2\u03e5\u03e4\3\2\2\2\u03e6\u03e9\3\2"\r
13274             + "\2\2\u03e7\u03e5\3\2\2\2\u03e7\u03e8\3\2\2\2\u03e8\u03ea\3\2\2\2\u03e9"\r
13275             + "\u03e7\3\2\2\2\u03ea\u03ec\7\5\2\2\u03eb\u03df\3\2\2\2\u03eb\u03e0\3\2"\r
13276             + "\2\2\u03ec\u009d\3\2\2\2\u03ed\u03ee\7G\2\2\u03ee\u03ef\5\4\3\2\u03ef"\r
13277             + "\u03f0\5\b\5\2\u03f0\u009f\3\2\2\2\u03f1\u03f2\7\64\2\2\u03f2\u03ff\5"\r
13278             + "\4\3\2\u03f3\u0400\7\3\2\2\u03f4\u03fb\7\4\2\2\u03f5\u03fa\5\u009eP\2"\r
13279             + "\u03f6\u03fa\5j\66\2\u03f7\u03fa\5\u00b2Z\2\u03f8\u03fa\5\u00b0Y\2\u03f9"\r
13280             + "\u03f5\3\2\2\2\u03f9\u03f6\3\2\2\2\u03f9\u03f7\3\2\2\2\u03f9\u03f8\3\2"\r
13281             + "\2\2\u03fa\u03fd\3\2\2\2\u03fb\u03f9\3\2\2\2\u03fb\u03fc\3\2\2\2\u03fc"\r
13282             + "\u03fe\3\2\2\2\u03fd\u03fb\3\2\2\2\u03fe\u0400\7\5\2\2\u03ff\u03f3\3\2"\r
13283             + "\2\2\u03ff\u03f4\3\2\2\2\u0400\u00a1\3\2\2\2\u0401\u0402\5\4\3\2\u0402"\r
13284             + "\u00a3\3\2\2\2\u0403\u0404\7\n\2\2\u0404\u0405\5\u00a2R\2\u0405\u0406"\r
13285             + "\5\b\5\2\u0406\u00a5\3\2\2\2\u0407\u0408\7I\2\2\u0408\u040f\5\4\3\2\u0409"\r
13286             + "\u0410\7\3\2\2\u040a\u040c\7\4\2\2\u040b\u040d\5\u00a4S\2\u040c\u040b"\r
13287             + "\3\2\2\2\u040c\u040d\3\2\2\2\u040d\u040e\3\2\2\2\u040e\u0410\7\5\2\2\u040f"\r
13288             + "\u0409\3\2\2\2\u040f\u040a\3\2\2\2\u0410\u00a7\3\2\2\2\u0411\u0412\7:"\r
13289             + "\2\2\u0412\u041f\5\4\3\2\u0413\u0420\7\3\2\2\u0414\u041b\7\4\2\2\u0415"\r
13290             + "\u041a\5\u00a6T\2\u0416\u041a\5j\66\2\u0417\u041a\5\u00b2Z\2\u0418\u041a"\r
13291             + "\5\u00b0Y\2\u0419\u0415\3\2\2\2\u0419\u0416\3\2\2\2\u0419\u0417\3\2\2"\r
13292             + "\2\u0419\u0418\3\2\2\2\u041a\u041d\3\2\2\2\u041b\u0419\3\2\2\2\u041b\u041c"\r
13293             + "\3\2\2\2\u041c\u041e\3\2\2\2\u041d\u041b\3\2\2\2\u041e\u0420\7\5\2\2\u041f"\r
13294             + "\u0413\3\2\2\2\u041f\u0414\3\2\2\2\u0420\u00a9\3\2\2\2\u0421\u0422\7\26"\r
13295             + "\2\2\u0422\u0423\5\4\3\2\u0423\u0424\5\b\5\2\u0424\u00ab\3\2\2\2\u0425"\r
13296             + "\u0426\7\27\2\2\u0426\u0430\5\4\3\2\u0427\u0431\7\3\2\2\u0428\u042a\7"\r
13297             + "\4\2\2\u0429\u042b\5\u00b2Z\2\u042a\u0429\3\2\2\2\u042a\u042b\3\2\2\2"\r
13298             + "\u042b\u042d\3\2\2\2\u042c\u042e\5\u00b0Y\2\u042d\u042c\3\2\2\2\u042d"\r
13299             + "\u042e\3\2\2\2\u042e\u042f\3\2\2\2\u042f\u0431\7\5\2\2\u0430\u0427\3\2"\r
13300             + "\2\2\u0430\u0428\3\2\2\2\u0431\u00ad\3\2\2\2\u0432\u0433\7\17\2\2\u0433"\r
13301             + "\u0434\5\4\3\2\u0434\u0435\5\b\5\2\u0435\u00af\3\2\2\2\u0436\u0437\7\32"\r
13302             + "\2\2\u0437\u0438\5\4\3\2\u0438\u0439\5\b\5\2\u0439\u00b1\3\2\2\2\u043a"\r
13303             + "\u043b\7>\2\2\u043b\u043c\5\4\3\2\u043c\u043d\5\b\5\2\u043d\u00b3\3\2"\r
13304             + "\2\2\u043e\u043f\7A\2\2\u043f\u0440\5\4\3\2\u0440\u0441\5\b\5\2\u0441"\r
13305             + "\u00b5\3\2\2\2\u0442\u0443\7\"\2\2\u0443\u0444\5\4\3\2\u0444\u0445\5\b"\r
13306             + "\5\2\u0445\u00b7\3\2\2\2\u0446\u0447\7F\2\2\u0447\u0448\5\4\3\2\u0448"\r
13307             + "\u0449\7\4\2\2\u0449\u044a\5\u00ba^\2\u044a\u044b\7\5\2\2\u044b\u00b9"\r
13308             + "\3\2\2\2\u044c\u044d\7\35\2\2\u044d\u044e\5\4\3\2\u044e\u044f\5\b\5\2"\r
13309             + "\u044f\u00bb\3\2\2\2\u0450\u0451\7%\2\2\u0451\u0452\5\4\3\2\u0452\u0453"\r
13310             + "\5\b\5\2\u0453\u00bd\3\2\2\2\u0454\u0455\7\61\2\2\u0455\u045c\5\4\3\2"\r
13311             + "\u0456\u045d\7\3\2\2\u0457\u0459\7\4\2\2\u0458\u045a\5\u00aaV\2\u0459"\r
13312             + "\u0458\3\2\2\2\u0459\u045a\3\2\2\2\u045a\u045b\3\2\2\2\u045b\u045d\7\5"\r
13313             + "\2\2\u045c\u0456\3\2\2\2\u045c\u0457\3\2\2\2\u045d\u00bf\3\2\2\2\u045e"\r
13314             + "\u045f\7\62\2\2\u045f\u0460\5\4\3\2\u0460\u0461\7\4\2\2\u0461\u0463\5"\r
13315             + "\u00ba^\2\u0462\u0464\5\u00aaV\2\u0463\u0462\3\2\2\2\u0463\u0464\3\2\2"\r
13316             + "\2\u0464\u0465\3\2\2\2\u0465\u0466\7\5\2\2\u0466\u00c1\3\2\2\2\u0467\u0468"\r
13317             + "\7\13\2\2\u0468\u0469\5\4\3\2\u0469\u046a\5\b\5\2\u046a\u00c3\3\2\2\2"\r
13318             + "\u046b\u0473\5H%\2\u046c\u0473\5F$\2\u046d\u0473\5D#\2\u046e\u0473\5B"\r
13319             + "\"\2\u046f\u0473\5<\37\2\u0470\u0473\5\66\34\2\u0471\u0473\5\64\33\2\u0472"\r
13320             + "\u046b\3\2\2\2\u0472\u046c\3\2\2\2\u0472\u046d\3\2\2\2\u0472\u046e\3\2"\r
13321             + "\2\2\u0472\u046f\3\2\2\2\u0472\u0470\3\2\2\2\u0472\u0471\3\2\2\2\u0473"\r
13322             + "\u00c5\3\2\2\2\u0474\u047f\5\u00a8U\2\u0475\u047f\5\u009cO\2\u0476\u047f"\r
13323             + "\5\u00a0Q\2\u0477\u047f\5\u0098M\2\u0478\u047f\5J&\2\u0479\u047f\5\u00c4"\r
13324             + "c\2\u047a\u047f\5\36\20\2\u047b\u047f\5\32\16\2\u047c\u047f\5\24\13\2"\r
13325             + "\u047d\u047f\5\22\n\2\u047e\u0474\3\2\2\2\u047e\u0475\3\2\2\2\u047e\u0476"\r
13326             + "\3\2\2\2\u047e\u0477\3\2\2\2\u047e\u0478\3\2\2\2\u047e\u0479\3\2\2\2\u047e"\r
13327             + "\u047a\3\2\2\2\u047e\u047b\3\2\2\2\u047e\u047c\3\2\2\2\u047e\u047d\3\2"\r
13328             + "\2\2\u047f\u0481\3\2\2\2\u0480\u047e\3\2\2\2\u0481\u0484\3\2\2\2\u0482"\r
13329             + "\u0480\3\2\2\2\u0482\u0483\3\2\2\2\u0483\u00c7\3\2\2\2\u0484\u0482\3\2"\r
13330             + "\2\2\u0485\u0487\5\u00acW\2\u0486\u0485\3\2\2\2\u0487\u048a\3\2\2\2\u0488"\r
13331             + "\u0486\3\2\2\2\u0488\u0489\3\2\2\2\u0489\u00c9\3\2\2\2\u048a\u0488\3\2"\r
13332             + "\2\2\u048b\u048e\5\u00c0a\2\u048c\u048e\5\u00be`\2\u048d\u048b\3\2\2\2"\r
13333             + "\u048d\u048c\3\2\2\2\u048e\u0491\3\2\2\2\u048f\u048d\3\2\2\2\u048f\u0490"\r
13334             + "\3\2\2\2\u0490\u00cb\3\2\2\2\u0491\u048f\3\2\2\2\u0492\u0497\5\u00b6\\"\r
13335             + "\2\u0493\u0497\5\u00b4[\2\u0494\u0497\5\u00b2Z\2\u0495\u0497\5\u00b0Y"\r
13336             + "\2\u0496\u0492\3\2\2\2\u0496\u0493\3\2\2\2\u0496\u0494\3\2\2\2\u0496\u0495"\r
13337             + "\3\2\2\2\u0497\u049a\3\2\2\2\u0498\u0496\3\2\2\2\u0498\u0499\3\2\2\2\u0499"\r
13338             + "\u00cd\3\2\2\2\u049a\u0498\3\2\2\2\u049b\u049e\5\u00c2b\2\u049c\u049e"\r
13339             + "\5\u00b8]\2\u049d\u049b\3\2\2\2\u049d\u049c\3\2\2\2\u049e\u049f\3\2\2"\r
13340             + "\2\u049f\u049d\3\2\2\2\u049f\u04a0\3\2\2\2\u04a0\u00cf\3\2\2\2\u04a1\u04a5"\r
13341             + "\5\u00c2b\2\u04a2\u04a5\5\u00bc_\2\u04a3\u04a5\5\u00ba^\2\u04a4\u04a1"\r
13342             + "\3\2\2\2\u04a4\u04a2\3\2\2\2\u04a4\u04a3\3\2\2\2\u04a5\u04a6\3\2\2\2\u04a6"\r
13343             + "\u04a4\3\2\2\2\u04a6\u04a7\3\2\2\2\u04a7\u00d1\3\2\2\2\u04a8\u04a9\7\23"\r
13344             + "\2\2\u04a9\u04aa\5\4\3\2\u04aa\u04ab\7\4\2\2\u04ab\u04ac\5\u00ceh\2\u04ac"\r
13345             + "\u04ad\5\u00caf\2\u04ad\u04ae\5\u00ccg\2\u04ae\u04af\5\u00c8e\2\u04af"\r
13346             + "\u04b0\5\u00c6d\2\u04b0\u04b1\7\5\2\2\u04b1\u00d3\3\2\2\2\u04b2\u04b3"\r
13347             + "\7\'\2\2\u04b3\u04b4\5\4\3\2\u04b4\u04b5\7\4\2\2\u04b5\u04b6\5\u00d0i"\r
13348             + "\2\u04b6\u04b7\5\u00caf\2\u04b7\u04b8\5\u00ccg\2\u04b8\u04b9\5\u00c8e"\r
13349             + "\2\u04b9\u04ba\5\u00c6d\2\u04ba\u04bb\7\5\2\2\u04bb\u00d5\3\2\2\2\u008c"\r
13350             + "\u00d8\u00df\u00e4\u00ea\u00ee\u00f1\u00fe\u0100\u0104\u010e\u0110\u0114"\r
13351             + "\u0122\u0124\u0128\u012f\u0132\u013d\u013f\u014e\u0150\u0154\u015b\u015d"\r
13352             + "\u0166\u0168\u0178\u017a\u017e\u0186\u0188\u018c\u0199\u019b\u01aa\u01ac"\r
13353             + "\u01b5\u01b7\u01bc\u01be\u01c6\u01c8\u01d1\u01d3\u01dc\u01de\u01e7\u01e9"\r
13354             + "\u01f1\u01f3\u01fd\u0206\u020a\u0218\u021a\u021e\u022d\u022f\u0233\u0240"\r
13355             + "\u0242\u0246\u024d\u025e\u0260\u0264\u0281\u0283\u0297\u0299\u02ad\u02af"\r
13356             + "\u02c4\u02c6\u02ca\u02d7\u02d9\u02dd\u02fe\u0300\u0304\u032f\u0331\u0335"\r
13357             + "\u033a\u033f\u0344\u035b\u035d\u0361\u0366\u0375\u0377\u037b\u0386\u0388"\r
13358             + "\u038c\u0390\u0392\u039a\u039f\u03a1\u03ac\u03ae\u03b2\u03bf\u03c8\u03d3"\r
13359             + "\u03d5\u03e5\u03e7\u03eb\u03f9\u03fb\u03ff\u040c\u040f\u0419\u041b\u041f"\r
13360             + "\u042a\u042d\u0430\u0459\u045c\u0463\u0472\u047e\u0482\u0488\u048d\u048f"\r
13361             + "\u0496\u0498\u049d\u049f\u04a4\u04a6";\r
13362     public static final ATN _ATN = ATNSimulator.deserialize(_serializedATN\r
13363             .toCharArray());\r
13364     static {\r
13365         _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];\r
13366     }\r
13367 }