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 org.antlr.v4.runtime.atn.*;\r
  11 import org.antlr.v4.runtime.dfa.DFA;\r
  12 import org.antlr.v4.runtime.*;\r
  13 import org.antlr.v4.runtime.misc.*;\r
  14 import org.antlr.v4.runtime.tree.*;\r
  15 import java.util.List;\r
  16 import java.util.Iterator;\r
  17 import java.util.ArrayList;\r
  18 \r
  19 @SuppressWarnings({ "all", "warnings", "unchecked", "unused", "cast" })\r
  20 public class YangParser extends Parser {\r
  21     protected static final DFA[] _decisionToDFA;\r
  22     protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache();\r
  23     public static final int CHOICE_KEYWORD = 65, YIN_ELEMENT_KEYWORD = 8,\r
  24             WHEN_KEYWORD = 10, REVISION_KEYWORD = 21, DESCRIPTION_KEYWORD = 60,\r
  25             NAMESPACE_KEYWORD = 35, MODULE_KEYWORD = 37,\r
  26             REFERENCE_KEYWORD = 24, CONTACT_KEYWORD = 63,\r
  27             LEAF_LIST_KEYWORD = 43, REVISION_DATE_KEYWORD = 20,\r
  28             BELONGS_TO_KEYWORD = 68, LEAF_KEYWORD = 44, PREFIX_KEYWORD = 27,\r
  29             DEFAULT_KEYWORD = 61, PRESENCE_KEYWORD = 26, ARGUMENT_KEYWORD = 71,\r
  30             NOTIFICATION_KEYWORD = 34, RPC_KEYWORD = 19,\r
  31             CONTAINER_KEYWORD = 62, DEVIATION_KEYWORD = 55,\r
  32             STATUS_KEYWORD = 18, IDENTITY_KEYWORD = 50, IDENTIFIER = 73,\r
  33             REFINE_KEYWORD = 23, USES_KEYWORD = 12, VALUE_KEYWORD = 11,\r
  34             IMPORT_KEYWORD = 48, INPUT_KEYWORD = 46, IF_FEATURE_KEYWORD = 49,\r
  35             PLUS = 4, PATTERN_KEYWORD = 29, LENGTH_KEYWORD = 42,\r
  36             FEATURE_KEYWORD = 53, REQUIRE_INSTANCE_KEYWORD = 22,\r
  37             ORGANIZATION_KEYWORD = 32, UNIQUE_KEYWORD = 14,\r
  38             SUBMODULE_KEYWORD = 17, TYPE_KEYWORD = 16, RIGHT_BRACE = 3,\r
  39             ERROR_MESSAGE_KEYWORD = 57, LINE_COMMENT = 6, OUTPUT_KEYWORD = 31,\r
  40             MIN_ELEMENTS_KEYWORD = 38, MUST_KEYWORD = 36, SEMICOLON = 1,\r
  41             POSITION_KEYWORD = 28, PATH_KEYWORD = 30, S = 75, KEY_KEYWORD = 45,\r
  42             EXTENSION_KEYWORD = 56, START_BLOCK_COMMENT = 7, WS = 5,\r
  43             MANDATORY_KEYWORD = 40, ORDERED_BY_KEYWORD = 33,\r
  44             ERROR_APP_TAG_KEYWORD = 58, INCLUDE_KEYWORD = 47,\r
  45             ANYXML_KEYWORD = 72, AUGMENT_KEYWORD = 70, DEVIATE_KEYWORD = 54,\r
  46             LEFT_BRACE = 2, YANG_VERSION_KEYWORD = 9, LIST_KEYWORD = 41,\r
  47             TYPEDEF_KEYWORD = 15, MAX_ELEMENTS_KEYWORD = 39, ENUM_KEYWORD = 59,\r
  48             CASE_KEYWORD = 66, UNITS_KEYWORD = 13, GROUPING_KEYWORD = 51,\r
  49             END_BLOCK_COMMENT = 76, BASE_KEYWORD = 69, RANGE_KEYWORD = 25,\r
  50             FRACTION_DIGITS_KEYWORD = 52, CONFIG_KEYWORD = 64,\r
  51             BIT_KEYWORD = 67, STRING = 74;\r
  52     public static final String[] tokenNames = { "<INVALID>", "SEMICOLON",\r
  53             "LEFT_BRACE", "'}'", "'+'", "WS", "LINE_COMMENT", "'/*'",\r
  54             "'yin-element'", "'yang-version'", "'when'", "'value'", "'uses'",\r
  55             "'units'", "'unique'", "'typedef'", "'type'", "'submodule'",\r
  56             "'status'", "'rpc'", "'revision-date'", "'revision'",\r
  57             "'require-instance'", "'refine'", "'reference'", "'range'",\r
  58             "'presence'", "'prefix'", "'position'", "'pattern'", "'path'",\r
  59             "'output'", "'organization'", "'ordered-by'", "'notification'",\r
  60             "'namespace'", "'must'", "'module'", "'min-elements'",\r
  61             "'max-elements'", "'mandatory'", "'list'", "'length'",\r
  62             "'leaf-list'", "'leaf'", "'key'", "'input'", "'include'",\r
  63             "'import'", "'if-feature'", "'identity'", "'grouping'",\r
  64             "'fraction-digits'", "'feature'", "'deviate'", "'deviation'",\r
  65             "'extension'", "'error-message'", "'error-app-tag'", "'enum'",\r
  66             "'description'", "'default'", "'container'", "'contact'",\r
  67             "'config'", "'choice'", "'case'", "'bit'", "'belongs-to'",\r
  68             "'base'", "'augment'", "'argument'", "'anyxml'", "IDENTIFIER",\r
  69             "STRING", "S", "'*/'" };\r
  70     public static final int RULE_yang = 0, RULE_string = 1,\r
  71             RULE_identifier_stmt = 2, RULE_stmtend = 3,\r
  72             RULE_deviate_replace_stmt = 4, RULE_deviate_delete_stmt = 5,\r
  73             RULE_deviate_add_stmt = 6, RULE_deviate_not_supported_stmt = 7,\r
  74             RULE_deviation_stmt = 8, RULE_notification_stmt = 9,\r
  75             RULE_output_stmt = 10, RULE_input_stmt = 11, RULE_rpc_stmt = 12,\r
  76             RULE_when_stmt = 13, RULE_augment_stmt = 14,\r
  77             RULE_uses_augment_stmt = 15, RULE_refine_anyxml_stmts = 16,\r
  78             RULE_refine_case_stmts = 17, RULE_refine_choice_stmts = 18,\r
  79             RULE_refine_list_stmts = 19, RULE_refine_leaf_list_stmts = 20,\r
  80             RULE_refine_leaf_stmts = 21, RULE_refine_container_stmts = 22,\r
  81             RULE_refune_pom = 23, RULE_refine_stmt = 24, RULE_uses_stmt = 25,\r
  82             RULE_anyxml_stmt = 26, RULE_case_stmt = 27,\r
  83             RULE_short_case_stmt = 28, RULE_choice_stmt = 29,\r
  84             RULE_unique_stmt = 30, RULE_key_stmt = 31, RULE_list_stmt = 32,\r
  85             RULE_leaf_list_stmt = 33, RULE_leaf_stmt = 34,\r
  86             RULE_container_stmt = 35, RULE_grouping_stmt = 36,\r
  87             RULE_value_stmt = 37, RULE_max_value_arg = 38,\r
  88             RULE_max_elements_stmt = 39, RULE_min_elements_stmt = 40,\r
  89             RULE_error_app_tag_stmt = 41, RULE_error_message_stmt = 42,\r
  90             RULE_must_stmt = 43, RULE_ordered_by_arg = 44,\r
  91             RULE_ordered_by_stmt = 45, RULE_presence_stmt = 46,\r
  92             RULE_mandatory_arg = 47, RULE_mandatory_stmt = 48,\r
  93             RULE_config_arg = 49, RULE_config_stmt = 50, RULE_status_arg = 51,\r
  94             RULE_status_stmt = 52, RULE_position_stmt = 53, RULE_bit_stmt = 54,\r
  95             RULE_bits_specification = 55, RULE_union_specification = 56,\r
  96             RULE_identityref_specification = 57,\r
  97             RULE_instance_identifier_specification = 58,\r
  98             RULE_require_instance_arg = 59, RULE_require_instance_stmt = 60,\r
  99             RULE_path_stmt = 61, RULE_leafref_specification = 62,\r
 100             RULE_enum_stmt = 63, RULE_enum_specification = 64,\r
 101             RULE_default_stmt = 65, RULE_pattern_stmt = 66,\r
 102             RULE_length_stmt = 67, RULE_string_restrictions = 68,\r
 103             RULE_fraction_digits_stmt = 69, RULE_decimal64_specification = 70,\r
 104             RULE_range_stmt = 71, RULE_numerical_restrictions = 72,\r
 105             RULE_type_body_stmts = 73, RULE_type_stmt = 74,\r
 106             RULE_typedef_stmt = 75, RULE_if_feature_stmt = 76,\r
 107             RULE_feature_stmt = 77, RULE_base_stmt = 78,\r
 108             RULE_identity_stmt = 79, RULE_yin_element_arg = 80,\r
 109             RULE_yin_element_stmt = 81, RULE_argument_stmt = 82,\r
 110             RULE_extension_stmt = 83, RULE_revision_date_stmt = 84,\r
 111             RULE_revision_stmt = 85, RULE_units_stmt = 86,\r
 112             RULE_reference_stmt = 87, RULE_description_stmt = 88,\r
 113             RULE_contact_stmt = 89, RULE_organization_stmt = 90,\r
 114             RULE_belongs_to_stmt = 91, RULE_prefix_stmt = 92,\r
 115             RULE_namespace_stmt = 93, RULE_include_stmt = 94,\r
 116             RULE_import_stmt = 95, RULE_yang_version_stmt = 96,\r
 117             RULE_data_def_stmt = 97, RULE_body_stmts = 98,\r
 118             RULE_revision_stmts = 99, RULE_linkage_stmts = 100,\r
 119             RULE_meta_stmts = 101, RULE_submodule_header_stmts = 102,\r
 120             RULE_module_header_stmts = 103, RULE_submodule_stmt = 104,\r
 121             RULE_module_stmt = 105;\r
 122     public static final String[] ruleNames = { "yang", "string",\r
 123             "identifier_stmt", "stmtend", "deviate_replace_stmt",\r
 124             "deviate_delete_stmt", "deviate_add_stmt",\r
 125             "deviate_not_supported_stmt", "deviation_stmt",\r
 126             "notification_stmt", "output_stmt", "input_stmt", "rpc_stmt",\r
 127             "when_stmt", "augment_stmt", "uses_augment_stmt",\r
 128             "refine_anyxml_stmts", "refine_case_stmts", "refine_choice_stmts",\r
 129             "refine_list_stmts", "refine_leaf_list_stmts", "refine_leaf_stmts",\r
 130             "refine_container_stmts", "refune_pom", "refine_stmt", "uses_stmt",\r
 131             "anyxml_stmt", "case_stmt", "short_case_stmt", "choice_stmt",\r
 132             "unique_stmt", "key_stmt", "list_stmt", "leaf_list_stmt",\r
 133             "leaf_stmt", "container_stmt", "grouping_stmt", "value_stmt",\r
 134             "max_value_arg", "max_elements_stmt", "min_elements_stmt",\r
 135             "error_app_tag_stmt", "error_message_stmt", "must_stmt",\r
 136             "ordered_by_arg", "ordered_by_stmt", "presence_stmt",\r
 137             "mandatory_arg", "mandatory_stmt", "config_arg", "config_stmt",\r
 138             "status_arg", "status_stmt", "position_stmt", "bit_stmt",\r
 139             "bits_specification", "union_specification",\r
 140             "identityref_specification", "instance_identifier_specification",\r
 141             "require_instance_arg", "require_instance_stmt", "path_stmt",\r
 142             "leafref_specification", "enum_stmt", "enum_specification",\r
 143             "default_stmt", "pattern_stmt", "length_stmt",\r
 144             "string_restrictions", "fraction_digits_stmt",\r
 145             "decimal64_specification", "range_stmt", "numerical_restrictions",\r
 146             "type_body_stmts", "type_stmt", "typedef_stmt", "if_feature_stmt",\r
 147             "feature_stmt", "base_stmt", "identity_stmt", "yin_element_arg",\r
 148             "yin_element_stmt", "argument_stmt", "extension_stmt",\r
 149             "revision_date_stmt", "revision_stmt", "units_stmt",\r
 150             "reference_stmt", "description_stmt", "contact_stmt",\r
 151             "organization_stmt", "belongs_to_stmt", "prefix_stmt",\r
 152             "namespace_stmt", "include_stmt", "import_stmt",\r
 153             "yang_version_stmt", "data_def_stmt", "body_stmts",\r
 154             "revision_stmts", "linkage_stmts", "meta_stmts",\r
 155             "submodule_header_stmts", "module_header_stmts", "submodule_stmt",\r
 156             "module_stmt" };\r
 157 \r
 158     @Override\r
 159     public String getGrammarFileName() {\r
 160         return "yangParser.g4";\r
 161     }\r
 162 \r
 163     @Override\r
 164     public String[] getTokenNames() {\r
 165         return tokenNames;\r
 166     }\r
 167 \r
 168     @Override\r
 169     public String[] getRuleNames() {\r
 170         return ruleNames;\r
 171     }\r
 172 \r
 173     @Override\r
 174     public ATN getATN() {\r
 175         return _ATN;\r
 176     }\r
 177 \r
 178     public YangParser(TokenStream input) {\r
 179         super(input);\r
 180         _interp = new ParserATNSimulator(this, _ATN, _decisionToDFA,\r
 181                 _sharedContextCache);\r
 182     }\r
 183 \r
 184     public static class YangContext extends ParserRuleContext {\r
 185         public Submodule_stmtContext submodule_stmt() {\r
 186             return getRuleContext(Submodule_stmtContext.class, 0);\r
 187         }\r
 188 \r
 189         public Module_stmtContext module_stmt() {\r
 190             return getRuleContext(Module_stmtContext.class, 0);\r
 191         }\r
 192 \r
 193         public YangContext(ParserRuleContext parent, int invokingState) {\r
 194             super(parent, invokingState);\r
 195         }\r
 196 \r
 197         @Override\r
 198         public int getRuleIndex() {\r
 199             return RULE_yang;\r
 200         }\r
 201 \r
 202         @Override\r
 203         public void enterRule(ParseTreeListener listener) {\r
 204             if (listener instanceof YangParserListener)\r
 205                 ((YangParserListener) listener).enterYang(this);\r
 206         }\r
 207 \r
 208         @Override\r
 209         public void exitRule(ParseTreeListener listener) {\r
 210             if (listener instanceof YangParserListener)\r
 211                 ((YangParserListener) listener).exitYang(this);\r
 212         }\r
 213 \r
 214         @Override\r
 215         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
 216             if (visitor instanceof YangParserVisitor)\r
 217                 return ((YangParserVisitor<? extends T>) visitor)\r
 218                         .visitYang(this);\r
 219             else\r
 220                 return visitor.visitChildren(this);\r
 221         }\r
 222     }\r
 223 \r
 224     public final YangContext yang() throws RecognitionException {\r
 225         YangContext _localctx = new YangContext(_ctx, getState());\r
 226         enterRule(_localctx, 0, RULE_yang);\r
 227         try {\r
 228             setState(214);\r
 229             switch (_input.LA(1)) {\r
 230             case MODULE_KEYWORD:\r
 231                 enterOuterAlt(_localctx, 1);\r
 232                 {\r
 233                     setState(212);\r
 234                     module_stmt();\r
 235                 }\r
 236                 break;\r
 237             case SUBMODULE_KEYWORD:\r
 238                 enterOuterAlt(_localctx, 2);\r
 239                 {\r
 240                     setState(213);\r
 241                     submodule_stmt();\r
 242                 }\r
 243                 break;\r
 244             default:\r
 245                 throw new NoViableAltException(this);\r
 246             }\r
 247         } catch (RecognitionException re) {\r
 248             _localctx.exception = re;\r
 249             _errHandler.reportError(this, re);\r
 250             _errHandler.recover(this, re);\r
 251         } finally {\r
 252             exitRule();\r
 253         }\r
 254         return _localctx;\r
 255     }\r
 256 \r
 257     public static class StringContext extends ParserRuleContext {\r
 258         public List<TerminalNode> PLUS() {\r
 259             return getTokens(YangParser.PLUS);\r
 260         }\r
 261 \r
 262         public TerminalNode STRING(int i) {\r
 263             return getToken(YangParser.STRING, i);\r
 264         }\r
 265 \r
 266         public TerminalNode PLUS(int i) {\r
 267             return getToken(YangParser.PLUS, i);\r
 268         }\r
 269 \r
 270         public List<TerminalNode> STRING() {\r
 271             return getTokens(YangParser.STRING);\r
 272         }\r
 273 \r
 274         public StringContext(ParserRuleContext parent, int invokingState) {\r
 275             super(parent, invokingState);\r
 276         }\r
 277 \r
 278         @Override\r
 279         public int getRuleIndex() {\r
 280             return RULE_string;\r
 281         }\r
 282 \r
 283         @Override\r
 284         public void enterRule(ParseTreeListener listener) {\r
 285             if (listener instanceof YangParserListener)\r
 286                 ((YangParserListener) listener).enterString(this);\r
 287         }\r
 288 \r
 289         @Override\r
 290         public void exitRule(ParseTreeListener listener) {\r
 291             if (listener instanceof YangParserListener)\r
 292                 ((YangParserListener) listener).exitString(this);\r
 293         }\r
 294 \r
 295         @Override\r
 296         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
 297             if (visitor instanceof YangParserVisitor)\r
 298                 return ((YangParserVisitor<? extends T>) visitor)\r
 299                         .visitString(this);\r
 300             else\r
 301                 return visitor.visitChildren(this);\r
 302         }\r
 303     }\r
 304 \r
 305     public final StringContext string() throws RecognitionException {\r
 306         StringContext _localctx = new StringContext(_ctx, getState());\r
 307         enterRule(_localctx, 2, RULE_string);\r
 308         int _la;\r
 309         try {\r
 310             enterOuterAlt(_localctx, 1);\r
 311             {\r
 312                 setState(216);\r
 313                 match(STRING);\r
 314                 setState(221);\r
 315                 _errHandler.sync(this);\r
 316                 _la = _input.LA(1);\r
 317                 while (_la == PLUS) {\r
 318                     {\r
 319                         {\r
 320                             setState(217);\r
 321                             match(PLUS);\r
 322                             setState(218);\r
 323                             match(STRING);\r
 324                         }\r
 325                     }\r
 326                     setState(223);\r
 327                     _errHandler.sync(this);\r
 328                     _la = _input.LA(1);\r
 329                 }\r
 330             }\r
 331         } catch (RecognitionException re) {\r
 332             _localctx.exception = re;\r
 333             _errHandler.reportError(this, re);\r
 334             _errHandler.recover(this, re);\r
 335         } finally {\r
 336             exitRule();\r
 337         }\r
 338         return _localctx;\r
 339     }\r
 340 \r
 341     public static class Identifier_stmtContext extends ParserRuleContext {\r
 342         public StringContext string() {\r
 343             return getRuleContext(StringContext.class, 0);\r
 344         }\r
 345 \r
 346         public StmtendContext stmtend() {\r
 347             return getRuleContext(StmtendContext.class, 0);\r
 348         }\r
 349 \r
 350         public TerminalNode IDENTIFIER() {\r
 351             return getToken(YangParser.IDENTIFIER, 0);\r
 352         }\r
 353 \r
 354         public Identifier_stmtContext(ParserRuleContext parent,\r
 355                 int invokingState) {\r
 356             super(parent, invokingState);\r
 357         }\r
 358 \r
 359         @Override\r
 360         public int getRuleIndex() {\r
 361             return RULE_identifier_stmt;\r
 362         }\r
 363 \r
 364         @Override\r
 365         public void enterRule(ParseTreeListener listener) {\r
 366             if (listener instanceof YangParserListener)\r
 367                 ((YangParserListener) listener).enterIdentifier_stmt(this);\r
 368         }\r
 369 \r
 370         @Override\r
 371         public void exitRule(ParseTreeListener listener) {\r
 372             if (listener instanceof YangParserListener)\r
 373                 ((YangParserListener) listener).exitIdentifier_stmt(this);\r
 374         }\r
 375 \r
 376         @Override\r
 377         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
 378             if (visitor instanceof YangParserVisitor)\r
 379                 return ((YangParserVisitor<? extends T>) visitor)\r
 380                         .visitIdentifier_stmt(this);\r
 381             else\r
 382                 return visitor.visitChildren(this);\r
 383         }\r
 384     }\r
 385 \r
 386     public final Identifier_stmtContext identifier_stmt()\r
 387             throws RecognitionException {\r
 388         Identifier_stmtContext _localctx = new Identifier_stmtContext(_ctx,\r
 389                 getState());\r
 390         enterRule(_localctx, 4, RULE_identifier_stmt);\r
 391         int _la;\r
 392         try {\r
 393             enterOuterAlt(_localctx, 1);\r
 394             {\r
 395                 setState(224);\r
 396                 match(IDENTIFIER);\r
 397                 setState(226);\r
 398                 _la = _input.LA(1);\r
 399                 if (_la == STRING) {\r
 400                     {\r
 401                         setState(225);\r
 402                         string();\r
 403                     }\r
 404                 }\r
 405 \r
 406                 setState(228);\r
 407                 stmtend();\r
 408             }\r
 409         } catch (RecognitionException re) {\r
 410             _localctx.exception = re;\r
 411             _errHandler.reportError(this, re);\r
 412             _errHandler.recover(this, re);\r
 413         } finally {\r
 414             exitRule();\r
 415         }\r
 416         return _localctx;\r
 417     }\r
 418 \r
 419     public static class StmtendContext extends ParserRuleContext {\r
 420         public TerminalNode RIGHT_BRACE() {\r
 421             return getToken(YangParser.RIGHT_BRACE, 0);\r
 422         }\r
 423 \r
 424         public TerminalNode SEMICOLON() {\r
 425             return getToken(YangParser.SEMICOLON, 0);\r
 426         }\r
 427 \r
 428         public Identifier_stmtContext identifier_stmt() {\r
 429             return getRuleContext(Identifier_stmtContext.class, 0);\r
 430         }\r
 431 \r
 432         public TerminalNode LEFT_BRACE() {\r
 433             return getToken(YangParser.LEFT_BRACE, 0);\r
 434         }\r
 435 \r
 436         public StmtendContext(ParserRuleContext parent, int invokingState) {\r
 437             super(parent, invokingState);\r
 438         }\r
 439 \r
 440         @Override\r
 441         public int getRuleIndex() {\r
 442             return RULE_stmtend;\r
 443         }\r
 444 \r
 445         @Override\r
 446         public void enterRule(ParseTreeListener listener) {\r
 447             if (listener instanceof YangParserListener)\r
 448                 ((YangParserListener) listener).enterStmtend(this);\r
 449         }\r
 450 \r
 451         @Override\r
 452         public void exitRule(ParseTreeListener listener) {\r
 453             if (listener instanceof YangParserListener)\r
 454                 ((YangParserListener) listener).exitStmtend(this);\r
 455         }\r
 456 \r
 457         @Override\r
 458         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
 459             if (visitor instanceof YangParserVisitor)\r
 460                 return ((YangParserVisitor<? extends T>) visitor)\r
 461                         .visitStmtend(this);\r
 462             else\r
 463                 return visitor.visitChildren(this);\r
 464         }\r
 465     }\r
 466 \r
 467     public final StmtendContext stmtend() throws RecognitionException {\r
 468         StmtendContext _localctx = new StmtendContext(_ctx, getState());\r
 469         enterRule(_localctx, 6, RULE_stmtend);\r
 470         int _la;\r
 471         try {\r
 472             setState(239);\r
 473             switch (_input.LA(1)) {\r
 474             case SEMICOLON:\r
 475                 enterOuterAlt(_localctx, 1);\r
 476                 {\r
 477                     {\r
 478                         setState(230);\r
 479                         match(SEMICOLON);\r
 480                         setState(232);\r
 481                         switch (getInterpreter().adaptivePredict(_input, 3,\r
 482                                 _ctx)) {\r
 483                         case 1: {\r
 484                             setState(231);\r
 485                             identifier_stmt();\r
 486                         }\r
 487                             break;\r
 488                         }\r
 489                     }\r
 490                 }\r
 491                 break;\r
 492             case LEFT_BRACE:\r
 493                 enterOuterAlt(_localctx, 2);\r
 494                 {\r
 495                     {\r
 496                         setState(234);\r
 497                         match(LEFT_BRACE);\r
 498                         setState(236);\r
 499                         _la = _input.LA(1);\r
 500                         if (_la == IDENTIFIER) {\r
 501                             {\r
 502                                 setState(235);\r
 503                                 identifier_stmt();\r
 504                             }\r
 505                         }\r
 506 \r
 507                         setState(238);\r
 508                         match(RIGHT_BRACE);\r
 509                     }\r
 510                 }\r
 511                 break;\r
 512             default:\r
 513                 throw new NoViableAltException(this);\r
 514             }\r
 515         } catch (RecognitionException re) {\r
 516             _localctx.exception = re;\r
 517             _errHandler.reportError(this, re);\r
 518             _errHandler.recover(this, re);\r
 519         } finally {\r
 520             exitRule();\r
 521         }\r
 522         return _localctx;\r
 523     }\r
 524 \r
 525     public static class Deviate_replace_stmtContext extends ParserRuleContext {\r
 526         public TerminalNode RIGHT_BRACE() {\r
 527             return getToken(YangParser.RIGHT_BRACE, 0);\r
 528         }\r
 529 \r
 530         public Units_stmtContext units_stmt(int i) {\r
 531             return getRuleContext(Units_stmtContext.class, i);\r
 532         }\r
 533 \r
 534         public Default_stmtContext default_stmt(int i) {\r
 535             return getRuleContext(Default_stmtContext.class, i);\r
 536         }\r
 537 \r
 538         public List<Units_stmtContext> units_stmt() {\r
 539             return getRuleContexts(Units_stmtContext.class);\r
 540         }\r
 541 \r
 542         public List<Max_elements_stmtContext> max_elements_stmt() {\r
 543             return getRuleContexts(Max_elements_stmtContext.class);\r
 544         }\r
 545 \r
 546         public Type_stmtContext type_stmt(int i) {\r
 547             return getRuleContext(Type_stmtContext.class, i);\r
 548         }\r
 549 \r
 550         public TerminalNode DEVIATE_KEYWORD() {\r
 551             return getToken(YangParser.DEVIATE_KEYWORD, 0);\r
 552         }\r
 553 \r
 554         public TerminalNode LEFT_BRACE() {\r
 555             return getToken(YangParser.LEFT_BRACE, 0);\r
 556         }\r
 557 \r
 558         public List<Mandatory_stmtContext> mandatory_stmt() {\r
 559             return getRuleContexts(Mandatory_stmtContext.class);\r
 560         }\r
 561 \r
 562         public List<Type_stmtContext> type_stmt() {\r
 563             return getRuleContexts(Type_stmtContext.class);\r
 564         }\r
 565 \r
 566         public Min_elements_stmtContext min_elements_stmt(int i) {\r
 567             return getRuleContext(Min_elements_stmtContext.class, i);\r
 568         }\r
 569 \r
 570         public List<Default_stmtContext> default_stmt() {\r
 571             return getRuleContexts(Default_stmtContext.class);\r
 572         }\r
 573 \r
 574         public Mandatory_stmtContext mandatory_stmt(int i) {\r
 575             return getRuleContext(Mandatory_stmtContext.class, i);\r
 576         }\r
 577 \r
 578         public Config_stmtContext config_stmt(int i) {\r
 579             return getRuleContext(Config_stmtContext.class, i);\r
 580         }\r
 581 \r
 582         public TerminalNode SEMICOLON() {\r
 583             return getToken(YangParser.SEMICOLON, 0);\r
 584         }\r
 585 \r
 586         public List<Min_elements_stmtContext> min_elements_stmt() {\r
 587             return getRuleContexts(Min_elements_stmtContext.class);\r
 588         }\r
 589 \r
 590         public StringContext string() {\r
 591             return getRuleContext(StringContext.class, 0);\r
 592         }\r
 593 \r
 594         public List<Config_stmtContext> config_stmt() {\r
 595             return getRuleContexts(Config_stmtContext.class);\r
 596         }\r
 597 \r
 598         public Max_elements_stmtContext max_elements_stmt(int i) {\r
 599             return getRuleContext(Max_elements_stmtContext.class, i);\r
 600         }\r
 601 \r
 602         public Deviate_replace_stmtContext(ParserRuleContext parent,\r
 603                 int invokingState) {\r
 604             super(parent, invokingState);\r
 605         }\r
 606 \r
 607         @Override\r
 608         public int getRuleIndex() {\r
 609             return RULE_deviate_replace_stmt;\r
 610         }\r
 611 \r
 612         @Override\r
 613         public void enterRule(ParseTreeListener listener) {\r
 614             if (listener instanceof YangParserListener)\r
 615                 ((YangParserListener) listener).enterDeviate_replace_stmt(this);\r
 616         }\r
 617 \r
 618         @Override\r
 619         public void exitRule(ParseTreeListener listener) {\r
 620             if (listener instanceof YangParserListener)\r
 621                 ((YangParserListener) listener).exitDeviate_replace_stmt(this);\r
 622         }\r
 623 \r
 624         @Override\r
 625         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
 626             if (visitor instanceof YangParserVisitor)\r
 627                 return ((YangParserVisitor<? extends T>) visitor)\r
 628                         .visitDeviate_replace_stmt(this);\r
 629             else\r
 630                 return visitor.visitChildren(this);\r
 631         }\r
 632     }\r
 633 \r
 634     public final Deviate_replace_stmtContext deviate_replace_stmt()\r
 635             throws RecognitionException {\r
 636         Deviate_replace_stmtContext _localctx = new Deviate_replace_stmtContext(\r
 637                 _ctx, getState());\r
 638         enterRule(_localctx, 8, RULE_deviate_replace_stmt);\r
 639         int _la;\r
 640         try {\r
 641             enterOuterAlt(_localctx, 1);\r
 642             {\r
 643                 setState(241);\r
 644                 match(DEVIATE_KEYWORD);\r
 645                 setState(242);\r
 646                 string();\r
 647                 setState(258);\r
 648                 switch (_input.LA(1)) {\r
 649                 case SEMICOLON: {\r
 650                     setState(243);\r
 651                     match(SEMICOLON);\r
 652                 }\r
 653                     break;\r
 654                 case LEFT_BRACE: {\r
 655                     {\r
 656                         setState(244);\r
 657                         match(LEFT_BRACE);\r
 658                         setState(254);\r
 659                         _errHandler.sync(this);\r
 660                         _la = _input.LA(1);\r
 661                         while (((((_la - 13)) & ~0x3f) == 0 && ((1L << (_la - 13)) & ((1L << (UNITS_KEYWORD - 13))\r
 662                                 | (1L << (TYPE_KEYWORD - 13))\r
 663                                 | (1L << (MIN_ELEMENTS_KEYWORD - 13))\r
 664                                 | (1L << (MAX_ELEMENTS_KEYWORD - 13))\r
 665                                 | (1L << (MANDATORY_KEYWORD - 13))\r
 666                                 | (1L << (DEFAULT_KEYWORD - 13)) | (1L << (CONFIG_KEYWORD - 13)))) != 0)) {\r
 667                             {\r
 668                                 setState(252);\r
 669                                 switch (_input.LA(1)) {\r
 670                                 case TYPE_KEYWORD: {\r
 671                                     setState(245);\r
 672                                     type_stmt();\r
 673                                 }\r
 674                                     break;\r
 675                                 case UNITS_KEYWORD: {\r
 676                                     setState(246);\r
 677                                     units_stmt();\r
 678                                 }\r
 679                                     break;\r
 680                                 case DEFAULT_KEYWORD: {\r
 681                                     setState(247);\r
 682                                     default_stmt();\r
 683                                 }\r
 684                                     break;\r
 685                                 case CONFIG_KEYWORD: {\r
 686                                     setState(248);\r
 687                                     config_stmt();\r
 688                                 }\r
 689                                     break;\r
 690                                 case MANDATORY_KEYWORD: {\r
 691                                     setState(249);\r
 692                                     mandatory_stmt();\r
 693                                 }\r
 694                                     break;\r
 695                                 case MIN_ELEMENTS_KEYWORD: {\r
 696                                     setState(250);\r
 697                                     min_elements_stmt();\r
 698                                 }\r
 699                                     break;\r
 700                                 case MAX_ELEMENTS_KEYWORD: {\r
 701                                     setState(251);\r
 702                                     max_elements_stmt();\r
 703                                 }\r
 704                                     break;\r
 705                                 default:\r
 706                                     throw new NoViableAltException(this);\r
 707                                 }\r
 708                             }\r
 709                             setState(256);\r
 710                             _errHandler.sync(this);\r
 711                             _la = _input.LA(1);\r
 712                         }\r
 713                         setState(257);\r
 714                         match(RIGHT_BRACE);\r
 715                     }\r
 716                 }\r
 717                     break;\r
 718                 default:\r
 719                     throw new NoViableAltException(this);\r
 720                 }\r
 721             }\r
 722         } catch (RecognitionException re) {\r
 723             _localctx.exception = re;\r
 724             _errHandler.reportError(this, re);\r
 725             _errHandler.recover(this, re);\r
 726         } finally {\r
 727             exitRule();\r
 728         }\r
 729         return _localctx;\r
 730     }\r
 731 \r
 732     public static class Deviate_delete_stmtContext extends ParserRuleContext {\r
 733         public Units_stmtContext units_stmt(int i) {\r
 734             return getRuleContext(Units_stmtContext.class, i);\r
 735         }\r
 736 \r
 737         public TerminalNode RIGHT_BRACE() {\r
 738             return getToken(YangParser.RIGHT_BRACE, 0);\r
 739         }\r
 740 \r
 741         public List<Default_stmtContext> default_stmt() {\r
 742             return getRuleContexts(Default_stmtContext.class);\r
 743         }\r
 744 \r
 745         public Default_stmtContext default_stmt(int i) {\r
 746             return getRuleContext(Default_stmtContext.class, i);\r
 747         }\r
 748 \r
 749         public List<Units_stmtContext> units_stmt() {\r
 750             return getRuleContexts(Units_stmtContext.class);\r
 751         }\r
 752 \r
 753         public TerminalNode SEMICOLON() {\r
 754             return getToken(YangParser.SEMICOLON, 0);\r
 755         }\r
 756 \r
 757         public List<Must_stmtContext> must_stmt() {\r
 758             return getRuleContexts(Must_stmtContext.class);\r
 759         }\r
 760 \r
 761         public StringContext string() {\r
 762             return getRuleContext(StringContext.class, 0);\r
 763         }\r
 764 \r
 765         public List<Unique_stmtContext> unique_stmt() {\r
 766             return getRuleContexts(Unique_stmtContext.class);\r
 767         }\r
 768 \r
 769         public TerminalNode DEVIATE_KEYWORD() {\r
 770             return getToken(YangParser.DEVIATE_KEYWORD, 0);\r
 771         }\r
 772 \r
 773         public TerminalNode LEFT_BRACE() {\r
 774             return getToken(YangParser.LEFT_BRACE, 0);\r
 775         }\r
 776 \r
 777         public Must_stmtContext must_stmt(int i) {\r
 778             return getRuleContext(Must_stmtContext.class, i);\r
 779         }\r
 780 \r
 781         public Unique_stmtContext unique_stmt(int i) {\r
 782             return getRuleContext(Unique_stmtContext.class, i);\r
 783         }\r
 784 \r
 785         public Deviate_delete_stmtContext(ParserRuleContext parent,\r
 786                 int invokingState) {\r
 787             super(parent, invokingState);\r
 788         }\r
 789 \r
 790         @Override\r
 791         public int getRuleIndex() {\r
 792             return RULE_deviate_delete_stmt;\r
 793         }\r
 794 \r
 795         @Override\r
 796         public void enterRule(ParseTreeListener listener) {\r
 797             if (listener instanceof YangParserListener)\r
 798                 ((YangParserListener) listener).enterDeviate_delete_stmt(this);\r
 799         }\r
 800 \r
 801         @Override\r
 802         public void exitRule(ParseTreeListener listener) {\r
 803             if (listener instanceof YangParserListener)\r
 804                 ((YangParserListener) listener).exitDeviate_delete_stmt(this);\r
 805         }\r
 806 \r
 807         @Override\r
 808         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
 809             if (visitor instanceof YangParserVisitor)\r
 810                 return ((YangParserVisitor<? extends T>) visitor)\r
 811                         .visitDeviate_delete_stmt(this);\r
 812             else\r
 813                 return visitor.visitChildren(this);\r
 814         }\r
 815     }\r
 816 \r
 817     public final Deviate_delete_stmtContext deviate_delete_stmt()\r
 818             throws RecognitionException {\r
 819         Deviate_delete_stmtContext _localctx = new Deviate_delete_stmtContext(\r
 820                 _ctx, getState());\r
 821         enterRule(_localctx, 10, RULE_deviate_delete_stmt);\r
 822         int _la;\r
 823         try {\r
 824             enterOuterAlt(_localctx, 1);\r
 825             {\r
 826                 setState(260);\r
 827                 match(DEVIATE_KEYWORD);\r
 828                 setState(261);\r
 829                 string();\r
 830                 setState(274);\r
 831                 switch (_input.LA(1)) {\r
 832                 case SEMICOLON: {\r
 833                     setState(262);\r
 834                     match(SEMICOLON);\r
 835                 }\r
 836                     break;\r
 837                 case LEFT_BRACE: {\r
 838                     {\r
 839                         setState(263);\r
 840                         match(LEFT_BRACE);\r
 841                         setState(270);\r
 842                         _errHandler.sync(this);\r
 843                         _la = _input.LA(1);\r
 844                         while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << UNITS_KEYWORD)\r
 845                                 | (1L << UNIQUE_KEYWORD) | (1L << MUST_KEYWORD) | (1L << DEFAULT_KEYWORD))) != 0)) {\r
 846                             {\r
 847                                 setState(268);\r
 848                                 switch (_input.LA(1)) {\r
 849                                 case UNITS_KEYWORD: {\r
 850                                     setState(264);\r
 851                                     units_stmt();\r
 852                                 }\r
 853                                     break;\r
 854                                 case MUST_KEYWORD: {\r
 855                                     setState(265);\r
 856                                     must_stmt();\r
 857                                 }\r
 858                                     break;\r
 859                                 case UNIQUE_KEYWORD: {\r
 860                                     setState(266);\r
 861                                     unique_stmt();\r
 862                                 }\r
 863                                     break;\r
 864                                 case DEFAULT_KEYWORD: {\r
 865                                     setState(267);\r
 866                                     default_stmt();\r
 867                                 }\r
 868                                     break;\r
 869                                 default:\r
 870                                     throw new NoViableAltException(this);\r
 871                                 }\r
 872                             }\r
 873                             setState(272);\r
 874                             _errHandler.sync(this);\r
 875                             _la = _input.LA(1);\r
 876                         }\r
 877                         setState(273);\r
 878                         match(RIGHT_BRACE);\r
 879                     }\r
 880                 }\r
 881                     break;\r
 882                 default:\r
 883                     throw new NoViableAltException(this);\r
 884                 }\r
 885             }\r
 886         } catch (RecognitionException re) {\r
 887             _localctx.exception = re;\r
 888             _errHandler.reportError(this, re);\r
 889             _errHandler.recover(this, re);\r
 890         } finally {\r
 891             exitRule();\r
 892         }\r
 893         return _localctx;\r
 894     }\r
 895 \r
 896     public static class Deviate_add_stmtContext extends ParserRuleContext {\r
 897         public TerminalNode RIGHT_BRACE() {\r
 898             return getToken(YangParser.RIGHT_BRACE, 0);\r
 899         }\r
 900 \r
 901         public Units_stmtContext units_stmt(int i) {\r
 902             return getRuleContext(Units_stmtContext.class, i);\r
 903         }\r
 904 \r
 905         public Default_stmtContext default_stmt(int i) {\r
 906             return getRuleContext(Default_stmtContext.class, i);\r
 907         }\r
 908 \r
 909         public List<Units_stmtContext> units_stmt() {\r
 910             return getRuleContexts(Units_stmtContext.class);\r
 911         }\r
 912 \r
 913         public List<Max_elements_stmtContext> max_elements_stmt() {\r
 914             return getRuleContexts(Max_elements_stmtContext.class);\r
 915         }\r
 916 \r
 917         public TerminalNode DEVIATE_KEYWORD() {\r
 918             return getToken(YangParser.DEVIATE_KEYWORD, 0);\r
 919         }\r
 920 \r
 921         public TerminalNode LEFT_BRACE() {\r
 922             return getToken(YangParser.LEFT_BRACE, 0);\r
 923         }\r
 924 \r
 925         public List<Mandatory_stmtContext> mandatory_stmt() {\r
 926             return getRuleContexts(Mandatory_stmtContext.class);\r
 927         }\r
 928 \r
 929         public Must_stmtContext must_stmt(int i) {\r
 930             return getRuleContext(Must_stmtContext.class, i);\r
 931         }\r
 932 \r
 933         public Min_elements_stmtContext min_elements_stmt(int i) {\r
 934             return getRuleContext(Min_elements_stmtContext.class, i);\r
 935         }\r
 936 \r
 937         public List<Default_stmtContext> default_stmt() {\r
 938             return getRuleContexts(Default_stmtContext.class);\r
 939         }\r
 940 \r
 941         public Mandatory_stmtContext mandatory_stmt(int i) {\r
 942             return getRuleContext(Mandatory_stmtContext.class, i);\r
 943         }\r
 944 \r
 945         public Config_stmtContext config_stmt(int i) {\r
 946             return getRuleContext(Config_stmtContext.class, i);\r
 947         }\r
 948 \r
 949         public TerminalNode SEMICOLON() {\r
 950             return getToken(YangParser.SEMICOLON, 0);\r
 951         }\r
 952 \r
 953         public List<Min_elements_stmtContext> min_elements_stmt() {\r
 954             return getRuleContexts(Min_elements_stmtContext.class);\r
 955         }\r
 956 \r
 957         public List<Config_stmtContext> config_stmt() {\r
 958             return getRuleContexts(Config_stmtContext.class);\r
 959         }\r
 960 \r
 961         public StringContext string() {\r
 962             return getRuleContext(StringContext.class, 0);\r
 963         }\r
 964 \r
 965         public List<Must_stmtContext> must_stmt() {\r
 966             return getRuleContexts(Must_stmtContext.class);\r
 967         }\r
 968 \r
 969         public List<Unique_stmtContext> unique_stmt() {\r
 970             return getRuleContexts(Unique_stmtContext.class);\r
 971         }\r
 972 \r
 973         public Max_elements_stmtContext max_elements_stmt(int i) {\r
 974             return getRuleContext(Max_elements_stmtContext.class, i);\r
 975         }\r
 976 \r
 977         public Unique_stmtContext unique_stmt(int i) {\r
 978             return getRuleContext(Unique_stmtContext.class, i);\r
 979         }\r
 980 \r
 981         public Deviate_add_stmtContext(ParserRuleContext parent,\r
 982                 int invokingState) {\r
 983             super(parent, invokingState);\r
 984         }\r
 985 \r
 986         @Override\r
 987         public int getRuleIndex() {\r
 988             return RULE_deviate_add_stmt;\r
 989         }\r
 990 \r
 991         @Override\r
 992         public void enterRule(ParseTreeListener listener) {\r
 993             if (listener instanceof YangParserListener)\r
 994                 ((YangParserListener) listener).enterDeviate_add_stmt(this);\r
 995         }\r
 996 \r
 997         @Override\r
 998         public void exitRule(ParseTreeListener listener) {\r
 999             if (listener instanceof YangParserListener)\r
1000                 ((YangParserListener) listener).exitDeviate_add_stmt(this);\r
1001         }\r
1002 \r
1003         @Override\r
1004         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
1005             if (visitor instanceof YangParserVisitor)\r
1006                 return ((YangParserVisitor<? extends T>) visitor)\r
1007                         .visitDeviate_add_stmt(this);\r
1008             else\r
1009                 return visitor.visitChildren(this);\r
1010         }\r
1011     }\r
1012 \r
1013     public final Deviate_add_stmtContext deviate_add_stmt()\r
1014             throws RecognitionException {\r
1015         Deviate_add_stmtContext _localctx = new Deviate_add_stmtContext(_ctx,\r
1016                 getState());\r
1017         enterRule(_localctx, 12, RULE_deviate_add_stmt);\r
1018         int _la;\r
1019         try {\r
1020             enterOuterAlt(_localctx, 1);\r
1021             {\r
1022                 setState(276);\r
1023                 match(DEVIATE_KEYWORD);\r
1024                 setState(277);\r
1025                 string();\r
1026                 setState(294);\r
1027                 switch (_input.LA(1)) {\r
1028                 case SEMICOLON: {\r
1029                     setState(278);\r
1030                     match(SEMICOLON);\r
1031                 }\r
1032                     break;\r
1033                 case LEFT_BRACE: {\r
1034                     {\r
1035                         setState(279);\r
1036                         match(LEFT_BRACE);\r
1037                         setState(290);\r
1038                         _errHandler.sync(this);\r
1039                         _la = _input.LA(1);\r
1040                         while (((((_la - 13)) & ~0x3f) == 0 && ((1L << (_la - 13)) & ((1L << (UNITS_KEYWORD - 13))\r
1041                                 | (1L << (UNIQUE_KEYWORD - 13))\r
1042                                 | (1L << (MUST_KEYWORD - 13))\r
1043                                 | (1L << (MIN_ELEMENTS_KEYWORD - 13))\r
1044                                 | (1L << (MAX_ELEMENTS_KEYWORD - 13))\r
1045                                 | (1L << (MANDATORY_KEYWORD - 13))\r
1046                                 | (1L << (DEFAULT_KEYWORD - 13)) | (1L << (CONFIG_KEYWORD - 13)))) != 0)) {\r
1047                             {\r
1048                                 setState(288);\r
1049                                 switch (_input.LA(1)) {\r
1050                                 case UNITS_KEYWORD: {\r
1051                                     setState(280);\r
1052                                     units_stmt();\r
1053                                 }\r
1054                                     break;\r
1055                                 case MUST_KEYWORD: {\r
1056                                     setState(281);\r
1057                                     must_stmt();\r
1058                                 }\r
1059                                     break;\r
1060                                 case UNIQUE_KEYWORD: {\r
1061                                     setState(282);\r
1062                                     unique_stmt();\r
1063                                 }\r
1064                                     break;\r
1065                                 case DEFAULT_KEYWORD: {\r
1066                                     setState(283);\r
1067                                     default_stmt();\r
1068                                 }\r
1069                                     break;\r
1070                                 case CONFIG_KEYWORD: {\r
1071                                     setState(284);\r
1072                                     config_stmt();\r
1073                                 }\r
1074                                     break;\r
1075                                 case MANDATORY_KEYWORD: {\r
1076                                     setState(285);\r
1077                                     mandatory_stmt();\r
1078                                 }\r
1079                                     break;\r
1080                                 case MIN_ELEMENTS_KEYWORD: {\r
1081                                     setState(286);\r
1082                                     min_elements_stmt();\r
1083                                 }\r
1084                                     break;\r
1085                                 case MAX_ELEMENTS_KEYWORD: {\r
1086                                     setState(287);\r
1087                                     max_elements_stmt();\r
1088                                 }\r
1089                                     break;\r
1090                                 default:\r
1091                                     throw new NoViableAltException(this);\r
1092                                 }\r
1093                             }\r
1094                             setState(292);\r
1095                             _errHandler.sync(this);\r
1096                             _la = _input.LA(1);\r
1097                         }\r
1098                         setState(293);\r
1099                         match(RIGHT_BRACE);\r
1100                     }\r
1101                 }\r
1102                     break;\r
1103                 default:\r
1104                     throw new NoViableAltException(this);\r
1105                 }\r
1106             }\r
1107         } catch (RecognitionException re) {\r
1108             _localctx.exception = re;\r
1109             _errHandler.reportError(this, re);\r
1110             _errHandler.recover(this, re);\r
1111         } finally {\r
1112             exitRule();\r
1113         }\r
1114         return _localctx;\r
1115     }\r
1116 \r
1117     public static class Deviate_not_supported_stmtContext extends\r
1118             ParserRuleContext {\r
1119         public TerminalNode RIGHT_BRACE() {\r
1120             return getToken(YangParser.RIGHT_BRACE, 0);\r
1121         }\r
1122 \r
1123         public TerminalNode SEMICOLON() {\r
1124             return getToken(YangParser.SEMICOLON, 0);\r
1125         }\r
1126 \r
1127         public Identifier_stmtContext identifier_stmt() {\r
1128             return getRuleContext(Identifier_stmtContext.class, 0);\r
1129         }\r
1130 \r
1131         public StringContext string() {\r
1132             return getRuleContext(StringContext.class, 0);\r
1133         }\r
1134 \r
1135         public TerminalNode DEVIATE_KEYWORD() {\r
1136             return getToken(YangParser.DEVIATE_KEYWORD, 0);\r
1137         }\r
1138 \r
1139         public TerminalNode LEFT_BRACE() {\r
1140             return getToken(YangParser.LEFT_BRACE, 0);\r
1141         }\r
1142 \r
1143         public Deviate_not_supported_stmtContext(ParserRuleContext parent,\r
1144                 int invokingState) {\r
1145             super(parent, invokingState);\r
1146         }\r
1147 \r
1148         @Override\r
1149         public int getRuleIndex() {\r
1150             return RULE_deviate_not_supported_stmt;\r
1151         }\r
1152 \r
1153         @Override\r
1154         public void enterRule(ParseTreeListener listener) {\r
1155             if (listener instanceof YangParserListener)\r
1156                 ((YangParserListener) listener)\r
1157                         .enterDeviate_not_supported_stmt(this);\r
1158         }\r
1159 \r
1160         @Override\r
1161         public void exitRule(ParseTreeListener listener) {\r
1162             if (listener instanceof YangParserListener)\r
1163                 ((YangParserListener) listener)\r
1164                         .exitDeviate_not_supported_stmt(this);\r
1165         }\r
1166 \r
1167         @Override\r
1168         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
1169             if (visitor instanceof YangParserVisitor)\r
1170                 return ((YangParserVisitor<? extends T>) visitor)\r
1171                         .visitDeviate_not_supported_stmt(this);\r
1172             else\r
1173                 return visitor.visitChildren(this);\r
1174         }\r
1175     }\r
1176 \r
1177     public final Deviate_not_supported_stmtContext deviate_not_supported_stmt()\r
1178             throws RecognitionException {\r
1179         Deviate_not_supported_stmtContext _localctx = new Deviate_not_supported_stmtContext(\r
1180                 _ctx, getState());\r
1181         enterRule(_localctx, 14, RULE_deviate_not_supported_stmt);\r
1182         int _la;\r
1183         try {\r
1184             enterOuterAlt(_localctx, 1);\r
1185             {\r
1186                 setState(296);\r
1187                 match(DEVIATE_KEYWORD);\r
1188                 setState(297);\r
1189                 string();\r
1190                 setState(304);\r
1191                 switch (_input.LA(1)) {\r
1192                 case SEMICOLON: {\r
1193                     setState(298);\r
1194                     match(SEMICOLON);\r
1195                 }\r
1196                     break;\r
1197                 case LEFT_BRACE: {\r
1198                     {\r
1199                         setState(299);\r
1200                         match(LEFT_BRACE);\r
1201                         setState(301);\r
1202                         _la = _input.LA(1);\r
1203                         if (_la == IDENTIFIER) {\r
1204                             {\r
1205                                 setState(300);\r
1206                                 identifier_stmt();\r
1207                             }\r
1208                         }\r
1209 \r
1210                         setState(303);\r
1211                         match(RIGHT_BRACE);\r
1212                     }\r
1213                 }\r
1214                     break;\r
1215                 default:\r
1216                     throw new NoViableAltException(this);\r
1217                 }\r
1218             }\r
1219         } catch (RecognitionException re) {\r
1220             _localctx.exception = re;\r
1221             _errHandler.reportError(this, re);\r
1222             _errHandler.recover(this, re);\r
1223         } finally {\r
1224             exitRule();\r
1225         }\r
1226         return _localctx;\r
1227     }\r
1228 \r
1229     public static class Deviation_stmtContext extends ParserRuleContext {\r
1230         public TerminalNode RIGHT_BRACE() {\r
1231             return getToken(YangParser.RIGHT_BRACE, 0);\r
1232         }\r
1233 \r
1234         public List<Reference_stmtContext> reference_stmt() {\r
1235             return getRuleContexts(Reference_stmtContext.class);\r
1236         }\r
1237 \r
1238         public Description_stmtContext description_stmt(int i) {\r
1239             return getRuleContext(Description_stmtContext.class, i);\r
1240         }\r
1241 \r
1242         public TerminalNode DEVIATION_KEYWORD() {\r
1243             return getToken(YangParser.DEVIATION_KEYWORD, 0);\r
1244         }\r
1245 \r
1246         public Deviate_replace_stmtContext deviate_replace_stmt(int i) {\r
1247             return getRuleContext(Deviate_replace_stmtContext.class, i);\r
1248         }\r
1249 \r
1250         public TerminalNode LEFT_BRACE() {\r
1251             return getToken(YangParser.LEFT_BRACE, 0);\r
1252         }\r
1253 \r
1254         public Deviate_delete_stmtContext deviate_delete_stmt(int i) {\r
1255             return getRuleContext(Deviate_delete_stmtContext.class, i);\r
1256         }\r
1257 \r
1258         public List<Deviate_delete_stmtContext> deviate_delete_stmt() {\r
1259             return getRuleContexts(Deviate_delete_stmtContext.class);\r
1260         }\r
1261 \r
1262         public Deviate_add_stmtContext deviate_add_stmt(int i) {\r
1263             return getRuleContext(Deviate_add_stmtContext.class, i);\r
1264         }\r
1265 \r
1266         public List<Deviate_add_stmtContext> deviate_add_stmt() {\r
1267             return getRuleContexts(Deviate_add_stmtContext.class);\r
1268         }\r
1269 \r
1270         public StringContext string() {\r
1271             return getRuleContext(StringContext.class, 0);\r
1272         }\r
1273 \r
1274         public List<Deviate_replace_stmtContext> deviate_replace_stmt() {\r
1275             return getRuleContexts(Deviate_replace_stmtContext.class);\r
1276         }\r
1277 \r
1278         public List<Description_stmtContext> description_stmt() {\r
1279             return getRuleContexts(Description_stmtContext.class);\r
1280         }\r
1281 \r
1282         public List<Deviate_not_supported_stmtContext> deviate_not_supported_stmt() {\r
1283             return getRuleContexts(Deviate_not_supported_stmtContext.class);\r
1284         }\r
1285 \r
1286         public Deviate_not_supported_stmtContext deviate_not_supported_stmt(\r
1287                 int i) {\r
1288             return getRuleContext(Deviate_not_supported_stmtContext.class, i);\r
1289         }\r
1290 \r
1291         public Reference_stmtContext reference_stmt(int i) {\r
1292             return getRuleContext(Reference_stmtContext.class, i);\r
1293         }\r
1294 \r
1295         public Deviation_stmtContext(ParserRuleContext parent, int invokingState) {\r
1296             super(parent, invokingState);\r
1297         }\r
1298 \r
1299         @Override\r
1300         public int getRuleIndex() {\r
1301             return RULE_deviation_stmt;\r
1302         }\r
1303 \r
1304         @Override\r
1305         public void enterRule(ParseTreeListener listener) {\r
1306             if (listener instanceof YangParserListener)\r
1307                 ((YangParserListener) listener).enterDeviation_stmt(this);\r
1308         }\r
1309 \r
1310         @Override\r
1311         public void exitRule(ParseTreeListener listener) {\r
1312             if (listener instanceof YangParserListener)\r
1313                 ((YangParserListener) listener).exitDeviation_stmt(this);\r
1314         }\r
1315 \r
1316         @Override\r
1317         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
1318             if (visitor instanceof YangParserVisitor)\r
1319                 return ((YangParserVisitor<? extends T>) visitor)\r
1320                         .visitDeviation_stmt(this);\r
1321             else\r
1322                 return visitor.visitChildren(this);\r
1323         }\r
1324     }\r
1325 \r
1326     public final Deviation_stmtContext deviation_stmt()\r
1327             throws RecognitionException {\r
1328         Deviation_stmtContext _localctx = new Deviation_stmtContext(_ctx,\r
1329                 getState());\r
1330         enterRule(_localctx, 16, RULE_deviation_stmt);\r
1331         int _la;\r
1332         try {\r
1333             enterOuterAlt(_localctx, 1);\r
1334             {\r
1335                 setState(306);\r
1336                 match(DEVIATION_KEYWORD);\r
1337                 setState(307);\r
1338                 string();\r
1339                 setState(308);\r
1340                 match(LEFT_BRACE);\r
1341                 setState(315);\r
1342                 _errHandler.sync(this);\r
1343                 _la = _input.LA(1);\r
1344                 do {\r
1345                     {\r
1346                         setState(315);\r
1347                         switch (getInterpreter().adaptivePredict(_input, 17,\r
1348                                 _ctx)) {\r
1349                         case 1: {\r
1350                             setState(309);\r
1351                             description_stmt();\r
1352                         }\r
1353                             break;\r
1354 \r
1355                         case 2: {\r
1356                             setState(310);\r
1357                             reference_stmt();\r
1358                         }\r
1359                             break;\r
1360 \r
1361                         case 3: {\r
1362                             setState(311);\r
1363                             deviate_not_supported_stmt();\r
1364                         }\r
1365                             break;\r
1366 \r
1367                         case 4: {\r
1368                             setState(312);\r
1369                             deviate_add_stmt();\r
1370                         }\r
1371                             break;\r
1372 \r
1373                         case 5: {\r
1374                             setState(313);\r
1375                             deviate_replace_stmt();\r
1376                         }\r
1377                             break;\r
1378 \r
1379                         case 6: {\r
1380                             setState(314);\r
1381                             deviate_delete_stmt();\r
1382                         }\r
1383                             break;\r
1384                         }\r
1385                     }\r
1386                     setState(317);\r
1387                     _errHandler.sync(this);\r
1388                     _la = _input.LA(1);\r
1389                 } while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << REFERENCE_KEYWORD)\r
1390                         | (1L << DEVIATE_KEYWORD) | (1L << DESCRIPTION_KEYWORD))) != 0));\r
1391                 setState(319);\r
1392                 match(RIGHT_BRACE);\r
1393             }\r
1394         } catch (RecognitionException re) {\r
1395             _localctx.exception = re;\r
1396             _errHandler.reportError(this, re);\r
1397             _errHandler.recover(this, re);\r
1398         } finally {\r
1399             exitRule();\r
1400         }\r
1401         return _localctx;\r
1402     }\r
1403 \r
1404     public static class Notification_stmtContext extends ParserRuleContext {\r
1405         public List<Grouping_stmtContext> grouping_stmt() {\r
1406             return getRuleContexts(Grouping_stmtContext.class);\r
1407         }\r
1408 \r
1409         public TerminalNode RIGHT_BRACE() {\r
1410             return getToken(YangParser.RIGHT_BRACE, 0);\r
1411         }\r
1412 \r
1413         public List<Reference_stmtContext> reference_stmt() {\r
1414             return getRuleContexts(Reference_stmtContext.class);\r
1415         }\r
1416 \r
1417         public Typedef_stmtContext typedef_stmt(int i) {\r
1418             return getRuleContext(Typedef_stmtContext.class, i);\r
1419         }\r
1420 \r
1421         public Description_stmtContext description_stmt(int i) {\r
1422             return getRuleContext(Description_stmtContext.class, i);\r
1423         }\r
1424 \r
1425         public Grouping_stmtContext grouping_stmt(int i) {\r
1426             return getRuleContext(Grouping_stmtContext.class, i);\r
1427         }\r
1428 \r
1429         public If_feature_stmtContext if_feature_stmt(int i) {\r
1430             return getRuleContext(If_feature_stmtContext.class, i);\r
1431         }\r
1432 \r
1433         public TerminalNode LEFT_BRACE() {\r
1434             return getToken(YangParser.LEFT_BRACE, 0);\r
1435         }\r
1436 \r
1437         public Data_def_stmtContext data_def_stmt(int i) {\r
1438             return getRuleContext(Data_def_stmtContext.class, i);\r
1439         }\r
1440 \r
1441         public List<Typedef_stmtContext> typedef_stmt() {\r
1442             return getRuleContexts(Typedef_stmtContext.class);\r
1443         }\r
1444 \r
1445         public Status_stmtContext status_stmt(int i) {\r
1446             return getRuleContext(Status_stmtContext.class, i);\r
1447         }\r
1448 \r
1449         public List<If_feature_stmtContext> if_feature_stmt() {\r
1450             return getRuleContexts(If_feature_stmtContext.class);\r
1451         }\r
1452 \r
1453         public List<Data_def_stmtContext> data_def_stmt() {\r
1454             return getRuleContexts(Data_def_stmtContext.class);\r
1455         }\r
1456 \r
1457         public TerminalNode SEMICOLON() {\r
1458             return getToken(YangParser.SEMICOLON, 0);\r
1459         }\r
1460 \r
1461         public List<Status_stmtContext> status_stmt() {\r
1462             return getRuleContexts(Status_stmtContext.class);\r
1463         }\r
1464 \r
1465         public StringContext string() {\r
1466             return getRuleContext(StringContext.class, 0);\r
1467         }\r
1468 \r
1469         public List<Description_stmtContext> description_stmt() {\r
1470             return getRuleContexts(Description_stmtContext.class);\r
1471         }\r
1472 \r
1473         public Reference_stmtContext reference_stmt(int i) {\r
1474             return getRuleContext(Reference_stmtContext.class, i);\r
1475         }\r
1476 \r
1477         public TerminalNode NOTIFICATION_KEYWORD() {\r
1478             return getToken(YangParser.NOTIFICATION_KEYWORD, 0);\r
1479         }\r
1480 \r
1481         public Notification_stmtContext(ParserRuleContext parent,\r
1482                 int invokingState) {\r
1483             super(parent, invokingState);\r
1484         }\r
1485 \r
1486         @Override\r
1487         public int getRuleIndex() {\r
1488             return RULE_notification_stmt;\r
1489         }\r
1490 \r
1491         @Override\r
1492         public void enterRule(ParseTreeListener listener) {\r
1493             if (listener instanceof YangParserListener)\r
1494                 ((YangParserListener) listener).enterNotification_stmt(this);\r
1495         }\r
1496 \r
1497         @Override\r
1498         public void exitRule(ParseTreeListener listener) {\r
1499             if (listener instanceof YangParserListener)\r
1500                 ((YangParserListener) listener).exitNotification_stmt(this);\r
1501         }\r
1502 \r
1503         @Override\r
1504         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
1505             if (visitor instanceof YangParserVisitor)\r
1506                 return ((YangParserVisitor<? extends T>) visitor)\r
1507                         .visitNotification_stmt(this);\r
1508             else\r
1509                 return visitor.visitChildren(this);\r
1510         }\r
1511     }\r
1512 \r
1513     public final Notification_stmtContext notification_stmt()\r
1514             throws RecognitionException {\r
1515         Notification_stmtContext _localctx = new Notification_stmtContext(_ctx,\r
1516                 getState());\r
1517         enterRule(_localctx, 18, RULE_notification_stmt);\r
1518         int _la;\r
1519         try {\r
1520             enterOuterAlt(_localctx, 1);\r
1521             {\r
1522                 setState(321);\r
1523                 match(NOTIFICATION_KEYWORD);\r
1524                 setState(322);\r
1525                 string();\r
1526                 setState(338);\r
1527                 switch (_input.LA(1)) {\r
1528                 case SEMICOLON: {\r
1529                     setState(323);\r
1530                     match(SEMICOLON);\r
1531                 }\r
1532                     break;\r
1533                 case LEFT_BRACE: {\r
1534                     {\r
1535                         setState(324);\r
1536                         match(LEFT_BRACE);\r
1537                         setState(334);\r
1538                         _errHandler.sync(this);\r
1539                         _la = _input.LA(1);\r
1540                         while (((((_la - 12)) & ~0x3f) == 0 && ((1L << (_la - 12)) & ((1L << (USES_KEYWORD - 12))\r
1541                                 | (1L << (TYPEDEF_KEYWORD - 12))\r
1542                                 | (1L << (STATUS_KEYWORD - 12))\r
1543                                 | (1L << (REFERENCE_KEYWORD - 12))\r
1544                                 | (1L << (LIST_KEYWORD - 12))\r
1545                                 | (1L << (LEAF_LIST_KEYWORD - 12))\r
1546                                 | (1L << (LEAF_KEYWORD - 12))\r
1547                                 | (1L << (IF_FEATURE_KEYWORD - 12))\r
1548                                 | (1L << (GROUPING_KEYWORD - 12))\r
1549                                 | (1L << (DESCRIPTION_KEYWORD - 12))\r
1550                                 | (1L << (CONTAINER_KEYWORD - 12))\r
1551                                 | (1L << (CHOICE_KEYWORD - 12)) | (1L << (ANYXML_KEYWORD - 12)))) != 0)) {\r
1552                             {\r
1553                                 setState(332);\r
1554                                 switch (_input.LA(1)) {\r
1555                                 case IF_FEATURE_KEYWORD: {\r
1556                                     setState(325);\r
1557                                     if_feature_stmt();\r
1558                                 }\r
1559                                     break;\r
1560                                 case STATUS_KEYWORD: {\r
1561                                     setState(326);\r
1562                                     status_stmt();\r
1563                                 }\r
1564                                     break;\r
1565                                 case DESCRIPTION_KEYWORD: {\r
1566                                     setState(327);\r
1567                                     description_stmt();\r
1568                                 }\r
1569                                     break;\r
1570                                 case REFERENCE_KEYWORD: {\r
1571                                     setState(328);\r
1572                                     reference_stmt();\r
1573                                 }\r
1574                                     break;\r
1575                                 case TYPEDEF_KEYWORD: {\r
1576                                     setState(329);\r
1577                                     typedef_stmt();\r
1578                                 }\r
1579                                     break;\r
1580                                 case GROUPING_KEYWORD: {\r
1581                                     setState(330);\r
1582                                     grouping_stmt();\r
1583                                 }\r
1584                                     break;\r
1585                                 case USES_KEYWORD:\r
1586                                 case LIST_KEYWORD:\r
1587                                 case LEAF_LIST_KEYWORD:\r
1588                                 case LEAF_KEYWORD:\r
1589                                 case CONTAINER_KEYWORD:\r
1590                                 case CHOICE_KEYWORD:\r
1591                                 case ANYXML_KEYWORD: {\r
1592                                     setState(331);\r
1593                                     data_def_stmt();\r
1594                                 }\r
1595                                     break;\r
1596                                 default:\r
1597                                     throw new NoViableAltException(this);\r
1598                                 }\r
1599                             }\r
1600                             setState(336);\r
1601                             _errHandler.sync(this);\r
1602                             _la = _input.LA(1);\r
1603                         }\r
1604                         setState(337);\r
1605                         match(RIGHT_BRACE);\r
1606                     }\r
1607                 }\r
1608                     break;\r
1609                 default:\r
1610                     throw new NoViableAltException(this);\r
1611                 }\r
1612             }\r
1613         } catch (RecognitionException re) {\r
1614             _localctx.exception = re;\r
1615             _errHandler.reportError(this, re);\r
1616             _errHandler.recover(this, re);\r
1617         } finally {\r
1618             exitRule();\r
1619         }\r
1620         return _localctx;\r
1621     }\r
1622 \r
1623     public static class Output_stmtContext extends ParserRuleContext {\r
1624         public List<Grouping_stmtContext> grouping_stmt() {\r
1625             return getRuleContexts(Grouping_stmtContext.class);\r
1626         }\r
1627 \r
1628         public TerminalNode RIGHT_BRACE() {\r
1629             return getToken(YangParser.RIGHT_BRACE, 0);\r
1630         }\r
1631 \r
1632         public Typedef_stmtContext typedef_stmt(int i) {\r
1633             return getRuleContext(Typedef_stmtContext.class, i);\r
1634         }\r
1635 \r
1636         public List<Data_def_stmtContext> data_def_stmt() {\r
1637             return getRuleContexts(Data_def_stmtContext.class);\r
1638         }\r
1639 \r
1640         public Grouping_stmtContext grouping_stmt(int i) {\r
1641             return getRuleContext(Grouping_stmtContext.class, i);\r
1642         }\r
1643 \r
1644         public TerminalNode OUTPUT_KEYWORD() {\r
1645             return getToken(YangParser.OUTPUT_KEYWORD, 0);\r
1646         }\r
1647 \r
1648         public TerminalNode LEFT_BRACE() {\r
1649             return getToken(YangParser.LEFT_BRACE, 0);\r
1650         }\r
1651 \r
1652         public Data_def_stmtContext data_def_stmt(int i) {\r
1653             return getRuleContext(Data_def_stmtContext.class, i);\r
1654         }\r
1655 \r
1656         public List<Typedef_stmtContext> typedef_stmt() {\r
1657             return getRuleContexts(Typedef_stmtContext.class);\r
1658         }\r
1659 \r
1660         public Output_stmtContext(ParserRuleContext parent, int invokingState) {\r
1661             super(parent, invokingState);\r
1662         }\r
1663 \r
1664         @Override\r
1665         public int getRuleIndex() {\r
1666             return RULE_output_stmt;\r
1667         }\r
1668 \r
1669         @Override\r
1670         public void enterRule(ParseTreeListener listener) {\r
1671             if (listener instanceof YangParserListener)\r
1672                 ((YangParserListener) listener).enterOutput_stmt(this);\r
1673         }\r
1674 \r
1675         @Override\r
1676         public void exitRule(ParseTreeListener listener) {\r
1677             if (listener instanceof YangParserListener)\r
1678                 ((YangParserListener) listener).exitOutput_stmt(this);\r
1679         }\r
1680 \r
1681         @Override\r
1682         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
1683             if (visitor instanceof YangParserVisitor)\r
1684                 return ((YangParserVisitor<? extends T>) visitor)\r
1685                         .visitOutput_stmt(this);\r
1686             else\r
1687                 return visitor.visitChildren(this);\r
1688         }\r
1689     }\r
1690 \r
1691     public final Output_stmtContext output_stmt() throws RecognitionException {\r
1692         Output_stmtContext _localctx = new Output_stmtContext(_ctx, getState());\r
1693         enterRule(_localctx, 20, RULE_output_stmt);\r
1694         int _la;\r
1695         try {\r
1696             enterOuterAlt(_localctx, 1);\r
1697             {\r
1698                 setState(340);\r
1699                 match(OUTPUT_KEYWORD);\r
1700                 setState(341);\r
1701                 match(LEFT_BRACE);\r
1702                 setState(345);\r
1703                 _errHandler.sync(this);\r
1704                 _la = _input.LA(1);\r
1705                 do {\r
1706                     {\r
1707                         setState(345);\r
1708                         switch (_input.LA(1)) {\r
1709                         case TYPEDEF_KEYWORD: {\r
1710                             setState(342);\r
1711                             typedef_stmt();\r
1712                         }\r
1713                             break;\r
1714                         case GROUPING_KEYWORD: {\r
1715                             setState(343);\r
1716                             grouping_stmt();\r
1717                         }\r
1718                             break;\r
1719                         case USES_KEYWORD:\r
1720                         case LIST_KEYWORD:\r
1721                         case LEAF_LIST_KEYWORD:\r
1722                         case LEAF_KEYWORD:\r
1723                         case CONTAINER_KEYWORD:\r
1724                         case CHOICE_KEYWORD:\r
1725                         case ANYXML_KEYWORD: {\r
1726                             setState(344);\r
1727                             data_def_stmt();\r
1728                         }\r
1729                             break;\r
1730                         default:\r
1731                             throw new NoViableAltException(this);\r
1732                         }\r
1733                     }\r
1734                     setState(347);\r
1735                     _errHandler.sync(this);\r
1736                     _la = _input.LA(1);\r
1737                 } while (((((_la - 12)) & ~0x3f) == 0 && ((1L << (_la - 12)) & ((1L << (USES_KEYWORD - 12))\r
1738                         | (1L << (TYPEDEF_KEYWORD - 12))\r
1739                         | (1L << (LIST_KEYWORD - 12))\r
1740                         | (1L << (LEAF_LIST_KEYWORD - 12))\r
1741                         | (1L << (LEAF_KEYWORD - 12))\r
1742                         | (1L << (GROUPING_KEYWORD - 12))\r
1743                         | (1L << (CONTAINER_KEYWORD - 12))\r
1744                         | (1L << (CHOICE_KEYWORD - 12)) | (1L << (ANYXML_KEYWORD - 12)))) != 0));\r
1745                 setState(349);\r
1746                 match(RIGHT_BRACE);\r
1747             }\r
1748         } catch (RecognitionException re) {\r
1749             _localctx.exception = re;\r
1750             _errHandler.reportError(this, re);\r
1751             _errHandler.recover(this, re);\r
1752         } finally {\r
1753             exitRule();\r
1754         }\r
1755         return _localctx;\r
1756     }\r
1757 \r
1758     public static class Input_stmtContext extends ParserRuleContext {\r
1759         public List<Grouping_stmtContext> grouping_stmt() {\r
1760             return getRuleContexts(Grouping_stmtContext.class);\r
1761         }\r
1762 \r
1763         public TerminalNode RIGHT_BRACE() {\r
1764             return getToken(YangParser.RIGHT_BRACE, 0);\r
1765         }\r
1766 \r
1767         public Typedef_stmtContext typedef_stmt(int i) {\r
1768             return getRuleContext(Typedef_stmtContext.class, i);\r
1769         }\r
1770 \r
1771         public TerminalNode INPUT_KEYWORD() {\r
1772             return getToken(YangParser.INPUT_KEYWORD, 0);\r
1773         }\r
1774 \r
1775         public List<Data_def_stmtContext> data_def_stmt() {\r
1776             return getRuleContexts(Data_def_stmtContext.class);\r
1777         }\r
1778 \r
1779         public Grouping_stmtContext grouping_stmt(int i) {\r
1780             return getRuleContext(Grouping_stmtContext.class, i);\r
1781         }\r
1782 \r
1783         public TerminalNode LEFT_BRACE() {\r
1784             return getToken(YangParser.LEFT_BRACE, 0);\r
1785         }\r
1786 \r
1787         public Data_def_stmtContext data_def_stmt(int i) {\r
1788             return getRuleContext(Data_def_stmtContext.class, i);\r
1789         }\r
1790 \r
1791         public List<Typedef_stmtContext> typedef_stmt() {\r
1792             return getRuleContexts(Typedef_stmtContext.class);\r
1793         }\r
1794 \r
1795         public Input_stmtContext(ParserRuleContext parent, int invokingState) {\r
1796             super(parent, invokingState);\r
1797         }\r
1798 \r
1799         @Override\r
1800         public int getRuleIndex() {\r
1801             return RULE_input_stmt;\r
1802         }\r
1803 \r
1804         @Override\r
1805         public void enterRule(ParseTreeListener listener) {\r
1806             if (listener instanceof YangParserListener)\r
1807                 ((YangParserListener) listener).enterInput_stmt(this);\r
1808         }\r
1809 \r
1810         @Override\r
1811         public void exitRule(ParseTreeListener listener) {\r
1812             if (listener instanceof YangParserListener)\r
1813                 ((YangParserListener) listener).exitInput_stmt(this);\r
1814         }\r
1815 \r
1816         @Override\r
1817         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
1818             if (visitor instanceof YangParserVisitor)\r
1819                 return ((YangParserVisitor<? extends T>) visitor)\r
1820                         .visitInput_stmt(this);\r
1821             else\r
1822                 return visitor.visitChildren(this);\r
1823         }\r
1824     }\r
1825 \r
1826     public final Input_stmtContext input_stmt() throws RecognitionException {\r
1827         Input_stmtContext _localctx = new Input_stmtContext(_ctx, getState());\r
1828         enterRule(_localctx, 22, RULE_input_stmt);\r
1829         int _la;\r
1830         try {\r
1831             enterOuterAlt(_localctx, 1);\r
1832             {\r
1833                 setState(351);\r
1834                 match(INPUT_KEYWORD);\r
1835                 setState(352);\r
1836                 match(LEFT_BRACE);\r
1837                 setState(356);\r
1838                 _errHandler.sync(this);\r
1839                 _la = _input.LA(1);\r
1840                 do {\r
1841                     {\r
1842                         setState(356);\r
1843                         switch (_input.LA(1)) {\r
1844                         case TYPEDEF_KEYWORD: {\r
1845                             setState(353);\r
1846                             typedef_stmt();\r
1847                         }\r
1848                             break;\r
1849                         case GROUPING_KEYWORD: {\r
1850                             setState(354);\r
1851                             grouping_stmt();\r
1852                         }\r
1853                             break;\r
1854                         case USES_KEYWORD:\r
1855                         case LIST_KEYWORD:\r
1856                         case LEAF_LIST_KEYWORD:\r
1857                         case LEAF_KEYWORD:\r
1858                         case CONTAINER_KEYWORD:\r
1859                         case CHOICE_KEYWORD:\r
1860                         case ANYXML_KEYWORD: {\r
1861                             setState(355);\r
1862                             data_def_stmt();\r
1863                         }\r
1864                             break;\r
1865                         default:\r
1866                             throw new NoViableAltException(this);\r
1867                         }\r
1868                     }\r
1869                     setState(358);\r
1870                     _errHandler.sync(this);\r
1871                     _la = _input.LA(1);\r
1872                 } while (((((_la - 12)) & ~0x3f) == 0 && ((1L << (_la - 12)) & ((1L << (USES_KEYWORD - 12))\r
1873                         | (1L << (TYPEDEF_KEYWORD - 12))\r
1874                         | (1L << (LIST_KEYWORD - 12))\r
1875                         | (1L << (LEAF_LIST_KEYWORD - 12))\r
1876                         | (1L << (LEAF_KEYWORD - 12))\r
1877                         | (1L << (GROUPING_KEYWORD - 12))\r
1878                         | (1L << (CONTAINER_KEYWORD - 12))\r
1879                         | (1L << (CHOICE_KEYWORD - 12)) | (1L << (ANYXML_KEYWORD - 12)))) != 0));\r
1880                 setState(360);\r
1881                 match(RIGHT_BRACE);\r
1882             }\r
1883         } catch (RecognitionException re) {\r
1884             _localctx.exception = re;\r
1885             _errHandler.reportError(this, re);\r
1886             _errHandler.recover(this, re);\r
1887         } finally {\r
1888             exitRule();\r
1889         }\r
1890         return _localctx;\r
1891     }\r
1892 \r
1893     public static class Rpc_stmtContext extends ParserRuleContext {\r
1894         public List<Grouping_stmtContext> grouping_stmt() {\r
1895             return getRuleContexts(Grouping_stmtContext.class);\r
1896         }\r
1897 \r
1898         public TerminalNode RIGHT_BRACE() {\r
1899             return getToken(YangParser.RIGHT_BRACE, 0);\r
1900         }\r
1901 \r
1902         public Output_stmtContext output_stmt(int i) {\r
1903             return getRuleContext(Output_stmtContext.class, i);\r
1904         }\r
1905 \r
1906         public List<Reference_stmtContext> reference_stmt() {\r
1907             return getRuleContexts(Reference_stmtContext.class);\r
1908         }\r
1909 \r
1910         public Typedef_stmtContext typedef_stmt(int i) {\r
1911             return getRuleContext(Typedef_stmtContext.class, i);\r
1912         }\r
1913 \r
1914         public Description_stmtContext description_stmt(int i) {\r
1915             return getRuleContext(Description_stmtContext.class, i);\r
1916         }\r
1917 \r
1918         public Grouping_stmtContext grouping_stmt(int i) {\r
1919             return getRuleContext(Grouping_stmtContext.class, i);\r
1920         }\r
1921 \r
1922         public Input_stmtContext input_stmt(int i) {\r
1923             return getRuleContext(Input_stmtContext.class, i);\r
1924         }\r
1925 \r
1926         public List<Input_stmtContext> input_stmt() {\r
1927             return getRuleContexts(Input_stmtContext.class);\r
1928         }\r
1929 \r
1930         public If_feature_stmtContext if_feature_stmt(int i) {\r
1931             return getRuleContext(If_feature_stmtContext.class, i);\r
1932         }\r
1933 \r
1934         public TerminalNode LEFT_BRACE() {\r
1935             return getToken(YangParser.LEFT_BRACE, 0);\r
1936         }\r
1937 \r
1938         public List<Typedef_stmtContext> typedef_stmt() {\r
1939             return getRuleContexts(Typedef_stmtContext.class);\r
1940         }\r
1941 \r
1942         public Status_stmtContext status_stmt(int i) {\r
1943             return getRuleContext(Status_stmtContext.class, i);\r
1944         }\r
1945 \r
1946         public List<If_feature_stmtContext> if_feature_stmt() {\r
1947             return getRuleContexts(If_feature_stmtContext.class);\r
1948         }\r
1949 \r
1950         public TerminalNode SEMICOLON() {\r
1951             return getToken(YangParser.SEMICOLON, 0);\r
1952         }\r
1953 \r
1954         public List<Status_stmtContext> status_stmt() {\r
1955             return getRuleContexts(Status_stmtContext.class);\r
1956         }\r
1957 \r
1958         public StringContext string() {\r
1959             return getRuleContext(StringContext.class, 0);\r
1960         }\r
1961 \r
1962         public List<Description_stmtContext> description_stmt() {\r
1963             return getRuleContexts(Description_stmtContext.class);\r
1964         }\r
1965 \r
1966         public Reference_stmtContext reference_stmt(int i) {\r
1967             return getRuleContext(Reference_stmtContext.class, i);\r
1968         }\r
1969 \r
1970         public List<Output_stmtContext> output_stmt() {\r
1971             return getRuleContexts(Output_stmtContext.class);\r
1972         }\r
1973 \r
1974         public TerminalNode RPC_KEYWORD() {\r
1975             return getToken(YangParser.RPC_KEYWORD, 0);\r
1976         }\r
1977 \r
1978         public Rpc_stmtContext(ParserRuleContext parent, int invokingState) {\r
1979             super(parent, invokingState);\r
1980         }\r
1981 \r
1982         @Override\r
1983         public int getRuleIndex() {\r
1984             return RULE_rpc_stmt;\r
1985         }\r
1986 \r
1987         @Override\r
1988         public void enterRule(ParseTreeListener listener) {\r
1989             if (listener instanceof YangParserListener)\r
1990                 ((YangParserListener) listener).enterRpc_stmt(this);\r
1991         }\r
1992 \r
1993         @Override\r
1994         public void exitRule(ParseTreeListener listener) {\r
1995             if (listener instanceof YangParserListener)\r
1996                 ((YangParserListener) listener).exitRpc_stmt(this);\r
1997         }\r
1998 \r
1999         @Override\r
2000         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
2001             if (visitor instanceof YangParserVisitor)\r
2002                 return ((YangParserVisitor<? extends T>) visitor)\r
2003                         .visitRpc_stmt(this);\r
2004             else\r
2005                 return visitor.visitChildren(this);\r
2006         }\r
2007     }\r
2008 \r
2009     public final Rpc_stmtContext rpc_stmt() throws RecognitionException {\r
2010         Rpc_stmtContext _localctx = new Rpc_stmtContext(_ctx, getState());\r
2011         enterRule(_localctx, 24, RULE_rpc_stmt);\r
2012         int _la;\r
2013         try {\r
2014             enterOuterAlt(_localctx, 1);\r
2015             {\r
2016                 setState(362);\r
2017                 match(RPC_KEYWORD);\r
2018                 setState(363);\r
2019                 string();\r
2020                 setState(380);\r
2021                 switch (_input.LA(1)) {\r
2022                 case SEMICOLON: {\r
2023                     setState(364);\r
2024                     match(SEMICOLON);\r
2025                 }\r
2026                     break;\r
2027                 case LEFT_BRACE: {\r
2028                     {\r
2029                         setState(365);\r
2030                         match(LEFT_BRACE);\r
2031                         setState(376);\r
2032                         _errHandler.sync(this);\r
2033                         _la = _input.LA(1);\r
2034                         while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << TYPEDEF_KEYWORD)\r
2035                                 | (1L << STATUS_KEYWORD)\r
2036                                 | (1L << REFERENCE_KEYWORD)\r
2037                                 | (1L << OUTPUT_KEYWORD)\r
2038                                 | (1L << INPUT_KEYWORD)\r
2039                                 | (1L << IF_FEATURE_KEYWORD)\r
2040                                 | (1L << GROUPING_KEYWORD) | (1L << DESCRIPTION_KEYWORD))) != 0)) {\r
2041                             {\r
2042                                 setState(374);\r
2043                                 switch (_input.LA(1)) {\r
2044                                 case IF_FEATURE_KEYWORD: {\r
2045                                     setState(366);\r
2046                                     if_feature_stmt();\r
2047                                 }\r
2048                                     break;\r
2049                                 case STATUS_KEYWORD: {\r
2050                                     setState(367);\r
2051                                     status_stmt();\r
2052                                 }\r
2053                                     break;\r
2054                                 case DESCRIPTION_KEYWORD: {\r
2055                                     setState(368);\r
2056                                     description_stmt();\r
2057                                 }\r
2058                                     break;\r
2059                                 case REFERENCE_KEYWORD: {\r
2060                                     setState(369);\r
2061                                     reference_stmt();\r
2062                                 }\r
2063                                     break;\r
2064                                 case TYPEDEF_KEYWORD: {\r
2065                                     setState(370);\r
2066                                     typedef_stmt();\r
2067                                 }\r
2068                                     break;\r
2069                                 case GROUPING_KEYWORD: {\r
2070                                     setState(371);\r
2071                                     grouping_stmt();\r
2072                                 }\r
2073                                     break;\r
2074                                 case INPUT_KEYWORD: {\r
2075                                     setState(372);\r
2076                                     input_stmt();\r
2077                                 }\r
2078                                     break;\r
2079                                 case OUTPUT_KEYWORD: {\r
2080                                     setState(373);\r
2081                                     output_stmt();\r
2082                                 }\r
2083                                     break;\r
2084                                 default:\r
2085                                     throw new NoViableAltException(this);\r
2086                                 }\r
2087                             }\r
2088                             setState(378);\r
2089                             _errHandler.sync(this);\r
2090                             _la = _input.LA(1);\r
2091                         }\r
2092                         setState(379);\r
2093                         match(RIGHT_BRACE);\r
2094                     }\r
2095                 }\r
2096                     break;\r
2097                 default:\r
2098                     throw new NoViableAltException(this);\r
2099                 }\r
2100             }\r
2101         } catch (RecognitionException re) {\r
2102             _localctx.exception = re;\r
2103             _errHandler.reportError(this, re);\r
2104             _errHandler.recover(this, re);\r
2105         } finally {\r
2106             exitRule();\r
2107         }\r
2108         return _localctx;\r
2109     }\r
2110 \r
2111     public static class When_stmtContext extends ParserRuleContext {\r
2112         public TerminalNode RIGHT_BRACE() {\r
2113             return getToken(YangParser.RIGHT_BRACE, 0);\r
2114         }\r
2115 \r
2116         public List<Reference_stmtContext> reference_stmt() {\r
2117             return getRuleContexts(Reference_stmtContext.class);\r
2118         }\r
2119 \r
2120         public Description_stmtContext description_stmt(int i) {\r
2121             return getRuleContext(Description_stmtContext.class, i);\r
2122         }\r
2123 \r
2124         public TerminalNode WHEN_KEYWORD() {\r
2125             return getToken(YangParser.WHEN_KEYWORD, 0);\r
2126         }\r
2127 \r
2128         public TerminalNode SEMICOLON() {\r
2129             return getToken(YangParser.SEMICOLON, 0);\r
2130         }\r
2131 \r
2132         public StringContext string() {\r
2133             return getRuleContext(StringContext.class, 0);\r
2134         }\r
2135 \r
2136         public List<Description_stmtContext> description_stmt() {\r
2137             return getRuleContexts(Description_stmtContext.class);\r
2138         }\r
2139 \r
2140         public TerminalNode LEFT_BRACE() {\r
2141             return getToken(YangParser.LEFT_BRACE, 0);\r
2142         }\r
2143 \r
2144         public Reference_stmtContext reference_stmt(int i) {\r
2145             return getRuleContext(Reference_stmtContext.class, i);\r
2146         }\r
2147 \r
2148         public When_stmtContext(ParserRuleContext parent, int invokingState) {\r
2149             super(parent, invokingState);\r
2150         }\r
2151 \r
2152         @Override\r
2153         public int getRuleIndex() {\r
2154             return RULE_when_stmt;\r
2155         }\r
2156 \r
2157         @Override\r
2158         public void enterRule(ParseTreeListener listener) {\r
2159             if (listener instanceof YangParserListener)\r
2160                 ((YangParserListener) listener).enterWhen_stmt(this);\r
2161         }\r
2162 \r
2163         @Override\r
2164         public void exitRule(ParseTreeListener listener) {\r
2165             if (listener instanceof YangParserListener)\r
2166                 ((YangParserListener) listener).exitWhen_stmt(this);\r
2167         }\r
2168 \r
2169         @Override\r
2170         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
2171             if (visitor instanceof YangParserVisitor)\r
2172                 return ((YangParserVisitor<? extends T>) visitor)\r
2173                         .visitWhen_stmt(this);\r
2174             else\r
2175                 return visitor.visitChildren(this);\r
2176         }\r
2177     }\r
2178 \r
2179     public final When_stmtContext when_stmt() throws RecognitionException {\r
2180         When_stmtContext _localctx = new When_stmtContext(_ctx, getState());\r
2181         enterRule(_localctx, 26, RULE_when_stmt);\r
2182         int _la;\r
2183         try {\r
2184             enterOuterAlt(_localctx, 1);\r
2185             {\r
2186                 setState(382);\r
2187                 match(WHEN_KEYWORD);\r
2188                 setState(383);\r
2189                 string();\r
2190                 setState(394);\r
2191                 switch (_input.LA(1)) {\r
2192                 case SEMICOLON: {\r
2193                     setState(384);\r
2194                     match(SEMICOLON);\r
2195                 }\r
2196                     break;\r
2197                 case LEFT_BRACE: {\r
2198                     {\r
2199                         setState(385);\r
2200                         match(LEFT_BRACE);\r
2201                         setState(390);\r
2202                         _errHandler.sync(this);\r
2203                         _la = _input.LA(1);\r
2204                         while (_la == REFERENCE_KEYWORD\r
2205                                 || _la == DESCRIPTION_KEYWORD) {\r
2206                             {\r
2207                                 setState(388);\r
2208                                 switch (_input.LA(1)) {\r
2209                                 case DESCRIPTION_KEYWORD: {\r
2210                                     setState(386);\r
2211                                     description_stmt();\r
2212                                 }\r
2213                                     break;\r
2214                                 case REFERENCE_KEYWORD: {\r
2215                                     setState(387);\r
2216                                     reference_stmt();\r
2217                                 }\r
2218                                     break;\r
2219                                 default:\r
2220                                     throw new NoViableAltException(this);\r
2221                                 }\r
2222                             }\r
2223                             setState(392);\r
2224                             _errHandler.sync(this);\r
2225                             _la = _input.LA(1);\r
2226                         }\r
2227                         setState(393);\r
2228                         match(RIGHT_BRACE);\r
2229                     }\r
2230                 }\r
2231                     break;\r
2232                 default:\r
2233                     throw new NoViableAltException(this);\r
2234                 }\r
2235             }\r
2236         } catch (RecognitionException re) {\r
2237             _localctx.exception = re;\r
2238             _errHandler.reportError(this, re);\r
2239             _errHandler.recover(this, re);\r
2240         } finally {\r
2241             exitRule();\r
2242         }\r
2243         return _localctx;\r
2244     }\r
2245 \r
2246     public static class Augment_stmtContext extends ParserRuleContext {\r
2247         public TerminalNode RIGHT_BRACE() {\r
2248             return getToken(YangParser.RIGHT_BRACE, 0);\r
2249         }\r
2250 \r
2251         public List<Reference_stmtContext> reference_stmt() {\r
2252             return getRuleContexts(Reference_stmtContext.class);\r
2253         }\r
2254 \r
2255         public Description_stmtContext description_stmt(int i) {\r
2256             return getRuleContext(Description_stmtContext.class, i);\r
2257         }\r
2258 \r
2259         public List<When_stmtContext> when_stmt() {\r
2260             return getRuleContexts(When_stmtContext.class);\r
2261         }\r
2262 \r
2263         public List<Case_stmtContext> case_stmt() {\r
2264             return getRuleContexts(Case_stmtContext.class);\r
2265         }\r
2266 \r
2267         public TerminalNode AUGMENT_KEYWORD() {\r
2268             return getToken(YangParser.AUGMENT_KEYWORD, 0);\r
2269         }\r
2270 \r
2271         public If_feature_stmtContext if_feature_stmt(int i) {\r
2272             return getRuleContext(If_feature_stmtContext.class, i);\r
2273         }\r
2274 \r
2275         public TerminalNode LEFT_BRACE() {\r
2276             return getToken(YangParser.LEFT_BRACE, 0);\r
2277         }\r
2278 \r
2279         public Data_def_stmtContext data_def_stmt(int i) {\r
2280             return getRuleContext(Data_def_stmtContext.class, i);\r
2281         }\r
2282 \r
2283         public Status_stmtContext status_stmt(int i) {\r
2284             return getRuleContext(Status_stmtContext.class, i);\r
2285         }\r
2286 \r
2287         public List<If_feature_stmtContext> if_feature_stmt() {\r
2288             return getRuleContexts(If_feature_stmtContext.class);\r
2289         }\r
2290 \r
2291         public Identifier_stmtContext identifier_stmt(int i) {\r
2292             return getRuleContext(Identifier_stmtContext.class, i);\r
2293         }\r
2294 \r
2295         public List<Data_def_stmtContext> data_def_stmt() {\r
2296             return getRuleContexts(Data_def_stmtContext.class);\r
2297         }\r
2298 \r
2299         public List<Status_stmtContext> status_stmt() {\r
2300             return getRuleContexts(Status_stmtContext.class);\r
2301         }\r
2302 \r
2303         public StringContext string() {\r
2304             return getRuleContext(StringContext.class, 0);\r
2305         }\r
2306 \r
2307         public List<Identifier_stmtContext> identifier_stmt() {\r
2308             return getRuleContexts(Identifier_stmtContext.class);\r
2309         }\r
2310 \r
2311         public List<Description_stmtContext> description_stmt() {\r
2312             return getRuleContexts(Description_stmtContext.class);\r
2313         }\r
2314 \r
2315         public Reference_stmtContext reference_stmt(int i) {\r
2316             return getRuleContext(Reference_stmtContext.class, i);\r
2317         }\r
2318 \r
2319         public When_stmtContext when_stmt(int i) {\r
2320             return getRuleContext(When_stmtContext.class, i);\r
2321         }\r
2322 \r
2323         public Case_stmtContext case_stmt(int i) {\r
2324             return getRuleContext(Case_stmtContext.class, i);\r
2325         }\r
2326 \r
2327         public Augment_stmtContext(ParserRuleContext parent, int invokingState) {\r
2328             super(parent, invokingState);\r
2329         }\r
2330 \r
2331         @Override\r
2332         public int getRuleIndex() {\r
2333             return RULE_augment_stmt;\r
2334         }\r
2335 \r
2336         @Override\r
2337         public void enterRule(ParseTreeListener listener) {\r
2338             if (listener instanceof YangParserListener)\r
2339                 ((YangParserListener) listener).enterAugment_stmt(this);\r
2340         }\r
2341 \r
2342         @Override\r
2343         public void exitRule(ParseTreeListener listener) {\r
2344             if (listener instanceof YangParserListener)\r
2345                 ((YangParserListener) listener).exitAugment_stmt(this);\r
2346         }\r
2347 \r
2348         @Override\r
2349         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
2350             if (visitor instanceof YangParserVisitor)\r
2351                 return ((YangParserVisitor<? extends T>) visitor)\r
2352                         .visitAugment_stmt(this);\r
2353             else\r
2354                 return visitor.visitChildren(this);\r
2355         }\r
2356     }\r
2357 \r
2358     public final Augment_stmtContext augment_stmt() throws RecognitionException {\r
2359         Augment_stmtContext _localctx = new Augment_stmtContext(_ctx,\r
2360                 getState());\r
2361         enterRule(_localctx, 28, RULE_augment_stmt);\r
2362         int _la;\r
2363         try {\r
2364             enterOuterAlt(_localctx, 1);\r
2365             {\r
2366                 setState(396);\r
2367                 match(AUGMENT_KEYWORD);\r
2368                 setState(397);\r
2369                 string();\r
2370                 setState(398);\r
2371                 match(LEFT_BRACE);\r
2372                 setState(407);\r
2373                 _errHandler.sync(this);\r
2374                 _la = _input.LA(1);\r
2375                 do {\r
2376                     {\r
2377                         setState(407);\r
2378                         switch (_input.LA(1)) {\r
2379                         case IDENTIFIER: {\r
2380                             setState(399);\r
2381                             identifier_stmt();\r
2382                         }\r
2383                             break;\r
2384                         case WHEN_KEYWORD: {\r
2385                             setState(400);\r
2386                             when_stmt();\r
2387                         }\r
2388                             break;\r
2389                         case IF_FEATURE_KEYWORD: {\r
2390                             setState(401);\r
2391                             if_feature_stmt();\r
2392                         }\r
2393                             break;\r
2394                         case STATUS_KEYWORD: {\r
2395                             setState(402);\r
2396                             status_stmt();\r
2397                         }\r
2398                             break;\r
2399                         case DESCRIPTION_KEYWORD: {\r
2400                             setState(403);\r
2401                             description_stmt();\r
2402                         }\r
2403                             break;\r
2404                         case REFERENCE_KEYWORD: {\r
2405                             setState(404);\r
2406                             reference_stmt();\r
2407                         }\r
2408                             break;\r
2409                         case USES_KEYWORD:\r
2410                         case LIST_KEYWORD:\r
2411                         case LEAF_LIST_KEYWORD:\r
2412                         case LEAF_KEYWORD:\r
2413                         case CONTAINER_KEYWORD:\r
2414                         case CHOICE_KEYWORD:\r
2415                         case ANYXML_KEYWORD: {\r
2416                             setState(405);\r
2417                             data_def_stmt();\r
2418                         }\r
2419                             break;\r
2420                         case CASE_KEYWORD: {\r
2421                             setState(406);\r
2422                             case_stmt();\r
2423                         }\r
2424                             break;\r
2425                         default:\r
2426                             throw new NoViableAltException(this);\r
2427                         }\r
2428                     }\r
2429                     setState(409);\r
2430                     _errHandler.sync(this);\r
2431                     _la = _input.LA(1);\r
2432                 } while (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (WHEN_KEYWORD - 10))\r
2433                         | (1L << (USES_KEYWORD - 10))\r
2434                         | (1L << (STATUS_KEYWORD - 10))\r
2435                         | (1L << (REFERENCE_KEYWORD - 10))\r
2436                         | (1L << (LIST_KEYWORD - 10))\r
2437                         | (1L << (LEAF_LIST_KEYWORD - 10))\r
2438                         | (1L << (LEAF_KEYWORD - 10))\r
2439                         | (1L << (IF_FEATURE_KEYWORD - 10))\r
2440                         | (1L << (DESCRIPTION_KEYWORD - 10))\r
2441                         | (1L << (CONTAINER_KEYWORD - 10))\r
2442                         | (1L << (CHOICE_KEYWORD - 10))\r
2443                         | (1L << (CASE_KEYWORD - 10))\r
2444                         | (1L << (ANYXML_KEYWORD - 10)) | (1L << (IDENTIFIER - 10)))) != 0));\r
2445                 setState(411);\r
2446                 match(RIGHT_BRACE);\r
2447             }\r
2448         } catch (RecognitionException re) {\r
2449             _localctx.exception = re;\r
2450             _errHandler.reportError(this, re);\r
2451             _errHandler.recover(this, re);\r
2452         } finally {\r
2453             exitRule();\r
2454         }\r
2455         return _localctx;\r
2456     }\r
2457 \r
2458     public static class Uses_augment_stmtContext extends ParserRuleContext {\r
2459         public TerminalNode RIGHT_BRACE() {\r
2460             return getToken(YangParser.RIGHT_BRACE, 0);\r
2461         }\r
2462 \r
2463         public List<Reference_stmtContext> reference_stmt() {\r
2464             return getRuleContexts(Reference_stmtContext.class);\r
2465         }\r
2466 \r
2467         public Description_stmtContext description_stmt(int i) {\r
2468             return getRuleContext(Description_stmtContext.class, i);\r
2469         }\r
2470 \r
2471         public List<When_stmtContext> when_stmt() {\r
2472             return getRuleContexts(When_stmtContext.class);\r
2473         }\r
2474 \r
2475         public List<Case_stmtContext> case_stmt() {\r
2476             return getRuleContexts(Case_stmtContext.class);\r
2477         }\r
2478 \r
2479         public TerminalNode AUGMENT_KEYWORD() {\r
2480             return getToken(YangParser.AUGMENT_KEYWORD, 0);\r
2481         }\r
2482 \r
2483         public If_feature_stmtContext if_feature_stmt(int i) {\r
2484             return getRuleContext(If_feature_stmtContext.class, i);\r
2485         }\r
2486 \r
2487         public TerminalNode LEFT_BRACE() {\r
2488             return getToken(YangParser.LEFT_BRACE, 0);\r
2489         }\r
2490 \r
2491         public Data_def_stmtContext data_def_stmt(int i) {\r
2492             return getRuleContext(Data_def_stmtContext.class, i);\r
2493         }\r
2494 \r
2495         public Status_stmtContext status_stmt(int i) {\r
2496             return getRuleContext(Status_stmtContext.class, i);\r
2497         }\r
2498 \r
2499         public List<If_feature_stmtContext> if_feature_stmt() {\r
2500             return getRuleContexts(If_feature_stmtContext.class);\r
2501         }\r
2502 \r
2503         public Identifier_stmtContext identifier_stmt(int i) {\r
2504             return getRuleContext(Identifier_stmtContext.class, i);\r
2505         }\r
2506 \r
2507         public List<Data_def_stmtContext> data_def_stmt() {\r
2508             return getRuleContexts(Data_def_stmtContext.class);\r
2509         }\r
2510 \r
2511         public List<Status_stmtContext> status_stmt() {\r
2512             return getRuleContexts(Status_stmtContext.class);\r
2513         }\r
2514 \r
2515         public StringContext string() {\r
2516             return getRuleContext(StringContext.class, 0);\r
2517         }\r
2518 \r
2519         public List<Identifier_stmtContext> identifier_stmt() {\r
2520             return getRuleContexts(Identifier_stmtContext.class);\r
2521         }\r
2522 \r
2523         public List<Description_stmtContext> description_stmt() {\r
2524             return getRuleContexts(Description_stmtContext.class);\r
2525         }\r
2526 \r
2527         public Reference_stmtContext reference_stmt(int i) {\r
2528             return getRuleContext(Reference_stmtContext.class, i);\r
2529         }\r
2530 \r
2531         public When_stmtContext when_stmt(int i) {\r
2532             return getRuleContext(When_stmtContext.class, i);\r
2533         }\r
2534 \r
2535         public Case_stmtContext case_stmt(int i) {\r
2536             return getRuleContext(Case_stmtContext.class, i);\r
2537         }\r
2538 \r
2539         public Uses_augment_stmtContext(ParserRuleContext parent,\r
2540                 int invokingState) {\r
2541             super(parent, invokingState);\r
2542         }\r
2543 \r
2544         @Override\r
2545         public int getRuleIndex() {\r
2546             return RULE_uses_augment_stmt;\r
2547         }\r
2548 \r
2549         @Override\r
2550         public void enterRule(ParseTreeListener listener) {\r
2551             if (listener instanceof YangParserListener)\r
2552                 ((YangParserListener) listener).enterUses_augment_stmt(this);\r
2553         }\r
2554 \r
2555         @Override\r
2556         public void exitRule(ParseTreeListener listener) {\r
2557             if (listener instanceof YangParserListener)\r
2558                 ((YangParserListener) listener).exitUses_augment_stmt(this);\r
2559         }\r
2560 \r
2561         @Override\r
2562         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
2563             if (visitor instanceof YangParserVisitor)\r
2564                 return ((YangParserVisitor<? extends T>) visitor)\r
2565                         .visitUses_augment_stmt(this);\r
2566             else\r
2567                 return visitor.visitChildren(this);\r
2568         }\r
2569     }\r
2570 \r
2571     public final Uses_augment_stmtContext uses_augment_stmt()\r
2572             throws RecognitionException {\r
2573         Uses_augment_stmtContext _localctx = new Uses_augment_stmtContext(_ctx,\r
2574                 getState());\r
2575         enterRule(_localctx, 30, RULE_uses_augment_stmt);\r
2576         int _la;\r
2577         try {\r
2578             enterOuterAlt(_localctx, 1);\r
2579             {\r
2580                 setState(413);\r
2581                 match(AUGMENT_KEYWORD);\r
2582                 setState(414);\r
2583                 string();\r
2584                 setState(415);\r
2585                 match(LEFT_BRACE);\r
2586                 setState(424);\r
2587                 _errHandler.sync(this);\r
2588                 _la = _input.LA(1);\r
2589                 do {\r
2590                     {\r
2591                         setState(424);\r
2592                         switch (_input.LA(1)) {\r
2593                         case IDENTIFIER: {\r
2594                             setState(416);\r
2595                             identifier_stmt();\r
2596                         }\r
2597                             break;\r
2598                         case WHEN_KEYWORD: {\r
2599                             setState(417);\r
2600                             when_stmt();\r
2601                         }\r
2602                             break;\r
2603                         case IF_FEATURE_KEYWORD: {\r
2604                             setState(418);\r
2605                             if_feature_stmt();\r
2606                         }\r
2607                             break;\r
2608                         case STATUS_KEYWORD: {\r
2609                             setState(419);\r
2610                             status_stmt();\r
2611                         }\r
2612                             break;\r
2613                         case DESCRIPTION_KEYWORD: {\r
2614                             setState(420);\r
2615                             description_stmt();\r
2616                         }\r
2617                             break;\r
2618                         case REFERENCE_KEYWORD: {\r
2619                             setState(421);\r
2620                             reference_stmt();\r
2621                         }\r
2622                             break;\r
2623                         case USES_KEYWORD:\r
2624                         case LIST_KEYWORD:\r
2625                         case LEAF_LIST_KEYWORD:\r
2626                         case LEAF_KEYWORD:\r
2627                         case CONTAINER_KEYWORD:\r
2628                         case CHOICE_KEYWORD:\r
2629                         case ANYXML_KEYWORD: {\r
2630                             setState(422);\r
2631                             data_def_stmt();\r
2632                         }\r
2633                             break;\r
2634                         case CASE_KEYWORD: {\r
2635                             setState(423);\r
2636                             case_stmt();\r
2637                         }\r
2638                             break;\r
2639                         default:\r
2640                             throw new NoViableAltException(this);\r
2641                         }\r
2642                     }\r
2643                     setState(426);\r
2644                     _errHandler.sync(this);\r
2645                     _la = _input.LA(1);\r
2646                 } while (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (WHEN_KEYWORD - 10))\r
2647                         | (1L << (USES_KEYWORD - 10))\r
2648                         | (1L << (STATUS_KEYWORD - 10))\r
2649                         | (1L << (REFERENCE_KEYWORD - 10))\r
2650                         | (1L << (LIST_KEYWORD - 10))\r
2651                         | (1L << (LEAF_LIST_KEYWORD - 10))\r
2652                         | (1L << (LEAF_KEYWORD - 10))\r
2653                         | (1L << (IF_FEATURE_KEYWORD - 10))\r
2654                         | (1L << (DESCRIPTION_KEYWORD - 10))\r
2655                         | (1L << (CONTAINER_KEYWORD - 10))\r
2656                         | (1L << (CHOICE_KEYWORD - 10))\r
2657                         | (1L << (CASE_KEYWORD - 10))\r
2658                         | (1L << (ANYXML_KEYWORD - 10)) | (1L << (IDENTIFIER - 10)))) != 0));\r
2659                 setState(428);\r
2660                 match(RIGHT_BRACE);\r
2661             }\r
2662         } catch (RecognitionException re) {\r
2663             _localctx.exception = re;\r
2664             _errHandler.reportError(this, re);\r
2665             _errHandler.recover(this, re);\r
2666         } finally {\r
2667             exitRule();\r
2668         }\r
2669         return _localctx;\r
2670     }\r
2671 \r
2672     public static class Refine_anyxml_stmtsContext extends ParserRuleContext {\r
2673         public List<Reference_stmtContext> reference_stmt() {\r
2674             return getRuleContexts(Reference_stmtContext.class);\r
2675         }\r
2676 \r
2677         public Description_stmtContext description_stmt(int i) {\r
2678             return getRuleContext(Description_stmtContext.class, i);\r
2679         }\r
2680 \r
2681         public Mandatory_stmtContext mandatory_stmt(int i) {\r
2682             return getRuleContext(Mandatory_stmtContext.class, i);\r
2683         }\r
2684 \r
2685         public Config_stmtContext config_stmt(int i) {\r
2686             return getRuleContext(Config_stmtContext.class, i);\r
2687         }\r
2688 \r
2689         public List<Config_stmtContext> config_stmt() {\r
2690             return getRuleContexts(Config_stmtContext.class);\r
2691         }\r
2692 \r
2693         public List<Must_stmtContext> must_stmt() {\r
2694             return getRuleContexts(Must_stmtContext.class);\r
2695         }\r
2696 \r
2697         public List<Description_stmtContext> description_stmt() {\r
2698             return getRuleContexts(Description_stmtContext.class);\r
2699         }\r
2700 \r
2701         public Reference_stmtContext reference_stmt(int i) {\r
2702             return getRuleContext(Reference_stmtContext.class, i);\r
2703         }\r
2704 \r
2705         public List<Mandatory_stmtContext> mandatory_stmt() {\r
2706             return getRuleContexts(Mandatory_stmtContext.class);\r
2707         }\r
2708 \r
2709         public Must_stmtContext must_stmt(int i) {\r
2710             return getRuleContext(Must_stmtContext.class, i);\r
2711         }\r
2712 \r
2713         public Refine_anyxml_stmtsContext(ParserRuleContext parent,\r
2714                 int invokingState) {\r
2715             super(parent, invokingState);\r
2716         }\r
2717 \r
2718         @Override\r
2719         public int getRuleIndex() {\r
2720             return RULE_refine_anyxml_stmts;\r
2721         }\r
2722 \r
2723         @Override\r
2724         public void enterRule(ParseTreeListener listener) {\r
2725             if (listener instanceof YangParserListener)\r
2726                 ((YangParserListener) listener).enterRefine_anyxml_stmts(this);\r
2727         }\r
2728 \r
2729         @Override\r
2730         public void exitRule(ParseTreeListener listener) {\r
2731             if (listener instanceof YangParserListener)\r
2732                 ((YangParserListener) listener).exitRefine_anyxml_stmts(this);\r
2733         }\r
2734 \r
2735         @Override\r
2736         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
2737             if (visitor instanceof YangParserVisitor)\r
2738                 return ((YangParserVisitor<? extends T>) visitor)\r
2739                         .visitRefine_anyxml_stmts(this);\r
2740             else\r
2741                 return visitor.visitChildren(this);\r
2742         }\r
2743     }\r
2744 \r
2745     public final Refine_anyxml_stmtsContext refine_anyxml_stmts()\r
2746             throws RecognitionException {\r
2747         Refine_anyxml_stmtsContext _localctx = new Refine_anyxml_stmtsContext(\r
2748                 _ctx, getState());\r
2749         enterRule(_localctx, 32, RULE_refine_anyxml_stmts);\r
2750         try {\r
2751             int _alt;\r
2752             enterOuterAlt(_localctx, 1);\r
2753             {\r
2754                 setState(437);\r
2755                 _errHandler.sync(this);\r
2756                 _alt = getInterpreter().adaptivePredict(_input, 37, _ctx);\r
2757                 while (_alt != 2 && _alt != -1) {\r
2758                     if (_alt == 1) {\r
2759                         {\r
2760                             setState(435);\r
2761                             switch (_input.LA(1)) {\r
2762                             case MUST_KEYWORD: {\r
2763                                 setState(430);\r
2764                                 must_stmt();\r
2765                             }\r
2766                                 break;\r
2767                             case CONFIG_KEYWORD: {\r
2768                                 setState(431);\r
2769                                 config_stmt();\r
2770                             }\r
2771                                 break;\r
2772                             case MANDATORY_KEYWORD: {\r
2773                                 setState(432);\r
2774                                 mandatory_stmt();\r
2775                             }\r
2776                                 break;\r
2777                             case DESCRIPTION_KEYWORD: {\r
2778                                 setState(433);\r
2779                                 description_stmt();\r
2780                             }\r
2781                                 break;\r
2782                             case REFERENCE_KEYWORD: {\r
2783                                 setState(434);\r
2784                                 reference_stmt();\r
2785                             }\r
2786                                 break;\r
2787                             default:\r
2788                                 throw new NoViableAltException(this);\r
2789                             }\r
2790                         }\r
2791                     }\r
2792                     setState(439);\r
2793                     _errHandler.sync(this);\r
2794                     _alt = getInterpreter().adaptivePredict(_input, 37, _ctx);\r
2795                 }\r
2796             }\r
2797         } catch (RecognitionException re) {\r
2798             _localctx.exception = re;\r
2799             _errHandler.reportError(this, re);\r
2800             _errHandler.recover(this, re);\r
2801         } finally {\r
2802             exitRule();\r
2803         }\r
2804         return _localctx;\r
2805     }\r
2806 \r
2807     public static class Refine_case_stmtsContext extends ParserRuleContext {\r
2808         public List<Reference_stmtContext> reference_stmt() {\r
2809             return getRuleContexts(Reference_stmtContext.class);\r
2810         }\r
2811 \r
2812         public Description_stmtContext description_stmt(int i) {\r
2813             return getRuleContext(Description_stmtContext.class, i);\r
2814         }\r
2815 \r
2816         public List<Description_stmtContext> description_stmt() {\r
2817             return getRuleContexts(Description_stmtContext.class);\r
2818         }\r
2819 \r
2820         public Reference_stmtContext reference_stmt(int i) {\r
2821             return getRuleContext(Reference_stmtContext.class, i);\r
2822         }\r
2823 \r
2824         public Refine_case_stmtsContext(ParserRuleContext parent,\r
2825                 int invokingState) {\r
2826             super(parent, invokingState);\r
2827         }\r
2828 \r
2829         @Override\r
2830         public int getRuleIndex() {\r
2831             return RULE_refine_case_stmts;\r
2832         }\r
2833 \r
2834         @Override\r
2835         public void enterRule(ParseTreeListener listener) {\r
2836             if (listener instanceof YangParserListener)\r
2837                 ((YangParserListener) listener).enterRefine_case_stmts(this);\r
2838         }\r
2839 \r
2840         @Override\r
2841         public void exitRule(ParseTreeListener listener) {\r
2842             if (listener instanceof YangParserListener)\r
2843                 ((YangParserListener) listener).exitRefine_case_stmts(this);\r
2844         }\r
2845 \r
2846         @Override\r
2847         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
2848             if (visitor instanceof YangParserVisitor)\r
2849                 return ((YangParserVisitor<? extends T>) visitor)\r
2850                         .visitRefine_case_stmts(this);\r
2851             else\r
2852                 return visitor.visitChildren(this);\r
2853         }\r
2854     }\r
2855 \r
2856     public final Refine_case_stmtsContext refine_case_stmts()\r
2857             throws RecognitionException {\r
2858         Refine_case_stmtsContext _localctx = new Refine_case_stmtsContext(_ctx,\r
2859                 getState());\r
2860         enterRule(_localctx, 34, RULE_refine_case_stmts);\r
2861         try {\r
2862             int _alt;\r
2863             enterOuterAlt(_localctx, 1);\r
2864             {\r
2865                 setState(444);\r
2866                 _errHandler.sync(this);\r
2867                 _alt = getInterpreter().adaptivePredict(_input, 39, _ctx);\r
2868                 while (_alt != 2 && _alt != -1) {\r
2869                     if (_alt == 1) {\r
2870                         {\r
2871                             setState(442);\r
2872                             switch (_input.LA(1)) {\r
2873                             case DESCRIPTION_KEYWORD: {\r
2874                                 setState(440);\r
2875                                 description_stmt();\r
2876                             }\r
2877                                 break;\r
2878                             case REFERENCE_KEYWORD: {\r
2879                                 setState(441);\r
2880                                 reference_stmt();\r
2881                             }\r
2882                                 break;\r
2883                             default:\r
2884                                 throw new NoViableAltException(this);\r
2885                             }\r
2886                         }\r
2887                     }\r
2888                     setState(446);\r
2889                     _errHandler.sync(this);\r
2890                     _alt = getInterpreter().adaptivePredict(_input, 39, _ctx);\r
2891                 }\r
2892             }\r
2893         } catch (RecognitionException re) {\r
2894             _localctx.exception = re;\r
2895             _errHandler.reportError(this, re);\r
2896             _errHandler.recover(this, re);\r
2897         } finally {\r
2898             exitRule();\r
2899         }\r
2900         return _localctx;\r
2901     }\r
2902 \r
2903     public static class Refine_choice_stmtsContext extends ParserRuleContext {\r
2904         public List<Reference_stmtContext> reference_stmt() {\r
2905             return getRuleContexts(Reference_stmtContext.class);\r
2906         }\r
2907 \r
2908         public List<Default_stmtContext> default_stmt() {\r
2909             return getRuleContexts(Default_stmtContext.class);\r
2910         }\r
2911 \r
2912         public Description_stmtContext description_stmt(int i) {\r
2913             return getRuleContext(Description_stmtContext.class, i);\r
2914         }\r
2915 \r
2916         public Default_stmtContext default_stmt(int i) {\r
2917             return getRuleContext(Default_stmtContext.class, i);\r
2918         }\r
2919 \r
2920         public Mandatory_stmtContext mandatory_stmt(int i) {\r
2921             return getRuleContext(Mandatory_stmtContext.class, i);\r
2922         }\r
2923 \r
2924         public Config_stmtContext config_stmt(int i) {\r
2925             return getRuleContext(Config_stmtContext.class, i);\r
2926         }\r
2927 \r
2928         public List<Config_stmtContext> config_stmt() {\r
2929             return getRuleContexts(Config_stmtContext.class);\r
2930         }\r
2931 \r
2932         public List<Description_stmtContext> description_stmt() {\r
2933             return getRuleContexts(Description_stmtContext.class);\r
2934         }\r
2935 \r
2936         public Reference_stmtContext reference_stmt(int i) {\r
2937             return getRuleContext(Reference_stmtContext.class, i);\r
2938         }\r
2939 \r
2940         public List<Mandatory_stmtContext> mandatory_stmt() {\r
2941             return getRuleContexts(Mandatory_stmtContext.class);\r
2942         }\r
2943 \r
2944         public Refine_choice_stmtsContext(ParserRuleContext parent,\r
2945                 int invokingState) {\r
2946             super(parent, invokingState);\r
2947         }\r
2948 \r
2949         @Override\r
2950         public int getRuleIndex() {\r
2951             return RULE_refine_choice_stmts;\r
2952         }\r
2953 \r
2954         @Override\r
2955         public void enterRule(ParseTreeListener listener) {\r
2956             if (listener instanceof YangParserListener)\r
2957                 ((YangParserListener) listener).enterRefine_choice_stmts(this);\r
2958         }\r
2959 \r
2960         @Override\r
2961         public void exitRule(ParseTreeListener listener) {\r
2962             if (listener instanceof YangParserListener)\r
2963                 ((YangParserListener) listener).exitRefine_choice_stmts(this);\r
2964         }\r
2965 \r
2966         @Override\r
2967         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
2968             if (visitor instanceof YangParserVisitor)\r
2969                 return ((YangParserVisitor<? extends T>) visitor)\r
2970                         .visitRefine_choice_stmts(this);\r
2971             else\r
2972                 return visitor.visitChildren(this);\r
2973         }\r
2974     }\r
2975 \r
2976     public final Refine_choice_stmtsContext refine_choice_stmts()\r
2977             throws RecognitionException {\r
2978         Refine_choice_stmtsContext _localctx = new Refine_choice_stmtsContext(\r
2979                 _ctx, getState());\r
2980         enterRule(_localctx, 36, RULE_refine_choice_stmts);\r
2981         try {\r
2982             int _alt;\r
2983             enterOuterAlt(_localctx, 1);\r
2984             {\r
2985                 setState(454);\r
2986                 _errHandler.sync(this);\r
2987                 _alt = getInterpreter().adaptivePredict(_input, 41, _ctx);\r
2988                 while (_alt != 2 && _alt != -1) {\r
2989                     if (_alt == 1) {\r
2990                         {\r
2991                             setState(452);\r
2992                             switch (_input.LA(1)) {\r
2993                             case DEFAULT_KEYWORD: {\r
2994                                 setState(447);\r
2995                                 default_stmt();\r
2996                             }\r
2997                                 break;\r
2998                             case CONFIG_KEYWORD: {\r
2999                                 setState(448);\r
3000                                 config_stmt();\r
3001                             }\r
3002                                 break;\r
3003                             case MANDATORY_KEYWORD: {\r
3004                                 setState(449);\r
3005                                 mandatory_stmt();\r
3006                             }\r
3007                                 break;\r
3008                             case DESCRIPTION_KEYWORD: {\r
3009                                 setState(450);\r
3010                                 description_stmt();\r
3011                             }\r
3012                                 break;\r
3013                             case REFERENCE_KEYWORD: {\r
3014                                 setState(451);\r
3015                                 reference_stmt();\r
3016                             }\r
3017                                 break;\r
3018                             default:\r
3019                                 throw new NoViableAltException(this);\r
3020                             }\r
3021                         }\r
3022                     }\r
3023                     setState(456);\r
3024                     _errHandler.sync(this);\r
3025                     _alt = getInterpreter().adaptivePredict(_input, 41, _ctx);\r
3026                 }\r
3027             }\r
3028         } catch (RecognitionException re) {\r
3029             _localctx.exception = re;\r
3030             _errHandler.reportError(this, re);\r
3031             _errHandler.recover(this, re);\r
3032         } finally {\r
3033             exitRule();\r
3034         }\r
3035         return _localctx;\r
3036     }\r
3037 \r
3038     public static class Refine_list_stmtsContext extends ParserRuleContext {\r
3039         public List<Reference_stmtContext> reference_stmt() {\r
3040             return getRuleContexts(Reference_stmtContext.class);\r
3041         }\r
3042 \r
3043         public Description_stmtContext description_stmt(int i) {\r
3044             return getRuleContext(Description_stmtContext.class, i);\r
3045         }\r
3046 \r
3047         public Config_stmtContext config_stmt(int i) {\r
3048             return getRuleContext(Config_stmtContext.class, i);\r
3049         }\r
3050 \r
3051         public List<Min_elements_stmtContext> min_elements_stmt() {\r
3052             return getRuleContexts(Min_elements_stmtContext.class);\r
3053         }\r
3054 \r
3055         public List<Max_elements_stmtContext> max_elements_stmt() {\r
3056             return getRuleContexts(Max_elements_stmtContext.class);\r
3057         }\r
3058 \r
3059         public List<Config_stmtContext> config_stmt() {\r
3060             return getRuleContexts(Config_stmtContext.class);\r
3061         }\r
3062 \r
3063         public List<Must_stmtContext> must_stmt() {\r
3064             return getRuleContexts(Must_stmtContext.class);\r
3065         }\r
3066 \r
3067         public Max_elements_stmtContext max_elements_stmt(int i) {\r
3068             return getRuleContext(Max_elements_stmtContext.class, i);\r
3069         }\r
3070 \r
3071         public List<Description_stmtContext> description_stmt() {\r
3072             return getRuleContexts(Description_stmtContext.class);\r
3073         }\r
3074 \r
3075         public Reference_stmtContext reference_stmt(int i) {\r
3076             return getRuleContext(Reference_stmtContext.class, i);\r
3077         }\r
3078 \r
3079         public Must_stmtContext must_stmt(int i) {\r
3080             return getRuleContext(Must_stmtContext.class, i);\r
3081         }\r
3082 \r
3083         public Min_elements_stmtContext min_elements_stmt(int i) {\r
3084             return getRuleContext(Min_elements_stmtContext.class, i);\r
3085         }\r
3086 \r
3087         public Refine_list_stmtsContext(ParserRuleContext parent,\r
3088                 int invokingState) {\r
3089             super(parent, invokingState);\r
3090         }\r
3091 \r
3092         @Override\r
3093         public int getRuleIndex() {\r
3094             return RULE_refine_list_stmts;\r
3095         }\r
3096 \r
3097         @Override\r
3098         public void enterRule(ParseTreeListener listener) {\r
3099             if (listener instanceof YangParserListener)\r
3100                 ((YangParserListener) listener).enterRefine_list_stmts(this);\r
3101         }\r
3102 \r
3103         @Override\r
3104         public void exitRule(ParseTreeListener listener) {\r
3105             if (listener instanceof YangParserListener)\r
3106                 ((YangParserListener) listener).exitRefine_list_stmts(this);\r
3107         }\r
3108 \r
3109         @Override\r
3110         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
3111             if (visitor instanceof YangParserVisitor)\r
3112                 return ((YangParserVisitor<? extends T>) visitor)\r
3113                         .visitRefine_list_stmts(this);\r
3114             else\r
3115                 return visitor.visitChildren(this);\r
3116         }\r
3117     }\r
3118 \r
3119     public final Refine_list_stmtsContext refine_list_stmts()\r
3120             throws RecognitionException {\r
3121         Refine_list_stmtsContext _localctx = new Refine_list_stmtsContext(_ctx,\r
3122                 getState());\r
3123         enterRule(_localctx, 38, RULE_refine_list_stmts);\r
3124         try {\r
3125             int _alt;\r
3126             enterOuterAlt(_localctx, 1);\r
3127             {\r
3128                 setState(465);\r
3129                 _errHandler.sync(this);\r
3130                 _alt = getInterpreter().adaptivePredict(_input, 43, _ctx);\r
3131                 while (_alt != 2 && _alt != -1) {\r
3132                     if (_alt == 1) {\r
3133                         {\r
3134                             setState(463);\r
3135                             switch (_input.LA(1)) {\r
3136                             case MUST_KEYWORD: {\r
3137                                 setState(457);\r
3138                                 must_stmt();\r
3139                             }\r
3140                                 break;\r
3141                             case CONFIG_KEYWORD: {\r
3142                                 setState(458);\r
3143                                 config_stmt();\r
3144                             }\r
3145                                 break;\r
3146                             case MIN_ELEMENTS_KEYWORD: {\r
3147                                 setState(459);\r
3148                                 min_elements_stmt();\r
3149                             }\r
3150                                 break;\r
3151                             case MAX_ELEMENTS_KEYWORD: {\r
3152                                 setState(460);\r
3153                                 max_elements_stmt();\r
3154                             }\r
3155                                 break;\r
3156                             case DESCRIPTION_KEYWORD: {\r
3157                                 setState(461);\r
3158                                 description_stmt();\r
3159                             }\r
3160                                 break;\r
3161                             case REFERENCE_KEYWORD: {\r
3162                                 setState(462);\r
3163                                 reference_stmt();\r
3164                             }\r
3165                                 break;\r
3166                             default:\r
3167                                 throw new NoViableAltException(this);\r
3168                             }\r
3169                         }\r
3170                     }\r
3171                     setState(467);\r
3172                     _errHandler.sync(this);\r
3173                     _alt = getInterpreter().adaptivePredict(_input, 43, _ctx);\r
3174                 }\r
3175             }\r
3176         } catch (RecognitionException re) {\r
3177             _localctx.exception = re;\r
3178             _errHandler.reportError(this, re);\r
3179             _errHandler.recover(this, re);\r
3180         } finally {\r
3181             exitRule();\r
3182         }\r
3183         return _localctx;\r
3184     }\r
3185 \r
3186     public static class Refine_leaf_list_stmtsContext extends ParserRuleContext {\r
3187         public List<Reference_stmtContext> reference_stmt() {\r
3188             return getRuleContexts(Reference_stmtContext.class);\r
3189         }\r
3190 \r
3191         public Description_stmtContext description_stmt(int i) {\r
3192             return getRuleContext(Description_stmtContext.class, i);\r
3193         }\r
3194 \r
3195         public Config_stmtContext config_stmt(int i) {\r
3196             return getRuleContext(Config_stmtContext.class, i);\r
3197         }\r
3198 \r
3199         public List<Min_elements_stmtContext> min_elements_stmt() {\r
3200             return getRuleContexts(Min_elements_stmtContext.class);\r
3201         }\r
3202 \r
3203         public List<Max_elements_stmtContext> max_elements_stmt() {\r
3204             return getRuleContexts(Max_elements_stmtContext.class);\r
3205         }\r
3206 \r
3207         public List<Config_stmtContext> config_stmt() {\r
3208             return getRuleContexts(Config_stmtContext.class);\r
3209         }\r
3210 \r
3211         public List<Must_stmtContext> must_stmt() {\r
3212             return getRuleContexts(Must_stmtContext.class);\r
3213         }\r
3214 \r
3215         public Max_elements_stmtContext max_elements_stmt(int i) {\r
3216             return getRuleContext(Max_elements_stmtContext.class, i);\r
3217         }\r
3218 \r
3219         public List<Description_stmtContext> description_stmt() {\r
3220             return getRuleContexts(Description_stmtContext.class);\r
3221         }\r
3222 \r
3223         public Reference_stmtContext reference_stmt(int i) {\r
3224             return getRuleContext(Reference_stmtContext.class, i);\r
3225         }\r
3226 \r
3227         public Must_stmtContext must_stmt(int i) {\r
3228             return getRuleContext(Must_stmtContext.class, i);\r
3229         }\r
3230 \r
3231         public Min_elements_stmtContext min_elements_stmt(int i) {\r
3232             return getRuleContext(Min_elements_stmtContext.class, i);\r
3233         }\r
3234 \r
3235         public Refine_leaf_list_stmtsContext(ParserRuleContext parent,\r
3236                 int invokingState) {\r
3237             super(parent, invokingState);\r
3238         }\r
3239 \r
3240         @Override\r
3241         public int getRuleIndex() {\r
3242             return RULE_refine_leaf_list_stmts;\r
3243         }\r
3244 \r
3245         @Override\r
3246         public void enterRule(ParseTreeListener listener) {\r
3247             if (listener instanceof YangParserListener)\r
3248                 ((YangParserListener) listener)\r
3249                         .enterRefine_leaf_list_stmts(this);\r
3250         }\r
3251 \r
3252         @Override\r
3253         public void exitRule(ParseTreeListener listener) {\r
3254             if (listener instanceof YangParserListener)\r
3255                 ((YangParserListener) listener)\r
3256                         .exitRefine_leaf_list_stmts(this);\r
3257         }\r
3258 \r
3259         @Override\r
3260         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
3261             if (visitor instanceof YangParserVisitor)\r
3262                 return ((YangParserVisitor<? extends T>) visitor)\r
3263                         .visitRefine_leaf_list_stmts(this);\r
3264             else\r
3265                 return visitor.visitChildren(this);\r
3266         }\r
3267     }\r
3268 \r
3269     public final Refine_leaf_list_stmtsContext refine_leaf_list_stmts()\r
3270             throws RecognitionException {\r
3271         Refine_leaf_list_stmtsContext _localctx = new Refine_leaf_list_stmtsContext(\r
3272                 _ctx, getState());\r
3273         enterRule(_localctx, 40, RULE_refine_leaf_list_stmts);\r
3274         try {\r
3275             int _alt;\r
3276             enterOuterAlt(_localctx, 1);\r
3277             {\r
3278                 setState(476);\r
3279                 _errHandler.sync(this);\r
3280                 _alt = getInterpreter().adaptivePredict(_input, 45, _ctx);\r
3281                 while (_alt != 2 && _alt != -1) {\r
3282                     if (_alt == 1) {\r
3283                         {\r
3284                             setState(474);\r
3285                             switch (_input.LA(1)) {\r
3286                             case MUST_KEYWORD: {\r
3287                                 setState(468);\r
3288                                 must_stmt();\r
3289                             }\r
3290                                 break;\r
3291                             case CONFIG_KEYWORD: {\r
3292                                 setState(469);\r
3293                                 config_stmt();\r
3294                             }\r
3295                                 break;\r
3296                             case MIN_ELEMENTS_KEYWORD: {\r
3297                                 setState(470);\r
3298                                 min_elements_stmt();\r
3299                             }\r
3300                                 break;\r
3301                             case MAX_ELEMENTS_KEYWORD: {\r
3302                                 setState(471);\r
3303                                 max_elements_stmt();\r
3304                             }\r
3305                                 break;\r
3306                             case DESCRIPTION_KEYWORD: {\r
3307                                 setState(472);\r
3308                                 description_stmt();\r
3309                             }\r
3310                                 break;\r
3311                             case REFERENCE_KEYWORD: {\r
3312                                 setState(473);\r
3313                                 reference_stmt();\r
3314                             }\r
3315                                 break;\r
3316                             default:\r
3317                                 throw new NoViableAltException(this);\r
3318                             }\r
3319                         }\r
3320                     }\r
3321                     setState(478);\r
3322                     _errHandler.sync(this);\r
3323                     _alt = getInterpreter().adaptivePredict(_input, 45, _ctx);\r
3324                 }\r
3325             }\r
3326         } catch (RecognitionException re) {\r
3327             _localctx.exception = re;\r
3328             _errHandler.reportError(this, re);\r
3329             _errHandler.recover(this, re);\r
3330         } finally {\r
3331             exitRule();\r
3332         }\r
3333         return _localctx;\r
3334     }\r
3335 \r
3336     public static class Refine_leaf_stmtsContext extends ParserRuleContext {\r
3337         public List<Reference_stmtContext> reference_stmt() {\r
3338             return getRuleContexts(Reference_stmtContext.class);\r
3339         }\r
3340 \r
3341         public List<Default_stmtContext> default_stmt() {\r
3342             return getRuleContexts(Default_stmtContext.class);\r
3343         }\r
3344 \r
3345         public Description_stmtContext description_stmt(int i) {\r
3346             return getRuleContext(Description_stmtContext.class, i);\r
3347         }\r
3348 \r
3349         public Default_stmtContext default_stmt(int i) {\r
3350             return getRuleContext(Default_stmtContext.class, i);\r
3351         }\r
3352 \r
3353         public Mandatory_stmtContext mandatory_stmt(int i) {\r
3354             return getRuleContext(Mandatory_stmtContext.class, i);\r
3355         }\r
3356 \r
3357         public Config_stmtContext config_stmt(int i) {\r
3358             return getRuleContext(Config_stmtContext.class, i);\r
3359         }\r
3360 \r
3361         public List<Config_stmtContext> config_stmt() {\r
3362             return getRuleContexts(Config_stmtContext.class);\r
3363         }\r
3364 \r
3365         public List<Must_stmtContext> must_stmt() {\r
3366             return getRuleContexts(Must_stmtContext.class);\r
3367         }\r
3368 \r
3369         public List<Description_stmtContext> description_stmt() {\r
3370             return getRuleContexts(Description_stmtContext.class);\r
3371         }\r
3372 \r
3373         public Reference_stmtContext reference_stmt(int i) {\r
3374             return getRuleContext(Reference_stmtContext.class, i);\r
3375         }\r
3376 \r
3377         public List<Mandatory_stmtContext> mandatory_stmt() {\r
3378             return getRuleContexts(Mandatory_stmtContext.class);\r
3379         }\r
3380 \r
3381         public Must_stmtContext must_stmt(int i) {\r
3382             return getRuleContext(Must_stmtContext.class, i);\r
3383         }\r
3384 \r
3385         public Refine_leaf_stmtsContext(ParserRuleContext parent,\r
3386                 int invokingState) {\r
3387             super(parent, invokingState);\r
3388         }\r
3389 \r
3390         @Override\r
3391         public int getRuleIndex() {\r
3392             return RULE_refine_leaf_stmts;\r
3393         }\r
3394 \r
3395         @Override\r
3396         public void enterRule(ParseTreeListener listener) {\r
3397             if (listener instanceof YangParserListener)\r
3398                 ((YangParserListener) listener).enterRefine_leaf_stmts(this);\r
3399         }\r
3400 \r
3401         @Override\r
3402         public void exitRule(ParseTreeListener listener) {\r
3403             if (listener instanceof YangParserListener)\r
3404                 ((YangParserListener) listener).exitRefine_leaf_stmts(this);\r
3405         }\r
3406 \r
3407         @Override\r
3408         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
3409             if (visitor instanceof YangParserVisitor)\r
3410                 return ((YangParserVisitor<? extends T>) visitor)\r
3411                         .visitRefine_leaf_stmts(this);\r
3412             else\r
3413                 return visitor.visitChildren(this);\r
3414         }\r
3415     }\r
3416 \r
3417     public final Refine_leaf_stmtsContext refine_leaf_stmts()\r
3418             throws RecognitionException {\r
3419         Refine_leaf_stmtsContext _localctx = new Refine_leaf_stmtsContext(_ctx,\r
3420                 getState());\r
3421         enterRule(_localctx, 42, RULE_refine_leaf_stmts);\r
3422         try {\r
3423             int _alt;\r
3424             enterOuterAlt(_localctx, 1);\r
3425             {\r
3426                 setState(487);\r
3427                 _errHandler.sync(this);\r
3428                 _alt = getInterpreter().adaptivePredict(_input, 47, _ctx);\r
3429                 while (_alt != 2 && _alt != -1) {\r
3430                     if (_alt == 1) {\r
3431                         {\r
3432                             setState(485);\r
3433                             switch (_input.LA(1)) {\r
3434                             case MUST_KEYWORD: {\r
3435                                 setState(479);\r
3436                                 must_stmt();\r
3437                             }\r
3438                                 break;\r
3439                             case DEFAULT_KEYWORD: {\r
3440                                 setState(480);\r
3441                                 default_stmt();\r
3442                             }\r
3443                                 break;\r
3444                             case CONFIG_KEYWORD: {\r
3445                                 setState(481);\r
3446                                 config_stmt();\r
3447                             }\r
3448                                 break;\r
3449                             case MANDATORY_KEYWORD: {\r
3450                                 setState(482);\r
3451                                 mandatory_stmt();\r
3452                             }\r
3453                                 break;\r
3454                             case DESCRIPTION_KEYWORD: {\r
3455                                 setState(483);\r
3456                                 description_stmt();\r
3457                             }\r
3458                                 break;\r
3459                             case REFERENCE_KEYWORD: {\r
3460                                 setState(484);\r
3461                                 reference_stmt();\r
3462                             }\r
3463                                 break;\r
3464                             default:\r
3465                                 throw new NoViableAltException(this);\r
3466                             }\r
3467                         }\r
3468                     }\r
3469                     setState(489);\r
3470                     _errHandler.sync(this);\r
3471                     _alt = getInterpreter().adaptivePredict(_input, 47, _ctx);\r
3472                 }\r
3473             }\r
3474         } catch (RecognitionException re) {\r
3475             _localctx.exception = re;\r
3476             _errHandler.reportError(this, re);\r
3477             _errHandler.recover(this, re);\r
3478         } finally {\r
3479             exitRule();\r
3480         }\r
3481         return _localctx;\r
3482     }\r
3483 \r
3484     public static class Refine_container_stmtsContext extends ParserRuleContext {\r
3485         public List<Reference_stmtContext> reference_stmt() {\r
3486             return getRuleContexts(Reference_stmtContext.class);\r
3487         }\r
3488 \r
3489         public List<Presence_stmtContext> presence_stmt() {\r
3490             return getRuleContexts(Presence_stmtContext.class);\r
3491         }\r
3492 \r
3493         public Description_stmtContext description_stmt(int i) {\r
3494             return getRuleContext(Description_stmtContext.class, i);\r
3495         }\r
3496 \r
3497         public Config_stmtContext config_stmt(int i) {\r
3498             return getRuleContext(Config_stmtContext.class, i);\r
3499         }\r
3500 \r
3501         public Presence_stmtContext presence_stmt(int i) {\r
3502             return getRuleContext(Presence_stmtContext.class, i);\r
3503         }\r
3504 \r
3505         public List<Config_stmtContext> config_stmt() {\r
3506             return getRuleContexts(Config_stmtContext.class);\r
3507         }\r
3508 \r
3509         public List<Must_stmtContext> must_stmt() {\r
3510             return getRuleContexts(Must_stmtContext.class);\r
3511         }\r
3512 \r
3513         public List<Description_stmtContext> description_stmt() {\r
3514             return getRuleContexts(Description_stmtContext.class);\r
3515         }\r
3516 \r
3517         public Reference_stmtContext reference_stmt(int i) {\r
3518             return getRuleContext(Reference_stmtContext.class, i);\r
3519         }\r
3520 \r
3521         public Must_stmtContext must_stmt(int i) {\r
3522             return getRuleContext(Must_stmtContext.class, i);\r
3523         }\r
3524 \r
3525         public Refine_container_stmtsContext(ParserRuleContext parent,\r
3526                 int invokingState) {\r
3527             super(parent, invokingState);\r
3528         }\r
3529 \r
3530         @Override\r
3531         public int getRuleIndex() {\r
3532             return RULE_refine_container_stmts;\r
3533         }\r
3534 \r
3535         @Override\r
3536         public void enterRule(ParseTreeListener listener) {\r
3537             if (listener instanceof YangParserListener)\r
3538                 ((YangParserListener) listener)\r
3539                         .enterRefine_container_stmts(this);\r
3540         }\r
3541 \r
3542         @Override\r
3543         public void exitRule(ParseTreeListener listener) {\r
3544             if (listener instanceof YangParserListener)\r
3545                 ((YangParserListener) listener)\r
3546                         .exitRefine_container_stmts(this);\r
3547         }\r
3548 \r
3549         @Override\r
3550         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
3551             if (visitor instanceof YangParserVisitor)\r
3552                 return ((YangParserVisitor<? extends T>) visitor)\r
3553                         .visitRefine_container_stmts(this);\r
3554             else\r
3555                 return visitor.visitChildren(this);\r
3556         }\r
3557     }\r
3558 \r
3559     public final Refine_container_stmtsContext refine_container_stmts()\r
3560             throws RecognitionException {\r
3561         Refine_container_stmtsContext _localctx = new Refine_container_stmtsContext(\r
3562                 _ctx, getState());\r
3563         enterRule(_localctx, 44, RULE_refine_container_stmts);\r
3564         try {\r
3565             int _alt;\r
3566             enterOuterAlt(_localctx, 1);\r
3567             {\r
3568                 setState(497);\r
3569                 _errHandler.sync(this);\r
3570                 _alt = getInterpreter().adaptivePredict(_input, 49, _ctx);\r
3571                 while (_alt != 2 && _alt != -1) {\r
3572                     if (_alt == 1) {\r
3573                         {\r
3574                             setState(495);\r
3575                             switch (_input.LA(1)) {\r
3576                             case MUST_KEYWORD: {\r
3577                                 setState(490);\r
3578                                 must_stmt();\r
3579                             }\r
3580                                 break;\r
3581                             case PRESENCE_KEYWORD: {\r
3582                                 setState(491);\r
3583                                 presence_stmt();\r
3584                             }\r
3585                                 break;\r
3586                             case CONFIG_KEYWORD: {\r
3587                                 setState(492);\r
3588                                 config_stmt();\r
3589                             }\r
3590                                 break;\r
3591                             case DESCRIPTION_KEYWORD: {\r
3592                                 setState(493);\r
3593                                 description_stmt();\r
3594                             }\r
3595                                 break;\r
3596                             case REFERENCE_KEYWORD: {\r
3597                                 setState(494);\r
3598                                 reference_stmt();\r
3599                             }\r
3600                                 break;\r
3601                             default:\r
3602                                 throw new NoViableAltException(this);\r
3603                             }\r
3604                         }\r
3605                     }\r
3606                     setState(499);\r
3607                     _errHandler.sync(this);\r
3608                     _alt = getInterpreter().adaptivePredict(_input, 49, _ctx);\r
3609                 }\r
3610             }\r
3611         } catch (RecognitionException re) {\r
3612             _localctx.exception = re;\r
3613             _errHandler.reportError(this, re);\r
3614             _errHandler.recover(this, re);\r
3615         } finally {\r
3616             exitRule();\r
3617         }\r
3618         return _localctx;\r
3619     }\r
3620 \r
3621     public static class Refune_pomContext extends ParserRuleContext {\r
3622         public Refine_list_stmtsContext refine_list_stmts() {\r
3623             return getRuleContext(Refine_list_stmtsContext.class, 0);\r
3624         }\r
3625 \r
3626         public Refine_choice_stmtsContext refine_choice_stmts() {\r
3627             return getRuleContext(Refine_choice_stmtsContext.class, 0);\r
3628         }\r
3629 \r
3630         public Refine_leaf_list_stmtsContext refine_leaf_list_stmts() {\r
3631             return getRuleContext(Refine_leaf_list_stmtsContext.class, 0);\r
3632         }\r
3633 \r
3634         public Refine_case_stmtsContext refine_case_stmts() {\r
3635             return getRuleContext(Refine_case_stmtsContext.class, 0);\r
3636         }\r
3637 \r
3638         public Refine_leaf_stmtsContext refine_leaf_stmts() {\r
3639             return getRuleContext(Refine_leaf_stmtsContext.class, 0);\r
3640         }\r
3641 \r
3642         public Refine_anyxml_stmtsContext refine_anyxml_stmts() {\r
3643             return getRuleContext(Refine_anyxml_stmtsContext.class, 0);\r
3644         }\r
3645 \r
3646         public Refine_container_stmtsContext refine_container_stmts() {\r
3647             return getRuleContext(Refine_container_stmtsContext.class, 0);\r
3648         }\r
3649 \r
3650         public Refune_pomContext(ParserRuleContext parent, int invokingState) {\r
3651             super(parent, invokingState);\r
3652         }\r
3653 \r
3654         @Override\r
3655         public int getRuleIndex() {\r
3656             return RULE_refune_pom;\r
3657         }\r
3658 \r
3659         @Override\r
3660         public void enterRule(ParseTreeListener listener) {\r
3661             if (listener instanceof YangParserListener)\r
3662                 ((YangParserListener) listener).enterRefune_pom(this);\r
3663         }\r
3664 \r
3665         @Override\r
3666         public void exitRule(ParseTreeListener listener) {\r
3667             if (listener instanceof YangParserListener)\r
3668                 ((YangParserListener) listener).exitRefune_pom(this);\r
3669         }\r
3670 \r
3671         @Override\r
3672         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
3673             if (visitor instanceof YangParserVisitor)\r
3674                 return ((YangParserVisitor<? extends T>) visitor)\r
3675                         .visitRefune_pom(this);\r
3676             else\r
3677                 return visitor.visitChildren(this);\r
3678         }\r
3679     }\r
3680 \r
3681     public final Refune_pomContext refune_pom() throws RecognitionException {\r
3682         Refune_pomContext _localctx = new Refune_pomContext(_ctx, getState());\r
3683         enterRule(_localctx, 46, RULE_refune_pom);\r
3684         try {\r
3685             enterOuterAlt(_localctx, 1);\r
3686             {\r
3687                 setState(507);\r
3688                 switch (getInterpreter().adaptivePredict(_input, 50, _ctx)) {\r
3689                 case 1: {\r
3690                     setState(500);\r
3691                     refine_container_stmts();\r
3692                 }\r
3693                     break;\r
3694 \r
3695                 case 2: {\r
3696                     setState(501);\r
3697                     refine_leaf_stmts();\r
3698                 }\r
3699                     break;\r
3700 \r
3701                 case 3: {\r
3702                     setState(502);\r
3703                     refine_leaf_list_stmts();\r
3704                 }\r
3705                     break;\r
3706 \r
3707                 case 4: {\r
3708                     setState(503);\r
3709                     refine_list_stmts();\r
3710                 }\r
3711                     break;\r
3712 \r
3713                 case 5: {\r
3714                     setState(504);\r
3715                     refine_choice_stmts();\r
3716                 }\r
3717                     break;\r
3718 \r
3719                 case 6: {\r
3720                     setState(505);\r
3721                     refine_case_stmts();\r
3722                 }\r
3723                     break;\r
3724 \r
3725                 case 7: {\r
3726                     setState(506);\r
3727                     refine_anyxml_stmts();\r
3728                 }\r
3729                     break;\r
3730                 }\r
3731             }\r
3732         } catch (RecognitionException re) {\r
3733             _localctx.exception = re;\r
3734             _errHandler.reportError(this, re);\r
3735             _errHandler.recover(this, re);\r
3736         } finally {\r
3737             exitRule();\r
3738         }\r
3739         return _localctx;\r
3740     }\r
3741 \r
3742     public static class Refine_stmtContext extends ParserRuleContext {\r
3743         public List<Refune_pomContext> refune_pom() {\r
3744             return getRuleContexts(Refune_pomContext.class);\r
3745         }\r
3746 \r
3747         public TerminalNode RIGHT_BRACE() {\r
3748             return getToken(YangParser.RIGHT_BRACE, 0);\r
3749         }\r
3750 \r
3751         public TerminalNode SEMICOLON() {\r
3752             return getToken(YangParser.SEMICOLON, 0);\r
3753         }\r
3754 \r
3755         public StringContext string() {\r
3756             return getRuleContext(StringContext.class, 0);\r
3757         }\r
3758 \r
3759         public Refune_pomContext refune_pom(int i) {\r
3760             return getRuleContext(Refune_pomContext.class, i);\r
3761         }\r
3762 \r
3763         public TerminalNode LEFT_BRACE() {\r
3764             return getToken(YangParser.LEFT_BRACE, 0);\r
3765         }\r
3766 \r
3767         public TerminalNode REFINE_KEYWORD() {\r
3768             return getToken(YangParser.REFINE_KEYWORD, 0);\r
3769         }\r
3770 \r
3771         public Refine_stmtContext(ParserRuleContext parent, int invokingState) {\r
3772             super(parent, invokingState);\r
3773         }\r
3774 \r
3775         @Override\r
3776         public int getRuleIndex() {\r
3777             return RULE_refine_stmt;\r
3778         }\r
3779 \r
3780         @Override\r
3781         public void enterRule(ParseTreeListener listener) {\r
3782             if (listener instanceof YangParserListener)\r
3783                 ((YangParserListener) listener).enterRefine_stmt(this);\r
3784         }\r
3785 \r
3786         @Override\r
3787         public void exitRule(ParseTreeListener listener) {\r
3788             if (listener instanceof YangParserListener)\r
3789                 ((YangParserListener) listener).exitRefine_stmt(this);\r
3790         }\r
3791 \r
3792         @Override\r
3793         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
3794             if (visitor instanceof YangParserVisitor)\r
3795                 return ((YangParserVisitor<? extends T>) visitor)\r
3796                         .visitRefine_stmt(this);\r
3797             else\r
3798                 return visitor.visitChildren(this);\r
3799         }\r
3800     }\r
3801 \r
3802     public final Refine_stmtContext refine_stmt() throws RecognitionException {\r
3803         Refine_stmtContext _localctx = new Refine_stmtContext(_ctx, getState());\r
3804         enterRule(_localctx, 48, RULE_refine_stmt);\r
3805         try {\r
3806             int _alt;\r
3807             enterOuterAlt(_localctx, 1);\r
3808             {\r
3809                 setState(509);\r
3810                 match(REFINE_KEYWORD);\r
3811                 setState(510);\r
3812                 string();\r
3813                 setState(520);\r
3814                 switch (_input.LA(1)) {\r
3815                 case SEMICOLON: {\r
3816                     setState(511);\r
3817                     match(SEMICOLON);\r
3818                 }\r
3819                     break;\r
3820                 case LEFT_BRACE: {\r
3821                     {\r
3822                         setState(512);\r
3823                         match(LEFT_BRACE);\r
3824                         setState(514);\r
3825                         _errHandler.sync(this);\r
3826                         _alt = getInterpreter().adaptivePredict(_input, 51,\r
3827                                 _ctx);\r
3828                         do {\r
3829                             switch (_alt) {\r
3830                             case 1: {\r
3831                                 {\r
3832                                     setState(513);\r
3833                                     refune_pom();\r
3834                                 }\r
3835                             }\r
3836                                 break;\r
3837                             default:\r
3838                                 throw new NoViableAltException(this);\r
3839                             }\r
3840                             setState(516);\r
3841                             _errHandler.sync(this);\r
3842                             _alt = getInterpreter().adaptivePredict(_input, 51,\r
3843                                     _ctx);\r
3844                         } while (_alt != 2 && _alt != -1);\r
3845                         setState(518);\r
3846                         match(RIGHT_BRACE);\r
3847                     }\r
3848                 }\r
3849                     break;\r
3850                 default:\r
3851                     throw new NoViableAltException(this);\r
3852                 }\r
3853             }\r
3854         } catch (RecognitionException re) {\r
3855             _localctx.exception = re;\r
3856             _errHandler.reportError(this, re);\r
3857             _errHandler.recover(this, re);\r
3858         } finally {\r
3859             exitRule();\r
3860         }\r
3861         return _localctx;\r
3862     }\r
3863 \r
3864     public static class Uses_stmtContext extends ParserRuleContext {\r
3865         public TerminalNode RIGHT_BRACE() {\r
3866             return getToken(YangParser.RIGHT_BRACE, 0);\r
3867         }\r
3868 \r
3869         public List<Reference_stmtContext> reference_stmt() {\r
3870             return getRuleContexts(Reference_stmtContext.class);\r
3871         }\r
3872 \r
3873         public Description_stmtContext description_stmt(int i) {\r
3874             return getRuleContext(Description_stmtContext.class, i);\r
3875         }\r
3876 \r
3877         public List<When_stmtContext> when_stmt() {\r
3878             return getRuleContexts(When_stmtContext.class);\r
3879         }\r
3880 \r
3881         public List<Uses_augment_stmtContext> uses_augment_stmt() {\r
3882             return getRuleContexts(Uses_augment_stmtContext.class);\r
3883         }\r
3884 \r
3885         public If_feature_stmtContext if_feature_stmt(int i) {\r
3886             return getRuleContext(If_feature_stmtContext.class, i);\r
3887         }\r
3888 \r
3889         public TerminalNode USES_KEYWORD() {\r
3890             return getToken(YangParser.USES_KEYWORD, 0);\r
3891         }\r
3892 \r
3893         public TerminalNode LEFT_BRACE() {\r
3894             return getToken(YangParser.LEFT_BRACE, 0);\r
3895         }\r
3896 \r
3897         public Status_stmtContext status_stmt(int i) {\r
3898             return getRuleContext(Status_stmtContext.class, i);\r
3899         }\r
3900 \r
3901         public List<If_feature_stmtContext> if_feature_stmt() {\r
3902             return getRuleContexts(If_feature_stmtContext.class);\r
3903         }\r
3904 \r
3905         public Identifier_stmtContext identifier_stmt(int i) {\r
3906             return getRuleContext(Identifier_stmtContext.class, i);\r
3907         }\r
3908 \r
3909         public TerminalNode SEMICOLON() {\r
3910             return getToken(YangParser.SEMICOLON, 0);\r
3911         }\r
3912 \r
3913         public List<Status_stmtContext> status_stmt() {\r
3914             return getRuleContexts(Status_stmtContext.class);\r
3915         }\r
3916 \r
3917         public Refine_stmtContext refine_stmt(int i) {\r
3918             return getRuleContext(Refine_stmtContext.class, i);\r
3919         }\r
3920 \r
3921         public StringContext string() {\r
3922             return getRuleContext(StringContext.class, 0);\r
3923         }\r
3924 \r
3925         public List<Identifier_stmtContext> identifier_stmt() {\r
3926             return getRuleContexts(Identifier_stmtContext.class);\r
3927         }\r
3928 \r
3929         public List<Description_stmtContext> description_stmt() {\r
3930             return getRuleContexts(Description_stmtContext.class);\r
3931         }\r
3932 \r
3933         public Reference_stmtContext reference_stmt(int i) {\r
3934             return getRuleContext(Reference_stmtContext.class, i);\r
3935         }\r
3936 \r
3937         public When_stmtContext when_stmt(int i) {\r
3938             return getRuleContext(When_stmtContext.class, i);\r
3939         }\r
3940 \r
3941         public Uses_augment_stmtContext uses_augment_stmt(int i) {\r
3942             return getRuleContext(Uses_augment_stmtContext.class, i);\r
3943         }\r
3944 \r
3945         public List<Refine_stmtContext> refine_stmt() {\r
3946             return getRuleContexts(Refine_stmtContext.class);\r
3947         }\r
3948 \r
3949         public Uses_stmtContext(ParserRuleContext parent, int invokingState) {\r
3950             super(parent, invokingState);\r
3951         }\r
3952 \r
3953         @Override\r
3954         public int getRuleIndex() {\r
3955             return RULE_uses_stmt;\r
3956         }\r
3957 \r
3958         @Override\r
3959         public void enterRule(ParseTreeListener listener) {\r
3960             if (listener instanceof YangParserListener)\r
3961                 ((YangParserListener) listener).enterUses_stmt(this);\r
3962         }\r
3963 \r
3964         @Override\r
3965         public void exitRule(ParseTreeListener listener) {\r
3966             if (listener instanceof YangParserListener)\r
3967                 ((YangParserListener) listener).exitUses_stmt(this);\r
3968         }\r
3969 \r
3970         @Override\r
3971         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
3972             if (visitor instanceof YangParserVisitor)\r
3973                 return ((YangParserVisitor<? extends T>) visitor)\r
3974                         .visitUses_stmt(this);\r
3975             else\r
3976                 return visitor.visitChildren(this);\r
3977         }\r
3978     }\r
3979 \r
3980     public final Uses_stmtContext uses_stmt() throws RecognitionException {\r
3981         Uses_stmtContext _localctx = new Uses_stmtContext(_ctx, getState());\r
3982         enterRule(_localctx, 50, RULE_uses_stmt);\r
3983         int _la;\r
3984         try {\r
3985             enterOuterAlt(_localctx, 1);\r
3986             {\r
3987                 setState(522);\r
3988                 match(USES_KEYWORD);\r
3989                 setState(523);\r
3990                 string();\r
3991                 setState(540);\r
3992                 switch (_input.LA(1)) {\r
3993                 case SEMICOLON: {\r
3994                     setState(524);\r
3995                     match(SEMICOLON);\r
3996                 }\r
3997                     break;\r
3998                 case LEFT_BRACE: {\r
3999                     {\r
4000                         setState(525);\r
4001                         match(LEFT_BRACE);\r
4002                         setState(536);\r
4003                         _errHandler.sync(this);\r
4004                         _la = _input.LA(1);\r
4005                         while (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (WHEN_KEYWORD - 10))\r
4006                                 | (1L << (STATUS_KEYWORD - 10))\r
4007                                 | (1L << (REFINE_KEYWORD - 10))\r
4008                                 | (1L << (REFERENCE_KEYWORD - 10))\r
4009                                 | (1L << (IF_FEATURE_KEYWORD - 10))\r
4010                                 | (1L << (DESCRIPTION_KEYWORD - 10))\r
4011                                 | (1L << (AUGMENT_KEYWORD - 10)) | (1L << (IDENTIFIER - 10)))) != 0)) {\r
4012                             {\r
4013                                 setState(534);\r
4014                                 switch (_input.LA(1)) {\r
4015                                 case IDENTIFIER: {\r
4016                                     setState(526);\r
4017                                     identifier_stmt();\r
4018                                 }\r
4019                                     break;\r
4020                                 case WHEN_KEYWORD: {\r
4021                                     setState(527);\r
4022                                     when_stmt();\r
4023                                 }\r
4024                                     break;\r
4025                                 case IF_FEATURE_KEYWORD: {\r
4026                                     setState(528);\r
4027                                     if_feature_stmt();\r
4028                                 }\r
4029                                     break;\r
4030                                 case STATUS_KEYWORD: {\r
4031                                     setState(529);\r
4032                                     status_stmt();\r
4033                                 }\r
4034                                     break;\r
4035                                 case DESCRIPTION_KEYWORD: {\r
4036                                     setState(530);\r
4037                                     description_stmt();\r
4038                                 }\r
4039                                     break;\r
4040                                 case REFERENCE_KEYWORD: {\r
4041                                     setState(531);\r
4042                                     reference_stmt();\r
4043                                 }\r
4044                                     break;\r
4045                                 case REFINE_KEYWORD: {\r
4046                                     setState(532);\r
4047                                     refine_stmt();\r
4048                                 }\r
4049                                     break;\r
4050                                 case AUGMENT_KEYWORD: {\r
4051                                     setState(533);\r
4052                                     uses_augment_stmt();\r
4053                                 }\r
4054                                     break;\r
4055                                 default:\r
4056                                     throw new NoViableAltException(this);\r
4057                                 }\r
4058                             }\r
4059                             setState(538);\r
4060                             _errHandler.sync(this);\r
4061                             _la = _input.LA(1);\r
4062                         }\r
4063                         setState(539);\r
4064                         match(RIGHT_BRACE);\r
4065                     }\r
4066                 }\r
4067                     break;\r
4068                 default:\r
4069                     throw new NoViableAltException(this);\r
4070                 }\r
4071             }\r
4072         } catch (RecognitionException re) {\r
4073             _localctx.exception = re;\r
4074             _errHandler.reportError(this, re);\r
4075             _errHandler.recover(this, re);\r
4076         } finally {\r
4077             exitRule();\r
4078         }\r
4079         return _localctx;\r
4080     }\r
4081 \r
4082     public static class Anyxml_stmtContext extends ParserRuleContext {\r
4083         public TerminalNode RIGHT_BRACE() {\r
4084             return getToken(YangParser.RIGHT_BRACE, 0);\r
4085         }\r
4086 \r
4087         public List<Reference_stmtContext> reference_stmt() {\r
4088             return getRuleContexts(Reference_stmtContext.class);\r
4089         }\r
4090 \r
4091         public Description_stmtContext description_stmt(int i) {\r
4092             return getRuleContext(Description_stmtContext.class, i);\r
4093         }\r
4094 \r
4095         public List<When_stmtContext> when_stmt() {\r
4096             return getRuleContexts(When_stmtContext.class);\r
4097         }\r
4098 \r
4099         public TerminalNode ANYXML_KEYWORD() {\r
4100             return getToken(YangParser.ANYXML_KEYWORD, 0);\r
4101         }\r
4102 \r
4103         public If_feature_stmtContext if_feature_stmt(int i) {\r
4104             return getRuleContext(If_feature_stmtContext.class, i);\r
4105         }\r
4106 \r
4107         public TerminalNode LEFT_BRACE() {\r
4108             return getToken(YangParser.LEFT_BRACE, 0);\r
4109         }\r
4110 \r
4111         public Status_stmtContext status_stmt(int i) {\r
4112             return getRuleContext(Status_stmtContext.class, i);\r
4113         }\r
4114 \r
4115         public List<Mandatory_stmtContext> mandatory_stmt() {\r
4116             return getRuleContexts(Mandatory_stmtContext.class);\r
4117         }\r
4118 \r
4119         public Must_stmtContext must_stmt(int i) {\r
4120             return getRuleContext(Must_stmtContext.class, i);\r
4121         }\r
4122 \r
4123         public List<If_feature_stmtContext> if_feature_stmt() {\r
4124             return getRuleContexts(If_feature_stmtContext.class);\r
4125         }\r
4126 \r
4127         public Identifier_stmtContext identifier_stmt(int i) {\r
4128             return getRuleContext(Identifier_stmtContext.class, i);\r
4129         }\r
4130 \r
4131         public List<Status_stmtContext> status_stmt() {\r
4132             return getRuleContexts(Status_stmtContext.class);\r
4133         }\r
4134 \r
4135         public Mandatory_stmtContext mandatory_stmt(int i) {\r
4136             return getRuleContext(Mandatory_stmtContext.class, i);\r
4137         }\r
4138 \r
4139         public Config_stmtContext config_stmt(int i) {\r
4140             return getRuleContext(Config_stmtContext.class, i);\r
4141         }\r
4142 \r
4143         public TerminalNode SEMICOLON() {\r
4144             return getToken(YangParser.SEMICOLON, 0);\r
4145         }\r
4146 \r
4147         public List<Config_stmtContext> config_stmt() {\r
4148             return getRuleContexts(Config_stmtContext.class);\r
4149         }\r
4150 \r
4151         public StringContext string() {\r
4152             return getRuleContext(StringContext.class, 0);\r
4153         }\r
4154 \r
4155         public List<Identifier_stmtContext> identifier_stmt() {\r
4156             return getRuleContexts(Identifier_stmtContext.class);\r
4157         }\r
4158 \r
4159         public List<Must_stmtContext> must_stmt() {\r
4160             return getRuleContexts(Must_stmtContext.class);\r
4161         }\r
4162 \r
4163         public List<Description_stmtContext> description_stmt() {\r
4164             return getRuleContexts(Description_stmtContext.class);\r
4165         }\r
4166 \r
4167         public Reference_stmtContext reference_stmt(int i) {\r
4168             return getRuleContext(Reference_stmtContext.class, i);\r
4169         }\r
4170 \r
4171         public When_stmtContext when_stmt(int i) {\r
4172             return getRuleContext(When_stmtContext.class, i);\r
4173         }\r
4174 \r
4175         public Anyxml_stmtContext(ParserRuleContext parent, int invokingState) {\r
4176             super(parent, invokingState);\r
4177         }\r
4178 \r
4179         @Override\r
4180         public int getRuleIndex() {\r
4181             return RULE_anyxml_stmt;\r
4182         }\r
4183 \r
4184         @Override\r
4185         public void enterRule(ParseTreeListener listener) {\r
4186             if (listener instanceof YangParserListener)\r
4187                 ((YangParserListener) listener).enterAnyxml_stmt(this);\r
4188         }\r
4189 \r
4190         @Override\r
4191         public void exitRule(ParseTreeListener listener) {\r
4192             if (listener instanceof YangParserListener)\r
4193                 ((YangParserListener) listener).exitAnyxml_stmt(this);\r
4194         }\r
4195 \r
4196         @Override\r
4197         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
4198             if (visitor instanceof YangParserVisitor)\r
4199                 return ((YangParserVisitor<? extends T>) visitor)\r
4200                         .visitAnyxml_stmt(this);\r
4201             else\r
4202                 return visitor.visitChildren(this);\r
4203         }\r
4204     }\r
4205 \r
4206     public final Anyxml_stmtContext anyxml_stmt() throws RecognitionException {\r
4207         Anyxml_stmtContext _localctx = new Anyxml_stmtContext(_ctx, getState());\r
4208         enterRule(_localctx, 52, RULE_anyxml_stmt);\r
4209         int _la;\r
4210         try {\r
4211             enterOuterAlt(_localctx, 1);\r
4212             {\r
4213                 setState(542);\r
4214                 match(ANYXML_KEYWORD);\r
4215                 setState(543);\r
4216                 string();\r
4217                 setState(561);\r
4218                 switch (_input.LA(1)) {\r
4219                 case SEMICOLON: {\r
4220                     setState(544);\r
4221                     match(SEMICOLON);\r
4222                 }\r
4223                     break;\r
4224                 case LEFT_BRACE: {\r
4225                     {\r
4226                         setState(545);\r
4227                         match(LEFT_BRACE);\r
4228                         setState(557);\r
4229                         _errHandler.sync(this);\r
4230                         _la = _input.LA(1);\r
4231                         while (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (WHEN_KEYWORD - 10))\r
4232                                 | (1L << (STATUS_KEYWORD - 10))\r
4233                                 | (1L << (REFERENCE_KEYWORD - 10))\r
4234                                 | (1L << (MUST_KEYWORD - 10))\r
4235                                 | (1L << (MANDATORY_KEYWORD - 10))\r
4236                                 | (1L << (IF_FEATURE_KEYWORD - 10))\r
4237                                 | (1L << (DESCRIPTION_KEYWORD - 10))\r
4238                                 | (1L << (CONFIG_KEYWORD - 10)) | (1L << (IDENTIFIER - 10)))) != 0)) {\r
4239                             {\r
4240                                 setState(555);\r
4241                                 switch (_input.LA(1)) {\r
4242                                 case IDENTIFIER: {\r
4243                                     setState(546);\r
4244                                     identifier_stmt();\r
4245                                 }\r
4246                                     break;\r
4247                                 case WHEN_KEYWORD: {\r
4248                                     setState(547);\r
4249                                     when_stmt();\r
4250                                 }\r
4251                                     break;\r
4252                                 case IF_FEATURE_KEYWORD: {\r
4253                                     setState(548);\r
4254                                     if_feature_stmt();\r
4255                                 }\r
4256                                     break;\r
4257                                 case MUST_KEYWORD: {\r
4258                                     setState(549);\r
4259                                     must_stmt();\r
4260                                 }\r
4261                                     break;\r
4262                                 case CONFIG_KEYWORD: {\r
4263                                     setState(550);\r
4264                                     config_stmt();\r
4265                                 }\r
4266                                     break;\r
4267                                 case MANDATORY_KEYWORD: {\r
4268                                     setState(551);\r
4269                                     mandatory_stmt();\r
4270                                 }\r
4271                                     break;\r
4272                                 case STATUS_KEYWORD: {\r
4273                                     setState(552);\r
4274                                     status_stmt();\r
4275                                 }\r
4276                                     break;\r
4277                                 case DESCRIPTION_KEYWORD: {\r
4278                                     setState(553);\r
4279                                     description_stmt();\r
4280                                 }\r
4281                                     break;\r
4282                                 case REFERENCE_KEYWORD: {\r
4283                                     setState(554);\r
4284                                     reference_stmt();\r
4285                                 }\r
4286                                     break;\r
4287                                 default:\r
4288                                     throw new NoViableAltException(this);\r
4289                                 }\r
4290                             }\r
4291                             setState(559);\r
4292                             _errHandler.sync(this);\r
4293                             _la = _input.LA(1);\r
4294                         }\r
4295                         setState(560);\r
4296                         match(RIGHT_BRACE);\r
4297                     }\r
4298                 }\r
4299                     break;\r
4300                 default:\r
4301                     throw new NoViableAltException(this);\r
4302                 }\r
4303             }\r
4304         } catch (RecognitionException re) {\r
4305             _localctx.exception = re;\r
4306             _errHandler.reportError(this, re);\r
4307             _errHandler.recover(this, re);\r
4308         } finally {\r
4309             exitRule();\r
4310         }\r
4311         return _localctx;\r
4312     }\r
4313 \r
4314     public static class Case_stmtContext extends ParserRuleContext {\r
4315         public TerminalNode RIGHT_BRACE() {\r
4316             return getToken(YangParser.RIGHT_BRACE, 0);\r
4317         }\r
4318 \r
4319         public List<Reference_stmtContext> reference_stmt() {\r
4320             return getRuleContexts(Reference_stmtContext.class);\r
4321         }\r
4322 \r
4323         public Description_stmtContext description_stmt(int i) {\r
4324             return getRuleContext(Description_stmtContext.class, i);\r
4325         }\r
4326 \r
4327         public List<When_stmtContext> when_stmt() {\r
4328             return getRuleContexts(When_stmtContext.class);\r
4329         }\r
4330 \r
4331         public If_feature_stmtContext if_feature_stmt(int i) {\r
4332             return getRuleContext(If_feature_stmtContext.class, i);\r
4333         }\r
4334 \r
4335         public TerminalNode LEFT_BRACE() {\r
4336             return getToken(YangParser.LEFT_BRACE, 0);\r
4337         }\r
4338 \r
4339         public Data_def_stmtContext data_def_stmt(int i) {\r
4340             return getRuleContext(Data_def_stmtContext.class, i);\r
4341         }\r
4342 \r
4343         public Status_stmtContext status_stmt(int i) {\r
4344             return getRuleContext(Status_stmtContext.class, i);\r
4345         }\r
4346 \r
4347         public List<If_feature_stmtContext> if_feature_stmt() {\r
4348             return getRuleContexts(If_feature_stmtContext.class);\r
4349         }\r
4350 \r
4351         public Identifier_stmtContext identifier_stmt(int i) {\r
4352             return getRuleContext(Identifier_stmtContext.class, i);\r
4353         }\r
4354 \r
4355         public TerminalNode CASE_KEYWORD() {\r
4356             return getToken(YangParser.CASE_KEYWORD, 0);\r
4357         }\r
4358 \r
4359         public List<Data_def_stmtContext> data_def_stmt() {\r
4360             return getRuleContexts(Data_def_stmtContext.class);\r
4361         }\r
4362 \r
4363         public TerminalNode SEMICOLON() {\r
4364             return getToken(YangParser.SEMICOLON, 0);\r
4365         }\r
4366 \r
4367         public List<Status_stmtContext> status_stmt() {\r
4368             return getRuleContexts(Status_stmtContext.class);\r
4369         }\r
4370 \r
4371         public StringContext string() {\r
4372             return getRuleContext(StringContext.class, 0);\r
4373         }\r
4374 \r
4375         public List<Identifier_stmtContext> identifier_stmt() {\r
4376             return getRuleContexts(Identifier_stmtContext.class);\r
4377         }\r
4378 \r
4379         public List<Description_stmtContext> description_stmt() {\r
4380             return getRuleContexts(Description_stmtContext.class);\r
4381         }\r
4382 \r
4383         public Reference_stmtContext reference_stmt(int i) {\r
4384             return getRuleContext(Reference_stmtContext.class, i);\r
4385         }\r
4386 \r
4387         public When_stmtContext when_stmt(int i) {\r
4388             return getRuleContext(When_stmtContext.class, i);\r
4389         }\r
4390 \r
4391         public Case_stmtContext(ParserRuleContext parent, int invokingState) {\r
4392             super(parent, invokingState);\r
4393         }\r
4394 \r
4395         @Override\r
4396         public int getRuleIndex() {\r
4397             return RULE_case_stmt;\r
4398         }\r
4399 \r
4400         @Override\r
4401         public void enterRule(ParseTreeListener listener) {\r
4402             if (listener instanceof YangParserListener)\r
4403                 ((YangParserListener) listener).enterCase_stmt(this);\r
4404         }\r
4405 \r
4406         @Override\r
4407         public void exitRule(ParseTreeListener listener) {\r
4408             if (listener instanceof YangParserListener)\r
4409                 ((YangParserListener) listener).exitCase_stmt(this);\r
4410         }\r
4411 \r
4412         @Override\r
4413         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
4414             if (visitor instanceof YangParserVisitor)\r
4415                 return ((YangParserVisitor<? extends T>) visitor)\r
4416                         .visitCase_stmt(this);\r
4417             else\r
4418                 return visitor.visitChildren(this);\r
4419         }\r
4420     }\r
4421 \r
4422     public final Case_stmtContext case_stmt() throws RecognitionException {\r
4423         Case_stmtContext _localctx = new Case_stmtContext(_ctx, getState());\r
4424         enterRule(_localctx, 54, RULE_case_stmt);\r
4425         int _la;\r
4426         try {\r
4427             enterOuterAlt(_localctx, 1);\r
4428             {\r
4429                 setState(563);\r
4430                 match(CASE_KEYWORD);\r
4431                 setState(564);\r
4432                 string();\r
4433                 setState(580);\r
4434                 switch (_input.LA(1)) {\r
4435                 case SEMICOLON: {\r
4436                     setState(565);\r
4437                     match(SEMICOLON);\r
4438                 }\r
4439                     break;\r
4440                 case LEFT_BRACE: {\r
4441                     {\r
4442                         setState(566);\r
4443                         match(LEFT_BRACE);\r
4444                         setState(576);\r
4445                         _errHandler.sync(this);\r
4446                         _la = _input.LA(1);\r
4447                         while (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (WHEN_KEYWORD - 10))\r
4448                                 | (1L << (USES_KEYWORD - 10))\r
4449                                 | (1L << (STATUS_KEYWORD - 10))\r
4450                                 | (1L << (REFERENCE_KEYWORD - 10))\r
4451                                 | (1L << (LIST_KEYWORD - 10))\r
4452                                 | (1L << (LEAF_LIST_KEYWORD - 10))\r
4453                                 | (1L << (LEAF_KEYWORD - 10))\r
4454                                 | (1L << (IF_FEATURE_KEYWORD - 10))\r
4455                                 | (1L << (DESCRIPTION_KEYWORD - 10))\r
4456                                 | (1L << (CONTAINER_KEYWORD - 10))\r
4457                                 | (1L << (CHOICE_KEYWORD - 10))\r
4458                                 | (1L << (ANYXML_KEYWORD - 10)) | (1L << (IDENTIFIER - 10)))) != 0)) {\r
4459                             {\r
4460                                 setState(574);\r
4461                                 switch (_input.LA(1)) {\r
4462                                 case IDENTIFIER: {\r
4463                                     setState(567);\r
4464                                     identifier_stmt();\r
4465                                 }\r
4466                                     break;\r
4467                                 case WHEN_KEYWORD: {\r
4468                                     setState(568);\r
4469                                     when_stmt();\r
4470                                 }\r
4471                                     break;\r
4472                                 case IF_FEATURE_KEYWORD: {\r
4473                                     setState(569);\r
4474                                     if_feature_stmt();\r
4475                                 }\r
4476                                     break;\r
4477                                 case STATUS_KEYWORD: {\r
4478                                     setState(570);\r
4479                                     status_stmt();\r
4480                                 }\r
4481                                     break;\r
4482                                 case DESCRIPTION_KEYWORD: {\r
4483                                     setState(571);\r
4484                                     description_stmt();\r
4485                                 }\r
4486                                     break;\r
4487                                 case REFERENCE_KEYWORD: {\r
4488                                     setState(572);\r
4489                                     reference_stmt();\r
4490                                 }\r
4491                                     break;\r
4492                                 case USES_KEYWORD:\r
4493                                 case LIST_KEYWORD:\r
4494                                 case LEAF_LIST_KEYWORD:\r
4495                                 case LEAF_KEYWORD:\r
4496                                 case CONTAINER_KEYWORD:\r
4497                                 case CHOICE_KEYWORD:\r
4498                                 case ANYXML_KEYWORD: {\r
4499                                     setState(573);\r
4500                                     data_def_stmt();\r
4501                                 }\r
4502                                     break;\r
4503                                 default:\r
4504                                     throw new NoViableAltException(this);\r
4505                                 }\r
4506                             }\r
4507                             setState(578);\r
4508                             _errHandler.sync(this);\r
4509                             _la = _input.LA(1);\r
4510                         }\r
4511                         setState(579);\r
4512                         match(RIGHT_BRACE);\r
4513                     }\r
4514                 }\r
4515                     break;\r
4516                 default:\r
4517                     throw new NoViableAltException(this);\r
4518                 }\r
4519             }\r
4520         } catch (RecognitionException re) {\r
4521             _localctx.exception = re;\r
4522             _errHandler.reportError(this, re);\r
4523             _errHandler.recover(this, re);\r
4524         } finally {\r
4525             exitRule();\r
4526         }\r
4527         return _localctx;\r
4528     }\r
4529 \r
4530     public static class Short_case_stmtContext extends ParserRuleContext {\r
4531         public Anyxml_stmtContext anyxml_stmt() {\r
4532             return getRuleContext(Anyxml_stmtContext.class, 0);\r
4533         }\r
4534 \r
4535         public List_stmtContext list_stmt() {\r
4536             return getRuleContext(List_stmtContext.class, 0);\r
4537         }\r
4538 \r
4539         public Leaf_stmtContext leaf_stmt() {\r
4540             return getRuleContext(Leaf_stmtContext.class, 0);\r
4541         }\r
4542 \r
4543         public Container_stmtContext container_stmt() {\r
4544             return getRuleContext(Container_stmtContext.class, 0);\r
4545         }\r
4546 \r
4547         public Leaf_list_stmtContext leaf_list_stmt() {\r
4548             return getRuleContext(Leaf_list_stmtContext.class, 0);\r
4549         }\r
4550 \r
4551         public Short_case_stmtContext(ParserRuleContext parent,\r
4552                 int invokingState) {\r
4553             super(parent, invokingState);\r
4554         }\r
4555 \r
4556         @Override\r
4557         public int getRuleIndex() {\r
4558             return RULE_short_case_stmt;\r
4559         }\r
4560 \r
4561         @Override\r
4562         public void enterRule(ParseTreeListener listener) {\r
4563             if (listener instanceof YangParserListener)\r
4564                 ((YangParserListener) listener).enterShort_case_stmt(this);\r
4565         }\r
4566 \r
4567         @Override\r
4568         public void exitRule(ParseTreeListener listener) {\r
4569             if (listener instanceof YangParserListener)\r
4570                 ((YangParserListener) listener).exitShort_case_stmt(this);\r
4571         }\r
4572 \r
4573         @Override\r
4574         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
4575             if (visitor instanceof YangParserVisitor)\r
4576                 return ((YangParserVisitor<? extends T>) visitor)\r
4577                         .visitShort_case_stmt(this);\r
4578             else\r
4579                 return visitor.visitChildren(this);\r
4580         }\r
4581     }\r
4582 \r
4583     public final Short_case_stmtContext short_case_stmt()\r
4584             throws RecognitionException {\r
4585         Short_case_stmtContext _localctx = new Short_case_stmtContext(_ctx,\r
4586                 getState());\r
4587         enterRule(_localctx, 56, RULE_short_case_stmt);\r
4588         try {\r
4589             setState(587);\r
4590             switch (_input.LA(1)) {\r
4591             case CONTAINER_KEYWORD:\r
4592                 enterOuterAlt(_localctx, 1);\r
4593                 {\r
4594                     setState(582);\r
4595                     container_stmt();\r
4596                 }\r
4597                 break;\r
4598             case LEAF_KEYWORD:\r
4599                 enterOuterAlt(_localctx, 2);\r
4600                 {\r
4601                     setState(583);\r
4602                     leaf_stmt();\r
4603                 }\r
4604                 break;\r
4605             case LEAF_LIST_KEYWORD:\r
4606                 enterOuterAlt(_localctx, 3);\r
4607                 {\r
4608                     setState(584);\r
4609                     leaf_list_stmt();\r
4610                 }\r
4611                 break;\r
4612             case LIST_KEYWORD:\r
4613                 enterOuterAlt(_localctx, 4);\r
4614                 {\r
4615                     setState(585);\r
4616                     list_stmt();\r
4617                 }\r
4618                 break;\r
4619             case ANYXML_KEYWORD:\r
4620                 enterOuterAlt(_localctx, 5);\r
4621                 {\r
4622                     setState(586);\r
4623                     anyxml_stmt();\r
4624                 }\r
4625                 break;\r
4626             default:\r
4627                 throw new NoViableAltException(this);\r
4628             }\r
4629         } catch (RecognitionException re) {\r
4630             _localctx.exception = re;\r
4631             _errHandler.reportError(this, re);\r
4632             _errHandler.recover(this, re);\r
4633         } finally {\r
4634             exitRule();\r
4635         }\r
4636         return _localctx;\r
4637     }\r
4638 \r
4639     public static class Choice_stmtContext extends ParserRuleContext {\r
4640         public TerminalNode RIGHT_BRACE() {\r
4641             return getToken(YangParser.RIGHT_BRACE, 0);\r
4642         }\r
4643 \r
4644         public List<Reference_stmtContext> reference_stmt() {\r
4645             return getRuleContexts(Reference_stmtContext.class);\r
4646         }\r
4647 \r
4648         public Description_stmtContext description_stmt(int i) {\r
4649             return getRuleContext(Description_stmtContext.class, i);\r
4650         }\r
4651 \r
4652         public Default_stmtContext default_stmt(int i) {\r
4653             return getRuleContext(Default_stmtContext.class, i);\r
4654         }\r
4655 \r
4656         public TerminalNode CHOICE_KEYWORD() {\r
4657             return getToken(YangParser.CHOICE_KEYWORD, 0);\r
4658         }\r
4659 \r
4660         public List<When_stmtContext> when_stmt() {\r
4661             return getRuleContexts(When_stmtContext.class);\r
4662         }\r
4663 \r
4664         public List<Case_stmtContext> case_stmt() {\r
4665             return getRuleContexts(Case_stmtContext.class);\r
4666         }\r
4667 \r
4668         public If_feature_stmtContext if_feature_stmt(int i) {\r
4669             return getRuleContext(If_feature_stmtContext.class, i);\r
4670         }\r
4671 \r
4672         public TerminalNode LEFT_BRACE() {\r
4673             return getToken(YangParser.LEFT_BRACE, 0);\r
4674         }\r
4675 \r
4676         public Status_stmtContext status_stmt(int i) {\r
4677             return getRuleContext(Status_stmtContext.class, i);\r
4678         }\r
4679 \r
4680         public List<Mandatory_stmtContext> mandatory_stmt() {\r
4681             return getRuleContexts(Mandatory_stmtContext.class);\r
4682         }\r
4683 \r
4684         public List<If_feature_stmtContext> if_feature_stmt() {\r
4685             return getRuleContexts(If_feature_stmtContext.class);\r
4686         }\r
4687 \r
4688         public Identifier_stmtContext identifier_stmt(int i) {\r
4689             return getRuleContext(Identifier_stmtContext.class, i);\r
4690         }\r
4691 \r
4692         public List<Default_stmtContext> default_stmt() {\r
4693             return getRuleContexts(Default_stmtContext.class);\r
4694         }\r
4695 \r
4696         public List<Status_stmtContext> status_stmt() {\r
4697             return getRuleContexts(Status_stmtContext.class);\r
4698         }\r
4699 \r
4700         public Mandatory_stmtContext mandatory_stmt(int i) {\r
4701             return getRuleContext(Mandatory_stmtContext.class, i);\r
4702         }\r
4703 \r
4704         public Config_stmtContext config_stmt(int i) {\r
4705             return getRuleContext(Config_stmtContext.class, i);\r
4706         }\r
4707 \r
4708         public TerminalNode SEMICOLON() {\r
4709             return getToken(YangParser.SEMICOLON, 0);\r
4710         }\r
4711 \r
4712         public Short_case_stmtContext short_case_stmt(int i) {\r
4713             return getRuleContext(Short_case_stmtContext.class, i);\r
4714         }\r
4715 \r
4716         public List<Short_case_stmtContext> short_case_stmt() {\r
4717             return getRuleContexts(Short_case_stmtContext.class);\r
4718         }\r
4719 \r
4720         public List<Config_stmtContext> config_stmt() {\r
4721             return getRuleContexts(Config_stmtContext.class);\r
4722         }\r
4723 \r
4724         public StringContext string() {\r
4725             return getRuleContext(StringContext.class, 0);\r
4726         }\r
4727 \r
4728         public List<Identifier_stmtContext> identifier_stmt() {\r
4729             return getRuleContexts(Identifier_stmtContext.class);\r
4730         }\r
4731 \r
4732         public List<Description_stmtContext> description_stmt() {\r
4733             return getRuleContexts(Description_stmtContext.class);\r
4734         }\r
4735 \r
4736         public Reference_stmtContext reference_stmt(int i) {\r
4737             return getRuleContext(Reference_stmtContext.class, i);\r
4738         }\r
4739 \r
4740         public When_stmtContext when_stmt(int i) {\r
4741             return getRuleContext(When_stmtContext.class, i);\r
4742         }\r
4743 \r
4744         public Case_stmtContext case_stmt(int i) {\r
4745             return getRuleContext(Case_stmtContext.class, i);\r
4746         }\r
4747 \r
4748         public Choice_stmtContext(ParserRuleContext parent, int invokingState) {\r
4749             super(parent, invokingState);\r
4750         }\r
4751 \r
4752         @Override\r
4753         public int getRuleIndex() {\r
4754             return RULE_choice_stmt;\r
4755         }\r
4756 \r
4757         @Override\r
4758         public void enterRule(ParseTreeListener listener) {\r
4759             if (listener instanceof YangParserListener)\r
4760                 ((YangParserListener) listener).enterChoice_stmt(this);\r
4761         }\r
4762 \r
4763         @Override\r
4764         public void exitRule(ParseTreeListener listener) {\r
4765             if (listener instanceof YangParserListener)\r
4766                 ((YangParserListener) listener).exitChoice_stmt(this);\r
4767         }\r
4768 \r
4769         @Override\r
4770         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
4771             if (visitor instanceof YangParserVisitor)\r
4772                 return ((YangParserVisitor<? extends T>) visitor)\r
4773                         .visitChoice_stmt(this);\r
4774             else\r
4775                 return visitor.visitChildren(this);\r
4776         }\r
4777     }\r
4778 \r
4779     public final Choice_stmtContext choice_stmt() throws RecognitionException {\r
4780         Choice_stmtContext _localctx = new Choice_stmtContext(_ctx, getState());\r
4781         enterRule(_localctx, 58, RULE_choice_stmt);\r
4782         int _la;\r
4783         try {\r
4784             enterOuterAlt(_localctx, 1);\r
4785             {\r
4786                 setState(589);\r
4787                 match(CHOICE_KEYWORD);\r
4788                 setState(590);\r
4789                 string();\r
4790                 setState(610);\r
4791                 switch (_input.LA(1)) {\r
4792                 case SEMICOLON: {\r
4793                     setState(591);\r
4794                     match(SEMICOLON);\r
4795                 }\r
4796                     break;\r
4797                 case LEFT_BRACE: {\r
4798                     {\r
4799                         setState(592);\r
4800                         match(LEFT_BRACE);\r
4801                         setState(606);\r
4802                         _errHandler.sync(this);\r
4803                         _la = _input.LA(1);\r
4804                         while (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (WHEN_KEYWORD - 10))\r
4805                                 | (1L << (STATUS_KEYWORD - 10))\r
4806                                 | (1L << (REFERENCE_KEYWORD - 10))\r
4807                                 | (1L << (MANDATORY_KEYWORD - 10))\r
4808                                 | (1L << (LIST_KEYWORD - 10))\r
4809                                 | (1L << (LEAF_LIST_KEYWORD - 10))\r
4810                                 | (1L << (LEAF_KEYWORD - 10))\r
4811                                 | (1L << (IF_FEATURE_KEYWORD - 10))\r
4812                                 | (1L << (DESCRIPTION_KEYWORD - 10))\r
4813                                 | (1L << (DEFAULT_KEYWORD - 10))\r
4814                                 | (1L << (CONTAINER_KEYWORD - 10))\r
4815                                 | (1L << (CONFIG_KEYWORD - 10))\r
4816                                 | (1L << (CASE_KEYWORD - 10))\r
4817                                 | (1L << (ANYXML_KEYWORD - 10)) | (1L << (IDENTIFIER - 10)))) != 0)) {\r
4818                             {\r
4819                                 setState(604);\r
4820                                 switch (_input.LA(1)) {\r
4821                                 case IDENTIFIER: {\r
4822                                     setState(593);\r
4823                                     identifier_stmt();\r
4824                                 }\r
4825                                     break;\r
4826                                 case WHEN_KEYWORD: {\r
4827                                     setState(594);\r
4828                                     when_stmt();\r
4829                                 }\r
4830                                     break;\r
4831                                 case IF_FEATURE_KEYWORD: {\r
4832                                     setState(595);\r
4833                                     if_feature_stmt();\r
4834                                 }\r
4835                                     break;\r
4836                                 case DEFAULT_KEYWORD: {\r
4837                                     setState(596);\r
4838                                     default_stmt();\r
4839                                 }\r
4840                                     break;\r
4841                                 case CONFIG_KEYWORD: {\r
4842                                     setState(597);\r
4843                                     config_stmt();\r
4844                                 }\r
4845                                     break;\r
4846                                 case MANDATORY_KEYWORD: {\r
4847                                     setState(598);\r
4848                                     mandatory_stmt();\r
4849                                 }\r
4850                                     break;\r
4851                                 case STATUS_KEYWORD: {\r
4852                                     setState(599);\r
4853                                     status_stmt();\r
4854                                 }\r
4855                                     break;\r
4856                                 case DESCRIPTION_KEYWORD: {\r
4857                                     setState(600);\r
4858                                     description_stmt();\r
4859                                 }\r
4860                                     break;\r
4861                                 case REFERENCE_KEYWORD: {\r
4862                                     setState(601);\r
4863                                     reference_stmt();\r
4864                                 }\r
4865                                     break;\r
4866                                 case LIST_KEYWORD:\r
4867                                 case LEAF_LIST_KEYWORD:\r
4868                                 case LEAF_KEYWORD:\r
4869                                 case CONTAINER_KEYWORD:\r
4870                                 case ANYXML_KEYWORD: {\r
4871                                     setState(602);\r
4872                                     short_case_stmt();\r
4873                                 }\r
4874                                     break;\r
4875                                 case CASE_KEYWORD: {\r
4876                                     setState(603);\r
4877                                     case_stmt();\r
4878                                 }\r
4879                                     break;\r
4880                                 default:\r
4881                                     throw new NoViableAltException(this);\r
4882                                 }\r
4883                             }\r
4884                             setState(608);\r
4885                             _errHandler.sync(this);\r
4886                             _la = _input.LA(1);\r
4887                         }\r
4888                         setState(609);\r
4889                         match(RIGHT_BRACE);\r
4890                     }\r
4891                 }\r
4892                     break;\r
4893                 default:\r
4894                     throw new NoViableAltException(this);\r
4895                 }\r
4896             }\r
4897         } catch (RecognitionException re) {\r
4898             _localctx.exception = re;\r
4899             _errHandler.reportError(this, re);\r
4900             _errHandler.recover(this, re);\r
4901         } finally {\r
4902             exitRule();\r
4903         }\r
4904         return _localctx;\r
4905     }\r
4906 \r
4907     public static class Unique_stmtContext extends ParserRuleContext {\r
4908         public StringContext string() {\r
4909             return getRuleContext(StringContext.class, 0);\r
4910         }\r
4911 \r
4912         public StmtendContext stmtend() {\r
4913             return getRuleContext(StmtendContext.class, 0);\r
4914         }\r
4915 \r
4916         public TerminalNode UNIQUE_KEYWORD() {\r
4917             return getToken(YangParser.UNIQUE_KEYWORD, 0);\r
4918         }\r
4919 \r
4920         public Unique_stmtContext(ParserRuleContext parent, int invokingState) {\r
4921             super(parent, invokingState);\r
4922         }\r
4923 \r
4924         @Override\r
4925         public int getRuleIndex() {\r
4926             return RULE_unique_stmt;\r
4927         }\r
4928 \r
4929         @Override\r
4930         public void enterRule(ParseTreeListener listener) {\r
4931             if (listener instanceof YangParserListener)\r
4932                 ((YangParserListener) listener).enterUnique_stmt(this);\r
4933         }\r
4934 \r
4935         @Override\r
4936         public void exitRule(ParseTreeListener listener) {\r
4937             if (listener instanceof YangParserListener)\r
4938                 ((YangParserListener) listener).exitUnique_stmt(this);\r
4939         }\r
4940 \r
4941         @Override\r
4942         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
4943             if (visitor instanceof YangParserVisitor)\r
4944                 return ((YangParserVisitor<? extends T>) visitor)\r
4945                         .visitUnique_stmt(this);\r
4946             else\r
4947                 return visitor.visitChildren(this);\r
4948         }\r
4949     }\r
4950 \r
4951     public final Unique_stmtContext unique_stmt() throws RecognitionException {\r
4952         Unique_stmtContext _localctx = new Unique_stmtContext(_ctx, getState());\r
4953         enterRule(_localctx, 60, RULE_unique_stmt);\r
4954         try {\r
4955             enterOuterAlt(_localctx, 1);\r
4956             {\r
4957                 setState(612);\r
4958                 match(UNIQUE_KEYWORD);\r
4959                 setState(613);\r
4960                 string();\r
4961                 setState(614);\r
4962                 stmtend();\r
4963             }\r
4964         } catch (RecognitionException re) {\r
4965             _localctx.exception = re;\r
4966             _errHandler.reportError(this, re);\r
4967             _errHandler.recover(this, re);\r
4968         } finally {\r
4969             exitRule();\r
4970         }\r
4971         return _localctx;\r
4972     }\r
4973 \r
4974     public static class Key_stmtContext extends ParserRuleContext {\r
4975         public StringContext string() {\r
4976             return getRuleContext(StringContext.class, 0);\r
4977         }\r
4978 \r
4979         public StmtendContext stmtend() {\r
4980             return getRuleContext(StmtendContext.class, 0);\r
4981         }\r
4982 \r
4983         public TerminalNode KEY_KEYWORD() {\r
4984             return getToken(YangParser.KEY_KEYWORD, 0);\r
4985         }\r
4986 \r
4987         public Key_stmtContext(ParserRuleContext parent, int invokingState) {\r
4988             super(parent, invokingState);\r
4989         }\r
4990 \r
4991         @Override\r
4992         public int getRuleIndex() {\r
4993             return RULE_key_stmt;\r
4994         }\r
4995 \r
4996         @Override\r
4997         public void enterRule(ParseTreeListener listener) {\r
4998             if (listener instanceof YangParserListener)\r
4999                 ((YangParserListener) listener).enterKey_stmt(this);\r
5000         }\r
5001 \r
5002         @Override\r
5003         public void exitRule(ParseTreeListener listener) {\r
5004             if (listener instanceof YangParserListener)\r
5005                 ((YangParserListener) listener).exitKey_stmt(this);\r
5006         }\r
5007 \r
5008         @Override\r
5009         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
5010             if (visitor instanceof YangParserVisitor)\r
5011                 return ((YangParserVisitor<? extends T>) visitor)\r
5012                         .visitKey_stmt(this);\r
5013             else\r
5014                 return visitor.visitChildren(this);\r
5015         }\r
5016     }\r
5017 \r
5018     public final Key_stmtContext key_stmt() throws RecognitionException {\r
5019         Key_stmtContext _localctx = new Key_stmtContext(_ctx, getState());\r
5020         enterRule(_localctx, 62, RULE_key_stmt);\r
5021         try {\r
5022             enterOuterAlt(_localctx, 1);\r
5023             {\r
5024                 setState(616);\r
5025                 match(KEY_KEYWORD);\r
5026                 setState(617);\r
5027                 string();\r
5028                 setState(618);\r
5029                 stmtend();\r
5030             }\r
5031         } catch (RecognitionException re) {\r
5032             _localctx.exception = re;\r
5033             _errHandler.reportError(this, re);\r
5034             _errHandler.recover(this, re);\r
5035         } finally {\r
5036             exitRule();\r
5037         }\r
5038         return _localctx;\r
5039     }\r
5040 \r
5041     public static class List_stmtContext extends ParserRuleContext {\r
5042         public TerminalNode RIGHT_BRACE() {\r
5043             return getToken(YangParser.RIGHT_BRACE, 0);\r
5044         }\r
5045 \r
5046         public List<When_stmtContext> when_stmt() {\r
5047             return getRuleContexts(When_stmtContext.class);\r
5048         }\r
5049 \r
5050         public List<Max_elements_stmtContext> max_elements_stmt() {\r
5051             return getRuleContexts(Max_elements_stmtContext.class);\r
5052         }\r
5053 \r
5054         public Data_def_stmtContext data_def_stmt(int i) {\r
5055             return getRuleContext(Data_def_stmtContext.class, i);\r
5056         }\r
5057 \r
5058         public List<Typedef_stmtContext> typedef_stmt() {\r
5059             return getRuleContexts(Typedef_stmtContext.class);\r
5060         }\r
5061 \r
5062         public Min_elements_stmtContext min_elements_stmt(int i) {\r
5063             return getRuleContext(Min_elements_stmtContext.class, i);\r
5064         }\r
5065 \r
5066         public List<Data_def_stmtContext> data_def_stmt() {\r
5067             return getRuleContexts(Data_def_stmtContext.class);\r
5068         }\r
5069 \r
5070         public Config_stmtContext config_stmt(int i) {\r
5071             return getRuleContext(Config_stmtContext.class, i);\r
5072         }\r
5073 \r
5074         public List<Min_elements_stmtContext> min_elements_stmt() {\r
5075             return getRuleContexts(Min_elements_stmtContext.class);\r
5076         }\r
5077 \r
5078         public List<Description_stmtContext> description_stmt() {\r
5079             return getRuleContexts(Description_stmtContext.class);\r
5080         }\r
5081 \r
5082         public When_stmtContext when_stmt(int i) {\r
5083             return getRuleContext(When_stmtContext.class, i);\r
5084         }\r
5085 \r
5086         public Unique_stmtContext unique_stmt(int i) {\r
5087             return getRuleContext(Unique_stmtContext.class, i);\r
5088         }\r
5089 \r
5090         public List<Grouping_stmtContext> grouping_stmt() {\r
5091             return getRuleContexts(Grouping_stmtContext.class);\r
5092         }\r
5093 \r
5094         public List<Reference_stmtContext> reference_stmt() {\r
5095             return getRuleContexts(Reference_stmtContext.class);\r
5096         }\r
5097 \r
5098         public Typedef_stmtContext typedef_stmt(int i) {\r
5099             return getRuleContext(Typedef_stmtContext.class, i);\r
5100         }\r
5101 \r
5102         public Description_stmtContext description_stmt(int i) {\r
5103             return getRuleContext(Description_stmtContext.class, i);\r
5104         }\r
5105 \r
5106         public Ordered_by_stmtContext ordered_by_stmt(int i) {\r
5107             return getRuleContext(Ordered_by_stmtContext.class, i);\r
5108         }\r
5109 \r
5110         public Grouping_stmtContext grouping_stmt(int i) {\r
5111             return getRuleContext(Grouping_stmtContext.class, i);\r
5112         }\r
5113 \r
5114         public If_feature_stmtContext if_feature_stmt(int i) {\r
5115             return getRuleContext(If_feature_stmtContext.class, i);\r
5116         }\r
5117 \r
5118         public TerminalNode LEFT_BRACE() {\r
5119             return getToken(YangParser.LEFT_BRACE, 0);\r
5120         }\r
5121 \r
5122         public Status_stmtContext status_stmt(int i) {\r
5123             return getRuleContext(Status_stmtContext.class, i);\r
5124         }\r
5125 \r
5126         public List<Ordered_by_stmtContext> ordered_by_stmt() {\r
5127             return getRuleContexts(Ordered_by_stmtContext.class);\r
5128         }\r
5129 \r
5130         public Must_stmtContext must_stmt(int i) {\r
5131             return getRuleContext(Must_stmtContext.class, i);\r
5132         }\r
5133 \r
5134         public List<If_feature_stmtContext> if_feature_stmt() {\r
5135             return getRuleContexts(If_feature_stmtContext.class);\r
5136         }\r
5137 \r
5138         public TerminalNode LIST_KEYWORD() {\r
5139             return getToken(YangParser.LIST_KEYWORD, 0);\r
5140         }\r
5141 \r
5142         public Key_stmtContext key_stmt(int i) {\r
5143             return getRuleContext(Key_stmtContext.class, i);\r
5144         }\r
5145 \r
5146         public Identifier_stmtContext identifier_stmt(int i) {\r
5147             return getRuleContext(Identifier_stmtContext.class, i);\r
5148         }\r
5149 \r
5150         public List<Status_stmtContext> status_stmt() {\r
5151             return getRuleContexts(Status_stmtContext.class);\r
5152         }\r
5153 \r
5154         public List<Must_stmtContext> must_stmt() {\r
5155             return getRuleContexts(Must_stmtContext.class);\r
5156         }\r
5157 \r
5158         public List<Identifier_stmtContext> identifier_stmt() {\r
5159             return getRuleContexts(Identifier_stmtContext.class);\r
5160         }\r
5161 \r
5162         public StringContext string() {\r
5163             return getRuleContext(StringContext.class, 0);\r
5164         }\r
5165 \r
5166         public List<Config_stmtContext> config_stmt() {\r
5167             return getRuleContexts(Config_stmtContext.class);\r
5168         }\r
5169 \r
5170         public List<Unique_stmtContext> unique_stmt() {\r
5171             return getRuleContexts(Unique_stmtContext.class);\r
5172         }\r
5173 \r
5174         public Max_elements_stmtContext max_elements_stmt(int i) {\r
5175             return getRuleContext(Max_elements_stmtContext.class, i);\r
5176         }\r
5177 \r
5178         public List<Key_stmtContext> key_stmt() {\r
5179             return getRuleContexts(Key_stmtContext.class);\r
5180         }\r
5181 \r
5182         public Reference_stmtContext reference_stmt(int i) {\r
5183             return getRuleContext(Reference_stmtContext.class, i);\r
5184         }\r
5185 \r
5186         public List_stmtContext(ParserRuleContext parent, int invokingState) {\r
5187             super(parent, invokingState);\r
5188         }\r
5189 \r
5190         @Override\r
5191         public int getRuleIndex() {\r
5192             return RULE_list_stmt;\r
5193         }\r
5194 \r
5195         @Override\r
5196         public void enterRule(ParseTreeListener listener) {\r
5197             if (listener instanceof YangParserListener)\r
5198                 ((YangParserListener) listener).enterList_stmt(this);\r
5199         }\r
5200 \r
5201         @Override\r
5202         public void exitRule(ParseTreeListener listener) {\r
5203             if (listener instanceof YangParserListener)\r
5204                 ((YangParserListener) listener).exitList_stmt(this);\r
5205         }\r
5206 \r
5207         @Override\r
5208         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
5209             if (visitor instanceof YangParserVisitor)\r
5210                 return ((YangParserVisitor<? extends T>) visitor)\r
5211                         .visitList_stmt(this);\r
5212             else\r
5213                 return visitor.visitChildren(this);\r
5214         }\r
5215     }\r
5216 \r
5217     public final List_stmtContext list_stmt() throws RecognitionException {\r
5218         List_stmtContext _localctx = new List_stmtContext(_ctx, getState());\r
5219         enterRule(_localctx, 64, RULE_list_stmt);\r
5220         int _la;\r
5221         try {\r
5222             enterOuterAlt(_localctx, 1);\r
5223             {\r
5224                 setState(620);\r
5225                 match(LIST_KEYWORD);\r
5226                 setState(621);\r
5227                 string();\r
5228                 setState(622);\r
5229                 match(LEFT_BRACE);\r
5230                 setState(639);\r
5231                 _errHandler.sync(this);\r
5232                 _la = _input.LA(1);\r
5233                 do {\r
5234                     {\r
5235                         setState(639);\r
5236                         switch (_input.LA(1)) {\r
5237                         case IDENTIFIER: {\r
5238                             setState(623);\r
5239                             identifier_stmt();\r
5240                         }\r
5241                             break;\r
5242                         case WHEN_KEYWORD: {\r
5243                             setState(624);\r
5244                             when_stmt();\r
5245                         }\r
5246                             break;\r
5247                         case IF_FEATURE_KEYWORD: {\r
5248                             setState(625);\r
5249                             if_feature_stmt();\r
5250                         }\r
5251                             break;\r
5252                         case MUST_KEYWORD: {\r
5253                             setState(626);\r
5254                             must_stmt();\r
5255                         }\r
5256                             break;\r
5257                         case KEY_KEYWORD: {\r
5258                             setState(627);\r
5259                             key_stmt();\r
5260                         }\r
5261                             break;\r
5262                         case UNIQUE_KEYWORD: {\r
5263                             setState(628);\r
5264                             unique_stmt();\r
5265                         }\r
5266                             break;\r
5267                         case CONFIG_KEYWORD: {\r
5268                             setState(629);\r
5269                             config_stmt();\r
5270                         }\r
5271                             break;\r
5272                         case MIN_ELEMENTS_KEYWORD: {\r
5273                             setState(630);\r
5274                             min_elements_stmt();\r
5275                         }\r
5276                             break;\r
5277                         case MAX_ELEMENTS_KEYWORD: {\r
5278                             setState(631);\r
5279                             max_elements_stmt();\r
5280                         }\r
5281                             break;\r
5282                         case ORDERED_BY_KEYWORD: {\r
5283                             setState(632);\r
5284                             ordered_by_stmt();\r
5285                         }\r
5286                             break;\r
5287                         case STATUS_KEYWORD: {\r
5288                             setState(633);\r
5289                             status_stmt();\r
5290                         }\r
5291                             break;\r
5292                         case DESCRIPTION_KEYWORD: {\r
5293                             setState(634);\r
5294                             description_stmt();\r
5295                         }\r
5296                             break;\r
5297                         case REFERENCE_KEYWORD: {\r
5298                             setState(635);\r
5299                             reference_stmt();\r
5300                         }\r
5301                             break;\r
5302                         case TYPEDEF_KEYWORD: {\r
5303                             setState(636);\r
5304                             typedef_stmt();\r
5305                         }\r
5306                             break;\r
5307                         case GROUPING_KEYWORD: {\r
5308                             setState(637);\r
5309                             grouping_stmt();\r
5310                         }\r
5311                             break;\r
5312                         case USES_KEYWORD:\r
5313                         case LIST_KEYWORD:\r
5314                         case LEAF_LIST_KEYWORD:\r
5315                         case LEAF_KEYWORD:\r
5316                         case CONTAINER_KEYWORD:\r
5317                         case CHOICE_KEYWORD:\r
5318                         case ANYXML_KEYWORD: {\r
5319                             setState(638);\r
5320                             data_def_stmt();\r
5321                         }\r
5322                             break;\r
5323                         default:\r
5324                             throw new NoViableAltException(this);\r
5325                         }\r
5326                     }\r
5327                     setState(641);\r
5328                     _errHandler.sync(this);\r
5329                     _la = _input.LA(1);\r
5330                 } while (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (WHEN_KEYWORD - 10))\r
5331                         | (1L << (USES_KEYWORD - 10))\r
5332                         | (1L << (UNIQUE_KEYWORD - 10))\r
5333                         | (1L << (TYPEDEF_KEYWORD - 10))\r
5334                         | (1L << (STATUS_KEYWORD - 10))\r
5335                         | (1L << (REFERENCE_KEYWORD - 10))\r
5336                         | (1L << (ORDERED_BY_KEYWORD - 10))\r
5337                         | (1L << (MUST_KEYWORD - 10))\r
5338                         | (1L << (MIN_ELEMENTS_KEYWORD - 10))\r
5339                         | (1L << (MAX_ELEMENTS_KEYWORD - 10))\r
5340                         | (1L << (LIST_KEYWORD - 10))\r
5341                         | (1L << (LEAF_LIST_KEYWORD - 10))\r
5342                         | (1L << (LEAF_KEYWORD - 10))\r
5343                         | (1L << (KEY_KEYWORD - 10))\r
5344                         | (1L << (IF_FEATURE_KEYWORD - 10))\r
5345                         | (1L << (GROUPING_KEYWORD - 10))\r
5346                         | (1L << (DESCRIPTION_KEYWORD - 10))\r
5347                         | (1L << (CONTAINER_KEYWORD - 10))\r
5348                         | (1L << (CONFIG_KEYWORD - 10))\r
5349                         | (1L << (CHOICE_KEYWORD - 10))\r
5350                         | (1L << (ANYXML_KEYWORD - 10)) | (1L << (IDENTIFIER - 10)))) != 0));\r
5351                 setState(643);\r
5352                 match(RIGHT_BRACE);\r
5353             }\r
5354         } catch (RecognitionException re) {\r
5355             _localctx.exception = re;\r
5356             _errHandler.reportError(this, re);\r
5357             _errHandler.recover(this, re);\r
5358         } finally {\r
5359             exitRule();\r
5360         }\r
5361         return _localctx;\r
5362     }\r
5363 \r
5364     public static class Leaf_list_stmtContext extends ParserRuleContext {\r
5365         public TerminalNode RIGHT_BRACE() {\r
5366             return getToken(YangParser.RIGHT_BRACE, 0);\r
5367         }\r
5368 \r
5369         public List<When_stmtContext> when_stmt() {\r
5370             return getRuleContexts(When_stmtContext.class);\r
5371         }\r
5372 \r
5373         public Type_stmtContext type_stmt(int i) {\r
5374             return getRuleContext(Type_stmtContext.class, i);\r
5375         }\r
5376 \r
5377         public List<Max_elements_stmtContext> max_elements_stmt() {\r
5378             return getRuleContexts(Max_elements_stmtContext.class);\r
5379         }\r
5380 \r
5381         public Min_elements_stmtContext min_elements_stmt(int i) {\r
5382             return getRuleContext(Min_elements_stmtContext.class, i);\r
5383         }\r
5384 \r
5385         public TerminalNode LEAF_LIST_KEYWORD() {\r
5386             return getToken(YangParser.LEAF_LIST_KEYWORD, 0);\r
5387         }\r
5388 \r
5389         public Config_stmtContext config_stmt(int i) {\r
5390             return getRuleContext(Config_stmtContext.class, i);\r
5391         }\r
5392 \r
5393         public List<Min_elements_stmtContext> min_elements_stmt() {\r
5394             return getRuleContexts(Min_elements_stmtContext.class);\r
5395         }\r
5396 \r
5397         public List<Description_stmtContext> description_stmt() {\r
5398             return getRuleContexts(Description_stmtContext.class);\r
5399         }\r
5400 \r
5401         public When_stmtContext when_stmt(int i) {\r
5402             return getRuleContext(When_stmtContext.class, i);\r
5403         }\r
5404 \r
5405         public Units_stmtContext units_stmt(int i) {\r
5406             return getRuleContext(Units_stmtContext.class, i);\r
5407         }\r
5408 \r
5409         public List<Reference_stmtContext> reference_stmt() {\r
5410             return getRuleContexts(Reference_stmtContext.class);\r
5411         }\r
5412 \r
5413         public Description_stmtContext description_stmt(int i) {\r
5414             return getRuleContext(Description_stmtContext.class, i);\r
5415         }\r
5416 \r
5417         public Ordered_by_stmtContext ordered_by_stmt(int i) {\r
5418             return getRuleContext(Ordered_by_stmtContext.class, i);\r
5419         }\r
5420 \r
5421         public List<Units_stmtContext> units_stmt() {\r
5422             return getRuleContexts(Units_stmtContext.class);\r
5423         }\r
5424 \r
5425         public If_feature_stmtContext if_feature_stmt(int i) {\r
5426             return getRuleContext(If_feature_stmtContext.class, i);\r
5427         }\r
5428 \r
5429         public TerminalNode LEFT_BRACE() {\r
5430             return getToken(YangParser.LEFT_BRACE, 0);\r
5431         }\r
5432 \r
5433         public Status_stmtContext status_stmt(int i) {\r
5434             return getRuleContext(Status_stmtContext.class, i);\r
5435         }\r
5436 \r
5437         public List<Ordered_by_stmtContext> ordered_by_stmt() {\r
5438             return getRuleContexts(Ordered_by_stmtContext.class);\r
5439         }\r
5440 \r
5441         public List<Type_stmtContext> type_stmt() {\r
5442             return getRuleContexts(Type_stmtContext.class);\r
5443         }\r
5444 \r
5445         public List<If_feature_stmtContext> if_feature_stmt() {\r
5446             return getRuleContexts(If_feature_stmtContext.class);\r
5447         }\r
5448 \r
5449         public Must_stmtContext must_stmt(int i) {\r
5450             return getRuleContext(Must_stmtContext.class, i);\r
5451         }\r
5452 \r
5453         public Identifier_stmtContext identifier_stmt(int i) {\r
5454             return getRuleContext(Identifier_stmtContext.class, i);\r
5455         }\r
5456 \r
5457         public List<Status_stmtContext> status_stmt() {\r
5458             return getRuleContexts(Status_stmtContext.class);\r
5459         }\r
5460 \r
5461         public List<Identifier_stmtContext> identifier_stmt() {\r
5462             return getRuleContexts(Identifier_stmtContext.class);\r
5463         }\r
5464 \r
5465         public StringContext string() {\r
5466             return getRuleContext(StringContext.class, 0);\r
5467         }\r
5468 \r
5469         public List<Must_stmtContext> must_stmt() {\r
5470             return getRuleContexts(Must_stmtContext.class);\r
5471         }\r
5472 \r
5473         public List<Config_stmtContext> config_stmt() {\r
5474             return getRuleContexts(Config_stmtContext.class);\r
5475         }\r
5476 \r
5477         public Max_elements_stmtContext max_elements_stmt(int i) {\r
5478             return getRuleContext(Max_elements_stmtContext.class, i);\r
5479         }\r
5480 \r
5481         public Reference_stmtContext reference_stmt(int i) {\r
5482             return getRuleContext(Reference_stmtContext.class, i);\r
5483         }\r
5484 \r
5485         public Leaf_list_stmtContext(ParserRuleContext parent, int invokingState) {\r
5486             super(parent, invokingState);\r
5487         }\r
5488 \r
5489         @Override\r
5490         public int getRuleIndex() {\r
5491             return RULE_leaf_list_stmt;\r
5492         }\r
5493 \r
5494         @Override\r
5495         public void enterRule(ParseTreeListener listener) {\r
5496             if (listener instanceof YangParserListener)\r
5497                 ((YangParserListener) listener).enterLeaf_list_stmt(this);\r
5498         }\r
5499 \r
5500         @Override\r
5501         public void exitRule(ParseTreeListener listener) {\r
5502             if (listener instanceof YangParserListener)\r
5503                 ((YangParserListener) listener).exitLeaf_list_stmt(this);\r
5504         }\r
5505 \r
5506         @Override\r
5507         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
5508             if (visitor instanceof YangParserVisitor)\r
5509                 return ((YangParserVisitor<? extends T>) visitor)\r
5510                         .visitLeaf_list_stmt(this);\r
5511             else\r
5512                 return visitor.visitChildren(this);\r
5513         }\r
5514     }\r
5515 \r
5516     public final Leaf_list_stmtContext leaf_list_stmt()\r
5517             throws RecognitionException {\r
5518         Leaf_list_stmtContext _localctx = new Leaf_list_stmtContext(_ctx,\r
5519                 getState());\r
5520         enterRule(_localctx, 66, RULE_leaf_list_stmt);\r
5521         int _la;\r
5522         try {\r
5523             enterOuterAlt(_localctx, 1);\r
5524             {\r
5525                 setState(645);\r
5526                 match(LEAF_LIST_KEYWORD);\r
5527                 setState(646);\r
5528                 string();\r
5529                 setState(647);\r
5530                 match(LEFT_BRACE);\r
5531                 setState(663);\r
5532                 _errHandler.sync(this);\r
5533                 _la = _input.LA(1);\r
5534                 while (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (WHEN_KEYWORD - 10))\r
5535                         | (1L << (UNITS_KEYWORD - 10))\r
5536                         | (1L << (TYPE_KEYWORD - 10))\r
5537                         | (1L << (STATUS_KEYWORD - 10))\r
5538                         | (1L << (REFERENCE_KEYWORD - 10))\r
5539                         | (1L << (ORDERED_BY_KEYWORD - 10))\r
5540                         | (1L << (MUST_KEYWORD - 10))\r
5541                         | (1L << (MIN_ELEMENTS_KEYWORD - 10))\r
5542                         | (1L << (MAX_ELEMENTS_KEYWORD - 10))\r
5543                         | (1L << (IF_FEATURE_KEYWORD - 10))\r
5544                         | (1L << (DESCRIPTION_KEYWORD - 10))\r
5545                         | (1L << (CONFIG_KEYWORD - 10)) | (1L << (IDENTIFIER - 10)))) != 0)) {\r
5546                     {\r
5547                         setState(661);\r
5548                         switch (_input.LA(1)) {\r
5549                         case IDENTIFIER: {\r
5550                             setState(648);\r
5551                             identifier_stmt();\r
5552                         }\r
5553                             break;\r
5554                         case WHEN_KEYWORD: {\r
5555                             setState(649);\r
5556                             when_stmt();\r
5557                         }\r
5558                             break;\r
5559                         case IF_FEATURE_KEYWORD: {\r
5560                             setState(650);\r
5561                             if_feature_stmt();\r
5562                         }\r
5563                             break;\r
5564                         case TYPE_KEYWORD: {\r
5565                             setState(651);\r
5566                             type_stmt();\r
5567                         }\r
5568                             break;\r
5569                         case UNITS_KEYWORD: {\r
5570                             setState(652);\r
5571                             units_stmt();\r
5572                         }\r
5573                             break;\r
5574                         case MUST_KEYWORD: {\r
5575                             setState(653);\r
5576                             must_stmt();\r
5577                         }\r
5578                             break;\r
5579                         case CONFIG_KEYWORD: {\r
5580                             setState(654);\r
5581                             config_stmt();\r
5582                         }\r
5583                             break;\r
5584                         case MIN_ELEMENTS_KEYWORD: {\r
5585                             setState(655);\r
5586                             min_elements_stmt();\r
5587                         }\r
5588                             break;\r
5589                         case MAX_ELEMENTS_KEYWORD: {\r
5590                             setState(656);\r
5591                             max_elements_stmt();\r
5592                         }\r
5593                             break;\r
5594                         case ORDERED_BY_KEYWORD: {\r
5595                             setState(657);\r
5596                             ordered_by_stmt();\r
5597                         }\r
5598                             break;\r
5599                         case STATUS_KEYWORD: {\r
5600                             setState(658);\r
5601                             status_stmt();\r
5602                         }\r
5603                             break;\r
5604                         case DESCRIPTION_KEYWORD: {\r
5605                             setState(659);\r
5606                             description_stmt();\r
5607                         }\r
5608                             break;\r
5609                         case REFERENCE_KEYWORD: {\r
5610                             setState(660);\r
5611                             reference_stmt();\r
5612                         }\r
5613                             break;\r
5614                         default:\r
5615                             throw new NoViableAltException(this);\r
5616                         }\r
5617                     }\r
5618                     setState(665);\r
5619                     _errHandler.sync(this);\r
5620                     _la = _input.LA(1);\r
5621                 }\r
5622                 setState(666);\r
5623                 match(RIGHT_BRACE);\r
5624             }\r
5625         } catch (RecognitionException re) {\r
5626             _localctx.exception = re;\r
5627             _errHandler.reportError(this, re);\r
5628             _errHandler.recover(this, re);\r
5629         } finally {\r
5630             exitRule();\r
5631         }\r
5632         return _localctx;\r
5633     }\r
5634 \r
5635     public static class Leaf_stmtContext extends ParserRuleContext {\r
5636         public TerminalNode RIGHT_BRACE() {\r
5637             return getToken(YangParser.RIGHT_BRACE, 0);\r
5638         }\r
5639 \r
5640         public List<When_stmtContext> when_stmt() {\r
5641             return getRuleContexts(When_stmtContext.class);\r
5642         }\r
5643 \r
5644         public Type_stmtContext type_stmt(int i) {\r
5645             return getRuleContext(Type_stmtContext.class, i);\r
5646         }\r
5647 \r
5648         public List<Mandatory_stmtContext> mandatory_stmt() {\r
5649             return getRuleContexts(Mandatory_stmtContext.class);\r
5650         }\r
5651 \r
5652         public Config_stmtContext config_stmt(int i) {\r
5653             return getRuleContext(Config_stmtContext.class, i);\r
5654         }\r
5655 \r
5656         public TerminalNode LEAF_KEYWORD() {\r
5657             return getToken(YangParser.LEAF_KEYWORD, 0);\r
5658         }\r
5659 \r
5660         public List<Description_stmtContext> description_stmt() {\r
5661             return getRuleContexts(Description_stmtContext.class);\r
5662         }\r
5663 \r
5664         public When_stmtContext when_stmt(int i) {\r
5665             return getRuleContext(When_stmtContext.class, i);\r
5666         }\r
5667 \r
5668         public Units_stmtContext units_stmt(int i) {\r
5669             return getRuleContext(Units_stmtContext.class, i);\r
5670         }\r
5671 \r
5672         public List<Reference_stmtContext> reference_stmt() {\r
5673             return getRuleContexts(Reference_stmtContext.class);\r
5674         }\r
5675 \r
5676         public Description_stmtContext description_stmt(int i) {\r
5677             return getRuleContext(Description_stmtContext.class, i);\r
5678         }\r
5679 \r
5680         public Default_stmtContext default_stmt(int i) {\r
5681             return getRuleContext(Default_stmtContext.class, i);\r
5682         }\r
5683 \r
5684         public List<Units_stmtContext> units_stmt() {\r
5685             return getRuleContexts(Units_stmtContext.class);\r
5686         }\r
5687 \r
5688         public If_feature_stmtContext if_feature_stmt(int i) {\r
5689             return getRuleContext(If_feature_stmtContext.class, i);\r
5690         }\r
5691 \r
5692         public TerminalNode LEFT_BRACE() {\r
5693             return getToken(YangParser.LEFT_BRACE, 0);\r
5694         }\r
5695 \r
5696         public Status_stmtContext status_stmt(int i) {\r
5697             return getRuleContext(Status_stmtContext.class, i);\r
5698         }\r
5699 \r
5700         public List<Type_stmtContext> type_stmt() {\r
5701             return getRuleContexts(Type_stmtContext.class);\r
5702         }\r
5703 \r
5704         public List<If_feature_stmtContext> if_feature_stmt() {\r
5705             return getRuleContexts(If_feature_stmtContext.class);\r
5706         }\r
5707 \r
5708         public Must_stmtContext must_stmt(int i) {\r
5709             return getRuleContext(Must_stmtContext.class, i);\r
5710         }\r
5711 \r
5712         public Identifier_stmtContext identifier_stmt(int i) {\r
5713             return getRuleContext(Identifier_stmtContext.class, i);\r
5714         }\r
5715 \r
5716         public List<Default_stmtContext> default_stmt() {\r
5717             return getRuleContexts(Default_stmtContext.class);\r
5718         }\r
5719 \r
5720         public Mandatory_stmtContext mandatory_stmt(int i) {\r
5721             return getRuleContext(Mandatory_stmtContext.class, i);\r
5722         }\r
5723 \r
5724         public List<Status_stmtContext> status_stmt() {\r
5725             return getRuleContexts(Status_stmtContext.class);\r
5726         }\r
5727 \r
5728         public List<Identifier_stmtContext> identifier_stmt() {\r
5729             return getRuleContexts(Identifier_stmtContext.class);\r
5730         }\r
5731 \r
5732         public StringContext string() {\r
5733             return getRuleContext(StringContext.class, 0);\r
5734         }\r
5735 \r
5736         public List<Must_stmtContext> must_stmt() {\r
5737             return getRuleContexts(Must_stmtContext.class);\r
5738         }\r
5739 \r
5740         public List<Config_stmtContext> config_stmt() {\r
5741             return getRuleContexts(Config_stmtContext.class);\r
5742         }\r
5743 \r
5744         public Reference_stmtContext reference_stmt(int i) {\r
5745             return getRuleContext(Reference_stmtContext.class, i);\r
5746         }\r
5747 \r
5748         public Leaf_stmtContext(ParserRuleContext parent, int invokingState) {\r
5749             super(parent, invokingState);\r
5750         }\r
5751 \r
5752         @Override\r
5753         public int getRuleIndex() {\r
5754             return RULE_leaf_stmt;\r
5755         }\r
5756 \r
5757         @Override\r
5758         public void enterRule(ParseTreeListener listener) {\r
5759             if (listener instanceof YangParserListener)\r
5760                 ((YangParserListener) listener).enterLeaf_stmt(this);\r
5761         }\r
5762 \r
5763         @Override\r
5764         public void exitRule(ParseTreeListener listener) {\r
5765             if (listener instanceof YangParserListener)\r
5766                 ((YangParserListener) listener).exitLeaf_stmt(this);\r
5767         }\r
5768 \r
5769         @Override\r
5770         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
5771             if (visitor instanceof YangParserVisitor)\r
5772                 return ((YangParserVisitor<? extends T>) visitor)\r
5773                         .visitLeaf_stmt(this);\r
5774             else\r
5775                 return visitor.visitChildren(this);\r
5776         }\r
5777     }\r
5778 \r
5779     public final Leaf_stmtContext leaf_stmt() throws RecognitionException {\r
5780         Leaf_stmtContext _localctx = new Leaf_stmtContext(_ctx, getState());\r
5781         enterRule(_localctx, 68, RULE_leaf_stmt);\r
5782         int _la;\r
5783         try {\r
5784             enterOuterAlt(_localctx, 1);\r
5785             {\r
5786                 setState(668);\r
5787                 match(LEAF_KEYWORD);\r
5788                 setState(669);\r
5789                 string();\r
5790                 setState(670);\r
5791                 match(LEFT_BRACE);\r
5792                 setState(685);\r
5793                 _errHandler.sync(this);\r
5794                 _la = _input.LA(1);\r
5795                 while (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (WHEN_KEYWORD - 10))\r
5796                         | (1L << (UNITS_KEYWORD - 10))\r
5797                         | (1L << (TYPE_KEYWORD - 10))\r
5798                         | (1L << (STATUS_KEYWORD - 10))\r
5799                         | (1L << (REFERENCE_KEYWORD - 10))\r
5800                         | (1L << (MUST_KEYWORD - 10))\r
5801                         | (1L << (MANDATORY_KEYWORD - 10))\r
5802                         | (1L << (IF_FEATURE_KEYWORD - 10))\r
5803                         | (1L << (DESCRIPTION_KEYWORD - 10))\r
5804                         | (1L << (DEFAULT_KEYWORD - 10))\r
5805                         | (1L << (CONFIG_KEYWORD - 10)) | (1L << (IDENTIFIER - 10)))) != 0)) {\r
5806                     {\r
5807                         setState(683);\r
5808                         switch (_input.LA(1)) {\r
5809                         case IDENTIFIER: {\r
5810                             setState(671);\r
5811                             identifier_stmt();\r
5812                         }\r
5813                             break;\r
5814                         case WHEN_KEYWORD: {\r
5815                             setState(672);\r
5816                             when_stmt();\r
5817                         }\r
5818                             break;\r
5819                         case IF_FEATURE_KEYWORD: {\r
5820                             setState(673);\r
5821                             if_feature_stmt();\r
5822                         }\r
5823                             break;\r
5824                         case TYPE_KEYWORD: {\r
5825                             setState(674);\r
5826                             type_stmt();\r
5827                         }\r
5828                             break;\r
5829                         case UNITS_KEYWORD: {\r
5830                             setState(675);\r
5831                             units_stmt();\r
5832                         }\r
5833                             break;\r
5834                         case MUST_KEYWORD: {\r
5835                             setState(676);\r
5836                             must_stmt();\r
5837                         }\r
5838                             break;\r
5839                         case DEFAULT_KEYWORD: {\r
5840                             setState(677);\r
5841                             default_stmt();\r
5842                         }\r
5843                             break;\r
5844                         case CONFIG_KEYWORD: {\r
5845                             setState(678);\r
5846                             config_stmt();\r
5847                         }\r
5848                             break;\r
5849                         case MANDATORY_KEYWORD: {\r
5850                             setState(679);\r
5851                             mandatory_stmt();\r
5852                         }\r
5853                             break;\r
5854                         case STATUS_KEYWORD: {\r
5855                             setState(680);\r
5856                             status_stmt();\r
5857                         }\r
5858                             break;\r
5859                         case DESCRIPTION_KEYWORD: {\r
5860                             setState(681);\r
5861                             description_stmt();\r
5862                         }\r
5863                             break;\r
5864                         case REFERENCE_KEYWORD: {\r
5865                             setState(682);\r
5866                             reference_stmt();\r
5867                         }\r
5868                             break;\r
5869                         default:\r
5870                             throw new NoViableAltException(this);\r
5871                         }\r
5872                     }\r
5873                     setState(687);\r
5874                     _errHandler.sync(this);\r
5875                     _la = _input.LA(1);\r
5876                 }\r
5877                 setState(688);\r
5878                 match(RIGHT_BRACE);\r
5879             }\r
5880         } catch (RecognitionException re) {\r
5881             _localctx.exception = re;\r
5882             _errHandler.reportError(this, re);\r
5883             _errHandler.recover(this, re);\r
5884         } finally {\r
5885             exitRule();\r
5886         }\r
5887         return _localctx;\r
5888     }\r
5889 \r
5890     public static class Container_stmtContext extends ParserRuleContext {\r
5891         public TerminalNode RIGHT_BRACE() {\r
5892             return getToken(YangParser.RIGHT_BRACE, 0);\r
5893         }\r
5894 \r
5895         public List<When_stmtContext> when_stmt() {\r
5896             return getRuleContexts(When_stmtContext.class);\r
5897         }\r
5898 \r
5899         public Data_def_stmtContext data_def_stmt(int i) {\r
5900             return getRuleContext(Data_def_stmtContext.class, i);\r
5901         }\r
5902 \r
5903         public List<Typedef_stmtContext> typedef_stmt() {\r
5904             return getRuleContexts(Typedef_stmtContext.class);\r
5905         }\r
5906 \r
5907         public List<Data_def_stmtContext> data_def_stmt() {\r
5908             return getRuleContexts(Data_def_stmtContext.class);\r
5909         }\r
5910 \r
5911         public TerminalNode SEMICOLON() {\r
5912             return getToken(YangParser.SEMICOLON, 0);\r
5913         }\r
5914 \r
5915         public Config_stmtContext config_stmt(int i) {\r
5916             return getRuleContext(Config_stmtContext.class, i);\r
5917         }\r
5918 \r
5919         public List<Description_stmtContext> description_stmt() {\r
5920             return getRuleContexts(Description_stmtContext.class);\r
5921         }\r
5922 \r
5923         public When_stmtContext when_stmt(int i) {\r
5924             return getRuleContext(When_stmtContext.class, i);\r
5925         }\r
5926 \r
5927         public List<Grouping_stmtContext> grouping_stmt() {\r
5928             return getRuleContexts(Grouping_stmtContext.class);\r
5929         }\r
5930 \r
5931         public TerminalNode CONTAINER_KEYWORD() {\r
5932             return getToken(YangParser.CONTAINER_KEYWORD, 0);\r
5933         }\r
5934 \r
5935         public List<Presence_stmtContext> presence_stmt() {\r
5936             return getRuleContexts(Presence_stmtContext.class);\r
5937         }\r
5938 \r
5939         public List<Reference_stmtContext> reference_stmt() {\r
5940             return getRuleContexts(Reference_stmtContext.class);\r
5941         }\r
5942 \r
5943         public Typedef_stmtContext typedef_stmt(int i) {\r
5944             return getRuleContext(Typedef_stmtContext.class, i);\r
5945         }\r
5946 \r
5947         public Description_stmtContext description_stmt(int i) {\r
5948             return getRuleContext(Description_stmtContext.class, i);\r
5949         }\r
5950 \r
5951         public Grouping_stmtContext grouping_stmt(int i) {\r
5952             return getRuleContext(Grouping_stmtContext.class, i);\r
5953         }\r
5954 \r
5955         public If_feature_stmtContext if_feature_stmt(int i) {\r
5956             return getRuleContext(If_feature_stmtContext.class, i);\r
5957         }\r
5958 \r
5959         public TerminalNode LEFT_BRACE() {\r
5960             return getToken(YangParser.LEFT_BRACE, 0);\r
5961         }\r
5962 \r
5963         public Status_stmtContext status_stmt(int i) {\r
5964             return getRuleContext(Status_stmtContext.class, i);\r
5965         }\r
5966 \r
5967         public List<If_feature_stmtContext> if_feature_stmt() {\r
5968             return getRuleContexts(If_feature_stmtContext.class);\r
5969         }\r
5970 \r
5971         public Must_stmtContext must_stmt(int i) {\r
5972             return getRuleContext(Must_stmtContext.class, i);\r
5973         }\r
5974 \r
5975         public Identifier_stmtContext identifier_stmt(int i) {\r
5976             return getRuleContext(Identifier_stmtContext.class, i);\r
5977         }\r
5978 \r
5979         public List<Status_stmtContext> status_stmt() {\r
5980             return getRuleContexts(Status_stmtContext.class);\r
5981         }\r
5982 \r
5983         public Presence_stmtContext presence_stmt(int i) {\r
5984             return getRuleContext(Presence_stmtContext.class, i);\r
5985         }\r
5986 \r
5987         public List<Must_stmtContext> must_stmt() {\r
5988             return getRuleContexts(Must_stmtContext.class);\r
5989         }\r
5990 \r
5991         public List<Identifier_stmtContext> identifier_stmt() {\r
5992             return getRuleContexts(Identifier_stmtContext.class);\r
5993         }\r
5994 \r
5995         public StringContext string() {\r
5996             return getRuleContext(StringContext.class, 0);\r
5997         }\r
5998 \r
5999         public List<Config_stmtContext> config_stmt() {\r
6000             return getRuleContexts(Config_stmtContext.class);\r
6001         }\r
6002 \r
6003         public Reference_stmtContext reference_stmt(int i) {\r
6004             return getRuleContext(Reference_stmtContext.class, i);\r
6005         }\r
6006 \r
6007         public Container_stmtContext(ParserRuleContext parent, int invokingState) {\r
6008             super(parent, invokingState);\r
6009         }\r
6010 \r
6011         @Override\r
6012         public int getRuleIndex() {\r
6013             return RULE_container_stmt;\r
6014         }\r
6015 \r
6016         @Override\r
6017         public void enterRule(ParseTreeListener listener) {\r
6018             if (listener instanceof YangParserListener)\r
6019                 ((YangParserListener) listener).enterContainer_stmt(this);\r
6020         }\r
6021 \r
6022         @Override\r
6023         public void exitRule(ParseTreeListener listener) {\r
6024             if (listener instanceof YangParserListener)\r
6025                 ((YangParserListener) listener).exitContainer_stmt(this);\r
6026         }\r
6027 \r
6028         @Override\r
6029         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
6030             if (visitor instanceof YangParserVisitor)\r
6031                 return ((YangParserVisitor<? extends T>) visitor)\r
6032                         .visitContainer_stmt(this);\r
6033             else\r
6034                 return visitor.visitChildren(this);\r
6035         }\r
6036     }\r
6037 \r
6038     public final Container_stmtContext container_stmt()\r
6039             throws RecognitionException {\r
6040         Container_stmtContext _localctx = new Container_stmtContext(_ctx,\r
6041                 getState());\r
6042         enterRule(_localctx, 70, RULE_container_stmt);\r
6043         int _la;\r
6044         try {\r
6045             enterOuterAlt(_localctx, 1);\r
6046             {\r
6047                 setState(690);\r
6048                 match(CONTAINER_KEYWORD);\r
6049                 setState(691);\r
6050                 string();\r
6051                 setState(712);\r
6052                 switch (_input.LA(1)) {\r
6053                 case SEMICOLON: {\r
6054                     setState(692);\r
6055                     match(SEMICOLON);\r
6056                 }\r
6057                     break;\r
6058                 case LEFT_BRACE: {\r
6059                     {\r
6060                         setState(693);\r
6061                         match(LEFT_BRACE);\r
6062                         setState(708);\r
6063                         _errHandler.sync(this);\r
6064                         _la = _input.LA(1);\r
6065                         while (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (WHEN_KEYWORD - 10))\r
6066                                 | (1L << (USES_KEYWORD - 10))\r
6067                                 | (1L << (TYPEDEF_KEYWORD - 10))\r
6068                                 | (1L << (STATUS_KEYWORD - 10))\r
6069                                 | (1L << (REFERENCE_KEYWORD - 10))\r
6070                                 | (1L << (PRESENCE_KEYWORD - 10))\r
6071                                 | (1L << (MUST_KEYWORD - 10))\r
6072                                 | (1L << (LIST_KEYWORD - 10))\r
6073                                 | (1L << (LEAF_LIST_KEYWORD - 10))\r
6074                                 | (1L << (LEAF_KEYWORD - 10))\r
6075                                 | (1L << (IF_FEATURE_KEYWORD - 10))\r
6076                                 | (1L << (GROUPING_KEYWORD - 10))\r
6077                                 | (1L << (DESCRIPTION_KEYWORD - 10))\r
6078                                 | (1L << (CONTAINER_KEYWORD - 10))\r
6079                                 | (1L << (CONFIG_KEYWORD - 10))\r
6080                                 | (1L << (CHOICE_KEYWORD - 10))\r
6081                                 | (1L << (ANYXML_KEYWORD - 10)) | (1L << (IDENTIFIER - 10)))) != 0)) {\r
6082                             {\r
6083                                 setState(706);\r
6084                                 switch (_input.LA(1)) {\r
6085                                 case IDENTIFIER: {\r
6086                                     setState(694);\r
6087                                     identifier_stmt();\r
6088                                 }\r
6089                                     break;\r
6090                                 case WHEN_KEYWORD: {\r
6091                                     setState(695);\r
6092                                     when_stmt();\r
6093                                 }\r
6094                                     break;\r
6095                                 case IF_FEATURE_KEYWORD: {\r
6096                                     setState(696);\r
6097                                     if_feature_stmt();\r
6098                                 }\r
6099                                     break;\r
6100                                 case MUST_KEYWORD: {\r
6101                                     setState(697);\r
6102                                     must_stmt();\r
6103                                 }\r
6104                                     break;\r
6105                                 case PRESENCE_KEYWORD: {\r
6106                                     setState(698);\r
6107                                     presence_stmt();\r
6108                                 }\r
6109                                     break;\r
6110                                 case CONFIG_KEYWORD: {\r
6111                                     setState(699);\r
6112                                     config_stmt();\r
6113                                 }\r
6114                                     break;\r
6115                                 case STATUS_KEYWORD: {\r
6116                                     setState(700);\r
6117                                     status_stmt();\r
6118                                 }\r
6119                                     break;\r
6120                                 case DESCRIPTION_KEYWORD: {\r
6121                                     setState(701);\r
6122                                     description_stmt();\r
6123                                 }\r
6124                                     break;\r
6125                                 case REFERENCE_KEYWORD: {\r
6126                                     setState(702);\r
6127                                     reference_stmt();\r
6128                                 }\r
6129                                     break;\r
6130                                 case TYPEDEF_KEYWORD: {\r
6131                                     setState(703);\r
6132                                     typedef_stmt();\r
6133                                 }\r
6134                                     break;\r
6135                                 case GROUPING_KEYWORD: {\r
6136                                     setState(704);\r
6137                                     grouping_stmt();\r
6138                                 }\r
6139                                     break;\r
6140                                 case USES_KEYWORD:\r
6141                                 case LIST_KEYWORD:\r
6142                                 case LEAF_LIST_KEYWORD:\r
6143                                 case LEAF_KEYWORD:\r
6144                                 case CONTAINER_KEYWORD:\r
6145                                 case CHOICE_KEYWORD:\r
6146                                 case ANYXML_KEYWORD: {\r
6147                                     setState(705);\r
6148                                     data_def_stmt();\r
6149                                 }\r
6150                                     break;\r
6151                                 default:\r
6152                                     throw new NoViableAltException(this);\r
6153                                 }\r
6154                             }\r
6155                             setState(710);\r
6156                             _errHandler.sync(this);\r
6157                             _la = _input.LA(1);\r
6158                         }\r
6159                         setState(711);\r
6160                         match(RIGHT_BRACE);\r
6161                     }\r
6162                 }\r
6163                     break;\r
6164                 default:\r
6165                     throw new NoViableAltException(this);\r
6166                 }\r
6167             }\r
6168         } catch (RecognitionException re) {\r
6169             _localctx.exception = re;\r
6170             _errHandler.reportError(this, re);\r
6171             _errHandler.recover(this, re);\r
6172         } finally {\r
6173             exitRule();\r
6174         }\r
6175         return _localctx;\r
6176     }\r
6177 \r
6178     public static class Grouping_stmtContext extends ParserRuleContext {\r
6179         public List<Grouping_stmtContext> grouping_stmt() {\r
6180             return getRuleContexts(Grouping_stmtContext.class);\r
6181         }\r
6182 \r
6183         public TerminalNode RIGHT_BRACE() {\r
6184             return getToken(YangParser.RIGHT_BRACE, 0);\r
6185         }\r
6186 \r
6187         public List<Reference_stmtContext> reference_stmt() {\r
6188             return getRuleContexts(Reference_stmtContext.class);\r
6189         }\r
6190 \r
6191         public Typedef_stmtContext typedef_stmt(int i) {\r
6192             return getRuleContext(Typedef_stmtContext.class, i);\r
6193         }\r
6194 \r
6195         public Description_stmtContext description_stmt(int i) {\r
6196             return getRuleContext(Description_stmtContext.class, i);\r
6197         }\r
6198 \r
6199         public Grouping_stmtContext grouping_stmt(int i) {\r
6200             return getRuleContext(Grouping_stmtContext.class, i);\r
6201         }\r
6202 \r
6203         public TerminalNode LEFT_BRACE() {\r
6204             return getToken(YangParser.LEFT_BRACE, 0);\r
6205         }\r
6206 \r
6207         public Data_def_stmtContext data_def_stmt(int i) {\r
6208             return getRuleContext(Data_def_stmtContext.class, i);\r
6209         }\r
6210 \r
6211         public List<Typedef_stmtContext> typedef_stmt() {\r
6212             return getRuleContexts(Typedef_stmtContext.class);\r
6213         }\r
6214 \r
6215         public Status_stmtContext status_stmt(int i) {\r
6216             return getRuleContext(Status_stmtContext.class, i);\r
6217         }\r
6218 \r
6219         public Identifier_stmtContext identifier_stmt(int i) {\r
6220             return getRuleContext(Identifier_stmtContext.class, i);\r
6221         }\r
6222 \r
6223         public List<Data_def_stmtContext> data_def_stmt() {\r
6224             return getRuleContexts(Data_def_stmtContext.class);\r
6225         }\r
6226 \r
6227         public TerminalNode GROUPING_KEYWORD() {\r
6228             return getToken(YangParser.GROUPING_KEYWORD, 0);\r
6229         }\r
6230 \r
6231         public TerminalNode SEMICOLON() {\r
6232             return getToken(YangParser.SEMICOLON, 0);\r
6233         }\r
6234 \r
6235         public List<Status_stmtContext> status_stmt() {\r
6236             return getRuleContexts(Status_stmtContext.class);\r
6237         }\r
6238 \r
6239         public StringContext string() {\r
6240             return getRuleContext(StringContext.class, 0);\r
6241         }\r
6242 \r
6243         public List<Identifier_stmtContext> identifier_stmt() {\r
6244             return getRuleContexts(Identifier_stmtContext.class);\r
6245         }\r
6246 \r
6247         public List<Description_stmtContext> description_stmt() {\r
6248             return getRuleContexts(Description_stmtContext.class);\r
6249         }\r
6250 \r
6251         public Reference_stmtContext reference_stmt(int i) {\r
6252             return getRuleContext(Reference_stmtContext.class, i);\r
6253         }\r
6254 \r
6255         public Grouping_stmtContext(ParserRuleContext parent, int invokingState) {\r
6256             super(parent, invokingState);\r
6257         }\r
6258 \r
6259         @Override\r
6260         public int getRuleIndex() {\r
6261             return RULE_grouping_stmt;\r
6262         }\r
6263 \r
6264         @Override\r
6265         public void enterRule(ParseTreeListener listener) {\r
6266             if (listener instanceof YangParserListener)\r
6267                 ((YangParserListener) listener).enterGrouping_stmt(this);\r
6268         }\r
6269 \r
6270         @Override\r
6271         public void exitRule(ParseTreeListener listener) {\r
6272             if (listener instanceof YangParserListener)\r
6273                 ((YangParserListener) listener).exitGrouping_stmt(this);\r
6274         }\r
6275 \r
6276         @Override\r
6277         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
6278             if (visitor instanceof YangParserVisitor)\r
6279                 return ((YangParserVisitor<? extends T>) visitor)\r
6280                         .visitGrouping_stmt(this);\r
6281             else\r
6282                 return visitor.visitChildren(this);\r
6283         }\r
6284     }\r
6285 \r
6286     public final Grouping_stmtContext grouping_stmt()\r
6287             throws RecognitionException {\r
6288         Grouping_stmtContext _localctx = new Grouping_stmtContext(_ctx,\r
6289                 getState());\r
6290         enterRule(_localctx, 72, RULE_grouping_stmt);\r
6291         int _la;\r
6292         try {\r
6293             enterOuterAlt(_localctx, 1);\r
6294             {\r
6295                 setState(714);\r
6296                 match(GROUPING_KEYWORD);\r
6297                 setState(715);\r
6298                 string();\r
6299                 setState(731);\r
6300                 switch (_input.LA(1)) {\r
6301                 case SEMICOLON: {\r
6302                     setState(716);\r
6303                     match(SEMICOLON);\r
6304                 }\r
6305                     break;\r
6306                 case LEFT_BRACE: {\r
6307                     {\r
6308                         setState(717);\r
6309                         match(LEFT_BRACE);\r
6310                         setState(727);\r
6311                         _errHandler.sync(this);\r
6312                         _la = _input.LA(1);\r
6313                         while (((((_la - 12)) & ~0x3f) == 0 && ((1L << (_la - 12)) & ((1L << (USES_KEYWORD - 12))\r
6314                                 | (1L << (TYPEDEF_KEYWORD - 12))\r
6315                                 | (1L << (STATUS_KEYWORD - 12))\r
6316                                 | (1L << (REFERENCE_KEYWORD - 12))\r
6317                                 | (1L << (LIST_KEYWORD - 12))\r
6318                                 | (1L << (LEAF_LIST_KEYWORD - 12))\r
6319                                 | (1L << (LEAF_KEYWORD - 12))\r
6320                                 | (1L << (GROUPING_KEYWORD - 12))\r
6321                                 | (1L << (DESCRIPTION_KEYWORD - 12))\r
6322                                 | (1L << (CONTAINER_KEYWORD - 12))\r
6323                                 | (1L << (CHOICE_KEYWORD - 12))\r
6324                                 | (1L << (ANYXML_KEYWORD - 12)) | (1L << (IDENTIFIER - 12)))) != 0)) {\r
6325                             {\r
6326                                 setState(725);\r
6327                                 switch (_input.LA(1)) {\r
6328                                 case IDENTIFIER: {\r
6329                                     setState(718);\r
6330                                     identifier_stmt();\r
6331                                 }\r
6332                                     break;\r
6333                                 case STATUS_KEYWORD: {\r
6334                                     setState(719);\r
6335                                     status_stmt();\r
6336                                 }\r
6337                                     break;\r
6338                                 case DESCRIPTION_KEYWORD: {\r
6339                                     setState(720);\r
6340                                     description_stmt();\r
6341                                 }\r
6342                                     break;\r
6343                                 case REFERENCE_KEYWORD: {\r
6344                                     setState(721);\r
6345                                     reference_stmt();\r
6346                                 }\r
6347                                     break;\r
6348                                 case TYPEDEF_KEYWORD: {\r
6349                                     setState(722);\r
6350                                     typedef_stmt();\r
6351                                 }\r
6352                                     break;\r
6353                                 case GROUPING_KEYWORD: {\r
6354                                     setState(723);\r
6355                                     grouping_stmt();\r
6356                                 }\r
6357                                     break;\r
6358                                 case USES_KEYWORD:\r
6359                                 case LIST_KEYWORD:\r
6360                                 case LEAF_LIST_KEYWORD:\r
6361                                 case LEAF_KEYWORD:\r
6362                                 case CONTAINER_KEYWORD:\r
6363                                 case CHOICE_KEYWORD:\r
6364                                 case ANYXML_KEYWORD: {\r
6365                                     setState(724);\r
6366                                     data_def_stmt();\r
6367                                 }\r
6368                                     break;\r
6369                                 default:\r
6370                                     throw new NoViableAltException(this);\r
6371                                 }\r
6372                             }\r
6373                             setState(729);\r
6374                             _errHandler.sync(this);\r
6375                             _la = _input.LA(1);\r
6376                         }\r
6377                         setState(730);\r
6378                         match(RIGHT_BRACE);\r
6379                     }\r
6380                 }\r
6381                     break;\r
6382                 default:\r
6383                     throw new NoViableAltException(this);\r
6384                 }\r
6385             }\r
6386         } catch (RecognitionException re) {\r
6387             _localctx.exception = re;\r
6388             _errHandler.reportError(this, re);\r
6389             _errHandler.recover(this, re);\r
6390         } finally {\r
6391             exitRule();\r
6392         }\r
6393         return _localctx;\r
6394     }\r
6395 \r
6396     public static class Value_stmtContext extends ParserRuleContext {\r
6397         public StringContext string() {\r
6398             return getRuleContext(StringContext.class, 0);\r
6399         }\r
6400 \r
6401         public StmtendContext stmtend() {\r
6402             return getRuleContext(StmtendContext.class, 0);\r
6403         }\r
6404 \r
6405         public TerminalNode VALUE_KEYWORD() {\r
6406             return getToken(YangParser.VALUE_KEYWORD, 0);\r
6407         }\r
6408 \r
6409         public Value_stmtContext(ParserRuleContext parent, int invokingState) {\r
6410             super(parent, invokingState);\r
6411         }\r
6412 \r
6413         @Override\r
6414         public int getRuleIndex() {\r
6415             return RULE_value_stmt;\r
6416         }\r
6417 \r
6418         @Override\r
6419         public void enterRule(ParseTreeListener listener) {\r
6420             if (listener instanceof YangParserListener)\r
6421                 ((YangParserListener) listener).enterValue_stmt(this);\r
6422         }\r
6423 \r
6424         @Override\r
6425         public void exitRule(ParseTreeListener listener) {\r
6426             if (listener instanceof YangParserListener)\r
6427                 ((YangParserListener) listener).exitValue_stmt(this);\r
6428         }\r
6429 \r
6430         @Override\r
6431         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
6432             if (visitor instanceof YangParserVisitor)\r
6433                 return ((YangParserVisitor<? extends T>) visitor)\r
6434                         .visitValue_stmt(this);\r
6435             else\r
6436                 return visitor.visitChildren(this);\r
6437         }\r
6438     }\r
6439 \r
6440     public final Value_stmtContext value_stmt() throws RecognitionException {\r
6441         Value_stmtContext _localctx = new Value_stmtContext(_ctx, getState());\r
6442         enterRule(_localctx, 74, RULE_value_stmt);\r
6443         try {\r
6444             enterOuterAlt(_localctx, 1);\r
6445             {\r
6446                 setState(733);\r
6447                 match(VALUE_KEYWORD);\r
6448                 setState(734);\r
6449                 string();\r
6450                 setState(735);\r
6451                 stmtend();\r
6452             }\r
6453         } catch (RecognitionException re) {\r
6454             _localctx.exception = re;\r
6455             _errHandler.reportError(this, re);\r
6456             _errHandler.recover(this, re);\r
6457         } finally {\r
6458             exitRule();\r
6459         }\r
6460         return _localctx;\r
6461     }\r
6462 \r
6463     public static class Max_value_argContext extends ParserRuleContext {\r
6464         public StringContext string() {\r
6465             return getRuleContext(StringContext.class, 0);\r
6466         }\r
6467 \r
6468         public Max_value_argContext(ParserRuleContext parent, int invokingState) {\r
6469             super(parent, invokingState);\r
6470         }\r
6471 \r
6472         @Override\r
6473         public int getRuleIndex() {\r
6474             return RULE_max_value_arg;\r
6475         }\r
6476 \r
6477         @Override\r
6478         public void enterRule(ParseTreeListener listener) {\r
6479             if (listener instanceof YangParserListener)\r
6480                 ((YangParserListener) listener).enterMax_value_arg(this);\r
6481         }\r
6482 \r
6483         @Override\r
6484         public void exitRule(ParseTreeListener listener) {\r
6485             if (listener instanceof YangParserListener)\r
6486                 ((YangParserListener) listener).exitMax_value_arg(this);\r
6487         }\r
6488 \r
6489         @Override\r
6490         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
6491             if (visitor instanceof YangParserVisitor)\r
6492                 return ((YangParserVisitor<? extends T>) visitor)\r
6493                         .visitMax_value_arg(this);\r
6494             else\r
6495                 return visitor.visitChildren(this);\r
6496         }\r
6497     }\r
6498 \r
6499     public final Max_value_argContext max_value_arg()\r
6500             throws RecognitionException {\r
6501         Max_value_argContext _localctx = new Max_value_argContext(_ctx,\r
6502                 getState());\r
6503         enterRule(_localctx, 76, RULE_max_value_arg);\r
6504         try {\r
6505             enterOuterAlt(_localctx, 1);\r
6506             {\r
6507                 setState(737);\r
6508                 string();\r
6509             }\r
6510         } catch (RecognitionException re) {\r
6511             _localctx.exception = re;\r
6512             _errHandler.reportError(this, re);\r
6513             _errHandler.recover(this, re);\r
6514         } finally {\r
6515             exitRule();\r
6516         }\r
6517         return _localctx;\r
6518     }\r
6519 \r
6520     public static class Max_elements_stmtContext extends ParserRuleContext {\r
6521         public TerminalNode MAX_ELEMENTS_KEYWORD() {\r
6522             return getToken(YangParser.MAX_ELEMENTS_KEYWORD, 0);\r
6523         }\r
6524 \r
6525         public Max_value_argContext max_value_arg() {\r
6526             return getRuleContext(Max_value_argContext.class, 0);\r
6527         }\r
6528 \r
6529         public StmtendContext stmtend() {\r
6530             return getRuleContext(StmtendContext.class, 0);\r
6531         }\r
6532 \r
6533         public Max_elements_stmtContext(ParserRuleContext parent,\r
6534                 int invokingState) {\r
6535             super(parent, invokingState);\r
6536         }\r
6537 \r
6538         @Override\r
6539         public int getRuleIndex() {\r
6540             return RULE_max_elements_stmt;\r
6541         }\r
6542 \r
6543         @Override\r
6544         public void enterRule(ParseTreeListener listener) {\r
6545             if (listener instanceof YangParserListener)\r
6546                 ((YangParserListener) listener).enterMax_elements_stmt(this);\r
6547         }\r
6548 \r
6549         @Override\r
6550         public void exitRule(ParseTreeListener listener) {\r
6551             if (listener instanceof YangParserListener)\r
6552                 ((YangParserListener) listener).exitMax_elements_stmt(this);\r
6553         }\r
6554 \r
6555         @Override\r
6556         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
6557             if (visitor instanceof YangParserVisitor)\r
6558                 return ((YangParserVisitor<? extends T>) visitor)\r
6559                         .visitMax_elements_stmt(this);\r
6560             else\r
6561                 return visitor.visitChildren(this);\r
6562         }\r
6563     }\r
6564 \r
6565     public final Max_elements_stmtContext max_elements_stmt()\r
6566             throws RecognitionException {\r
6567         Max_elements_stmtContext _localctx = new Max_elements_stmtContext(_ctx,\r
6568                 getState());\r
6569         enterRule(_localctx, 78, RULE_max_elements_stmt);\r
6570         try {\r
6571             enterOuterAlt(_localctx, 1);\r
6572             {\r
6573                 setState(739);\r
6574                 match(MAX_ELEMENTS_KEYWORD);\r
6575                 setState(740);\r
6576                 max_value_arg();\r
6577                 setState(741);\r
6578                 stmtend();\r
6579             }\r
6580         } catch (RecognitionException re) {\r
6581             _localctx.exception = re;\r
6582             _errHandler.reportError(this, re);\r
6583             _errHandler.recover(this, re);\r
6584         } finally {\r
6585             exitRule();\r
6586         }\r
6587         return _localctx;\r
6588     }\r
6589 \r
6590     public static class Min_elements_stmtContext extends ParserRuleContext {\r
6591         public StringContext string() {\r
6592             return getRuleContext(StringContext.class, 0);\r
6593         }\r
6594 \r
6595         public StmtendContext stmtend() {\r
6596             return getRuleContext(StmtendContext.class, 0);\r
6597         }\r
6598 \r
6599         public TerminalNode MIN_ELEMENTS_KEYWORD() {\r
6600             return getToken(YangParser.MIN_ELEMENTS_KEYWORD, 0);\r
6601         }\r
6602 \r
6603         public Min_elements_stmtContext(ParserRuleContext parent,\r
6604                 int invokingState) {\r
6605             super(parent, invokingState);\r
6606         }\r
6607 \r
6608         @Override\r
6609         public int getRuleIndex() {\r
6610             return RULE_min_elements_stmt;\r
6611         }\r
6612 \r
6613         @Override\r
6614         public void enterRule(ParseTreeListener listener) {\r
6615             if (listener instanceof YangParserListener)\r
6616                 ((YangParserListener) listener).enterMin_elements_stmt(this);\r
6617         }\r
6618 \r
6619         @Override\r
6620         public void exitRule(ParseTreeListener listener) {\r
6621             if (listener instanceof YangParserListener)\r
6622                 ((YangParserListener) listener).exitMin_elements_stmt(this);\r
6623         }\r
6624 \r
6625         @Override\r
6626         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
6627             if (visitor instanceof YangParserVisitor)\r
6628                 return ((YangParserVisitor<? extends T>) visitor)\r
6629                         .visitMin_elements_stmt(this);\r
6630             else\r
6631                 return visitor.visitChildren(this);\r
6632         }\r
6633     }\r
6634 \r
6635     public final Min_elements_stmtContext min_elements_stmt()\r
6636             throws RecognitionException {\r
6637         Min_elements_stmtContext _localctx = new Min_elements_stmtContext(_ctx,\r
6638                 getState());\r
6639         enterRule(_localctx, 80, RULE_min_elements_stmt);\r
6640         try {\r
6641             enterOuterAlt(_localctx, 1);\r
6642             {\r
6643                 setState(743);\r
6644                 match(MIN_ELEMENTS_KEYWORD);\r
6645                 setState(744);\r
6646                 string();\r
6647                 setState(745);\r
6648                 stmtend();\r
6649             }\r
6650         } catch (RecognitionException re) {\r
6651             _localctx.exception = re;\r
6652             _errHandler.reportError(this, re);\r
6653             _errHandler.recover(this, re);\r
6654         } finally {\r
6655             exitRule();\r
6656         }\r
6657         return _localctx;\r
6658     }\r
6659 \r
6660     public static class Error_app_tag_stmtContext extends ParserRuleContext {\r
6661         public StringContext string() {\r
6662             return getRuleContext(StringContext.class, 0);\r
6663         }\r
6664 \r
6665         public TerminalNode ERROR_APP_TAG_KEYWORD() {\r
6666             return getToken(YangParser.ERROR_APP_TAG_KEYWORD, 0);\r
6667         }\r
6668 \r
6669         public StmtendContext stmtend() {\r
6670             return getRuleContext(StmtendContext.class, 0);\r
6671         }\r
6672 \r
6673         public Error_app_tag_stmtContext(ParserRuleContext parent,\r
6674                 int invokingState) {\r
6675             super(parent, invokingState);\r
6676         }\r
6677 \r
6678         @Override\r
6679         public int getRuleIndex() {\r
6680             return RULE_error_app_tag_stmt;\r
6681         }\r
6682 \r
6683         @Override\r
6684         public void enterRule(ParseTreeListener listener) {\r
6685             if (listener instanceof YangParserListener)\r
6686                 ((YangParserListener) listener).enterError_app_tag_stmt(this);\r
6687         }\r
6688 \r
6689         @Override\r
6690         public void exitRule(ParseTreeListener listener) {\r
6691             if (listener instanceof YangParserListener)\r
6692                 ((YangParserListener) listener).exitError_app_tag_stmt(this);\r
6693         }\r
6694 \r
6695         @Override\r
6696         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
6697             if (visitor instanceof YangParserVisitor)\r
6698                 return ((YangParserVisitor<? extends T>) visitor)\r
6699                         .visitError_app_tag_stmt(this);\r
6700             else\r
6701                 return visitor.visitChildren(this);\r
6702         }\r
6703     }\r
6704 \r
6705     public final Error_app_tag_stmtContext error_app_tag_stmt()\r
6706             throws RecognitionException {\r
6707         Error_app_tag_stmtContext _localctx = new Error_app_tag_stmtContext(\r
6708                 _ctx, getState());\r
6709         enterRule(_localctx, 82, RULE_error_app_tag_stmt);\r
6710         try {\r
6711             enterOuterAlt(_localctx, 1);\r
6712             {\r
6713                 setState(747);\r
6714                 match(ERROR_APP_TAG_KEYWORD);\r
6715                 setState(748);\r
6716                 string();\r
6717                 setState(749);\r
6718                 stmtend();\r
6719             }\r
6720         } catch (RecognitionException re) {\r
6721             _localctx.exception = re;\r
6722             _errHandler.reportError(this, re);\r
6723             _errHandler.recover(this, re);\r
6724         } finally {\r
6725             exitRule();\r
6726         }\r
6727         return _localctx;\r
6728     }\r
6729 \r
6730     public static class Error_message_stmtContext extends ParserRuleContext {\r
6731         public StringContext string() {\r
6732             return getRuleContext(StringContext.class, 0);\r
6733         }\r
6734 \r
6735         public TerminalNode ERROR_MESSAGE_KEYWORD() {\r
6736             return getToken(YangParser.ERROR_MESSAGE_KEYWORD, 0);\r
6737         }\r
6738 \r
6739         public StmtendContext stmtend() {\r
6740             return getRuleContext(StmtendContext.class, 0);\r
6741         }\r
6742 \r
6743         public Error_message_stmtContext(ParserRuleContext parent,\r
6744                 int invokingState) {\r
6745             super(parent, invokingState);\r
6746         }\r
6747 \r
6748         @Override\r
6749         public int getRuleIndex() {\r
6750             return RULE_error_message_stmt;\r
6751         }\r
6752 \r
6753         @Override\r
6754         public void enterRule(ParseTreeListener listener) {\r
6755             if (listener instanceof YangParserListener)\r
6756                 ((YangParserListener) listener).enterError_message_stmt(this);\r
6757         }\r
6758 \r
6759         @Override\r
6760         public void exitRule(ParseTreeListener listener) {\r
6761             if (listener instanceof YangParserListener)\r
6762                 ((YangParserListener) listener).exitError_message_stmt(this);\r
6763         }\r
6764 \r
6765         @Override\r
6766         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
6767             if (visitor instanceof YangParserVisitor)\r
6768                 return ((YangParserVisitor<? extends T>) visitor)\r
6769                         .visitError_message_stmt(this);\r
6770             else\r
6771                 return visitor.visitChildren(this);\r
6772         }\r
6773     }\r
6774 \r
6775     public final Error_message_stmtContext error_message_stmt()\r
6776             throws RecognitionException {\r
6777         Error_message_stmtContext _localctx = new Error_message_stmtContext(\r
6778                 _ctx, getState());\r
6779         enterRule(_localctx, 84, RULE_error_message_stmt);\r
6780         try {\r
6781             enterOuterAlt(_localctx, 1);\r
6782             {\r
6783                 setState(751);\r
6784                 match(ERROR_MESSAGE_KEYWORD);\r
6785                 setState(752);\r
6786                 string();\r
6787                 setState(753);\r
6788                 stmtend();\r
6789             }\r
6790         } catch (RecognitionException re) {\r
6791             _localctx.exception = re;\r
6792             _errHandler.reportError(this, re);\r
6793             _errHandler.recover(this, re);\r
6794         } finally {\r
6795             exitRule();\r
6796         }\r
6797         return _localctx;\r
6798     }\r
6799 \r
6800     public static class Must_stmtContext extends ParserRuleContext {\r
6801         public TerminalNode RIGHT_BRACE() {\r
6802             return getToken(YangParser.RIGHT_BRACE, 0);\r
6803         }\r
6804 \r
6805         public List<Reference_stmtContext> reference_stmt() {\r
6806             return getRuleContexts(Reference_stmtContext.class);\r
6807         }\r
6808 \r
6809         public Description_stmtContext description_stmt(int i) {\r
6810             return getRuleContext(Description_stmtContext.class, i);\r
6811         }\r
6812 \r
6813         public TerminalNode LEFT_BRACE() {\r
6814             return getToken(YangParser.LEFT_BRACE, 0);\r
6815         }\r
6816 \r
6817         public List<Error_app_tag_stmtContext> error_app_tag_stmt() {\r
6818             return getRuleContexts(Error_app_tag_stmtContext.class);\r
6819         }\r
6820 \r
6821         public TerminalNode MUST_KEYWORD() {\r
6822             return getToken(YangParser.MUST_KEYWORD, 0);\r
6823         }\r
6824 \r
6825         public Error_message_stmtContext error_message_stmt(int i) {\r
6826             return getRuleContext(Error_message_stmtContext.class, i);\r
6827         }\r
6828 \r
6829         public Identifier_stmtContext identifier_stmt(int i) {\r
6830             return getRuleContext(Identifier_stmtContext.class, i);\r
6831         }\r
6832 \r
6833         public TerminalNode SEMICOLON() {\r
6834             return getToken(YangParser.SEMICOLON, 0);\r
6835         }\r
6836 \r
6837         public StringContext string() {\r
6838             return getRuleContext(StringContext.class, 0);\r
6839         }\r
6840 \r
6841         public List<Identifier_stmtContext> identifier_stmt() {\r
6842             return getRuleContexts(Identifier_stmtContext.class);\r
6843         }\r
6844 \r
6845         public Error_app_tag_stmtContext error_app_tag_stmt(int i) {\r
6846             return getRuleContext(Error_app_tag_stmtContext.class, i);\r
6847         }\r
6848 \r
6849         public List<Error_message_stmtContext> error_message_stmt() {\r
6850             return getRuleContexts(Error_message_stmtContext.class);\r
6851         }\r
6852 \r
6853         public List<Description_stmtContext> description_stmt() {\r
6854             return getRuleContexts(Description_stmtContext.class);\r
6855         }\r
6856 \r
6857         public Reference_stmtContext reference_stmt(int i) {\r
6858             return getRuleContext(Reference_stmtContext.class, i);\r
6859         }\r
6860 \r
6861         public Must_stmtContext(ParserRuleContext parent, int invokingState) {\r
6862             super(parent, invokingState);\r
6863         }\r
6864 \r
6865         @Override\r
6866         public int getRuleIndex() {\r
6867             return RULE_must_stmt;\r
6868         }\r
6869 \r
6870         @Override\r
6871         public void enterRule(ParseTreeListener listener) {\r
6872             if (listener instanceof YangParserListener)\r
6873                 ((YangParserListener) listener).enterMust_stmt(this);\r
6874         }\r
6875 \r
6876         @Override\r
6877         public void exitRule(ParseTreeListener listener) {\r
6878             if (listener instanceof YangParserListener)\r
6879                 ((YangParserListener) listener).exitMust_stmt(this);\r
6880         }\r
6881 \r
6882         @Override\r
6883         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
6884             if (visitor instanceof YangParserVisitor)\r
6885                 return ((YangParserVisitor<? extends T>) visitor)\r
6886                         .visitMust_stmt(this);\r
6887             else\r
6888                 return visitor.visitChildren(this);\r
6889         }\r
6890     }\r
6891 \r
6892     public final Must_stmtContext must_stmt() throws RecognitionException {\r
6893         Must_stmtContext _localctx = new Must_stmtContext(_ctx, getState());\r
6894         enterRule(_localctx, 86, RULE_must_stmt);\r
6895         int _la;\r
6896         try {\r
6897             enterOuterAlt(_localctx, 1);\r
6898             {\r
6899                 setState(755);\r
6900                 match(MUST_KEYWORD);\r
6901                 setState(756);\r
6902                 string();\r
6903                 setState(770);\r
6904                 switch (_input.LA(1)) {\r
6905                 case SEMICOLON: {\r
6906                     setState(757);\r
6907                     match(SEMICOLON);\r
6908                 }\r
6909                     break;\r
6910                 case LEFT_BRACE: {\r
6911                     {\r
6912                         setState(758);\r
6913                         match(LEFT_BRACE);\r
6914                         setState(766);\r
6915                         _errHandler.sync(this);\r
6916                         _la = _input.LA(1);\r
6917                         while (((((_la - 24)) & ~0x3f) == 0 && ((1L << (_la - 24)) & ((1L << (REFERENCE_KEYWORD - 24))\r
6918                                 | (1L << (ERROR_MESSAGE_KEYWORD - 24))\r
6919                                 | (1L << (ERROR_APP_TAG_KEYWORD - 24))\r
6920                                 | (1L << (DESCRIPTION_KEYWORD - 24)) | (1L << (IDENTIFIER - 24)))) != 0)) {\r
6921                             {\r
6922                                 setState(764);\r
6923                                 switch (_input.LA(1)) {\r
6924                                 case IDENTIFIER: {\r
6925                                     setState(759);\r
6926                                     identifier_stmt();\r
6927                                 }\r
6928                                     break;\r
6929                                 case ERROR_MESSAGE_KEYWORD: {\r
6930                                     setState(760);\r
6931                                     error_message_stmt();\r
6932                                 }\r
6933                                     break;\r
6934                                 case ERROR_APP_TAG_KEYWORD: {\r
6935                                     setState(761);\r
6936                                     error_app_tag_stmt();\r
6937                                 }\r
6938                                     break;\r
6939                                 case DESCRIPTION_KEYWORD: {\r
6940                                     setState(762);\r
6941                                     description_stmt();\r
6942                                 }\r
6943                                     break;\r
6944                                 case REFERENCE_KEYWORD: {\r
6945                                     setState(763);\r
6946                                     reference_stmt();\r
6947                                 }\r
6948                                     break;\r
6949                                 default:\r
6950                                     throw new NoViableAltException(this);\r
6951                                 }\r
6952                             }\r
6953                             setState(768);\r
6954                             _errHandler.sync(this);\r
6955                             _la = _input.LA(1);\r
6956                         }\r
6957                         setState(769);\r
6958                         match(RIGHT_BRACE);\r
6959                     }\r
6960                 }\r
6961                     break;\r
6962                 default:\r
6963                     throw new NoViableAltException(this);\r
6964                 }\r
6965             }\r
6966         } catch (RecognitionException re) {\r
6967             _localctx.exception = re;\r
6968             _errHandler.reportError(this, re);\r
6969             _errHandler.recover(this, re);\r
6970         } finally {\r
6971             exitRule();\r
6972         }\r
6973         return _localctx;\r
6974     }\r
6975 \r
6976     public static class Ordered_by_argContext extends ParserRuleContext {\r
6977         public StringContext string() {\r
6978             return getRuleContext(StringContext.class, 0);\r
6979         }\r
6980 \r
6981         public Ordered_by_argContext(ParserRuleContext parent, int invokingState) {\r
6982             super(parent, invokingState);\r
6983         }\r
6984 \r
6985         @Override\r
6986         public int getRuleIndex() {\r
6987             return RULE_ordered_by_arg;\r
6988         }\r
6989 \r
6990         @Override\r
6991         public void enterRule(ParseTreeListener listener) {\r
6992             if (listener instanceof YangParserListener)\r
6993                 ((YangParserListener) listener).enterOrdered_by_arg(this);\r
6994         }\r
6995 \r
6996         @Override\r
6997         public void exitRule(ParseTreeListener listener) {\r
6998             if (listener instanceof YangParserListener)\r
6999                 ((YangParserListener) listener).exitOrdered_by_arg(this);\r
7000         }\r
7001 \r
7002         @Override\r
7003         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
7004             if (visitor instanceof YangParserVisitor)\r
7005                 return ((YangParserVisitor<? extends T>) visitor)\r
7006                         .visitOrdered_by_arg(this);\r
7007             else\r
7008                 return visitor.visitChildren(this);\r
7009         }\r
7010     }\r
7011 \r
7012     public final Ordered_by_argContext ordered_by_arg()\r
7013             throws RecognitionException {\r
7014         Ordered_by_argContext _localctx = new Ordered_by_argContext(_ctx,\r
7015                 getState());\r
7016         enterRule(_localctx, 88, RULE_ordered_by_arg);\r
7017         try {\r
7018             enterOuterAlt(_localctx, 1);\r
7019             {\r
7020                 setState(772);\r
7021                 string();\r
7022             }\r
7023         } catch (RecognitionException re) {\r
7024             _localctx.exception = re;\r
7025             _errHandler.reportError(this, re);\r
7026             _errHandler.recover(this, re);\r
7027         } finally {\r
7028             exitRule();\r
7029         }\r
7030         return _localctx;\r
7031     }\r
7032 \r
7033     public static class Ordered_by_stmtContext extends ParserRuleContext {\r
7034         public Ordered_by_argContext ordered_by_arg() {\r
7035             return getRuleContext(Ordered_by_argContext.class, 0);\r
7036         }\r
7037 \r
7038         public TerminalNode ORDERED_BY_KEYWORD() {\r
7039             return getToken(YangParser.ORDERED_BY_KEYWORD, 0);\r
7040         }\r
7041 \r
7042         public StmtendContext stmtend() {\r
7043             return getRuleContext(StmtendContext.class, 0);\r
7044         }\r
7045 \r
7046         public Ordered_by_stmtContext(ParserRuleContext parent,\r
7047                 int invokingState) {\r
7048             super(parent, invokingState);\r
7049         }\r
7050 \r
7051         @Override\r
7052         public int getRuleIndex() {\r
7053             return RULE_ordered_by_stmt;\r
7054         }\r
7055 \r
7056         @Override\r
7057         public void enterRule(ParseTreeListener listener) {\r
7058             if (listener instanceof YangParserListener)\r
7059                 ((YangParserListener) listener).enterOrdered_by_stmt(this);\r
7060         }\r
7061 \r
7062         @Override\r
7063         public void exitRule(ParseTreeListener listener) {\r
7064             if (listener instanceof YangParserListener)\r
7065                 ((YangParserListener) listener).exitOrdered_by_stmt(this);\r
7066         }\r
7067 \r
7068         @Override\r
7069         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
7070             if (visitor instanceof YangParserVisitor)\r
7071                 return ((YangParserVisitor<? extends T>) visitor)\r
7072                         .visitOrdered_by_stmt(this);\r
7073             else\r
7074                 return visitor.visitChildren(this);\r
7075         }\r
7076     }\r
7077 \r
7078     public final Ordered_by_stmtContext ordered_by_stmt()\r
7079             throws RecognitionException {\r
7080         Ordered_by_stmtContext _localctx = new Ordered_by_stmtContext(_ctx,\r
7081                 getState());\r
7082         enterRule(_localctx, 90, RULE_ordered_by_stmt);\r
7083         try {\r
7084             enterOuterAlt(_localctx, 1);\r
7085             {\r
7086                 setState(774);\r
7087                 match(ORDERED_BY_KEYWORD);\r
7088                 setState(775);\r
7089                 ordered_by_arg();\r
7090                 setState(776);\r
7091                 stmtend();\r
7092             }\r
7093         } catch (RecognitionException re) {\r
7094             _localctx.exception = re;\r
7095             _errHandler.reportError(this, re);\r
7096             _errHandler.recover(this, re);\r
7097         } finally {\r
7098             exitRule();\r
7099         }\r
7100         return _localctx;\r
7101     }\r
7102 \r
7103     public static class Presence_stmtContext extends ParserRuleContext {\r
7104         public StringContext string() {\r
7105             return getRuleContext(StringContext.class, 0);\r
7106         }\r
7107 \r
7108         public StmtendContext stmtend() {\r
7109             return getRuleContext(StmtendContext.class, 0);\r
7110         }\r
7111 \r
7112         public TerminalNode PRESENCE_KEYWORD() {\r
7113             return getToken(YangParser.PRESENCE_KEYWORD, 0);\r
7114         }\r
7115 \r
7116         public Presence_stmtContext(ParserRuleContext parent, int invokingState) {\r
7117             super(parent, invokingState);\r
7118         }\r
7119 \r
7120         @Override\r
7121         public int getRuleIndex() {\r
7122             return RULE_presence_stmt;\r
7123         }\r
7124 \r
7125         @Override\r
7126         public void enterRule(ParseTreeListener listener) {\r
7127             if (listener instanceof YangParserListener)\r
7128                 ((YangParserListener) listener).enterPresence_stmt(this);\r
7129         }\r
7130 \r
7131         @Override\r
7132         public void exitRule(ParseTreeListener listener) {\r
7133             if (listener instanceof YangParserListener)\r
7134                 ((YangParserListener) listener).exitPresence_stmt(this);\r
7135         }\r
7136 \r
7137         @Override\r
7138         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
7139             if (visitor instanceof YangParserVisitor)\r
7140                 return ((YangParserVisitor<? extends T>) visitor)\r
7141                         .visitPresence_stmt(this);\r
7142             else\r
7143                 return visitor.visitChildren(this);\r
7144         }\r
7145     }\r
7146 \r
7147     public final Presence_stmtContext presence_stmt()\r
7148             throws RecognitionException {\r
7149         Presence_stmtContext _localctx = new Presence_stmtContext(_ctx,\r
7150                 getState());\r
7151         enterRule(_localctx, 92, RULE_presence_stmt);\r
7152         try {\r
7153             enterOuterAlt(_localctx, 1);\r
7154             {\r
7155                 setState(778);\r
7156                 match(PRESENCE_KEYWORD);\r
7157                 setState(779);\r
7158                 string();\r
7159                 setState(780);\r
7160                 stmtend();\r
7161             }\r
7162         } catch (RecognitionException re) {\r
7163             _localctx.exception = re;\r
7164             _errHandler.reportError(this, re);\r
7165             _errHandler.recover(this, re);\r
7166         } finally {\r
7167             exitRule();\r
7168         }\r
7169         return _localctx;\r
7170     }\r
7171 \r
7172     public static class Mandatory_argContext extends ParserRuleContext {\r
7173         public StringContext string() {\r
7174             return getRuleContext(StringContext.class, 0);\r
7175         }\r
7176 \r
7177         public Mandatory_argContext(ParserRuleContext parent, int invokingState) {\r
7178             super(parent, invokingState);\r
7179         }\r
7180 \r
7181         @Override\r
7182         public int getRuleIndex() {\r
7183             return RULE_mandatory_arg;\r
7184         }\r
7185 \r
7186         @Override\r
7187         public void enterRule(ParseTreeListener listener) {\r
7188             if (listener instanceof YangParserListener)\r
7189                 ((YangParserListener) listener).enterMandatory_arg(this);\r
7190         }\r
7191 \r
7192         @Override\r
7193         public void exitRule(ParseTreeListener listener) {\r
7194             if (listener instanceof YangParserListener)\r
7195                 ((YangParserListener) listener).exitMandatory_arg(this);\r
7196         }\r
7197 \r
7198         @Override\r
7199         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
7200             if (visitor instanceof YangParserVisitor)\r
7201                 return ((YangParserVisitor<? extends T>) visitor)\r
7202                         .visitMandatory_arg(this);\r
7203             else\r
7204                 return visitor.visitChildren(this);\r
7205         }\r
7206     }\r
7207 \r
7208     public final Mandatory_argContext mandatory_arg()\r
7209             throws RecognitionException {\r
7210         Mandatory_argContext _localctx = new Mandatory_argContext(_ctx,\r
7211                 getState());\r
7212         enterRule(_localctx, 94, RULE_mandatory_arg);\r
7213         try {\r
7214             enterOuterAlt(_localctx, 1);\r
7215             {\r
7216                 setState(782);\r
7217                 string();\r
7218             }\r
7219         } catch (RecognitionException re) {\r
7220             _localctx.exception = re;\r
7221             _errHandler.reportError(this, re);\r
7222             _errHandler.recover(this, re);\r
7223         } finally {\r
7224             exitRule();\r
7225         }\r
7226         return _localctx;\r
7227     }\r
7228 \r
7229     public static class Mandatory_stmtContext extends ParserRuleContext {\r
7230         public TerminalNode MANDATORY_KEYWORD() {\r
7231             return getToken(YangParser.MANDATORY_KEYWORD, 0);\r
7232         }\r
7233 \r
7234         public Mandatory_argContext mandatory_arg() {\r
7235             return getRuleContext(Mandatory_argContext.class, 0);\r
7236         }\r
7237 \r
7238         public StmtendContext stmtend() {\r
7239             return getRuleContext(StmtendContext.class, 0);\r
7240         }\r
7241 \r
7242         public Mandatory_stmtContext(ParserRuleContext parent, int invokingState) {\r
7243             super(parent, invokingState);\r
7244         }\r
7245 \r
7246         @Override\r
7247         public int getRuleIndex() {\r
7248             return RULE_mandatory_stmt;\r
7249         }\r
7250 \r
7251         @Override\r
7252         public void enterRule(ParseTreeListener listener) {\r
7253             if (listener instanceof YangParserListener)\r
7254                 ((YangParserListener) listener).enterMandatory_stmt(this);\r
7255         }\r
7256 \r
7257         @Override\r
7258         public void exitRule(ParseTreeListener listener) {\r
7259             if (listener instanceof YangParserListener)\r
7260                 ((YangParserListener) listener).exitMandatory_stmt(this);\r
7261         }\r
7262 \r
7263         @Override\r
7264         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
7265             if (visitor instanceof YangParserVisitor)\r
7266                 return ((YangParserVisitor<? extends T>) visitor)\r
7267                         .visitMandatory_stmt(this);\r
7268             else\r
7269                 return visitor.visitChildren(this);\r
7270         }\r
7271     }\r
7272 \r
7273     public final Mandatory_stmtContext mandatory_stmt()\r
7274             throws RecognitionException {\r
7275         Mandatory_stmtContext _localctx = new Mandatory_stmtContext(_ctx,\r
7276                 getState());\r
7277         enterRule(_localctx, 96, RULE_mandatory_stmt);\r
7278         try {\r
7279             enterOuterAlt(_localctx, 1);\r
7280             {\r
7281                 setState(784);\r
7282                 match(MANDATORY_KEYWORD);\r
7283                 setState(785);\r
7284                 mandatory_arg();\r
7285                 setState(786);\r
7286                 stmtend();\r
7287             }\r
7288         } catch (RecognitionException re) {\r
7289             _localctx.exception = re;\r
7290             _errHandler.reportError(this, re);\r
7291             _errHandler.recover(this, re);\r
7292         } finally {\r
7293             exitRule();\r
7294         }\r
7295         return _localctx;\r
7296     }\r
7297 \r
7298     public static class Config_argContext extends ParserRuleContext {\r
7299         public StringContext string() {\r
7300             return getRuleContext(StringContext.class, 0);\r
7301         }\r
7302 \r
7303         public Config_argContext(ParserRuleContext parent, int invokingState) {\r
7304             super(parent, invokingState);\r
7305         }\r
7306 \r
7307         @Override\r
7308         public int getRuleIndex() {\r
7309             return RULE_config_arg;\r
7310         }\r
7311 \r
7312         @Override\r
7313         public void enterRule(ParseTreeListener listener) {\r
7314             if (listener instanceof YangParserListener)\r
7315                 ((YangParserListener) listener).enterConfig_arg(this);\r
7316         }\r
7317 \r
7318         @Override\r
7319         public void exitRule(ParseTreeListener listener) {\r
7320             if (listener instanceof YangParserListener)\r
7321                 ((YangParserListener) listener).exitConfig_arg(this);\r
7322         }\r
7323 \r
7324         @Override\r
7325         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
7326             if (visitor instanceof YangParserVisitor)\r
7327                 return ((YangParserVisitor<? extends T>) visitor)\r
7328                         .visitConfig_arg(this);\r
7329             else\r
7330                 return visitor.visitChildren(this);\r
7331         }\r
7332     }\r
7333 \r
7334     public final Config_argContext config_arg() throws RecognitionException {\r
7335         Config_argContext _localctx = new Config_argContext(_ctx, getState());\r
7336         enterRule(_localctx, 98, RULE_config_arg);\r
7337         try {\r
7338             enterOuterAlt(_localctx, 1);\r
7339             {\r
7340                 setState(788);\r
7341                 string();\r
7342             }\r
7343         } catch (RecognitionException re) {\r
7344             _localctx.exception = re;\r
7345             _errHandler.reportError(this, re);\r
7346             _errHandler.recover(this, re);\r
7347         } finally {\r
7348             exitRule();\r
7349         }\r
7350         return _localctx;\r
7351     }\r
7352 \r
7353     public static class Config_stmtContext extends ParserRuleContext {\r
7354         public Config_argContext config_arg() {\r
7355             return getRuleContext(Config_argContext.class, 0);\r
7356         }\r
7357 \r
7358         public TerminalNode CONFIG_KEYWORD() {\r
7359             return getToken(YangParser.CONFIG_KEYWORD, 0);\r
7360         }\r
7361 \r
7362         public StmtendContext stmtend() {\r
7363             return getRuleContext(StmtendContext.class, 0);\r
7364         }\r
7365 \r
7366         public Config_stmtContext(ParserRuleContext parent, int invokingState) {\r
7367             super(parent, invokingState);\r
7368         }\r
7369 \r
7370         @Override\r
7371         public int getRuleIndex() {\r
7372             return RULE_config_stmt;\r
7373         }\r
7374 \r
7375         @Override\r
7376         public void enterRule(ParseTreeListener listener) {\r
7377             if (listener instanceof YangParserListener)\r
7378                 ((YangParserListener) listener).enterConfig_stmt(this);\r
7379         }\r
7380 \r
7381         @Override\r
7382         public void exitRule(ParseTreeListener listener) {\r
7383             if (listener instanceof YangParserListener)\r
7384                 ((YangParserListener) listener).exitConfig_stmt(this);\r
7385         }\r
7386 \r
7387         @Override\r
7388         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
7389             if (visitor instanceof YangParserVisitor)\r
7390                 return ((YangParserVisitor<? extends T>) visitor)\r
7391                         .visitConfig_stmt(this);\r
7392             else\r
7393                 return visitor.visitChildren(this);\r
7394         }\r
7395     }\r
7396 \r
7397     public final Config_stmtContext config_stmt() throws RecognitionException {\r
7398         Config_stmtContext _localctx = new Config_stmtContext(_ctx, getState());\r
7399         enterRule(_localctx, 100, RULE_config_stmt);\r
7400         try {\r
7401             enterOuterAlt(_localctx, 1);\r
7402             {\r
7403                 setState(790);\r
7404                 match(CONFIG_KEYWORD);\r
7405                 setState(791);\r
7406                 config_arg();\r
7407                 setState(792);\r
7408                 stmtend();\r
7409             }\r
7410         } catch (RecognitionException re) {\r
7411             _localctx.exception = re;\r
7412             _errHandler.reportError(this, re);\r
7413             _errHandler.recover(this, re);\r
7414         } finally {\r
7415             exitRule();\r
7416         }\r
7417         return _localctx;\r
7418     }\r
7419 \r
7420     public static class Status_argContext extends ParserRuleContext {\r
7421         public StringContext string() {\r
7422             return getRuleContext(StringContext.class, 0);\r
7423         }\r
7424 \r
7425         public Status_argContext(ParserRuleContext parent, int invokingState) {\r
7426             super(parent, invokingState);\r
7427         }\r
7428 \r
7429         @Override\r
7430         public int getRuleIndex() {\r
7431             return RULE_status_arg;\r
7432         }\r
7433 \r
7434         @Override\r
7435         public void enterRule(ParseTreeListener listener) {\r
7436             if (listener instanceof YangParserListener)\r
7437                 ((YangParserListener) listener).enterStatus_arg(this);\r
7438         }\r
7439 \r
7440         @Override\r
7441         public void exitRule(ParseTreeListener listener) {\r
7442             if (listener instanceof YangParserListener)\r
7443                 ((YangParserListener) listener).exitStatus_arg(this);\r
7444         }\r
7445 \r
7446         @Override\r
7447         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
7448             if (visitor instanceof YangParserVisitor)\r
7449                 return ((YangParserVisitor<? extends T>) visitor)\r
7450                         .visitStatus_arg(this);\r
7451             else\r
7452                 return visitor.visitChildren(this);\r
7453         }\r
7454     }\r
7455 \r
7456     public final Status_argContext status_arg() throws RecognitionException {\r
7457         Status_argContext _localctx = new Status_argContext(_ctx, getState());\r
7458         enterRule(_localctx, 102, RULE_status_arg);\r
7459         try {\r
7460             enterOuterAlt(_localctx, 1);\r
7461             {\r
7462                 setState(794);\r
7463                 string();\r
7464             }\r
7465         } catch (RecognitionException re) {\r
7466             _localctx.exception = re;\r
7467             _errHandler.reportError(this, re);\r
7468             _errHandler.recover(this, re);\r
7469         } finally {\r
7470             exitRule();\r
7471         }\r
7472         return _localctx;\r
7473     }\r
7474 \r
7475     public static class Status_stmtContext extends ParserRuleContext {\r
7476         public Status_argContext status_arg() {\r
7477             return getRuleContext(Status_argContext.class, 0);\r
7478         }\r
7479 \r
7480         public TerminalNode STATUS_KEYWORD() {\r
7481             return getToken(YangParser.STATUS_KEYWORD, 0);\r
7482         }\r
7483 \r
7484         public StmtendContext stmtend() {\r
7485             return getRuleContext(StmtendContext.class, 0);\r
7486         }\r
7487 \r
7488         public Status_stmtContext(ParserRuleContext parent, int invokingState) {\r
7489             super(parent, invokingState);\r
7490         }\r
7491 \r
7492         @Override\r
7493         public int getRuleIndex() {\r
7494             return RULE_status_stmt;\r
7495         }\r
7496 \r
7497         @Override\r
7498         public void enterRule(ParseTreeListener listener) {\r
7499             if (listener instanceof YangParserListener)\r
7500                 ((YangParserListener) listener).enterStatus_stmt(this);\r
7501         }\r
7502 \r
7503         @Override\r
7504         public void exitRule(ParseTreeListener listener) {\r
7505             if (listener instanceof YangParserListener)\r
7506                 ((YangParserListener) listener).exitStatus_stmt(this);\r
7507         }\r
7508 \r
7509         @Override\r
7510         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
7511             if (visitor instanceof YangParserVisitor)\r
7512                 return ((YangParserVisitor<? extends T>) visitor)\r
7513                         .visitStatus_stmt(this);\r
7514             else\r
7515                 return visitor.visitChildren(this);\r
7516         }\r
7517     }\r
7518 \r
7519     public final Status_stmtContext status_stmt() throws RecognitionException {\r
7520         Status_stmtContext _localctx = new Status_stmtContext(_ctx, getState());\r
7521         enterRule(_localctx, 104, RULE_status_stmt);\r
7522         try {\r
7523             enterOuterAlt(_localctx, 1);\r
7524             {\r
7525                 setState(796);\r
7526                 match(STATUS_KEYWORD);\r
7527                 setState(797);\r
7528                 status_arg();\r
7529                 setState(798);\r
7530                 stmtend();\r
7531             }\r
7532         } catch (RecognitionException re) {\r
7533             _localctx.exception = re;\r
7534             _errHandler.reportError(this, re);\r
7535             _errHandler.recover(this, re);\r
7536         } finally {\r
7537             exitRule();\r
7538         }\r
7539         return _localctx;\r
7540     }\r
7541 \r
7542     public static class Position_stmtContext extends ParserRuleContext {\r
7543         public TerminalNode POSITION_KEYWORD() {\r
7544             return getToken(YangParser.POSITION_KEYWORD, 0);\r
7545         }\r
7546 \r
7547         public StringContext string() {\r
7548             return getRuleContext(StringContext.class, 0);\r
7549         }\r
7550 \r
7551         public StmtendContext stmtend() {\r
7552             return getRuleContext(StmtendContext.class, 0);\r
7553         }\r
7554 \r
7555         public Position_stmtContext(ParserRuleContext parent, int invokingState) {\r
7556             super(parent, invokingState);\r
7557         }\r
7558 \r
7559         @Override\r
7560         public int getRuleIndex() {\r
7561             return RULE_position_stmt;\r
7562         }\r
7563 \r
7564         @Override\r
7565         public void enterRule(ParseTreeListener listener) {\r
7566             if (listener instanceof YangParserListener)\r
7567                 ((YangParserListener) listener).enterPosition_stmt(this);\r
7568         }\r
7569 \r
7570         @Override\r
7571         public void exitRule(ParseTreeListener listener) {\r
7572             if (listener instanceof YangParserListener)\r
7573                 ((YangParserListener) listener).exitPosition_stmt(this);\r
7574         }\r
7575 \r
7576         @Override\r
7577         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
7578             if (visitor instanceof YangParserVisitor)\r
7579                 return ((YangParserVisitor<? extends T>) visitor)\r
7580                         .visitPosition_stmt(this);\r
7581             else\r
7582                 return visitor.visitChildren(this);\r
7583         }\r
7584     }\r
7585 \r
7586     public final Position_stmtContext position_stmt()\r
7587             throws RecognitionException {\r
7588         Position_stmtContext _localctx = new Position_stmtContext(_ctx,\r
7589                 getState());\r
7590         enterRule(_localctx, 106, RULE_position_stmt);\r
7591         try {\r
7592             enterOuterAlt(_localctx, 1);\r
7593             {\r
7594                 setState(800);\r
7595                 match(POSITION_KEYWORD);\r
7596                 setState(801);\r
7597                 string();\r
7598                 setState(802);\r
7599                 stmtend();\r
7600             }\r
7601         } catch (RecognitionException re) {\r
7602             _localctx.exception = re;\r
7603             _errHandler.reportError(this, re);\r
7604             _errHandler.recover(this, re);\r
7605         } finally {\r
7606             exitRule();\r
7607         }\r
7608         return _localctx;\r
7609     }\r
7610 \r
7611     public static class Bit_stmtContext extends ParserRuleContext {\r
7612         public TerminalNode RIGHT_BRACE() {\r
7613             return getToken(YangParser.RIGHT_BRACE, 0);\r
7614         }\r
7615 \r
7616         public List<Reference_stmtContext> reference_stmt() {\r
7617             return getRuleContexts(Reference_stmtContext.class);\r
7618         }\r
7619 \r
7620         public Position_stmtContext position_stmt(int i) {\r
7621             return getRuleContext(Position_stmtContext.class, i);\r
7622         }\r
7623 \r
7624         public Description_stmtContext description_stmt(int i) {\r
7625             return getRuleContext(Description_stmtContext.class, i);\r
7626         }\r
7627 \r
7628         public List<Position_stmtContext> position_stmt() {\r
7629             return getRuleContexts(Position_stmtContext.class);\r
7630         }\r
7631 \r
7632         public TerminalNode LEFT_BRACE() {\r
7633             return getToken(YangParser.LEFT_BRACE, 0);\r
7634         }\r
7635 \r
7636         public Status_stmtContext status_stmt(int i) {\r
7637             return getRuleContext(Status_stmtContext.class, i);\r
7638         }\r
7639 \r
7640         public Identifier_stmtContext identifier_stmt(int i) {\r
7641             return getRuleContext(Identifier_stmtContext.class, i);\r
7642         }\r
7643 \r
7644         public TerminalNode SEMICOLON() {\r
7645             return getToken(YangParser.SEMICOLON, 0);\r
7646         }\r
7647 \r
7648         public List<Status_stmtContext> status_stmt() {\r
7649             return getRuleContexts(Status_stmtContext.class);\r
7650         }\r
7651 \r
7652         public StringContext string() {\r
7653             return getRuleContext(StringContext.class, 0);\r
7654         }\r
7655 \r
7656         public List<Identifier_stmtContext> identifier_stmt() {\r
7657             return getRuleContexts(Identifier_stmtContext.class);\r
7658         }\r
7659 \r
7660         public List<Description_stmtContext> description_stmt() {\r
7661             return getRuleContexts(Description_stmtContext.class);\r
7662         }\r
7663 \r
7664         public Reference_stmtContext reference_stmt(int i) {\r
7665             return getRuleContext(Reference_stmtContext.class, i);\r
7666         }\r
7667 \r
7668         public TerminalNode BIT_KEYWORD() {\r
7669             return getToken(YangParser.BIT_KEYWORD, 0);\r
7670         }\r
7671 \r
7672         public Bit_stmtContext(ParserRuleContext parent, int invokingState) {\r
7673             super(parent, invokingState);\r
7674         }\r
7675 \r
7676         @Override\r
7677         public int getRuleIndex() {\r
7678             return RULE_bit_stmt;\r
7679         }\r
7680 \r
7681         @Override\r
7682         public void enterRule(ParseTreeListener listener) {\r
7683             if (listener instanceof YangParserListener)\r
7684                 ((YangParserListener) listener).enterBit_stmt(this);\r
7685         }\r
7686 \r
7687         @Override\r
7688         public void exitRule(ParseTreeListener listener) {\r
7689             if (listener instanceof YangParserListener)\r
7690                 ((YangParserListener) listener).exitBit_stmt(this);\r
7691         }\r
7692 \r
7693         @Override\r
7694         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
7695             if (visitor instanceof YangParserVisitor)\r
7696                 return ((YangParserVisitor<? extends T>) visitor)\r
7697                         .visitBit_stmt(this);\r
7698             else\r
7699                 return visitor.visitChildren(this);\r
7700         }\r
7701     }\r
7702 \r
7703     public final Bit_stmtContext bit_stmt() throws RecognitionException {\r
7704         Bit_stmtContext _localctx = new Bit_stmtContext(_ctx, getState());\r
7705         enterRule(_localctx, 108, RULE_bit_stmt);\r
7706         int _la;\r
7707         try {\r
7708             enterOuterAlt(_localctx, 1);\r
7709             {\r
7710                 setState(804);\r
7711                 match(BIT_KEYWORD);\r
7712                 setState(805);\r
7713                 string();\r
7714                 setState(819);\r
7715                 switch (_input.LA(1)) {\r
7716                 case SEMICOLON: {\r
7717                     setState(806);\r
7718                     match(SEMICOLON);\r
7719                 }\r
7720                     break;\r
7721                 case LEFT_BRACE: {\r
7722                     {\r
7723                         setState(807);\r
7724                         match(LEFT_BRACE);\r
7725                         setState(815);\r
7726                         _errHandler.sync(this);\r
7727                         _la = _input.LA(1);\r
7728                         while (((((_la - 18)) & ~0x3f) == 0 && ((1L << (_la - 18)) & ((1L << (STATUS_KEYWORD - 18))\r
7729                                 | (1L << (REFERENCE_KEYWORD - 18))\r
7730                                 | (1L << (POSITION_KEYWORD - 18))\r
7731                                 | (1L << (DESCRIPTION_KEYWORD - 18)) | (1L << (IDENTIFIER - 18)))) != 0)) {\r
7732                             {\r
7733                                 setState(813);\r
7734                                 switch (_input.LA(1)) {\r
7735                                 case IDENTIFIER: {\r
7736                                     setState(808);\r
7737                                     identifier_stmt();\r
7738                                 }\r
7739                                     break;\r
7740                                 case POSITION_KEYWORD: {\r
7741                                     setState(809);\r
7742                                     position_stmt();\r
7743                                 }\r
7744                                     break;\r
7745                                 case STATUS_KEYWORD: {\r
7746                                     setState(810);\r
7747                                     status_stmt();\r
7748                                 }\r
7749                                     break;\r
7750                                 case DESCRIPTION_KEYWORD: {\r
7751                                     setState(811);\r
7752                                     description_stmt();\r
7753                                 }\r
7754                                     break;\r
7755                                 case REFERENCE_KEYWORD: {\r
7756                                     setState(812);\r
7757                                     reference_stmt();\r
7758                                 }\r
7759                                     break;\r
7760                                 default:\r
7761                                     throw new NoViableAltException(this);\r
7762                                 }\r
7763                             }\r
7764                             setState(817);\r
7765                             _errHandler.sync(this);\r
7766                             _la = _input.LA(1);\r
7767                         }\r
7768                         setState(818);\r
7769                         match(RIGHT_BRACE);\r
7770                     }\r
7771                 }\r
7772                     break;\r
7773                 default:\r
7774                     throw new NoViableAltException(this);\r
7775                 }\r
7776             }\r
7777         } catch (RecognitionException re) {\r
7778             _localctx.exception = re;\r
7779             _errHandler.reportError(this, re);\r
7780             _errHandler.recover(this, re);\r
7781         } finally {\r
7782             exitRule();\r
7783         }\r
7784         return _localctx;\r
7785     }\r
7786 \r
7787     public static class Bits_specificationContext extends ParserRuleContext {\r
7788         public Bit_stmtContext bit_stmt(int i) {\r
7789             return getRuleContext(Bit_stmtContext.class, i);\r
7790         }\r
7791 \r
7792         public List<Bit_stmtContext> bit_stmt() {\r
7793             return getRuleContexts(Bit_stmtContext.class);\r
7794         }\r
7795 \r
7796         public Bits_specificationContext(ParserRuleContext parent,\r
7797                 int invokingState) {\r
7798             super(parent, invokingState);\r
7799         }\r
7800 \r
7801         @Override\r
7802         public int getRuleIndex() {\r
7803             return RULE_bits_specification;\r
7804         }\r
7805 \r
7806         @Override\r
7807         public void enterRule(ParseTreeListener listener) {\r
7808             if (listener instanceof YangParserListener)\r
7809                 ((YangParserListener) listener).enterBits_specification(this);\r
7810         }\r
7811 \r
7812         @Override\r
7813         public void exitRule(ParseTreeListener listener) {\r
7814             if (listener instanceof YangParserListener)\r
7815                 ((YangParserListener) listener).exitBits_specification(this);\r
7816         }\r
7817 \r
7818         @Override\r
7819         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
7820             if (visitor instanceof YangParserVisitor)\r
7821                 return ((YangParserVisitor<? extends T>) visitor)\r
7822                         .visitBits_specification(this);\r
7823             else\r
7824                 return visitor.visitChildren(this);\r
7825         }\r
7826     }\r
7827 \r
7828     public final Bits_specificationContext bits_specification()\r
7829             throws RecognitionException {\r
7830         Bits_specificationContext _localctx = new Bits_specificationContext(\r
7831                 _ctx, getState());\r
7832         enterRule(_localctx, 110, RULE_bits_specification);\r
7833         int _la;\r
7834         try {\r
7835             enterOuterAlt(_localctx, 1);\r
7836             {\r
7837                 setState(822);\r
7838                 _errHandler.sync(this);\r
7839                 _la = _input.LA(1);\r
7840                 do {\r
7841                     {\r
7842                         {\r
7843                             setState(821);\r
7844                             bit_stmt();\r
7845                         }\r
7846                     }\r
7847                     setState(824);\r
7848                     _errHandler.sync(this);\r
7849                     _la = _input.LA(1);\r
7850                 } while (_la == BIT_KEYWORD);\r
7851             }\r
7852         } catch (RecognitionException re) {\r
7853             _localctx.exception = re;\r
7854             _errHandler.reportError(this, re);\r
7855             _errHandler.recover(this, re);\r
7856         } finally {\r
7857             exitRule();\r
7858         }\r
7859         return _localctx;\r
7860     }\r
7861 \r
7862     public static class Union_specificationContext extends ParserRuleContext {\r
7863         public Type_stmtContext type_stmt(int i) {\r
7864             return getRuleContext(Type_stmtContext.class, i);\r
7865         }\r
7866 \r
7867         public List<Type_stmtContext> type_stmt() {\r
7868             return getRuleContexts(Type_stmtContext.class);\r
7869         }\r
7870 \r
7871         public Union_specificationContext(ParserRuleContext parent,\r
7872                 int invokingState) {\r
7873             super(parent, invokingState);\r
7874         }\r
7875 \r
7876         @Override\r
7877         public int getRuleIndex() {\r
7878             return RULE_union_specification;\r
7879         }\r
7880 \r
7881         @Override\r
7882         public void enterRule(ParseTreeListener listener) {\r
7883             if (listener instanceof YangParserListener)\r
7884                 ((YangParserListener) listener).enterUnion_specification(this);\r
7885         }\r
7886 \r
7887         @Override\r
7888         public void exitRule(ParseTreeListener listener) {\r
7889             if (listener instanceof YangParserListener)\r
7890                 ((YangParserListener) listener).exitUnion_specification(this);\r
7891         }\r
7892 \r
7893         @Override\r
7894         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
7895             if (visitor instanceof YangParserVisitor)\r
7896                 return ((YangParserVisitor<? extends T>) visitor)\r
7897                         .visitUnion_specification(this);\r
7898             else\r
7899                 return visitor.visitChildren(this);\r
7900         }\r
7901     }\r
7902 \r
7903     public final Union_specificationContext union_specification()\r
7904             throws RecognitionException {\r
7905         Union_specificationContext _localctx = new Union_specificationContext(\r
7906                 _ctx, getState());\r
7907         enterRule(_localctx, 112, RULE_union_specification);\r
7908         int _la;\r
7909         try {\r
7910             enterOuterAlt(_localctx, 1);\r
7911             {\r
7912                 setState(827);\r
7913                 _errHandler.sync(this);\r
7914                 _la = _input.LA(1);\r
7915                 do {\r
7916                     {\r
7917                         {\r
7918                             setState(826);\r
7919                             type_stmt();\r
7920                         }\r
7921                     }\r
7922                     setState(829);\r
7923                     _errHandler.sync(this);\r
7924                     _la = _input.LA(1);\r
7925                 } while (_la == TYPE_KEYWORD);\r
7926             }\r
7927         } catch (RecognitionException re) {\r
7928             _localctx.exception = re;\r
7929             _errHandler.reportError(this, re);\r
7930             _errHandler.recover(this, re);\r
7931         } finally {\r
7932             exitRule();\r
7933         }\r
7934         return _localctx;\r
7935     }\r
7936 \r
7937     public static class Identityref_specificationContext extends\r
7938             ParserRuleContext {\r
7939         public Base_stmtContext base_stmt() {\r
7940             return getRuleContext(Base_stmtContext.class, 0);\r
7941         }\r
7942 \r
7943         public Identityref_specificationContext(ParserRuleContext parent,\r
7944                 int invokingState) {\r
7945             super(parent, invokingState);\r
7946         }\r
7947 \r
7948         @Override\r
7949         public int getRuleIndex() {\r
7950             return RULE_identityref_specification;\r
7951         }\r
7952 \r
7953         @Override\r
7954         public void enterRule(ParseTreeListener listener) {\r
7955             if (listener instanceof YangParserListener)\r
7956                 ((YangParserListener) listener)\r
7957                         .enterIdentityref_specification(this);\r
7958         }\r
7959 \r
7960         @Override\r
7961         public void exitRule(ParseTreeListener listener) {\r
7962             if (listener instanceof YangParserListener)\r
7963                 ((YangParserListener) listener)\r
7964                         .exitIdentityref_specification(this);\r
7965         }\r
7966 \r
7967         @Override\r
7968         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
7969             if (visitor instanceof YangParserVisitor)\r
7970                 return ((YangParserVisitor<? extends T>) visitor)\r
7971                         .visitIdentityref_specification(this);\r
7972             else\r
7973                 return visitor.visitChildren(this);\r
7974         }\r
7975     }\r
7976 \r
7977     public final Identityref_specificationContext identityref_specification()\r
7978             throws RecognitionException {\r
7979         Identityref_specificationContext _localctx = new Identityref_specificationContext(\r
7980                 _ctx, getState());\r
7981         enterRule(_localctx, 114, RULE_identityref_specification);\r
7982         try {\r
7983             enterOuterAlt(_localctx, 1);\r
7984             {\r
7985                 setState(831);\r
7986                 base_stmt();\r
7987             }\r
7988         } catch (RecognitionException re) {\r
7989             _localctx.exception = re;\r
7990             _errHandler.reportError(this, re);\r
7991             _errHandler.recover(this, re);\r
7992         } finally {\r
7993             exitRule();\r
7994         }\r
7995         return _localctx;\r
7996     }\r
7997 \r
7998     public static class Instance_identifier_specificationContext extends\r
7999             ParserRuleContext {\r
8000         public Require_instance_stmtContext require_instance_stmt() {\r
8001             return getRuleContext(Require_instance_stmtContext.class, 0);\r
8002         }\r
8003 \r
8004         public Instance_identifier_specificationContext(\r
8005                 ParserRuleContext parent, int invokingState) {\r
8006             super(parent, invokingState);\r
8007         }\r
8008 \r
8009         @Override\r
8010         public int getRuleIndex() {\r
8011             return RULE_instance_identifier_specification;\r
8012         }\r
8013 \r
8014         @Override\r
8015         public void enterRule(ParseTreeListener listener) {\r
8016             if (listener instanceof YangParserListener)\r
8017                 ((YangParserListener) listener)\r
8018                         .enterInstance_identifier_specification(this);\r
8019         }\r
8020 \r
8021         @Override\r
8022         public void exitRule(ParseTreeListener listener) {\r
8023             if (listener instanceof YangParserListener)\r
8024                 ((YangParserListener) listener)\r
8025                         .exitInstance_identifier_specification(this);\r
8026         }\r
8027 \r
8028         @Override\r
8029         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
8030             if (visitor instanceof YangParserVisitor)\r
8031                 return ((YangParserVisitor<? extends T>) visitor)\r
8032                         .visitInstance_identifier_specification(this);\r
8033             else\r
8034                 return visitor.visitChildren(this);\r
8035         }\r
8036     }\r
8037 \r
8038     public final Instance_identifier_specificationContext instance_identifier_specification()\r
8039             throws RecognitionException {\r
8040         Instance_identifier_specificationContext _localctx = new Instance_identifier_specificationContext(\r
8041                 _ctx, getState());\r
8042         enterRule(_localctx, 116, RULE_instance_identifier_specification);\r
8043         int _la;\r
8044         try {\r
8045             enterOuterAlt(_localctx, 1);\r
8046             {\r
8047                 setState(834);\r
8048                 _la = _input.LA(1);\r
8049                 if (_la == REQUIRE_INSTANCE_KEYWORD) {\r
8050                     {\r
8051                         setState(833);\r
8052                         require_instance_stmt();\r
8053                     }\r
8054                 }\r
8055 \r
8056             }\r
8057         } catch (RecognitionException re) {\r
8058             _localctx.exception = re;\r
8059             _errHandler.reportError(this, re);\r
8060             _errHandler.recover(this, re);\r
8061         } finally {\r
8062             exitRule();\r
8063         }\r
8064         return _localctx;\r
8065     }\r
8066 \r
8067     public static class Require_instance_argContext extends ParserRuleContext {\r
8068         public StringContext string() {\r
8069             return getRuleContext(StringContext.class, 0);\r
8070         }\r
8071 \r
8072         public Require_instance_argContext(ParserRuleContext parent,\r
8073                 int invokingState) {\r
8074             super(parent, invokingState);\r
8075         }\r
8076 \r
8077         @Override\r
8078         public int getRuleIndex() {\r
8079             return RULE_require_instance_arg;\r
8080         }\r
8081 \r
8082         @Override\r
8083         public void enterRule(ParseTreeListener listener) {\r
8084             if (listener instanceof YangParserListener)\r
8085                 ((YangParserListener) listener).enterRequire_instance_arg(this);\r
8086         }\r
8087 \r
8088         @Override\r
8089         public void exitRule(ParseTreeListener listener) {\r
8090             if (listener instanceof YangParserListener)\r
8091                 ((YangParserListener) listener).exitRequire_instance_arg(this);\r
8092         }\r
8093 \r
8094         @Override\r
8095         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
8096             if (visitor instanceof YangParserVisitor)\r
8097                 return ((YangParserVisitor<? extends T>) visitor)\r
8098                         .visitRequire_instance_arg(this);\r
8099             else\r
8100                 return visitor.visitChildren(this);\r
8101         }\r
8102     }\r
8103 \r
8104     public final Require_instance_argContext require_instance_arg()\r
8105             throws RecognitionException {\r
8106         Require_instance_argContext _localctx = new Require_instance_argContext(\r
8107                 _ctx, getState());\r
8108         enterRule(_localctx, 118, RULE_require_instance_arg);\r
8109         try {\r
8110             enterOuterAlt(_localctx, 1);\r
8111             {\r
8112                 setState(836);\r
8113                 string();\r
8114             }\r
8115         } catch (RecognitionException re) {\r
8116             _localctx.exception = re;\r
8117             _errHandler.reportError(this, re);\r
8118             _errHandler.recover(this, re);\r
8119         } finally {\r
8120             exitRule();\r
8121         }\r
8122         return _localctx;\r
8123     }\r
8124 \r
8125     public static class Require_instance_stmtContext extends ParserRuleContext {\r
8126         public Require_instance_argContext require_instance_arg() {\r
8127             return getRuleContext(Require_instance_argContext.class, 0);\r
8128         }\r
8129 \r
8130         public TerminalNode REQUIRE_INSTANCE_KEYWORD() {\r
8131             return getToken(YangParser.REQUIRE_INSTANCE_KEYWORD, 0);\r
8132         }\r
8133 \r
8134         public StmtendContext stmtend() {\r
8135             return getRuleContext(StmtendContext.class, 0);\r
8136         }\r
8137 \r
8138         public Require_instance_stmtContext(ParserRuleContext parent,\r
8139                 int invokingState) {\r
8140             super(parent, invokingState);\r
8141         }\r
8142 \r
8143         @Override\r
8144         public int getRuleIndex() {\r
8145             return RULE_require_instance_stmt;\r
8146         }\r
8147 \r
8148         @Override\r
8149         public void enterRule(ParseTreeListener listener) {\r
8150             if (listener instanceof YangParserListener)\r
8151                 ((YangParserListener) listener)\r
8152                         .enterRequire_instance_stmt(this);\r
8153         }\r
8154 \r
8155         @Override\r
8156         public void exitRule(ParseTreeListener listener) {\r
8157             if (listener instanceof YangParserListener)\r
8158                 ((YangParserListener) listener).exitRequire_instance_stmt(this);\r
8159         }\r
8160 \r
8161         @Override\r
8162         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
8163             if (visitor instanceof YangParserVisitor)\r
8164                 return ((YangParserVisitor<? extends T>) visitor)\r
8165                         .visitRequire_instance_stmt(this);\r
8166             else\r
8167                 return visitor.visitChildren(this);\r
8168         }\r
8169     }\r
8170 \r
8171     public final Require_instance_stmtContext require_instance_stmt()\r
8172             throws RecognitionException {\r
8173         Require_instance_stmtContext _localctx = new Require_instance_stmtContext(\r
8174                 _ctx, getState());\r
8175         enterRule(_localctx, 120, RULE_require_instance_stmt);\r
8176         try {\r
8177             enterOuterAlt(_localctx, 1);\r
8178             {\r
8179                 setState(838);\r
8180                 match(REQUIRE_INSTANCE_KEYWORD);\r
8181                 setState(839);\r
8182                 require_instance_arg();\r
8183                 setState(840);\r
8184                 stmtend();\r
8185             }\r
8186         } catch (RecognitionException re) {\r
8187             _localctx.exception = re;\r
8188             _errHandler.reportError(this, re);\r
8189             _errHandler.recover(this, re);\r
8190         } finally {\r
8191             exitRule();\r
8192         }\r
8193         return _localctx;\r
8194     }\r
8195 \r
8196     public static class Path_stmtContext extends ParserRuleContext {\r
8197         public TerminalNode PATH_KEYWORD() {\r
8198             return getToken(YangParser.PATH_KEYWORD, 0);\r
8199         }\r
8200 \r
8201         public StringContext string() {\r
8202             return getRuleContext(StringContext.class, 0);\r
8203         }\r
8204 \r
8205         public StmtendContext stmtend() {\r
8206             return getRuleContext(StmtendContext.class, 0);\r
8207         }\r
8208 \r
8209         public Path_stmtContext(ParserRuleContext parent, int invokingState) {\r
8210             super(parent, invokingState);\r
8211         }\r
8212 \r
8213         @Override\r
8214         public int getRuleIndex() {\r
8215             return RULE_path_stmt;\r
8216         }\r
8217 \r
8218         @Override\r
8219         public void enterRule(ParseTreeListener listener) {\r
8220             if (listener instanceof YangParserListener)\r
8221                 ((YangParserListener) listener).enterPath_stmt(this);\r
8222         }\r
8223 \r
8224         @Override\r
8225         public void exitRule(ParseTreeListener listener) {\r
8226             if (listener instanceof YangParserListener)\r
8227                 ((YangParserListener) listener).exitPath_stmt(this);\r
8228         }\r
8229 \r
8230         @Override\r
8231         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
8232             if (visitor instanceof YangParserVisitor)\r
8233                 return ((YangParserVisitor<? extends T>) visitor)\r
8234                         .visitPath_stmt(this);\r
8235             else\r
8236                 return visitor.visitChildren(this);\r
8237         }\r
8238     }\r
8239 \r
8240     public final Path_stmtContext path_stmt() throws RecognitionException {\r
8241         Path_stmtContext _localctx = new Path_stmtContext(_ctx, getState());\r
8242         enterRule(_localctx, 122, RULE_path_stmt);\r
8243         try {\r
8244             enterOuterAlt(_localctx, 1);\r
8245             {\r
8246                 setState(842);\r
8247                 match(PATH_KEYWORD);\r
8248                 setState(843);\r
8249                 string();\r
8250                 setState(844);\r
8251                 stmtend();\r
8252             }\r
8253         } catch (RecognitionException re) {\r
8254             _localctx.exception = re;\r
8255             _errHandler.reportError(this, re);\r
8256             _errHandler.recover(this, re);\r
8257         } finally {\r
8258             exitRule();\r
8259         }\r
8260         return _localctx;\r
8261     }\r
8262 \r
8263     public static class Leafref_specificationContext extends ParserRuleContext {\r
8264         public Path_stmtContext path_stmt() {\r
8265             return getRuleContext(Path_stmtContext.class, 0);\r
8266         }\r
8267 \r
8268         public Leafref_specificationContext(ParserRuleContext parent,\r
8269                 int invokingState) {\r
8270             super(parent, invokingState);\r
8271         }\r
8272 \r
8273         @Override\r
8274         public int getRuleIndex() {\r
8275             return RULE_leafref_specification;\r
8276         }\r
8277 \r
8278         @Override\r
8279         public void enterRule(ParseTreeListener listener) {\r
8280             if (listener instanceof YangParserListener)\r
8281                 ((YangParserListener) listener)\r
8282                         .enterLeafref_specification(this);\r
8283         }\r
8284 \r
8285         @Override\r
8286         public void exitRule(ParseTreeListener listener) {\r
8287             if (listener instanceof YangParserListener)\r
8288                 ((YangParserListener) listener).exitLeafref_specification(this);\r
8289         }\r
8290 \r
8291         @Override\r
8292         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
8293             if (visitor instanceof YangParserVisitor)\r
8294                 return ((YangParserVisitor<? extends T>) visitor)\r
8295                         .visitLeafref_specification(this);\r
8296             else\r
8297                 return visitor.visitChildren(this);\r
8298         }\r
8299     }\r
8300 \r
8301     public final Leafref_specificationContext leafref_specification()\r
8302             throws RecognitionException {\r
8303         Leafref_specificationContext _localctx = new Leafref_specificationContext(\r
8304                 _ctx, getState());\r
8305         enterRule(_localctx, 124, RULE_leafref_specification);\r
8306         try {\r
8307             enterOuterAlt(_localctx, 1);\r
8308             {\r
8309                 setState(846);\r
8310                 path_stmt();\r
8311             }\r
8312         } catch (RecognitionException re) {\r
8313             _localctx.exception = re;\r
8314             _errHandler.reportError(this, re);\r
8315             _errHandler.recover(this, re);\r
8316         } finally {\r
8317             exitRule();\r
8318         }\r
8319         return _localctx;\r
8320     }\r
8321 \r
8322     public static class Enum_stmtContext extends ParserRuleContext {\r
8323         public TerminalNode RIGHT_BRACE() {\r
8324             return getToken(YangParser.RIGHT_BRACE, 0);\r
8325         }\r
8326 \r
8327         public List<Reference_stmtContext> reference_stmt() {\r
8328             return getRuleContexts(Reference_stmtContext.class);\r
8329         }\r
8330 \r
8331         public Description_stmtContext description_stmt(int i) {\r
8332             return getRuleContext(Description_stmtContext.class, i);\r
8333         }\r
8334 \r
8335         public TerminalNode LEFT_BRACE() {\r
8336             return getToken(YangParser.LEFT_BRACE, 0);\r
8337         }\r
8338 \r
8339         public Status_stmtContext status_stmt(int i) {\r
8340             return getRuleContext(Status_stmtContext.class, i);\r
8341         }\r
8342 \r
8343         public Value_stmtContext value_stmt(int i) {\r
8344             return getRuleContext(Value_stmtContext.class, i);\r
8345         }\r
8346 \r
8347         public List<Value_stmtContext> value_stmt() {\r
8348             return getRuleContexts(Value_stmtContext.class);\r
8349         }\r
8350 \r
8351         public TerminalNode ENUM_KEYWORD() {\r
8352             return getToken(YangParser.ENUM_KEYWORD, 0);\r
8353         }\r
8354 \r
8355         public Identifier_stmtContext identifier_stmt(int i) {\r
8356             return getRuleContext(Identifier_stmtContext.class, i);\r
8357         }\r
8358 \r
8359         public TerminalNode SEMICOLON() {\r
8360             return getToken(YangParser.SEMICOLON, 0);\r
8361         }\r
8362 \r
8363         public List<Status_stmtContext> status_stmt() {\r
8364             return getRuleContexts(Status_stmtContext.class);\r
8365         }\r
8366 \r
8367         public StringContext string() {\r
8368             return getRuleContext(StringContext.class, 0);\r
8369         }\r
8370 \r
8371         public List<Identifier_stmtContext> identifier_stmt() {\r
8372             return getRuleContexts(Identifier_stmtContext.class);\r
8373         }\r
8374 \r
8375         public List<Description_stmtContext> description_stmt() {\r
8376             return getRuleContexts(Description_stmtContext.class);\r
8377         }\r
8378 \r
8379         public Reference_stmtContext reference_stmt(int i) {\r
8380             return getRuleContext(Reference_stmtContext.class, i);\r
8381         }\r
8382 \r
8383         public Enum_stmtContext(ParserRuleContext parent, int invokingState) {\r
8384             super(parent, invokingState);\r
8385         }\r
8386 \r
8387         @Override\r
8388         public int getRuleIndex() {\r
8389             return RULE_enum_stmt;\r
8390         }\r
8391 \r
8392         @Override\r
8393         public void enterRule(ParseTreeListener listener) {\r
8394             if (listener instanceof YangParserListener)\r
8395                 ((YangParserListener) listener).enterEnum_stmt(this);\r
8396         }\r
8397 \r
8398         @Override\r
8399         public void exitRule(ParseTreeListener listener) {\r
8400             if (listener instanceof YangParserListener)\r
8401                 ((YangParserListener) listener).exitEnum_stmt(this);\r
8402         }\r
8403 \r
8404         @Override\r
8405         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
8406             if (visitor instanceof YangParserVisitor)\r
8407                 return ((YangParserVisitor<? extends T>) visitor)\r
8408                         .visitEnum_stmt(this);\r
8409             else\r
8410                 return visitor.visitChildren(this);\r
8411         }\r
8412     }\r
8413 \r
8414     public final Enum_stmtContext enum_stmt() throws RecognitionException {\r
8415         Enum_stmtContext _localctx = new Enum_stmtContext(_ctx, getState());\r
8416         enterRule(_localctx, 126, RULE_enum_stmt);\r
8417         int _la;\r
8418         try {\r
8419             enterOuterAlt(_localctx, 1);\r
8420             {\r
8421                 setState(848);\r
8422                 match(ENUM_KEYWORD);\r
8423                 setState(849);\r
8424                 string();\r
8425                 setState(863);\r
8426                 switch (_input.LA(1)) {\r
8427                 case SEMICOLON: {\r
8428                     setState(850);\r
8429                     match(SEMICOLON);\r
8430                 }\r
8431                     break;\r
8432                 case LEFT_BRACE: {\r
8433                     {\r
8434                         setState(851);\r
8435                         match(LEFT_BRACE);\r
8436                         setState(859);\r
8437                         _errHandler.sync(this);\r
8438                         _la = _input.LA(1);\r
8439                         while (((((_la - 11)) & ~0x3f) == 0 && ((1L << (_la - 11)) & ((1L << (VALUE_KEYWORD - 11))\r
8440                                 | (1L << (STATUS_KEYWORD - 11))\r
8441                                 | (1L << (REFERENCE_KEYWORD - 11))\r
8442                                 | (1L << (DESCRIPTION_KEYWORD - 11)) | (1L << (IDENTIFIER - 11)))) != 0)) {\r
8443                             {\r
8444                                 setState(857);\r
8445                                 switch (_input.LA(1)) {\r
8446                                 case IDENTIFIER: {\r
8447                                     setState(852);\r
8448                                     identifier_stmt();\r
8449                                 }\r
8450                                     break;\r
8451                                 case VALUE_KEYWORD: {\r
8452                                     setState(853);\r
8453                                     value_stmt();\r
8454                                 }\r
8455                                     break;\r
8456                                 case STATUS_KEYWORD: {\r
8457                                     setState(854);\r
8458                                     status_stmt();\r
8459                                 }\r
8460                                     break;\r
8461                                 case DESCRIPTION_KEYWORD: {\r
8462                                     setState(855);\r
8463                                     description_stmt();\r
8464                                 }\r
8465                                     break;\r
8466                                 case REFERENCE_KEYWORD: {\r
8467                                     setState(856);\r
8468                                     reference_stmt();\r
8469                                 }\r
8470                                     break;\r
8471                                 default:\r
8472                                     throw new NoViableAltException(this);\r
8473                                 }\r
8474                             }\r
8475                             setState(861);\r
8476                             _errHandler.sync(this);\r
8477                             _la = _input.LA(1);\r
8478                         }\r
8479                         setState(862);\r
8480                         match(RIGHT_BRACE);\r
8481                     }\r
8482                 }\r
8483                     break;\r
8484                 default:\r
8485                     throw new NoViableAltException(this);\r
8486                 }\r
8487             }\r
8488         } catch (RecognitionException re) {\r
8489             _localctx.exception = re;\r
8490             _errHandler.reportError(this, re);\r
8491             _errHandler.recover(this, re);\r
8492         } finally {\r
8493             exitRule();\r
8494         }\r
8495         return _localctx;\r
8496     }\r
8497 \r
8498     public static class Enum_specificationContext extends ParserRuleContext {\r
8499         public List<Enum_stmtContext> enum_stmt() {\r
8500             return getRuleContexts(Enum_stmtContext.class);\r
8501         }\r
8502 \r
8503         public Enum_stmtContext enum_stmt(int i) {\r
8504             return getRuleContext(Enum_stmtContext.class, i);\r
8505         }\r
8506 \r
8507         public Enum_specificationContext(ParserRuleContext parent,\r
8508                 int invokingState) {\r
8509             super(parent, invokingState);\r
8510         }\r
8511 \r
8512         @Override\r
8513         public int getRuleIndex() {\r
8514             return RULE_enum_specification;\r
8515         }\r
8516 \r
8517         @Override\r
8518         public void enterRule(ParseTreeListener listener) {\r
8519             if (listener instanceof YangParserListener)\r
8520                 ((YangParserListener) listener).enterEnum_specification(this);\r
8521         }\r
8522 \r
8523         @Override\r
8524         public void exitRule(ParseTreeListener listener) {\r
8525             if (listener instanceof YangParserListener)\r
8526                 ((YangParserListener) listener).exitEnum_specification(this);\r
8527         }\r
8528 \r
8529         @Override\r
8530         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
8531             if (visitor instanceof YangParserVisitor)\r
8532                 return ((YangParserVisitor<? extends T>) visitor)\r
8533                         .visitEnum_specification(this);\r
8534             else\r
8535                 return visitor.visitChildren(this);\r
8536         }\r
8537     }\r
8538 \r
8539     public final Enum_specificationContext enum_specification()\r
8540             throws RecognitionException {\r
8541         Enum_specificationContext _localctx = new Enum_specificationContext(\r
8542                 _ctx, getState());\r
8543         enterRule(_localctx, 128, RULE_enum_specification);\r
8544         int _la;\r
8545         try {\r
8546             enterOuterAlt(_localctx, 1);\r
8547             {\r
8548                 setState(866);\r
8549                 _errHandler.sync(this);\r
8550                 _la = _input.LA(1);\r
8551                 do {\r
8552                     {\r
8553                         {\r
8554                             setState(865);\r
8555                             enum_stmt();\r
8556                         }\r
8557                     }\r
8558                     setState(868);\r
8559                     _errHandler.sync(this);\r
8560                     _la = _input.LA(1);\r
8561                 } while (_la == ENUM_KEYWORD);\r
8562             }\r
8563         } catch (RecognitionException re) {\r
8564             _localctx.exception = re;\r
8565             _errHandler.reportError(this, re);\r
8566             _errHandler.recover(this, re);\r
8567         } finally {\r
8568             exitRule();\r
8569         }\r
8570         return _localctx;\r
8571     }\r
8572 \r
8573     public static class Default_stmtContext extends ParserRuleContext {\r
8574         public StringContext string() {\r
8575             return getRuleContext(StringContext.class, 0);\r
8576         }\r
8577 \r
8578         public StmtendContext stmtend() {\r
8579             return getRuleContext(StmtendContext.class, 0);\r
8580         }\r
8581 \r
8582         public TerminalNode DEFAULT_KEYWORD() {\r
8583             return getToken(YangParser.DEFAULT_KEYWORD, 0);\r
8584         }\r
8585 \r
8586         public Default_stmtContext(ParserRuleContext parent, int invokingState) {\r
8587             super(parent, invokingState);\r
8588         }\r
8589 \r
8590         @Override\r
8591         public int getRuleIndex() {\r
8592             return RULE_default_stmt;\r
8593         }\r
8594 \r
8595         @Override\r
8596         public void enterRule(ParseTreeListener listener) {\r
8597             if (listener instanceof YangParserListener)\r
8598                 ((YangParserListener) listener).enterDefault_stmt(this);\r
8599         }\r
8600 \r
8601         @Override\r
8602         public void exitRule(ParseTreeListener listener) {\r
8603             if (listener instanceof YangParserListener)\r
8604                 ((YangParserListener) listener).exitDefault_stmt(this);\r
8605         }\r
8606 \r
8607         @Override\r
8608         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
8609             if (visitor instanceof YangParserVisitor)\r
8610                 return ((YangParserVisitor<? extends T>) visitor)\r
8611                         .visitDefault_stmt(this);\r
8612             else\r
8613                 return visitor.visitChildren(this);\r
8614         }\r
8615     }\r
8616 \r
8617     public final Default_stmtContext default_stmt() throws RecognitionException {\r
8618         Default_stmtContext _localctx = new Default_stmtContext(_ctx,\r
8619                 getState());\r
8620         enterRule(_localctx, 130, RULE_default_stmt);\r
8621         try {\r
8622             enterOuterAlt(_localctx, 1);\r
8623             {\r
8624                 setState(870);\r
8625                 match(DEFAULT_KEYWORD);\r
8626                 setState(871);\r
8627                 string();\r
8628                 setState(872);\r
8629                 stmtend();\r
8630             }\r
8631         } catch (RecognitionException re) {\r
8632             _localctx.exception = re;\r
8633             _errHandler.reportError(this, re);\r
8634             _errHandler.recover(this, re);\r
8635         } finally {\r
8636             exitRule();\r
8637         }\r
8638         return _localctx;\r
8639     }\r
8640 \r
8641     public static class Pattern_stmtContext extends ParserRuleContext {\r
8642         public TerminalNode RIGHT_BRACE() {\r
8643             return getToken(YangParser.RIGHT_BRACE, 0);\r
8644         }\r
8645 \r
8646         public List<Reference_stmtContext> reference_stmt() {\r
8647             return getRuleContexts(Reference_stmtContext.class);\r
8648         }\r
8649 \r
8650         public Description_stmtContext description_stmt(int i) {\r
8651             return getRuleContext(Description_stmtContext.class, i);\r
8652         }\r
8653 \r
8654         public TerminalNode LEFT_BRACE() {\r
8655             return getToken(YangParser.LEFT_BRACE, 0);\r
8656         }\r
8657 \r
8658         public List<Error_app_tag_stmtContext> error_app_tag_stmt() {\r
8659             return getRuleContexts(Error_app_tag_stmtContext.class);\r
8660         }\r
8661 \r
8662         public Error_message_stmtContext error_message_stmt(int i) {\r
8663             return getRuleContext(Error_message_stmtContext.class, i);\r
8664         }\r
8665 \r
8666         public Identifier_stmtContext identifier_stmt(int i) {\r
8667             return getRuleContext(Identifier_stmtContext.class, i);\r
8668         }\r
8669 \r
8670         public TerminalNode PATTERN_KEYWORD() {\r
8671             return getToken(YangParser.PATTERN_KEYWORD, 0);\r
8672         }\r
8673 \r
8674         public TerminalNode SEMICOLON() {\r
8675             return getToken(YangParser.SEMICOLON, 0);\r
8676         }\r
8677 \r
8678         public StringContext string() {\r
8679             return getRuleContext(StringContext.class, 0);\r
8680         }\r
8681 \r
8682         public List<Identifier_stmtContext> identifier_stmt() {\r
8683             return getRuleContexts(Identifier_stmtContext.class);\r
8684         }\r
8685 \r
8686         public Error_app_tag_stmtContext error_app_tag_stmt(int i) {\r
8687             return getRuleContext(Error_app_tag_stmtContext.class, i);\r
8688         }\r
8689 \r
8690         public List<Error_message_stmtContext> error_message_stmt() {\r
8691             return getRuleContexts(Error_message_stmtContext.class);\r
8692         }\r
8693 \r
8694         public List<Description_stmtContext> description_stmt() {\r
8695             return getRuleContexts(Description_stmtContext.class);\r
8696         }\r
8697 \r
8698         public Reference_stmtContext reference_stmt(int i) {\r
8699             return getRuleContext(Reference_stmtContext.class, i);\r
8700         }\r
8701 \r
8702         public Pattern_stmtContext(ParserRuleContext parent, int invokingState) {\r
8703             super(parent, invokingState);\r
8704         }\r
8705 \r
8706         @Override\r
8707         public int getRuleIndex() {\r
8708             return RULE_pattern_stmt;\r
8709         }\r
8710 \r
8711         @Override\r
8712         public void enterRule(ParseTreeListener listener) {\r
8713             if (listener instanceof YangParserListener)\r
8714                 ((YangParserListener) listener).enterPattern_stmt(this);\r
8715         }\r
8716 \r
8717         @Override\r
8718         public void exitRule(ParseTreeListener listener) {\r
8719             if (listener instanceof YangParserListener)\r
8720                 ((YangParserListener) listener).exitPattern_stmt(this);\r
8721         }\r
8722 \r
8723         @Override\r
8724         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
8725             if (visitor instanceof YangParserVisitor)\r
8726                 return ((YangParserVisitor<? extends T>) visitor)\r
8727                         .visitPattern_stmt(this);\r
8728             else\r
8729                 return visitor.visitChildren(this);\r
8730         }\r
8731     }\r
8732 \r
8733     public final Pattern_stmtContext pattern_stmt() throws RecognitionException {\r
8734         Pattern_stmtContext _localctx = new Pattern_stmtContext(_ctx,\r
8735                 getState());\r
8736         enterRule(_localctx, 132, RULE_pattern_stmt);\r
8737         int _la;\r
8738         try {\r
8739             enterOuterAlt(_localctx, 1);\r
8740             {\r
8741                 setState(874);\r
8742                 match(PATTERN_KEYWORD);\r
8743                 setState(875);\r
8744                 string();\r
8745                 setState(889);\r
8746                 switch (_input.LA(1)) {\r
8747                 case SEMICOLON: {\r
8748                     setState(876);\r
8749                     match(SEMICOLON);\r
8750                 }\r
8751                     break;\r
8752                 case LEFT_BRACE: {\r
8753                     {\r
8754                         setState(877);\r
8755                         match(LEFT_BRACE);\r
8756                         setState(885);\r
8757                         _errHandler.sync(this);\r
8758                         _la = _input.LA(1);\r
8759                         while (((((_la - 24)) & ~0x3f) == 0 && ((1L << (_la - 24)) & ((1L << (REFERENCE_KEYWORD - 24))\r
8760                                 | (1L << (ERROR_MESSAGE_KEYWORD - 24))\r
8761                                 | (1L << (ERROR_APP_TAG_KEYWORD - 24))\r
8762                                 | (1L << (DESCRIPTION_KEYWORD - 24)) | (1L << (IDENTIFIER - 24)))) != 0)) {\r
8763                             {\r
8764                                 setState(883);\r
8765                                 switch (_input.LA(1)) {\r
8766                                 case IDENTIFIER: {\r
8767                                     setState(878);\r
8768                                     identifier_stmt();\r
8769                                 }\r
8770                                     break;\r
8771                                 case ERROR_MESSAGE_KEYWORD: {\r
8772                                     setState(879);\r
8773                                     error_message_stmt();\r
8774                                 }\r
8775                                     break;\r
8776                                 case ERROR_APP_TAG_KEYWORD: {\r
8777                                     setState(880);\r
8778                                     error_app_tag_stmt();\r
8779                                 }\r
8780                                     break;\r
8781                                 case DESCRIPTION_KEYWORD: {\r
8782                                     setState(881);\r
8783                                     description_stmt();\r
8784                                 }\r
8785                                     break;\r
8786                                 case REFERENCE_KEYWORD: {\r
8787                                     setState(882);\r
8788                                     reference_stmt();\r
8789                                 }\r
8790                                     break;\r
8791                                 default:\r
8792                                     throw new NoViableAltException(this);\r
8793                                 }\r
8794                             }\r
8795                             setState(887);\r
8796                             _errHandler.sync(this);\r
8797                             _la = _input.LA(1);\r
8798                         }\r
8799                         setState(888);\r
8800                         match(RIGHT_BRACE);\r
8801                     }\r
8802                 }\r
8803                     break;\r
8804                 default:\r
8805                     throw new NoViableAltException(this);\r
8806                 }\r
8807             }\r
8808         } catch (RecognitionException re) {\r
8809             _localctx.exception = re;\r
8810             _errHandler.reportError(this, re);\r
8811             _errHandler.recover(this, re);\r
8812         } finally {\r
8813             exitRule();\r
8814         }\r
8815         return _localctx;\r
8816     }\r
8817 \r
8818     public static class Length_stmtContext extends ParserRuleContext {\r
8819         public TerminalNode RIGHT_BRACE() {\r
8820             return getToken(YangParser.RIGHT_BRACE, 0);\r
8821         }\r
8822 \r
8823         public List<Reference_stmtContext> reference_stmt() {\r
8824             return getRuleContexts(Reference_stmtContext.class);\r
8825         }\r
8826 \r
8827         public Description_stmtContext description_stmt(int i) {\r
8828             return getRuleContext(Description_stmtContext.class, i);\r
8829         }\r
8830 \r
8831         public TerminalNode LEFT_BRACE() {\r
8832             return getToken(YangParser.LEFT_BRACE, 0);\r
8833         }\r
8834 \r
8835         public List<Error_app_tag_stmtContext> error_app_tag_stmt() {\r
8836             return getRuleContexts(Error_app_tag_stmtContext.class);\r
8837         }\r
8838 \r
8839         public Error_message_stmtContext error_message_stmt(int i) {\r
8840             return getRuleContext(Error_message_stmtContext.class, i);\r
8841         }\r
8842 \r
8843         public Identifier_stmtContext identifier_stmt(int i) {\r
8844             return getRuleContext(Identifier_stmtContext.class, i);\r
8845         }\r
8846 \r
8847         public TerminalNode SEMICOLON() {\r
8848             return getToken(YangParser.SEMICOLON, 0);\r
8849         }\r
8850 \r
8851         public StringContext string() {\r
8852             return getRuleContext(StringContext.class, 0);\r
8853         }\r
8854 \r
8855         public List<Identifier_stmtContext> identifier_stmt() {\r
8856             return getRuleContexts(Identifier_stmtContext.class);\r
8857         }\r
8858 \r
8859         public TerminalNode LENGTH_KEYWORD() {\r
8860             return getToken(YangParser.LENGTH_KEYWORD, 0);\r
8861         }\r
8862 \r
8863         public Error_app_tag_stmtContext error_app_tag_stmt(int i) {\r
8864             return getRuleContext(Error_app_tag_stmtContext.class, i);\r
8865         }\r
8866 \r
8867         public List<Error_message_stmtContext> error_message_stmt() {\r
8868             return getRuleContexts(Error_message_stmtContext.class);\r
8869         }\r
8870 \r
8871         public List<Description_stmtContext> description_stmt() {\r
8872             return getRuleContexts(Description_stmtContext.class);\r
8873         }\r
8874 \r
8875         public Reference_stmtContext reference_stmt(int i) {\r
8876             return getRuleContext(Reference_stmtContext.class, i);\r
8877         }\r
8878 \r
8879         public Length_stmtContext(ParserRuleContext parent, int invokingState) {\r
8880             super(parent, invokingState);\r
8881         }\r
8882 \r
8883         @Override\r
8884         public int getRuleIndex() {\r
8885             return RULE_length_stmt;\r
8886         }\r
8887 \r
8888         @Override\r
8889         public void enterRule(ParseTreeListener listener) {\r
8890             if (listener instanceof YangParserListener)\r
8891                 ((YangParserListener) listener).enterLength_stmt(this);\r
8892         }\r
8893 \r
8894         @Override\r
8895         public void exitRule(ParseTreeListener listener) {\r
8896             if (listener instanceof YangParserListener)\r
8897                 ((YangParserListener) listener).exitLength_stmt(this);\r
8898         }\r
8899 \r
8900         @Override\r
8901         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
8902             if (visitor instanceof YangParserVisitor)\r
8903                 return ((YangParserVisitor<? extends T>) visitor)\r
8904                         .visitLength_stmt(this);\r
8905             else\r
8906                 return visitor.visitChildren(this);\r
8907         }\r
8908     }\r
8909 \r
8910     public final Length_stmtContext length_stmt() throws RecognitionException {\r
8911         Length_stmtContext _localctx = new Length_stmtContext(_ctx, getState());\r
8912         enterRule(_localctx, 134, RULE_length_stmt);\r
8913         int _la;\r
8914         try {\r
8915             enterOuterAlt(_localctx, 1);\r
8916             {\r
8917                 setState(891);\r
8918                 match(LENGTH_KEYWORD);\r
8919                 setState(892);\r
8920                 string();\r
8921                 setState(906);\r
8922                 switch (_input.LA(1)) {\r
8923                 case SEMICOLON: {\r
8924                     setState(893);\r
8925                     match(SEMICOLON);\r
8926                 }\r
8927                     break;\r
8928                 case LEFT_BRACE: {\r
8929                     {\r
8930                         setState(894);\r
8931                         match(LEFT_BRACE);\r
8932                         setState(902);\r
8933                         _errHandler.sync(this);\r
8934                         _la = _input.LA(1);\r
8935                         while (((((_la - 24)) & ~0x3f) == 0 && ((1L << (_la - 24)) & ((1L << (REFERENCE_KEYWORD - 24))\r
8936                                 | (1L << (ERROR_MESSAGE_KEYWORD - 24))\r
8937                                 | (1L << (ERROR_APP_TAG_KEYWORD - 24))\r
8938                                 | (1L << (DESCRIPTION_KEYWORD - 24)) | (1L << (IDENTIFIER - 24)))) != 0)) {\r
8939                             {\r
8940                                 setState(900);\r
8941                                 switch (_input.LA(1)) {\r
8942                                 case IDENTIFIER: {\r
8943                                     setState(895);\r
8944                                     identifier_stmt();\r
8945                                 }\r
8946                                     break;\r
8947                                 case ERROR_MESSAGE_KEYWORD: {\r
8948                                     setState(896);\r
8949                                     error_message_stmt();\r
8950                                 }\r
8951                                     break;\r
8952                                 case ERROR_APP_TAG_KEYWORD: {\r
8953                                     setState(897);\r
8954                                     error_app_tag_stmt();\r
8955                                 }\r
8956                                     break;\r
8957                                 case DESCRIPTION_KEYWORD: {\r
8958                                     setState(898);\r
8959                                     description_stmt();\r
8960                                 }\r
8961                                     break;\r
8962                                 case REFERENCE_KEYWORD: {\r
8963                                     setState(899);\r
8964                                     reference_stmt();\r
8965                                 }\r
8966                                     break;\r
8967                                 default:\r
8968                                     throw new NoViableAltException(this);\r
8969                                 }\r
8970                             }\r
8971                             setState(904);\r
8972                             _errHandler.sync(this);\r
8973                             _la = _input.LA(1);\r
8974                         }\r
8975                         setState(905);\r
8976                         match(RIGHT_BRACE);\r
8977                     }\r
8978                 }\r
8979                     break;\r
8980                 default:\r
8981                     throw new NoViableAltException(this);\r
8982                 }\r
8983             }\r
8984         } catch (RecognitionException re) {\r
8985             _localctx.exception = re;\r
8986             _errHandler.reportError(this, re);\r
8987             _errHandler.recover(this, re);\r
8988         } finally {\r
8989             exitRule();\r
8990         }\r
8991         return _localctx;\r
8992     }\r
8993 \r
8994     public static class String_restrictionsContext extends ParserRuleContext {\r
8995         public Length_stmtContext length_stmt(int i) {\r
8996             return getRuleContext(Length_stmtContext.class, i);\r
8997         }\r
8998 \r
8999         public List<Pattern_stmtContext> pattern_stmt() {\r
9000             return getRuleContexts(Pattern_stmtContext.class);\r
9001         }\r
9002 \r
9003         public List<Length_stmtContext> length_stmt() {\r
9004             return getRuleContexts(Length_stmtContext.class);\r
9005         }\r
9006 \r
9007         public Pattern_stmtContext pattern_stmt(int i) {\r
9008             return getRuleContext(Pattern_stmtContext.class, i);\r
9009         }\r
9010 \r
9011         public String_restrictionsContext(ParserRuleContext parent,\r
9012                 int invokingState) {\r
9013             super(parent, invokingState);\r
9014         }\r
9015 \r
9016         @Override\r
9017         public int getRuleIndex() {\r
9018             return RULE_string_restrictions;\r
9019         }\r
9020 \r
9021         @Override\r
9022         public void enterRule(ParseTreeListener listener) {\r
9023             if (listener instanceof YangParserListener)\r
9024                 ((YangParserListener) listener).enterString_restrictions(this);\r
9025         }\r
9026 \r
9027         @Override\r
9028         public void exitRule(ParseTreeListener listener) {\r
9029             if (listener instanceof YangParserListener)\r
9030                 ((YangParserListener) listener).exitString_restrictions(this);\r
9031         }\r
9032 \r
9033         @Override\r
9034         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
9035             if (visitor instanceof YangParserVisitor)\r
9036                 return ((YangParserVisitor<? extends T>) visitor)\r
9037                         .visitString_restrictions(this);\r
9038             else\r
9039                 return visitor.visitChildren(this);\r
9040         }\r
9041     }\r
9042 \r
9043     public final String_restrictionsContext string_restrictions()\r
9044             throws RecognitionException {\r
9045         String_restrictionsContext _localctx = new String_restrictionsContext(\r
9046                 _ctx, getState());\r
9047         enterRule(_localctx, 136, RULE_string_restrictions);\r
9048         int _la;\r
9049         try {\r
9050             enterOuterAlt(_localctx, 1);\r
9051             {\r
9052                 setState(912);\r
9053                 _errHandler.sync(this);\r
9054                 _la = _input.LA(1);\r
9055                 while (_la == PATTERN_KEYWORD || _la == LENGTH_KEYWORD) {\r
9056                     {\r
9057                         setState(910);\r
9058                         switch (_input.LA(1)) {\r
9059                         case LENGTH_KEYWORD: {\r
9060                             setState(908);\r
9061                             length_stmt();\r
9062                         }\r
9063                             break;\r
9064                         case PATTERN_KEYWORD: {\r
9065                             setState(909);\r
9066                             pattern_stmt();\r
9067                         }\r
9068                             break;\r
9069                         default:\r
9070                             throw new NoViableAltException(this);\r
9071                         }\r
9072                     }\r
9073                     setState(914);\r
9074                     _errHandler.sync(this);\r
9075                     _la = _input.LA(1);\r
9076                 }\r
9077             }\r
9078         } catch (RecognitionException re) {\r
9079             _localctx.exception = re;\r
9080             _errHandler.reportError(this, re);\r
9081             _errHandler.recover(this, re);\r
9082         } finally {\r
9083             exitRule();\r
9084         }\r
9085         return _localctx;\r
9086     }\r
9087 \r
9088     public static class Fraction_digits_stmtContext extends ParserRuleContext {\r
9089         public StringContext string() {\r
9090             return getRuleContext(StringContext.class, 0);\r
9091         }\r
9092 \r
9093         public TerminalNode FRACTION_DIGITS_KEYWORD() {\r
9094             return getToken(YangParser.FRACTION_DIGITS_KEYWORD, 0);\r
9095         }\r
9096 \r
9097         public StmtendContext stmtend() {\r
9098             return getRuleContext(StmtendContext.class, 0);\r
9099         }\r
9100 \r
9101         public Fraction_digits_stmtContext(ParserRuleContext parent,\r
9102                 int invokingState) {\r
9103             super(parent, invokingState);\r
9104         }\r
9105 \r
9106         @Override\r
9107         public int getRuleIndex() {\r
9108             return RULE_fraction_digits_stmt;\r
9109         }\r
9110 \r
9111         @Override\r
9112         public void enterRule(ParseTreeListener listener) {\r
9113             if (listener instanceof YangParserListener)\r
9114                 ((YangParserListener) listener).enterFraction_digits_stmt(this);\r
9115         }\r
9116 \r
9117         @Override\r
9118         public void exitRule(ParseTreeListener listener) {\r
9119             if (listener instanceof YangParserListener)\r
9120                 ((YangParserListener) listener).exitFraction_digits_stmt(this);\r
9121         }\r
9122 \r
9123         @Override\r
9124         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
9125             if (visitor instanceof YangParserVisitor)\r
9126                 return ((YangParserVisitor<? extends T>) visitor)\r
9127                         .visitFraction_digits_stmt(this);\r
9128             else\r
9129                 return visitor.visitChildren(this);\r
9130         }\r
9131     }\r
9132 \r
9133     public final Fraction_digits_stmtContext fraction_digits_stmt()\r
9134             throws RecognitionException {\r
9135         Fraction_digits_stmtContext _localctx = new Fraction_digits_stmtContext(\r
9136                 _ctx, getState());\r
9137         enterRule(_localctx, 138, RULE_fraction_digits_stmt);\r
9138         try {\r
9139             enterOuterAlt(_localctx, 1);\r
9140             {\r
9141                 setState(915);\r
9142                 match(FRACTION_DIGITS_KEYWORD);\r
9143                 setState(916);\r
9144                 string();\r
9145                 setState(917);\r
9146                 stmtend();\r
9147             }\r
9148         } catch (RecognitionException re) {\r
9149             _localctx.exception = re;\r
9150             _errHandler.reportError(this, re);\r
9151             _errHandler.recover(this, re);\r
9152         } finally {\r
9153             exitRule();\r
9154         }\r
9155         return _localctx;\r
9156     }\r
9157 \r
9158     public static class Decimal64_specificationContext extends\r
9159             ParserRuleContext {\r
9160         public Fraction_digits_stmtContext fraction_digits_stmt() {\r
9161             return getRuleContext(Fraction_digits_stmtContext.class, 0);\r
9162         }\r
9163 \r
9164         public Numerical_restrictionsContext numerical_restrictions() {\r
9165             return getRuleContext(Numerical_restrictionsContext.class, 0);\r
9166         }\r
9167 \r
9168         public Decimal64_specificationContext(ParserRuleContext parent,\r
9169                 int invokingState) {\r
9170             super(parent, invokingState);\r
9171         }\r
9172 \r
9173         @Override\r
9174         public int getRuleIndex() {\r
9175             return RULE_decimal64_specification;\r
9176         }\r
9177 \r
9178         @Override\r
9179         public void enterRule(ParseTreeListener listener) {\r
9180             if (listener instanceof YangParserListener)\r
9181                 ((YangParserListener) listener)\r
9182                         .enterDecimal64_specification(this);\r
9183         }\r
9184 \r
9185         @Override\r
9186         public void exitRule(ParseTreeListener listener) {\r
9187             if (listener instanceof YangParserListener)\r
9188                 ((YangParserListener) listener)\r
9189                         .exitDecimal64_specification(this);\r
9190         }\r
9191 \r
9192         @Override\r
9193         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
9194             if (visitor instanceof YangParserVisitor)\r
9195                 return ((YangParserVisitor<? extends T>) visitor)\r
9196                         .visitDecimal64_specification(this);\r
9197             else\r
9198                 return visitor.visitChildren(this);\r
9199         }\r
9200     }\r
9201 \r
9202     public final Decimal64_specificationContext decimal64_specification()\r
9203             throws RecognitionException {\r
9204         Decimal64_specificationContext _localctx = new Decimal64_specificationContext(\r
9205                 _ctx, getState());\r
9206         enterRule(_localctx, 140, RULE_decimal64_specification);\r
9207         int _la;\r
9208         try {\r
9209             setState(927);\r
9210             switch (getInterpreter().adaptivePredict(_input, 101, _ctx)) {\r
9211             case 1:\r
9212                 enterOuterAlt(_localctx, 1);\r
9213                 {\r
9214                     setState(920);\r
9215                     _la = _input.LA(1);\r
9216                     if (_la == RANGE_KEYWORD) {\r
9217                         {\r
9218                             setState(919);\r
9219                             numerical_restrictions();\r
9220                         }\r
9221                     }\r
9222 \r
9223                     setState(922);\r
9224                     fraction_digits_stmt();\r
9225                 }\r
9226                 break;\r
9227 \r
9228             case 2:\r
9229                 enterOuterAlt(_localctx, 2);\r
9230                 {\r
9231                     setState(923);\r
9232                     fraction_digits_stmt();\r
9233                     setState(925);\r
9234                     _la = _input.LA(1);\r
9235                     if (_la == RANGE_KEYWORD) {\r
9236                         {\r
9237                             setState(924);\r
9238                             numerical_restrictions();\r
9239                         }\r
9240                     }\r
9241 \r
9242                 }\r
9243                 break;\r
9244             }\r
9245         } catch (RecognitionException re) {\r
9246             _localctx.exception = re;\r
9247             _errHandler.reportError(this, re);\r
9248             _errHandler.recover(this, re);\r
9249         } finally {\r
9250             exitRule();\r
9251         }\r
9252         return _localctx;\r
9253     }\r
9254 \r
9255     public static class Range_stmtContext extends ParserRuleContext {\r
9256         public TerminalNode RIGHT_BRACE() {\r
9257             return getToken(YangParser.RIGHT_BRACE, 0);\r
9258         }\r
9259 \r
9260         public List<Reference_stmtContext> reference_stmt() {\r
9261             return getRuleContexts(Reference_stmtContext.class);\r
9262         }\r
9263 \r
9264         public Description_stmtContext description_stmt(int i) {\r
9265             return getRuleContext(Description_stmtContext.class, i);\r
9266         }\r
9267 \r
9268         public TerminalNode LEFT_BRACE() {\r
9269             return getToken(YangParser.LEFT_BRACE, 0);\r
9270         }\r
9271 \r
9272         public List<Error_app_tag_stmtContext> error_app_tag_stmt() {\r
9273             return getRuleContexts(Error_app_tag_stmtContext.class);\r
9274         }\r
9275 \r
9276         public Error_message_stmtContext error_message_stmt(int i) {\r
9277             return getRuleContext(Error_message_stmtContext.class, i);\r
9278         }\r
9279 \r
9280         public Identifier_stmtContext identifier_stmt(int i) {\r
9281             return getRuleContext(Identifier_stmtContext.class, i);\r
9282         }\r
9283 \r
9284         public TerminalNode SEMICOLON() {\r
9285             return getToken(YangParser.SEMICOLON, 0);\r
9286         }\r
9287 \r
9288         public TerminalNode RANGE_KEYWORD() {\r
9289             return getToken(YangParser.RANGE_KEYWORD, 0);\r
9290         }\r
9291 \r
9292         public StringContext string() {\r
9293             return getRuleContext(StringContext.class, 0);\r
9294         }\r
9295 \r
9296         public List<Identifier_stmtContext> identifier_stmt() {\r
9297             return getRuleContexts(Identifier_stmtContext.class);\r
9298         }\r
9299 \r
9300         public Error_app_tag_stmtContext error_app_tag_stmt(int i) {\r
9301             return getRuleContext(Error_app_tag_stmtContext.class, i);\r
9302         }\r
9303 \r
9304         public List<Error_message_stmtContext> error_message_stmt() {\r
9305             return getRuleContexts(Error_message_stmtContext.class);\r
9306         }\r
9307 \r
9308         public List<Description_stmtContext> description_stmt() {\r
9309             return getRuleContexts(Description_stmtContext.class);\r
9310         }\r
9311 \r
9312         public Reference_stmtContext reference_stmt(int i) {\r
9313             return getRuleContext(Reference_stmtContext.class, i);\r
9314         }\r
9315 \r
9316         public Range_stmtContext(ParserRuleContext parent, int invokingState) {\r
9317             super(parent, invokingState);\r
9318         }\r
9319 \r
9320         @Override\r
9321         public int getRuleIndex() {\r
9322             return RULE_range_stmt;\r
9323         }\r
9324 \r
9325         @Override\r
9326         public void enterRule(ParseTreeListener listener) {\r
9327             if (listener instanceof YangParserListener)\r
9328                 ((YangParserListener) listener).enterRange_stmt(this);\r
9329         }\r
9330 \r
9331         @Override\r
9332         public void exitRule(ParseTreeListener listener) {\r
9333             if (listener instanceof YangParserListener)\r
9334                 ((YangParserListener) listener).exitRange_stmt(this);\r
9335         }\r
9336 \r
9337         @Override\r
9338         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
9339             if (visitor instanceof YangParserVisitor)\r
9340                 return ((YangParserVisitor<? extends T>) visitor)\r
9341                         .visitRange_stmt(this);\r
9342             else\r
9343                 return visitor.visitChildren(this);\r
9344         }\r
9345     }\r
9346 \r
9347     public final Range_stmtContext range_stmt() throws RecognitionException {\r
9348         Range_stmtContext _localctx = new Range_stmtContext(_ctx, getState());\r
9349         enterRule(_localctx, 142, RULE_range_stmt);\r
9350         int _la;\r
9351         try {\r
9352             enterOuterAlt(_localctx, 1);\r
9353             {\r
9354                 setState(929);\r
9355                 match(RANGE_KEYWORD);\r
9356                 setState(930);\r
9357                 string();\r
9358                 setState(944);\r
9359                 switch (_input.LA(1)) {\r
9360                 case SEMICOLON: {\r
9361                     setState(931);\r
9362                     match(SEMICOLON);\r
9363                 }\r
9364                     break;\r
9365                 case LEFT_BRACE: {\r
9366                     {\r
9367                         setState(932);\r
9368                         match(LEFT_BRACE);\r
9369                         setState(940);\r
9370                         _errHandler.sync(this);\r
9371                         _la = _input.LA(1);\r
9372                         while (((((_la - 24)) & ~0x3f) == 0 && ((1L << (_la - 24)) & ((1L << (REFERENCE_KEYWORD - 24))\r
9373                                 | (1L << (ERROR_MESSAGE_KEYWORD - 24))\r
9374                                 | (1L << (ERROR_APP_TAG_KEYWORD - 24))\r
9375                                 | (1L << (DESCRIPTION_KEYWORD - 24)) | (1L << (IDENTIFIER - 24)))) != 0)) {\r
9376                             {\r
9377                                 setState(938);\r
9378                                 switch (_input.LA(1)) {\r
9379                                 case IDENTIFIER: {\r
9380                                     setState(933);\r
9381                                     identifier_stmt();\r
9382                                 }\r
9383                                     break;\r
9384                                 case ERROR_MESSAGE_KEYWORD: {\r
9385                                     setState(934);\r
9386                                     error_message_stmt();\r
9387                                 }\r
9388                                     break;\r
9389                                 case ERROR_APP_TAG_KEYWORD: {\r
9390                                     setState(935);\r
9391                                     error_app_tag_stmt();\r
9392                                 }\r
9393                                     break;\r
9394                                 case DESCRIPTION_KEYWORD: {\r
9395                                     setState(936);\r
9396                                     description_stmt();\r
9397                                 }\r
9398                                     break;\r
9399                                 case REFERENCE_KEYWORD: {\r
9400                                     setState(937);\r
9401                                     reference_stmt();\r
9402                                 }\r
9403                                     break;\r
9404                                 default:\r
9405                                     throw new NoViableAltException(this);\r
9406                                 }\r
9407                             }\r
9408                             setState(942);\r
9409                             _errHandler.sync(this);\r
9410                             _la = _input.LA(1);\r
9411                         }\r
9412                         setState(943);\r
9413                         match(RIGHT_BRACE);\r
9414                     }\r
9415                 }\r
9416                     break;\r
9417                 default:\r
9418                     throw new NoViableAltException(this);\r
9419                 }\r
9420             }\r
9421         } catch (RecognitionException re) {\r
9422             _localctx.exception = re;\r
9423             _errHandler.reportError(this, re);\r
9424             _errHandler.recover(this, re);\r
9425         } finally {\r
9426             exitRule();\r
9427         }\r
9428         return _localctx;\r
9429     }\r
9430 \r
9431     public static class Numerical_restrictionsContext extends ParserRuleContext {\r
9432         public Range_stmtContext range_stmt() {\r
9433             return getRuleContext(Range_stmtContext.class, 0);\r
9434         }\r
9435 \r
9436         public Numerical_restrictionsContext(ParserRuleContext parent,\r
9437                 int invokingState) {\r
9438             super(parent, invokingState);\r
9439         }\r
9440 \r
9441         @Override\r
9442         public int getRuleIndex() {\r
9443             return RULE_numerical_restrictions;\r
9444         }\r
9445 \r
9446         @Override\r
9447         public void enterRule(ParseTreeListener listener) {\r
9448             if (listener instanceof YangParserListener)\r
9449                 ((YangParserListener) listener)\r
9450                         .enterNumerical_restrictions(this);\r
9451         }\r
9452 \r
9453         @Override\r
9454         public void exitRule(ParseTreeListener listener) {\r
9455             if (listener instanceof YangParserListener)\r
9456                 ((YangParserListener) listener)\r
9457                         .exitNumerical_restrictions(this);\r
9458         }\r
9459 \r
9460         @Override\r
9461         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
9462             if (visitor instanceof YangParserVisitor)\r
9463                 return ((YangParserVisitor<? extends T>) visitor)\r
9464                         .visitNumerical_restrictions(this);\r
9465             else\r
9466                 return visitor.visitChildren(this);\r
9467         }\r
9468     }\r
9469 \r
9470     public final Numerical_restrictionsContext numerical_restrictions()\r
9471             throws RecognitionException {\r
9472         Numerical_restrictionsContext _localctx = new Numerical_restrictionsContext(\r
9473                 _ctx, getState());\r
9474         enterRule(_localctx, 144, RULE_numerical_restrictions);\r
9475         try {\r
9476             enterOuterAlt(_localctx, 1);\r
9477             {\r
9478                 setState(946);\r
9479                 range_stmt();\r
9480             }\r
9481         } catch (RecognitionException re) {\r
9482             _localctx.exception = re;\r
9483             _errHandler.reportError(this, re);\r
9484             _errHandler.recover(this, re);\r
9485         } finally {\r
9486             exitRule();\r
9487         }\r
9488         return _localctx;\r
9489     }\r
9490 \r
9491     public static class Type_body_stmtsContext extends ParserRuleContext {\r
9492         public Bits_specificationContext bits_specification() {\r
9493             return getRuleContext(Bits_specificationContext.class, 0);\r
9494         }\r
9495 \r
9496         public Identityref_specificationContext identityref_specification() {\r
9497             return getRuleContext(Identityref_specificationContext.class, 0);\r
9498         }\r
9499 \r
9500         public Enum_specificationContext enum_specification() {\r
9501             return getRuleContext(Enum_specificationContext.class, 0);\r
9502         }\r
9503 \r
9504         public Numerical_restrictionsContext numerical_restrictions() {\r
9505             return getRuleContext(Numerical_restrictionsContext.class, 0);\r
9506         }\r
9507 \r
9508         public String_restrictionsContext string_restrictions() {\r
9509             return getRuleContext(String_restrictionsContext.class, 0);\r
9510         }\r
9511 \r
9512         public Leafref_specificationContext leafref_specification() {\r
9513             return getRuleContext(Leafref_specificationContext.class, 0);\r
9514         }\r
9515 \r
9516         public Decimal64_specificationContext decimal64_specification() {\r
9517             return getRuleContext(Decimal64_specificationContext.class, 0);\r
9518         }\r
9519 \r
9520         public Union_specificationContext union_specification() {\r
9521             return getRuleContext(Union_specificationContext.class, 0);\r
9522         }\r
9523 \r
9524         public Instance_identifier_specificationContext instance_identifier_specification() {\r
9525             return getRuleContext(\r
9526                     Instance_identifier_specificationContext.class, 0);\r
9527         }\r
9528 \r
9529         public Type_body_stmtsContext(ParserRuleContext parent,\r
9530                 int invokingState) {\r
9531             super(parent, invokingState);\r
9532         }\r
9533 \r
9534         @Override\r
9535         public int getRuleIndex() {\r
9536             return RULE_type_body_stmts;\r
9537         }\r
9538 \r
9539         @Override\r
9540         public void enterRule(ParseTreeListener listener) {\r
9541             if (listener instanceof YangParserListener)\r
9542                 ((YangParserListener) listener).enterType_body_stmts(this);\r
9543         }\r
9544 \r
9545         @Override\r
9546         public void exitRule(ParseTreeListener listener) {\r
9547             if (listener instanceof YangParserListener)\r
9548                 ((YangParserListener) listener).exitType_body_stmts(this);\r
9549         }\r
9550 \r
9551         @Override\r
9552         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
9553             if (visitor instanceof YangParserVisitor)\r
9554                 return ((YangParserVisitor<? extends T>) visitor)\r
9555                         .visitType_body_stmts(this);\r
9556             else\r
9557                 return visitor.visitChildren(this);\r
9558         }\r
9559     }\r
9560 \r
9561     public final Type_body_stmtsContext type_body_stmts()\r
9562             throws RecognitionException {\r
9563         Type_body_stmtsContext _localctx = new Type_body_stmtsContext(_ctx,\r
9564                 getState());\r
9565         enterRule(_localctx, 146, RULE_type_body_stmts);\r
9566         try {\r
9567             setState(957);\r
9568             switch (getInterpreter().adaptivePredict(_input, 105, _ctx)) {\r
9569             case 1:\r
9570                 enterOuterAlt(_localctx, 1);\r
9571                 {\r
9572                     setState(948);\r
9573                     numerical_restrictions();\r
9574                 }\r
9575                 break;\r
9576 \r
9577             case 2:\r
9578                 enterOuterAlt(_localctx, 2);\r
9579                 {\r
9580                     setState(949);\r
9581                     decimal64_specification();\r
9582                 }\r
9583                 break;\r
9584 \r
9585             case 3:\r
9586                 enterOuterAlt(_localctx, 3);\r
9587                 {\r
9588                     setState(950);\r
9589                     string_restrictions();\r
9590                 }\r
9591                 break;\r
9592 \r
9593             case 4:\r
9594                 enterOuterAlt(_localctx, 4);\r
9595                 {\r
9596                     setState(951);\r
9597                     enum_specification();\r
9598                 }\r
9599                 break;\r
9600 \r
9601             case 5:\r
9602                 enterOuterAlt(_localctx, 5);\r
9603                 {\r
9604                     setState(952);\r
9605                     leafref_specification();\r
9606                 }\r
9607                 break;\r
9608 \r
9609             case 6:\r
9610                 enterOuterAlt(_localctx, 6);\r
9611                 {\r
9612                     setState(953);\r
9613                     identityref_specification();\r
9614                 }\r
9615                 break;\r
9616 \r
9617             case 7:\r
9618                 enterOuterAlt(_localctx, 7);\r
9619                 {\r
9620                     setState(954);\r
9621                     instance_identifier_specification();\r
9622                 }\r
9623                 break;\r
9624 \r
9625             case 8:\r
9626                 enterOuterAlt(_localctx, 8);\r
9627                 {\r
9628                     setState(955);\r
9629                     bits_specification();\r
9630                 }\r
9631                 break;\r
9632 \r
9633             case 9:\r
9634                 enterOuterAlt(_localctx, 9);\r
9635                 {\r
9636                     setState(956);\r
9637                     union_specification();\r
9638                 }\r
9639                 break;\r
9640             }\r
9641         } catch (RecognitionException re) {\r
9642             _localctx.exception = re;\r
9643             _errHandler.reportError(this, re);\r
9644             _errHandler.recover(this, re);\r
9645         } finally {\r
9646             exitRule();\r
9647         }\r
9648         return _localctx;\r
9649     }\r
9650 \r
9651     public static class Type_stmtContext extends ParserRuleContext {\r
9652         public TerminalNode RIGHT_BRACE() {\r
9653             return getToken(YangParser.RIGHT_BRACE, 0);\r
9654         }\r
9655 \r
9656         public TerminalNode TYPE_KEYWORD() {\r
9657             return getToken(YangParser.TYPE_KEYWORD, 0);\r
9658         }\r
9659 \r
9660         public TerminalNode SEMICOLON() {\r
9661             return getToken(YangParser.SEMICOLON, 0);\r
9662         }\r
9663 \r
9664         public StringContext string() {\r
9665             return getRuleContext(StringContext.class, 0);\r
9666         }\r
9667 \r
9668         public TerminalNode LEFT_BRACE() {\r
9669             return getToken(YangParser.LEFT_BRACE, 0);\r
9670         }\r
9671 \r
9672         public Type_body_stmtsContext type_body_stmts() {\r
9673             return getRuleContext(Type_body_stmtsContext.class, 0);\r
9674         }\r
9675 \r
9676         public Type_stmtContext(ParserRuleContext parent, int invokingState) {\r
9677             super(parent, invokingState);\r
9678         }\r
9679 \r
9680         @Override\r
9681         public int getRuleIndex() {\r
9682             return RULE_type_stmt;\r
9683         }\r
9684 \r
9685         @Override\r
9686         public void enterRule(ParseTreeListener listener) {\r
9687             if (listener instanceof YangParserListener)\r
9688                 ((YangParserListener) listener).enterType_stmt(this);\r
9689         }\r
9690 \r
9691         @Override\r
9692         public void exitRule(ParseTreeListener listener) {\r
9693             if (listener instanceof YangParserListener)\r
9694                 ((YangParserListener) listener).exitType_stmt(this);\r
9695         }\r
9696 \r
9697         @Override\r
9698         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
9699             if (visitor instanceof YangParserVisitor)\r
9700                 return ((YangParserVisitor<? extends T>) visitor)\r
9701                         .visitType_stmt(this);\r
9702             else\r
9703                 return visitor.visitChildren(this);\r
9704         }\r
9705     }\r
9706 \r
9707     public final Type_stmtContext type_stmt() throws RecognitionException {\r
9708         Type_stmtContext _localctx = new Type_stmtContext(_ctx, getState());\r
9709         enterRule(_localctx, 148, RULE_type_stmt);\r
9710         try {\r
9711             enterOuterAlt(_localctx, 1);\r
9712             {\r
9713                 setState(959);\r
9714                 match(TYPE_KEYWORD);\r
9715                 setState(960);\r
9716                 string();\r
9717                 setState(966);\r
9718                 switch (_input.LA(1)) {\r
9719                 case SEMICOLON: {\r
9720                     setState(961);\r
9721                     match(SEMICOLON);\r
9722                 }\r
9723                     break;\r
9724                 case LEFT_BRACE: {\r
9725                     {\r
9726                         setState(962);\r
9727                         match(LEFT_BRACE);\r
9728                         setState(963);\r
9729                         type_body_stmts();\r
9730                         setState(964);\r
9731                         match(RIGHT_BRACE);\r
9732                     }\r
9733                 }\r
9734                     break;\r
9735                 default:\r
9736                     throw new NoViableAltException(this);\r
9737                 }\r
9738             }\r
9739         } catch (RecognitionException re) {\r
9740             _localctx.exception = re;\r
9741             _errHandler.reportError(this, re);\r
9742             _errHandler.recover(this, re);\r
9743         } finally {\r
9744             exitRule();\r
9745         }\r
9746         return _localctx;\r
9747     }\r
9748 \r
9749     public static class Typedef_stmtContext extends ParserRuleContext {\r
9750         public TerminalNode RIGHT_BRACE() {\r
9751             return getToken(YangParser.RIGHT_BRACE, 0);\r
9752         }\r
9753 \r
9754         public Units_stmtContext units_stmt(int i) {\r
9755             return getRuleContext(Units_stmtContext.class, i);\r
9756         }\r
9757 \r
9758         public List<Reference_stmtContext> reference_stmt() {\r
9759             return getRuleContexts(Reference_stmtContext.class);\r
9760         }\r
9761 \r
9762         public Description_stmtContext description_stmt(int i) {\r
9763             return getRuleContext(Description_stmtContext.class, i);\r
9764         }\r
9765 \r
9766         public Default_stmtContext default_stmt(int i) {\r
9767             return getRuleContext(Default_stmtContext.class, i);\r
9768         }\r
9769 \r
9770         public List<Units_stmtContext> units_stmt() {\r
9771             return getRuleContexts(Units_stmtContext.class);\r
9772         }\r
9773 \r
9774         public Type_stmtContext type_stmt(int i) {\r
9775             return getRuleContext(Type_stmtContext.class, i);\r
9776         }\r
9777 \r
9778         public TerminalNode LEFT_BRACE() {\r
9779             return getToken(YangParser.LEFT_BRACE, 0);\r
9780         }\r
9781 \r
9782         public Status_stmtContext status_stmt(int i) {\r
9783             return getRuleContext(Status_stmtContext.class, i);\r
9784         }\r
9785 \r
9786         public List<Type_stmtContext> type_stmt() {\r
9787             return getRuleContexts(Type_stmtContext.class);\r
9788         }\r
9789 \r
9790         public TerminalNode TYPEDEF_KEYWORD() {\r
9791             return getToken(YangParser.TYPEDEF_KEYWORD, 0);\r
9792         }\r
9793 \r
9794         public List<Default_stmtContext> default_stmt() {\r
9795             return getRuleContexts(Default_stmtContext.class);\r
9796         }\r
9797 \r
9798         public List<Status_stmtContext> status_stmt() {\r
9799             return getRuleContexts(Status_stmtContext.class);\r
9800         }\r
9801 \r
9802         public StringContext string() {\r
9803             return getRuleContext(StringContext.class, 0);\r
9804         }\r
9805 \r
9806         public List<Description_stmtContext> description_stmt() {\r
9807             return getRuleContexts(Description_stmtContext.class);\r
9808         }\r
9809 \r
9810         public Reference_stmtContext reference_stmt(int i) {\r
9811             return getRuleContext(Reference_stmtContext.class, i);\r
9812         }\r
9813 \r
9814         public Typedef_stmtContext(ParserRuleContext parent, int invokingState) {\r
9815             super(parent, invokingState);\r
9816         }\r
9817 \r
9818         @Override\r
9819         public int getRuleIndex() {\r
9820             return RULE_typedef_stmt;\r
9821         }\r
9822 \r
9823         @Override\r
9824         public void enterRule(ParseTreeListener listener) {\r
9825             if (listener instanceof YangParserListener)\r
9826                 ((YangParserListener) listener).enterTypedef_stmt(this);\r
9827         }\r
9828 \r
9829         @Override\r
9830         public void exitRule(ParseTreeListener listener) {\r
9831             if (listener instanceof YangParserListener)\r
9832                 ((YangParserListener) listener).exitTypedef_stmt(this);\r
9833         }\r
9834 \r
9835         @Override\r
9836         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
9837             if (visitor instanceof YangParserVisitor)\r
9838                 return ((YangParserVisitor<? extends T>) visitor)\r
9839                         .visitTypedef_stmt(this);\r
9840             else\r
9841                 return visitor.visitChildren(this);\r
9842         }\r
9843     }\r
9844 \r
9845     public final Typedef_stmtContext typedef_stmt() throws RecognitionException {\r
9846         Typedef_stmtContext _localctx = new Typedef_stmtContext(_ctx,\r
9847                 getState());\r
9848         enterRule(_localctx, 150, RULE_typedef_stmt);\r
9849         int _la;\r
9850         try {\r
9851             enterOuterAlt(_localctx, 1);\r
9852             {\r
9853                 setState(968);\r
9854                 match(TYPEDEF_KEYWORD);\r
9855                 setState(969);\r
9856                 string();\r
9857                 setState(970);\r
9858                 match(LEFT_BRACE);\r
9859                 setState(977);\r
9860                 _errHandler.sync(this);\r
9861                 _la = _input.LA(1);\r
9862                 do {\r
9863                     {\r
9864                         setState(977);\r
9865                         switch (_input.LA(1)) {\r
9866                         case TYPE_KEYWORD: {\r
9867                             setState(971);\r
9868                             type_stmt();\r
9869                         }\r
9870                             break;\r
9871                         case UNITS_KEYWORD: {\r
9872                             setState(972);\r
9873                             units_stmt();\r
9874                         }\r
9875                             break;\r
9876                         case DEFAULT_KEYWORD: {\r
9877                             setState(973);\r
9878                             default_stmt();\r
9879                         }\r
9880                             break;\r
9881                         case STATUS_KEYWORD: {\r
9882                             setState(974);\r
9883                             status_stmt();\r
9884                         }\r
9885                             break;\r
9886                         case DESCRIPTION_KEYWORD: {\r
9887                             setState(975);\r
9888                             description_stmt();\r
9889                         }\r
9890                             break;\r
9891                         case REFERENCE_KEYWORD: {\r
9892                             setState(976);\r
9893                             reference_stmt();\r
9894                         }\r
9895                             break;\r
9896                         default:\r
9897                             throw new NoViableAltException(this);\r
9898                         }\r
9899                     }\r
9900                     setState(979);\r
9901                     _errHandler.sync(this);\r
9902                     _la = _input.LA(1);\r
9903                 } while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << UNITS_KEYWORD)\r
9904                         | (1L << TYPE_KEYWORD)\r
9905                         | (1L << STATUS_KEYWORD)\r
9906                         | (1L << REFERENCE_KEYWORD)\r
9907                         | (1L << DESCRIPTION_KEYWORD) | (1L << DEFAULT_KEYWORD))) != 0));\r
9908                 setState(981);\r
9909                 match(RIGHT_BRACE);\r
9910             }\r
9911         } catch (RecognitionException re) {\r
9912             _localctx.exception = re;\r
9913             _errHandler.reportError(this, re);\r
9914             _errHandler.recover(this, re);\r
9915         } finally {\r
9916             exitRule();\r
9917         }\r
9918         return _localctx;\r
9919     }\r
9920 \r
9921     public static class If_feature_stmtContext extends ParserRuleContext {\r
9922         public TerminalNode IF_FEATURE_KEYWORD() {\r
9923             return getToken(YangParser.IF_FEATURE_KEYWORD, 0);\r
9924         }\r
9925 \r
9926         public StringContext string() {\r
9927             return getRuleContext(StringContext.class, 0);\r
9928         }\r
9929 \r
9930         public StmtendContext stmtend() {\r
9931             return getRuleContext(StmtendContext.class, 0);\r
9932         }\r
9933 \r
9934         public If_feature_stmtContext(ParserRuleContext parent,\r
9935                 int invokingState) {\r
9936             super(parent, invokingState);\r
9937         }\r
9938 \r
9939         @Override\r
9940         public int getRuleIndex() {\r
9941             return RULE_if_feature_stmt;\r
9942         }\r
9943 \r
9944         @Override\r
9945         public void enterRule(ParseTreeListener listener) {\r
9946             if (listener instanceof YangParserListener)\r
9947                 ((YangParserListener) listener).enterIf_feature_stmt(this);\r
9948         }\r
9949 \r
9950         @Override\r
9951         public void exitRule(ParseTreeListener listener) {\r
9952             if (listener instanceof YangParserListener)\r
9953                 ((YangParserListener) listener).exitIf_feature_stmt(this);\r
9954         }\r
9955 \r
9956         @Override\r
9957         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
9958             if (visitor instanceof YangParserVisitor)\r
9959                 return ((YangParserVisitor<? extends T>) visitor)\r
9960                         .visitIf_feature_stmt(this);\r
9961             else\r
9962                 return visitor.visitChildren(this);\r
9963         }\r
9964     }\r
9965 \r
9966     public final If_feature_stmtContext if_feature_stmt()\r
9967             throws RecognitionException {\r
9968         If_feature_stmtContext _localctx = new If_feature_stmtContext(_ctx,\r
9969                 getState());\r
9970         enterRule(_localctx, 152, RULE_if_feature_stmt);\r
9971         try {\r
9972             enterOuterAlt(_localctx, 1);\r
9973             {\r
9974                 setState(983);\r
9975                 match(IF_FEATURE_KEYWORD);\r
9976                 setState(984);\r
9977                 string();\r
9978                 setState(985);\r
9979                 stmtend();\r
9980             }\r
9981         } catch (RecognitionException re) {\r
9982             _localctx.exception = re;\r
9983             _errHandler.reportError(this, re);\r
9984             _errHandler.recover(this, re);\r
9985         } finally {\r
9986             exitRule();\r
9987         }\r
9988         return _localctx;\r
9989     }\r
9990 \r
9991     public static class Feature_stmtContext extends ParserRuleContext {\r
9992         public TerminalNode RIGHT_BRACE() {\r
9993             return getToken(YangParser.RIGHT_BRACE, 0);\r
9994         }\r
9995 \r
9996         public List<Reference_stmtContext> reference_stmt() {\r
9997             return getRuleContexts(Reference_stmtContext.class);\r
9998         }\r
9999 \r
10000         public Description_stmtContext description_stmt(int i) {\r
10001             return getRuleContext(Description_stmtContext.class, i);\r
10002         }\r
10003 \r
10004         public If_feature_stmtContext if_feature_stmt(int i) {\r
10005             return getRuleContext(If_feature_stmtContext.class, i);\r
10006         }\r
10007 \r
10008         public TerminalNode LEFT_BRACE() {\r
10009             return getToken(YangParser.LEFT_BRACE, 0);\r
10010         }\r
10011 \r
10012         public Status_stmtContext status_stmt(int i) {\r
10013             return getRuleContext(Status_stmtContext.class, i);\r
10014         }\r
10015 \r
10016         public List<If_feature_stmtContext> if_feature_stmt() {\r
10017             return getRuleContexts(If_feature_stmtContext.class);\r
10018         }\r
10019 \r
10020         public TerminalNode SEMICOLON() {\r
10021             return getToken(YangParser.SEMICOLON, 0);\r
10022         }\r
10023 \r
10024         public List<Status_stmtContext> status_stmt() {\r
10025             return getRuleContexts(Status_stmtContext.class);\r
10026         }\r
10027 \r
10028         public StringContext string() {\r
10029             return getRuleContext(StringContext.class, 0);\r
10030         }\r
10031 \r
10032         public TerminalNode FEATURE_KEYWORD() {\r
10033             return getToken(YangParser.FEATURE_KEYWORD, 0);\r
10034         }\r
10035 \r
10036         public List<Description_stmtContext> description_stmt() {\r
10037             return getRuleContexts(Description_stmtContext.class);\r
10038         }\r
10039 \r
10040         public Reference_stmtContext reference_stmt(int i) {\r
10041             return getRuleContext(Reference_stmtContext.class, i);\r
10042         }\r
10043 \r
10044         public Feature_stmtContext(ParserRuleContext parent, int invokingState) {\r
10045             super(parent, invokingState);\r
10046         }\r
10047 \r
10048         @Override\r
10049         public int getRuleIndex() {\r
10050             return RULE_feature_stmt;\r
10051         }\r
10052 \r
10053         @Override\r
10054         public void enterRule(ParseTreeListener listener) {\r
10055             if (listener instanceof YangParserListener)\r
10056                 ((YangParserListener) listener).enterFeature_stmt(this);\r
10057         }\r
10058 \r
10059         @Override\r
10060         public void exitRule(ParseTreeListener listener) {\r
10061             if (listener instanceof YangParserListener)\r
10062                 ((YangParserListener) listener).exitFeature_stmt(this);\r
10063         }\r
10064 \r
10065         @Override\r
10066         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
10067             if (visitor instanceof YangParserVisitor)\r
10068                 return ((YangParserVisitor<? extends T>) visitor)\r
10069                         .visitFeature_stmt(this);\r
10070             else\r
10071                 return visitor.visitChildren(this);\r
10072         }\r
10073     }\r
10074 \r
10075     public final Feature_stmtContext feature_stmt() throws RecognitionException {\r
10076         Feature_stmtContext _localctx = new Feature_stmtContext(_ctx,\r
10077                 getState());\r
10078         enterRule(_localctx, 154, RULE_feature_stmt);\r
10079         int _la;\r
10080         try {\r
10081             enterOuterAlt(_localctx, 1);\r
10082             {\r
10083                 setState(987);\r
10084                 match(FEATURE_KEYWORD);\r
10085                 setState(988);\r
10086                 string();\r
10087                 setState(1001);\r
10088                 switch (_input.LA(1)) {\r
10089                 case SEMICOLON: {\r
10090                     setState(989);\r
10091                     match(SEMICOLON);\r
10092                 }\r
10093                     break;\r
10094                 case LEFT_BRACE: {\r
10095                     {\r
10096                         setState(990);\r
10097                         match(LEFT_BRACE);\r
10098                         setState(997);\r
10099                         _errHandler.sync(this);\r
10100                         _la = _input.LA(1);\r
10101                         while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STATUS_KEYWORD)\r
10102                                 | (1L << REFERENCE_KEYWORD)\r
10103                                 | (1L << IF_FEATURE_KEYWORD) | (1L << DESCRIPTION_KEYWORD))) != 0)) {\r
10104                             {\r
10105                                 setState(995);\r
10106                                 switch (_input.LA(1)) {\r
10107                                 case IF_FEATURE_KEYWORD: {\r
10108                                     setState(991);\r
10109                                     if_feature_stmt();\r
10110                                 }\r
10111                                     break;\r
10112                                 case STATUS_KEYWORD: {\r
10113                                     setState(992);\r
10114                                     status_stmt();\r
10115                                 }\r
10116                                     break;\r
10117                                 case DESCRIPTION_KEYWORD: {\r
10118                                     setState(993);\r
10119                                     description_stmt();\r
10120                                 }\r
10121                                     break;\r
10122                                 case REFERENCE_KEYWORD: {\r
10123                                     setState(994);\r
10124                                     reference_stmt();\r
10125                                 }\r
10126                                     break;\r
10127                                 default:\r
10128                                     throw new NoViableAltException(this);\r
10129                                 }\r
10130                             }\r
10131                             setState(999);\r
10132                             _errHandler.sync(this);\r
10133                             _la = _input.LA(1);\r
10134                         }\r
10135                         setState(1000);\r
10136                         match(RIGHT_BRACE);\r
10137                     }\r
10138                 }\r
10139                     break;\r
10140                 default:\r
10141                     throw new NoViableAltException(this);\r
10142                 }\r
10143             }\r
10144         } catch (RecognitionException re) {\r
10145             _localctx.exception = re;\r
10146             _errHandler.reportError(this, re);\r
10147             _errHandler.recover(this, re);\r
10148         } finally {\r
10149             exitRule();\r
10150         }\r
10151         return _localctx;\r
10152     }\r
10153 \r
10154     public static class Base_stmtContext extends ParserRuleContext {\r
10155         public TerminalNode BASE_KEYWORD() {\r
10156             return getToken(YangParser.BASE_KEYWORD, 0);\r
10157         }\r
10158 \r
10159         public StringContext string() {\r
10160             return getRuleContext(StringContext.class, 0);\r
10161         }\r
10162 \r
10163         public StmtendContext stmtend() {\r
10164             return getRuleContext(StmtendContext.class, 0);\r
10165         }\r
10166 \r
10167         public Base_stmtContext(ParserRuleContext parent, int invokingState) {\r
10168             super(parent, invokingState);\r
10169         }\r
10170 \r
10171         @Override\r
10172         public int getRuleIndex() {\r
10173             return RULE_base_stmt;\r
10174         }\r
10175 \r
10176         @Override\r
10177         public void enterRule(ParseTreeListener listener) {\r
10178             if (listener instanceof YangParserListener)\r
10179                 ((YangParserListener) listener).enterBase_stmt(this);\r
10180         }\r
10181 \r
10182         @Override\r
10183         public void exitRule(ParseTreeListener listener) {\r
10184             if (listener instanceof YangParserListener)\r
10185                 ((YangParserListener) listener).exitBase_stmt(this);\r
10186         }\r
10187 \r
10188         @Override\r
10189         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
10190             if (visitor instanceof YangParserVisitor)\r
10191                 return ((YangParserVisitor<? extends T>) visitor)\r
10192                         .visitBase_stmt(this);\r
10193             else\r
10194                 return visitor.visitChildren(this);\r
10195         }\r
10196     }\r
10197 \r
10198     public final Base_stmtContext base_stmt() throws RecognitionException {\r
10199         Base_stmtContext _localctx = new Base_stmtContext(_ctx, getState());\r
10200         enterRule(_localctx, 156, RULE_base_stmt);\r
10201         try {\r
10202             enterOuterAlt(_localctx, 1);\r
10203             {\r
10204                 setState(1003);\r
10205                 match(BASE_KEYWORD);\r
10206                 setState(1004);\r
10207                 string();\r
10208                 setState(1005);\r
10209                 stmtend();\r
10210             }\r
10211         } catch (RecognitionException re) {\r
10212             _localctx.exception = re;\r
10213             _errHandler.reportError(this, re);\r
10214             _errHandler.recover(this, re);\r
10215         } finally {\r
10216             exitRule();\r
10217         }\r
10218         return _localctx;\r
10219     }\r
10220 \r
10221     public static class Identity_stmtContext extends ParserRuleContext {\r
10222         public TerminalNode RIGHT_BRACE() {\r
10223             return getToken(YangParser.RIGHT_BRACE, 0);\r
10224         }\r
10225 \r
10226         public List<Reference_stmtContext> reference_stmt() {\r
10227             return getRuleContexts(Reference_stmtContext.class);\r
10228         }\r
10229 \r
10230         public Description_stmtContext description_stmt(int i) {\r
10231             return getRuleContext(Description_stmtContext.class, i);\r
10232         }\r
10233 \r
10234         public Base_stmtContext base_stmt(int i) {\r
10235             return getRuleContext(Base_stmtContext.class, i);\r
10236         }\r
10237 \r
10238         public TerminalNode IDENTITY_KEYWORD() {\r
10239             return getToken(YangParser.IDENTITY_KEYWORD, 0);\r
10240         }\r
10241 \r
10242         public TerminalNode LEFT_BRACE() {\r
10243             return getToken(YangParser.LEFT_BRACE, 0);\r
10244         }\r
10245 \r
10246         public Status_stmtContext status_stmt(int i) {\r
10247             return getRuleContext(Status_stmtContext.class, i);\r
10248         }\r
10249 \r
10250         public TerminalNode SEMICOLON() {\r
10251             return getToken(YangParser.SEMICOLON, 0);\r
10252         }\r
10253 \r
10254         public List<Status_stmtContext> status_stmt() {\r
10255             return getRuleContexts(Status_stmtContext.class);\r
10256         }\r
10257 \r
10258         public StringContext string() {\r
10259             return getRuleContext(StringContext.class, 0);\r
10260         }\r
10261 \r
10262         public List<Base_stmtContext> base_stmt() {\r
10263             return getRuleContexts(Base_stmtContext.class);\r
10264         }\r
10265 \r
10266         public List<Description_stmtContext> description_stmt() {\r
10267             return getRuleContexts(Description_stmtContext.class);\r
10268         }\r
10269 \r
10270         public Reference_stmtContext reference_stmt(int i) {\r
10271             return getRuleContext(Reference_stmtContext.class, i);\r
10272         }\r
10273 \r
10274         public Identity_stmtContext(ParserRuleContext parent, int invokingState) {\r
10275             super(parent, invokingState);\r
10276         }\r
10277 \r
10278         @Override\r
10279         public int getRuleIndex() {\r
10280             return RULE_identity_stmt;\r
10281         }\r
10282 \r
10283         @Override\r
10284         public void enterRule(ParseTreeListener listener) {\r
10285             if (listener instanceof YangParserListener)\r
10286                 ((YangParserListener) listener).enterIdentity_stmt(this);\r
10287         }\r
10288 \r
10289         @Override\r
10290         public void exitRule(ParseTreeListener listener) {\r
10291             if (listener instanceof YangParserListener)\r
10292                 ((YangParserListener) listener).exitIdentity_stmt(this);\r
10293         }\r
10294 \r
10295         @Override\r
10296         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
10297             if (visitor instanceof YangParserVisitor)\r
10298                 return ((YangParserVisitor<? extends T>) visitor)\r
10299                         .visitIdentity_stmt(this);\r
10300             else\r
10301                 return visitor.visitChildren(this);\r
10302         }\r
10303     }\r
10304 \r
10305     public final Identity_stmtContext identity_stmt()\r
10306             throws RecognitionException {\r
10307         Identity_stmtContext _localctx = new Identity_stmtContext(_ctx,\r
10308                 getState());\r
10309         enterRule(_localctx, 158, RULE_identity_stmt);\r
10310         int _la;\r
10311         try {\r
10312             enterOuterAlt(_localctx, 1);\r
10313             {\r
10314                 setState(1007);\r
10315                 match(IDENTITY_KEYWORD);\r
10316                 setState(1008);\r
10317                 string();\r
10318                 setState(1021);\r
10319                 switch (_input.LA(1)) {\r
10320                 case SEMICOLON: {\r
10321                     setState(1009);\r
10322                     match(SEMICOLON);\r
10323                 }\r
10324                     break;\r
10325                 case LEFT_BRACE: {\r
10326                     {\r
10327                         setState(1010);\r
10328                         match(LEFT_BRACE);\r
10329                         setState(1017);\r
10330                         _errHandler.sync(this);\r
10331                         _la = _input.LA(1);\r
10332                         while (((((_la - 18)) & ~0x3f) == 0 && ((1L << (_la - 18)) & ((1L << (STATUS_KEYWORD - 18))\r
10333                                 | (1L << (REFERENCE_KEYWORD - 18))\r
10334                                 | (1L << (DESCRIPTION_KEYWORD - 18)) | (1L << (BASE_KEYWORD - 18)))) != 0)) {\r
10335                             {\r
10336                                 setState(1015);\r
10337                                 switch (_input.LA(1)) {\r
10338                                 case BASE_KEYWORD: {\r
10339                                     setState(1011);\r
10340                                     base_stmt();\r
10341                                 }\r
10342                                     break;\r
10343                                 case STATUS_KEYWORD: {\r
10344                                     setState(1012);\r
10345                                     status_stmt();\r
10346                                 }\r
10347                                     break;\r
10348                                 case DESCRIPTION_KEYWORD: {\r
10349                                     setState(1013);\r
10350                                     description_stmt();\r
10351                                 }\r
10352                                     break;\r
10353                                 case REFERENCE_KEYWORD: {\r
10354                                     setState(1014);\r
10355                                     reference_stmt();\r
10356                                 }\r
10357                                     break;\r
10358                                 default:\r
10359                                     throw new NoViableAltException(this);\r
10360                                 }\r
10361                             }\r
10362                             setState(1019);\r
10363                             _errHandler.sync(this);\r
10364                             _la = _input.LA(1);\r
10365                         }\r
10366                         setState(1020);\r
10367                         match(RIGHT_BRACE);\r
10368                     }\r
10369                 }\r
10370                     break;\r
10371                 default:\r
10372                     throw new NoViableAltException(this);\r
10373                 }\r
10374             }\r
10375         } catch (RecognitionException re) {\r
10376             _localctx.exception = re;\r
10377             _errHandler.reportError(this, re);\r
10378             _errHandler.recover(this, re);\r
10379         } finally {\r
10380             exitRule();\r
10381         }\r
10382         return _localctx;\r
10383     }\r
10384 \r
10385     public static class Yin_element_argContext extends ParserRuleContext {\r
10386         public StringContext string() {\r
10387             return getRuleContext(StringContext.class, 0);\r
10388         }\r
10389 \r
10390         public Yin_element_argContext(ParserRuleContext parent,\r
10391                 int invokingState) {\r
10392             super(parent, invokingState);\r
10393         }\r
10394 \r
10395         @Override\r
10396         public int getRuleIndex() {\r
10397             return RULE_yin_element_arg;\r
10398         }\r
10399 \r
10400         @Override\r
10401         public void enterRule(ParseTreeListener listener) {\r
10402             if (listener instanceof YangParserListener)\r
10403                 ((YangParserListener) listener).enterYin_element_arg(this);\r
10404         }\r
10405 \r
10406         @Override\r
10407         public void exitRule(ParseTreeListener listener) {\r
10408             if (listener instanceof YangParserListener)\r
10409                 ((YangParserListener) listener).exitYin_element_arg(this);\r
10410         }\r
10411 \r
10412         @Override\r
10413         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
10414             if (visitor instanceof YangParserVisitor)\r
10415                 return ((YangParserVisitor<? extends T>) visitor)\r
10416                         .visitYin_element_arg(this);\r
10417             else\r
10418                 return visitor.visitChildren(this);\r
10419         }\r
10420     }\r
10421 \r
10422     public final Yin_element_argContext yin_element_arg()\r
10423             throws RecognitionException {\r
10424         Yin_element_argContext _localctx = new Yin_element_argContext(_ctx,\r
10425                 getState());\r
10426         enterRule(_localctx, 160, RULE_yin_element_arg);\r
10427         try {\r
10428             enterOuterAlt(_localctx, 1);\r
10429             {\r
10430                 setState(1023);\r
10431                 string();\r
10432             }\r
10433         } catch (RecognitionException re) {\r
10434             _localctx.exception = re;\r
10435             _errHandler.reportError(this, re);\r
10436             _errHandler.recover(this, re);\r
10437         } finally {\r
10438             exitRule();\r
10439         }\r
10440         return _localctx;\r
10441     }\r
10442 \r
10443     public static class Yin_element_stmtContext extends ParserRuleContext {\r
10444         public TerminalNode YIN_ELEMENT_KEYWORD() {\r
10445             return getToken(YangParser.YIN_ELEMENT_KEYWORD, 0);\r
10446         }\r
10447 \r
10448         public Yin_element_argContext yin_element_arg() {\r
10449             return getRuleContext(Yin_element_argContext.class, 0);\r
10450         }\r
10451 \r
10452         public StmtendContext stmtend() {\r
10453             return getRuleContext(StmtendContext.class, 0);\r
10454         }\r
10455 \r
10456         public Yin_element_stmtContext(ParserRuleContext parent,\r
10457                 int invokingState) {\r
10458             super(parent, invokingState);\r
10459         }\r
10460 \r
10461         @Override\r
10462         public int getRuleIndex() {\r
10463             return RULE_yin_element_stmt;\r
10464         }\r
10465 \r
10466         @Override\r
10467         public void enterRule(ParseTreeListener listener) {\r
10468             if (listener instanceof YangParserListener)\r
10469                 ((YangParserListener) listener).enterYin_element_stmt(this);\r
10470         }\r
10471 \r
10472         @Override\r
10473         public void exitRule(ParseTreeListener listener) {\r
10474             if (listener instanceof YangParserListener)\r
10475                 ((YangParserListener) listener).exitYin_element_stmt(this);\r
10476         }\r
10477 \r
10478         @Override\r
10479         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
10480             if (visitor instanceof YangParserVisitor)\r
10481                 return ((YangParserVisitor<? extends T>) visitor)\r
10482                         .visitYin_element_stmt(this);\r
10483             else\r
10484                 return visitor.visitChildren(this);\r
10485         }\r
10486     }\r
10487 \r
10488     public final Yin_element_stmtContext yin_element_stmt()\r
10489             throws RecognitionException {\r
10490         Yin_element_stmtContext _localctx = new Yin_element_stmtContext(_ctx,\r
10491                 getState());\r
10492         enterRule(_localctx, 162, RULE_yin_element_stmt);\r
10493         try {\r
10494             enterOuterAlt(_localctx, 1);\r
10495             {\r
10496                 setState(1025);\r
10497                 match(YIN_ELEMENT_KEYWORD);\r
10498                 setState(1026);\r
10499                 yin_element_arg();\r
10500                 setState(1027);\r
10501                 stmtend();\r
10502             }\r
10503         } catch (RecognitionException re) {\r
10504             _localctx.exception = re;\r
10505             _errHandler.reportError(this, re);\r
10506             _errHandler.recover(this, re);\r
10507         } finally {\r
10508             exitRule();\r
10509         }\r
10510         return _localctx;\r
10511     }\r
10512 \r
10513     public static class Argument_stmtContext extends ParserRuleContext {\r
10514         public TerminalNode RIGHT_BRACE() {\r
10515             return getToken(YangParser.RIGHT_BRACE, 0);\r
10516         }\r
10517 \r
10518         public Yin_element_stmtContext yin_element_stmt() {\r
10519             return getRuleContext(Yin_element_stmtContext.class, 0);\r
10520         }\r
10521 \r
10522         public TerminalNode SEMICOLON() {\r
10523             return getToken(YangParser.SEMICOLON, 0);\r
10524         }\r
10525 \r
10526         public StringContext string() {\r
10527             return getRuleContext(StringContext.class, 0);\r
10528         }\r
10529 \r
10530         public TerminalNode LEFT_BRACE() {\r
10531             return getToken(YangParser.LEFT_BRACE, 0);\r
10532         }\r
10533 \r
10534         public TerminalNode ARGUMENT_KEYWORD() {\r
10535             return getToken(YangParser.ARGUMENT_KEYWORD, 0);\r
10536         }\r
10537 \r
10538         public Argument_stmtContext(ParserRuleContext parent, int invokingState) {\r
10539             super(parent, invokingState);\r
10540         }\r
10541 \r
10542         @Override\r
10543         public int getRuleIndex() {\r
10544             return RULE_argument_stmt;\r
10545         }\r
10546 \r
10547         @Override\r
10548         public void enterRule(ParseTreeListener listener) {\r
10549             if (listener instanceof YangParserListener)\r
10550                 ((YangParserListener) listener).enterArgument_stmt(this);\r
10551         }\r
10552 \r
10553         @Override\r
10554         public void exitRule(ParseTreeListener listener) {\r
10555             if (listener instanceof YangParserListener)\r
10556                 ((YangParserListener) listener).exitArgument_stmt(this);\r
10557         }\r
10558 \r
10559         @Override\r
10560         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
10561             if (visitor instanceof YangParserVisitor)\r
10562                 return ((YangParserVisitor<? extends T>) visitor)\r
10563                         .visitArgument_stmt(this);\r
10564             else\r
10565                 return visitor.visitChildren(this);\r
10566         }\r
10567     }\r
10568 \r
10569     public final Argument_stmtContext argument_stmt()\r
10570             throws RecognitionException {\r
10571         Argument_stmtContext _localctx = new Argument_stmtContext(_ctx,\r
10572                 getState());\r
10573         enterRule(_localctx, 164, RULE_argument_stmt);\r
10574         int _la;\r
10575         try {\r
10576             enterOuterAlt(_localctx, 1);\r
10577             {\r
10578                 setState(1029);\r
10579                 match(ARGUMENT_KEYWORD);\r
10580                 setState(1030);\r
10581                 string();\r
10582                 setState(1037);\r
10583                 switch (_input.LA(1)) {\r
10584                 case SEMICOLON: {\r
10585                     setState(1031);\r
10586                     match(SEMICOLON);\r
10587                 }\r
10588                     break;\r
10589                 case LEFT_BRACE: {\r
10590                     {\r
10591                         setState(1032);\r
10592                         match(LEFT_BRACE);\r
10593                         setState(1034);\r
10594                         _la = _input.LA(1);\r
10595                         if (_la == YIN_ELEMENT_KEYWORD) {\r
10596                             {\r
10597                                 setState(1033);\r
10598                                 yin_element_stmt();\r
10599                             }\r
10600                         }\r
10601 \r
10602                         setState(1036);\r
10603                         match(RIGHT_BRACE);\r
10604                     }\r
10605                 }\r
10606                     break;\r
10607                 default:\r
10608                     throw new NoViableAltException(this);\r
10609                 }\r
10610             }\r
10611         } catch (RecognitionException re) {\r
10612             _localctx.exception = re;\r
10613             _errHandler.reportError(this, re);\r
10614             _errHandler.recover(this, re);\r
10615         } finally {\r
10616             exitRule();\r
10617         }\r
10618         return _localctx;\r
10619     }\r
10620 \r
10621     public static class Extension_stmtContext extends ParserRuleContext {\r
10622         public TerminalNode RIGHT_BRACE() {\r
10623             return getToken(YangParser.RIGHT_BRACE, 0);\r
10624         }\r
10625 \r
10626         public TerminalNode EXTENSION_KEYWORD() {\r
10627             return getToken(YangParser.EXTENSION_KEYWORD, 0);\r
10628         }\r
10629 \r
10630         public List<Reference_stmtContext> reference_stmt() {\r
10631             return getRuleContexts(Reference_stmtContext.class);\r
10632         }\r
10633 \r
10634         public Description_stmtContext description_stmt(int i) {\r
10635             return getRuleContext(Description_stmtContext.class, i);\r
10636         }\r
10637 \r
10638         public List<Argument_stmtContext> argument_stmt() {\r
10639             return getRuleContexts(Argument_stmtContext.class);\r
10640         }\r
10641 \r
10642         public TerminalNode LEFT_BRACE() {\r
10643             return getToken(YangParser.LEFT_BRACE, 0);\r
10644         }\r
10645 \r
10646         public Status_stmtContext status_stmt(int i) {\r
10647             return getRuleContext(Status_stmtContext.class, i);\r
10648         }\r
10649 \r
10650         public TerminalNode SEMICOLON() {\r
10651             return getToken(YangParser.SEMICOLON, 0);\r
10652         }\r
10653 \r
10654         public List<Status_stmtContext> status_stmt() {\r
10655             return getRuleContexts(Status_stmtContext.class);\r
10656         }\r
10657 \r
10658         public StringContext string() {\r
10659             return getRuleContext(StringContext.class, 0);\r
10660         }\r
10661 \r
10662         public List<Description_stmtContext> description_stmt() {\r
10663             return getRuleContexts(Description_stmtContext.class);\r
10664         }\r
10665 \r
10666         public Reference_stmtContext reference_stmt(int i) {\r
10667             return getRuleContext(Reference_stmtContext.class, i);\r
10668         }\r
10669 \r
10670         public Argument_stmtContext argument_stmt(int i) {\r
10671             return getRuleContext(Argument_stmtContext.class, i);\r
10672         }\r
10673 \r
10674         public Extension_stmtContext(ParserRuleContext parent, int invokingState) {\r
10675             super(parent, invokingState);\r
10676         }\r
10677 \r
10678         @Override\r
10679         public int getRuleIndex() {\r
10680             return RULE_extension_stmt;\r
10681         }\r
10682 \r
10683         @Override\r
10684         public void enterRule(ParseTreeListener listener) {\r
10685             if (listener instanceof YangParserListener)\r
10686                 ((YangParserListener) listener).enterExtension_stmt(this);\r
10687         }\r
10688 \r
10689         @Override\r
10690         public void exitRule(ParseTreeListener listener) {\r
10691             if (listener instanceof YangParserListener)\r
10692                 ((YangParserListener) listener).exitExtension_stmt(this);\r
10693         }\r
10694 \r
10695         @Override\r
10696         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
10697             if (visitor instanceof YangParserVisitor)\r
10698                 return ((YangParserVisitor<? extends T>) visitor)\r
10699                         .visitExtension_stmt(this);\r
10700             else\r
10701                 return visitor.visitChildren(this);\r
10702         }\r
10703     }\r
10704 \r
10705     public final Extension_stmtContext extension_stmt()\r
10706             throws RecognitionException {\r
10707         Extension_stmtContext _localctx = new Extension_stmtContext(_ctx,\r
10708                 getState());\r
10709         enterRule(_localctx, 166, RULE_extension_stmt);\r
10710         int _la;\r
10711         try {\r
10712             enterOuterAlt(_localctx, 1);\r
10713             {\r
10714                 setState(1039);\r
10715                 match(EXTENSION_KEYWORD);\r
10716                 setState(1040);\r
10717                 string();\r
10718                 setState(1053);\r
10719                 switch (_input.LA(1)) {\r
10720                 case SEMICOLON: {\r
10721                     setState(1041);\r
10722                     match(SEMICOLON);\r
10723                 }\r
10724                     break;\r
10725                 case LEFT_BRACE: {\r
10726                     {\r
10727                         setState(1042);\r
10728                         match(LEFT_BRACE);\r
10729                         setState(1049);\r
10730                         _errHandler.sync(this);\r
10731                         _la = _input.LA(1);\r
10732                         while (((((_la - 18)) & ~0x3f) == 0 && ((1L << (_la - 18)) & ((1L << (STATUS_KEYWORD - 18))\r
10733                                 | (1L << (REFERENCE_KEYWORD - 18))\r
10734                                 | (1L << (DESCRIPTION_KEYWORD - 18)) | (1L << (ARGUMENT_KEYWORD - 18)))) != 0)) {\r
10735                             {\r
10736                                 setState(1047);\r
10737                                 switch (_input.LA(1)) {\r
10738                                 case ARGUMENT_KEYWORD: {\r
10739                                     setState(1043);\r
10740                                     argument_stmt();\r
10741                                 }\r
10742                                     break;\r
10743                                 case STATUS_KEYWORD: {\r
10744                                     setState(1044);\r
10745                                     status_stmt();\r
10746                                 }\r
10747                                     break;\r
10748                                 case DESCRIPTION_KEYWORD: {\r
10749                                     setState(1045);\r
10750                                     description_stmt();\r
10751                                 }\r
10752                                     break;\r
10753                                 case REFERENCE_KEYWORD: {\r
10754                                     setState(1046);\r
10755                                     reference_stmt();\r
10756                                 }\r
10757                                     break;\r
10758                                 default:\r
10759                                     throw new NoViableAltException(this);\r
10760                                 }\r
10761                             }\r
10762                             setState(1051);\r
10763                             _errHandler.sync(this);\r
10764                             _la = _input.LA(1);\r
10765                         }\r
10766                         setState(1052);\r
10767                         match(RIGHT_BRACE);\r
10768                     }\r
10769                 }\r
10770                     break;\r
10771                 default:\r
10772                     throw new NoViableAltException(this);\r
10773                 }\r
10774             }\r
10775         } catch (RecognitionException re) {\r
10776             _localctx.exception = re;\r
10777             _errHandler.reportError(this, re);\r
10778             _errHandler.recover(this, re);\r
10779         } finally {\r
10780             exitRule();\r
10781         }\r
10782         return _localctx;\r
10783     }\r
10784 \r
10785     public static class Revision_date_stmtContext extends ParserRuleContext {\r
10786         public TerminalNode REVISION_DATE_KEYWORD() {\r
10787             return getToken(YangParser.REVISION_DATE_KEYWORD, 0);\r
10788         }\r
10789 \r
10790         public StringContext string() {\r
10791             return getRuleContext(StringContext.class, 0);\r
10792         }\r
10793 \r
10794         public StmtendContext stmtend() {\r
10795             return getRuleContext(StmtendContext.class, 0);\r
10796         }\r
10797 \r
10798         public Revision_date_stmtContext(ParserRuleContext parent,\r
10799                 int invokingState) {\r
10800             super(parent, invokingState);\r
10801         }\r
10802 \r
10803         @Override\r
10804         public int getRuleIndex() {\r
10805             return RULE_revision_date_stmt;\r
10806         }\r
10807 \r
10808         @Override\r
10809         public void enterRule(ParseTreeListener listener) {\r
10810             if (listener instanceof YangParserListener)\r
10811                 ((YangParserListener) listener).enterRevision_date_stmt(this);\r
10812         }\r
10813 \r
10814         @Override\r
10815         public void exitRule(ParseTreeListener listener) {\r
10816             if (listener instanceof YangParserListener)\r
10817                 ((YangParserListener) listener).exitRevision_date_stmt(this);\r
10818         }\r
10819 \r
10820         @Override\r
10821         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
10822             if (visitor instanceof YangParserVisitor)\r
10823                 return ((YangParserVisitor<? extends T>) visitor)\r
10824                         .visitRevision_date_stmt(this);\r
10825             else\r
10826                 return visitor.visitChildren(this);\r
10827         }\r
10828     }\r
10829 \r
10830     public final Revision_date_stmtContext revision_date_stmt()\r
10831             throws RecognitionException {\r
10832         Revision_date_stmtContext _localctx = new Revision_date_stmtContext(\r
10833                 _ctx, getState());\r
10834         enterRule(_localctx, 168, RULE_revision_date_stmt);\r
10835         try {\r
10836             enterOuterAlt(_localctx, 1);\r
10837             {\r
10838                 setState(1055);\r
10839                 match(REVISION_DATE_KEYWORD);\r
10840                 setState(1056);\r
10841                 string();\r
10842                 setState(1057);\r
10843                 stmtend();\r
10844             }\r
10845         } catch (RecognitionException re) {\r
10846             _localctx.exception = re;\r
10847             _errHandler.reportError(this, re);\r
10848             _errHandler.recover(this, re);\r
10849         } finally {\r
10850             exitRule();\r
10851         }\r
10852         return _localctx;\r
10853     }\r
10854 \r
10855     public static class Revision_stmtContext extends ParserRuleContext {\r
10856         public TerminalNode RIGHT_BRACE() {\r
10857             return getToken(YangParser.RIGHT_BRACE, 0);\r
10858         }\r
10859 \r
10860         public Reference_stmtContext reference_stmt() {\r
10861             return getRuleContext(Reference_stmtContext.class, 0);\r
10862         }\r
10863 \r
10864         public TerminalNode SEMICOLON() {\r
10865             return getToken(YangParser.SEMICOLON, 0);\r
10866         }\r
10867 \r
10868         public TerminalNode REVISION_KEYWORD() {\r
10869             return getToken(YangParser.REVISION_KEYWORD, 0);\r
10870         }\r
10871 \r
10872         public StringContext string() {\r
10873             return getRuleContext(StringContext.class, 0);\r
10874         }\r
10875 \r
10876         public Description_stmtContext description_stmt() {\r
10877             return getRuleContext(Description_stmtContext.class, 0);\r
10878         }\r
10879 \r
10880         public TerminalNode LEFT_BRACE() {\r
10881             return getToken(YangParser.LEFT_BRACE, 0);\r
10882         }\r
10883 \r
10884         public Revision_stmtContext(ParserRuleContext parent, int invokingState) {\r
10885             super(parent, invokingState);\r
10886         }\r
10887 \r
10888         @Override\r
10889         public int getRuleIndex() {\r
10890             return RULE_revision_stmt;\r
10891         }\r
10892 \r
10893         @Override\r
10894         public void enterRule(ParseTreeListener listener) {\r
10895             if (listener instanceof YangParserListener)\r
10896                 ((YangParserListener) listener).enterRevision_stmt(this);\r
10897         }\r
10898 \r
10899         @Override\r
10900         public void exitRule(ParseTreeListener listener) {\r
10901             if (listener instanceof YangParserListener)\r
10902                 ((YangParserListener) listener).exitRevision_stmt(this);\r
10903         }\r
10904 \r
10905         @Override\r
10906         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
10907             if (visitor instanceof YangParserVisitor)\r
10908                 return ((YangParserVisitor<? extends T>) visitor)\r
10909                         .visitRevision_stmt(this);\r
10910             else\r
10911                 return visitor.visitChildren(this);\r
10912         }\r
10913     }\r
10914 \r
10915     public final Revision_stmtContext revision_stmt()\r
10916             throws RecognitionException {\r
10917         Revision_stmtContext _localctx = new Revision_stmtContext(_ctx,\r
10918                 getState());\r
10919         enterRule(_localctx, 170, RULE_revision_stmt);\r
10920         int _la;\r
10921         try {\r
10922             enterOuterAlt(_localctx, 1);\r
10923             {\r
10924                 setState(1059);\r
10925                 match(REVISION_KEYWORD);\r
10926                 setState(1060);\r
10927                 string();\r
10928                 setState(1070);\r
10929                 switch (_input.LA(1)) {\r
10930                 case SEMICOLON: {\r
10931                     setState(1061);\r
10932                     match(SEMICOLON);\r
10933                 }\r
10934                     break;\r
10935                 case LEFT_BRACE: {\r
10936                     {\r
10937                         setState(1062);\r
10938                         match(LEFT_BRACE);\r
10939                         setState(1064);\r
10940                         _la = _input.LA(1);\r
10941                         if (_la == DESCRIPTION_KEYWORD) {\r
10942                             {\r
10943                                 setState(1063);\r
10944                                 description_stmt();\r
10945                             }\r
10946                         }\r
10947 \r
10948                         setState(1067);\r
10949                         _la = _input.LA(1);\r
10950                         if (_la == REFERENCE_KEYWORD) {\r
10951                             {\r
10952                                 setState(1066);\r
10953                                 reference_stmt();\r
10954                             }\r
10955                         }\r
10956 \r
10957                         setState(1069);\r
10958                         match(RIGHT_BRACE);\r
10959                     }\r
10960                 }\r
10961                     break;\r
10962                 default:\r
10963                     throw new NoViableAltException(this);\r
10964                 }\r
10965             }\r
10966         } catch (RecognitionException re) {\r
10967             _localctx.exception = re;\r
10968             _errHandler.reportError(this, re);\r
10969             _errHandler.recover(this, re);\r
10970         } finally {\r
10971             exitRule();\r
10972         }\r
10973         return _localctx;\r
10974     }\r
10975 \r
10976     public static class Units_stmtContext extends ParserRuleContext {\r
10977         public TerminalNode UNITS_KEYWORD() {\r
10978             return getToken(YangParser.UNITS_KEYWORD, 0);\r
10979         }\r
10980 \r
10981         public StringContext string() {\r
10982             return getRuleContext(StringContext.class, 0);\r
10983         }\r
10984 \r
10985         public StmtendContext stmtend() {\r
10986             return getRuleContext(StmtendContext.class, 0);\r
10987         }\r
10988 \r
10989         public Units_stmtContext(ParserRuleContext parent, int invokingState) {\r
10990             super(parent, invokingState);\r
10991         }\r
10992 \r
10993         @Override\r
10994         public int getRuleIndex() {\r
10995             return RULE_units_stmt;\r
10996         }\r
10997 \r
10998         @Override\r
10999         public void enterRule(ParseTreeListener listener) {\r
11000             if (listener instanceof YangParserListener)\r
11001                 ((YangParserListener) listener).enterUnits_stmt(this);\r
11002         }\r
11003 \r
11004         @Override\r
11005         public void exitRule(ParseTreeListener listener) {\r
11006             if (listener instanceof YangParserListener)\r
11007                 ((YangParserListener) listener).exitUnits_stmt(this);\r
11008         }\r
11009 \r
11010         @Override\r
11011         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
11012             if (visitor instanceof YangParserVisitor)\r
11013                 return ((YangParserVisitor<? extends T>) visitor)\r
11014                         .visitUnits_stmt(this);\r
11015             else\r
11016                 return visitor.visitChildren(this);\r
11017         }\r
11018     }\r
11019 \r
11020     public final Units_stmtContext units_stmt() throws RecognitionException {\r
11021         Units_stmtContext _localctx = new Units_stmtContext(_ctx, getState());\r
11022         enterRule(_localctx, 172, RULE_units_stmt);\r
11023         try {\r
11024             enterOuterAlt(_localctx, 1);\r
11025             {\r
11026                 setState(1072);\r
11027                 match(UNITS_KEYWORD);\r
11028                 setState(1073);\r
11029                 string();\r
11030                 setState(1074);\r
11031                 stmtend();\r
11032             }\r
11033         } catch (RecognitionException re) {\r
11034             _localctx.exception = re;\r
11035             _errHandler.reportError(this, re);\r
11036             _errHandler.recover(this, re);\r
11037         } finally {\r
11038             exitRule();\r
11039         }\r
11040         return _localctx;\r
11041     }\r
11042 \r
11043     public static class Reference_stmtContext extends ParserRuleContext {\r
11044         public StringContext string() {\r
11045             return getRuleContext(StringContext.class, 0);\r
11046         }\r
11047 \r
11048         public StmtendContext stmtend() {\r
11049             return getRuleContext(StmtendContext.class, 0);\r
11050         }\r
11051 \r
11052         public TerminalNode REFERENCE_KEYWORD() {\r
11053             return getToken(YangParser.REFERENCE_KEYWORD, 0);\r
11054         }\r
11055 \r
11056         public Reference_stmtContext(ParserRuleContext parent, int invokingState) {\r
11057             super(parent, invokingState);\r
11058         }\r
11059 \r
11060         @Override\r
11061         public int getRuleIndex() {\r
11062             return RULE_reference_stmt;\r
11063         }\r
11064 \r
11065         @Override\r
11066         public void enterRule(ParseTreeListener listener) {\r
11067             if (listener instanceof YangParserListener)\r
11068                 ((YangParserListener) listener).enterReference_stmt(this);\r
11069         }\r
11070 \r
11071         @Override\r
11072         public void exitRule(ParseTreeListener listener) {\r
11073             if (listener instanceof YangParserListener)\r
11074                 ((YangParserListener) listener).exitReference_stmt(this);\r
11075         }\r
11076 \r
11077         @Override\r
11078         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
11079             if (visitor instanceof YangParserVisitor)\r
11080                 return ((YangParserVisitor<? extends T>) visitor)\r
11081                         .visitReference_stmt(this);\r
11082             else\r
11083                 return visitor.visitChildren(this);\r
11084         }\r
11085     }\r
11086 \r
11087     public final Reference_stmtContext reference_stmt()\r
11088             throws RecognitionException {\r
11089         Reference_stmtContext _localctx = new Reference_stmtContext(_ctx,\r
11090                 getState());\r
11091         enterRule(_localctx, 174, RULE_reference_stmt);\r
11092         try {\r
11093             enterOuterAlt(_localctx, 1);\r
11094             {\r
11095                 setState(1076);\r
11096                 match(REFERENCE_KEYWORD);\r
11097                 setState(1077);\r
11098                 string();\r
11099                 setState(1078);\r
11100                 stmtend();\r
11101             }\r
11102         } catch (RecognitionException re) {\r
11103             _localctx.exception = re;\r
11104             _errHandler.reportError(this, re);\r
11105             _errHandler.recover(this, re);\r
11106         } finally {\r
11107             exitRule();\r
11108         }\r
11109         return _localctx;\r
11110     }\r
11111 \r
11112     public static class Description_stmtContext extends ParserRuleContext {\r
11113         public StringContext string() {\r
11114             return getRuleContext(StringContext.class, 0);\r
11115         }\r
11116 \r
11117         public TerminalNode DESCRIPTION_KEYWORD() {\r
11118             return getToken(YangParser.DESCRIPTION_KEYWORD, 0);\r
11119         }\r
11120 \r
11121         public StmtendContext stmtend() {\r
11122             return getRuleContext(StmtendContext.class, 0);\r
11123         }\r
11124 \r
11125         public Description_stmtContext(ParserRuleContext parent,\r
11126                 int invokingState) {\r
11127             super(parent, invokingState);\r
11128         }\r
11129 \r
11130         @Override\r
11131         public int getRuleIndex() {\r
11132             return RULE_description_stmt;\r
11133         }\r
11134 \r
11135         @Override\r
11136         public void enterRule(ParseTreeListener listener) {\r
11137             if (listener instanceof YangParserListener)\r
11138                 ((YangParserListener) listener).enterDescription_stmt(this);\r
11139         }\r
11140 \r
11141         @Override\r
11142         public void exitRule(ParseTreeListener listener) {\r
11143             if (listener instanceof YangParserListener)\r
11144                 ((YangParserListener) listener).exitDescription_stmt(this);\r
11145         }\r
11146 \r
11147         @Override\r
11148         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
11149             if (visitor instanceof YangParserVisitor)\r
11150                 return ((YangParserVisitor<? extends T>) visitor)\r
11151                         .visitDescription_stmt(this);\r
11152             else\r
11153                 return visitor.visitChildren(this);\r
11154         }\r
11155     }\r
11156 \r
11157     public final Description_stmtContext description_stmt()\r
11158             throws RecognitionException {\r
11159         Description_stmtContext _localctx = new Description_stmtContext(_ctx,\r
11160                 getState());\r
11161         enterRule(_localctx, 176, RULE_description_stmt);\r
11162         try {\r
11163             enterOuterAlt(_localctx, 1);\r
11164             {\r
11165                 setState(1080);\r
11166                 match(DESCRIPTION_KEYWORD);\r
11167                 setState(1081);\r
11168                 string();\r
11169                 setState(1082);\r
11170                 stmtend();\r
11171             }\r
11172         } catch (RecognitionException re) {\r
11173             _localctx.exception = re;\r
11174             _errHandler.reportError(this, re);\r
11175             _errHandler.recover(this, re);\r
11176         } finally {\r
11177             exitRule();\r
11178         }\r
11179         return _localctx;\r
11180     }\r
11181 \r
11182     public static class Contact_stmtContext extends ParserRuleContext {\r
11183         public TerminalNode CONTACT_KEYWORD() {\r
11184             return getToken(YangParser.CONTACT_KEYWORD, 0);\r
11185         }\r
11186 \r
11187         public StringContext string() {\r
11188             return getRuleContext(StringContext.class, 0);\r
11189         }\r
11190 \r
11191         public StmtendContext stmtend() {\r
11192             return getRuleContext(StmtendContext.class, 0);\r
11193         }\r
11194 \r
11195         public Contact_stmtContext(ParserRuleContext parent, int invokingState) {\r
11196             super(parent, invokingState);\r
11197         }\r
11198 \r
11199         @Override\r
11200         public int getRuleIndex() {\r
11201             return RULE_contact_stmt;\r
11202         }\r
11203 \r
11204         @Override\r
11205         public void enterRule(ParseTreeListener listener) {\r
11206             if (listener instanceof YangParserListener)\r
11207                 ((YangParserListener) listener).enterContact_stmt(this);\r
11208         }\r
11209 \r
11210         @Override\r
11211         public void exitRule(ParseTreeListener listener) {\r
11212             if (listener instanceof YangParserListener)\r
11213                 ((YangParserListener) listener).exitContact_stmt(this);\r
11214         }\r
11215 \r
11216         @Override\r
11217         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
11218             if (visitor instanceof YangParserVisitor)\r
11219                 return ((YangParserVisitor<? extends T>) visitor)\r
11220                         .visitContact_stmt(this);\r
11221             else\r
11222                 return visitor.visitChildren(this);\r
11223         }\r
11224     }\r
11225 \r
11226     public final Contact_stmtContext contact_stmt() throws RecognitionException {\r
11227         Contact_stmtContext _localctx = new Contact_stmtContext(_ctx,\r
11228                 getState());\r
11229         enterRule(_localctx, 178, RULE_contact_stmt);\r
11230         try {\r
11231             enterOuterAlt(_localctx, 1);\r
11232             {\r
11233                 setState(1084);\r
11234                 match(CONTACT_KEYWORD);\r
11235                 setState(1085);\r
11236                 string();\r
11237                 setState(1086);\r
11238                 stmtend();\r
11239             }\r
11240         } catch (RecognitionException re) {\r
11241             _localctx.exception = re;\r
11242             _errHandler.reportError(this, re);\r
11243             _errHandler.recover(this, re);\r
11244         } finally {\r
11245             exitRule();\r
11246         }\r
11247         return _localctx;\r
11248     }\r
11249 \r
11250     public static class Organization_stmtContext extends ParserRuleContext {\r
11251         public StringContext string() {\r
11252             return getRuleContext(StringContext.class, 0);\r
11253         }\r
11254 \r
11255         public StmtendContext stmtend() {\r
11256             return getRuleContext(StmtendContext.class, 0);\r
11257         }\r
11258 \r
11259         public TerminalNode ORGANIZATION_KEYWORD() {\r
11260             return getToken(YangParser.ORGANIZATION_KEYWORD, 0);\r
11261         }\r
11262 \r
11263         public Organization_stmtContext(ParserRuleContext parent,\r
11264                 int invokingState) {\r
11265             super(parent, invokingState);\r
11266         }\r
11267 \r
11268         @Override\r
11269         public int getRuleIndex() {\r
11270             return RULE_organization_stmt;\r
11271         }\r
11272 \r
11273         @Override\r
11274         public void enterRule(ParseTreeListener listener) {\r
11275             if (listener instanceof YangParserListener)\r
11276                 ((YangParserListener) listener).enterOrganization_stmt(this);\r
11277         }\r
11278 \r
11279         @Override\r
11280         public void exitRule(ParseTreeListener listener) {\r
11281             if (listener instanceof YangParserListener)\r
11282                 ((YangParserListener) listener).exitOrganization_stmt(this);\r
11283         }\r
11284 \r
11285         @Override\r
11286         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
11287             if (visitor instanceof YangParserVisitor)\r
11288                 return ((YangParserVisitor<? extends T>) visitor)\r
11289                         .visitOrganization_stmt(this);\r
11290             else\r
11291                 return visitor.visitChildren(this);\r
11292         }\r
11293     }\r
11294 \r
11295     public final Organization_stmtContext organization_stmt()\r
11296             throws RecognitionException {\r
11297         Organization_stmtContext _localctx = new Organization_stmtContext(_ctx,\r
11298                 getState());\r
11299         enterRule(_localctx, 180, RULE_organization_stmt);\r
11300         try {\r
11301             enterOuterAlt(_localctx, 1);\r
11302             {\r
11303                 setState(1088);\r
11304                 match(ORGANIZATION_KEYWORD);\r
11305                 setState(1089);\r
11306                 string();\r
11307                 setState(1090);\r
11308                 stmtend();\r
11309             }\r
11310         } catch (RecognitionException re) {\r
11311             _localctx.exception = re;\r
11312             _errHandler.reportError(this, re);\r
11313             _errHandler.recover(this, re);\r
11314         } finally {\r
11315             exitRule();\r
11316         }\r
11317         return _localctx;\r
11318     }\r
11319 \r
11320     public static class Belongs_to_stmtContext extends ParserRuleContext {\r
11321         public TerminalNode RIGHT_BRACE() {\r
11322             return getToken(YangParser.RIGHT_BRACE, 0);\r
11323         }\r
11324 \r
11325         public StringContext string() {\r
11326             return getRuleContext(StringContext.class, 0);\r
11327         }\r
11328 \r
11329         public TerminalNode BELONGS_TO_KEYWORD() {\r
11330             return getToken(YangParser.BELONGS_TO_KEYWORD, 0);\r
11331         }\r
11332 \r
11333         public TerminalNode LEFT_BRACE() {\r
11334             return getToken(YangParser.LEFT_BRACE, 0);\r
11335         }\r
11336 \r
11337         public Prefix_stmtContext prefix_stmt() {\r
11338             return getRuleContext(Prefix_stmtContext.class, 0);\r
11339         }\r
11340 \r
11341         public Belongs_to_stmtContext(ParserRuleContext parent,\r
11342                 int invokingState) {\r
11343             super(parent, invokingState);\r
11344         }\r
11345 \r
11346         @Override\r
11347         public int getRuleIndex() {\r
11348             return RULE_belongs_to_stmt;\r
11349         }\r
11350 \r
11351         @Override\r
11352         public void enterRule(ParseTreeListener listener) {\r
11353             if (listener instanceof YangParserListener)\r
11354                 ((YangParserListener) listener).enterBelongs_to_stmt(this);\r
11355         }\r
11356 \r
11357         @Override\r
11358         public void exitRule(ParseTreeListener listener) {\r
11359             if (listener instanceof YangParserListener)\r
11360                 ((YangParserListener) listener).exitBelongs_to_stmt(this);\r
11361         }\r
11362 \r
11363         @Override\r
11364         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
11365             if (visitor instanceof YangParserVisitor)\r
11366                 return ((YangParserVisitor<? extends T>) visitor)\r
11367                         .visitBelongs_to_stmt(this);\r
11368             else\r
11369                 return visitor.visitChildren(this);\r
11370         }\r
11371     }\r
11372 \r
11373     public final Belongs_to_stmtContext belongs_to_stmt()\r
11374             throws RecognitionException {\r
11375         Belongs_to_stmtContext _localctx = new Belongs_to_stmtContext(_ctx,\r
11376                 getState());\r
11377         enterRule(_localctx, 182, RULE_belongs_to_stmt);\r
11378         try {\r
11379             enterOuterAlt(_localctx, 1);\r
11380             {\r
11381                 setState(1092);\r
11382                 match(BELONGS_TO_KEYWORD);\r
11383                 setState(1093);\r
11384                 string();\r
11385                 setState(1094);\r
11386                 match(LEFT_BRACE);\r
11387                 setState(1095);\r
11388                 prefix_stmt();\r
11389                 setState(1096);\r
11390                 match(RIGHT_BRACE);\r
11391             }\r
11392         } catch (RecognitionException re) {\r
11393             _localctx.exception = re;\r
11394             _errHandler.reportError(this, re);\r
11395             _errHandler.recover(this, re);\r
11396         } finally {\r
11397             exitRule();\r
11398         }\r
11399         return _localctx;\r
11400     }\r
11401 \r
11402     public static class Prefix_stmtContext extends ParserRuleContext {\r
11403         public StringContext string() {\r
11404             return getRuleContext(StringContext.class, 0);\r
11405         }\r
11406 \r
11407         public StmtendContext stmtend() {\r
11408             return getRuleContext(StmtendContext.class, 0);\r
11409         }\r
11410 \r
11411         public TerminalNode PREFIX_KEYWORD() {\r
11412             return getToken(YangParser.PREFIX_KEYWORD, 0);\r
11413         }\r
11414 \r
11415         public Prefix_stmtContext(ParserRuleContext parent, int invokingState) {\r
11416             super(parent, invokingState);\r
11417         }\r
11418 \r
11419         @Override\r
11420         public int getRuleIndex() {\r
11421             return RULE_prefix_stmt;\r
11422         }\r
11423 \r
11424         @Override\r
11425         public void enterRule(ParseTreeListener listener) {\r
11426             if (listener instanceof YangParserListener)\r
11427                 ((YangParserListener) listener).enterPrefix_stmt(this);\r
11428         }\r
11429 \r
11430         @Override\r
11431         public void exitRule(ParseTreeListener listener) {\r
11432             if (listener instanceof YangParserListener)\r
11433                 ((YangParserListener) listener).exitPrefix_stmt(this);\r
11434         }\r
11435 \r
11436         @Override\r
11437         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
11438             if (visitor instanceof YangParserVisitor)\r
11439                 return ((YangParserVisitor<? extends T>) visitor)\r
11440                         .visitPrefix_stmt(this);\r
11441             else\r
11442                 return visitor.visitChildren(this);\r
11443         }\r
11444     }\r
11445 \r
11446     public final Prefix_stmtContext prefix_stmt() throws RecognitionException {\r
11447         Prefix_stmtContext _localctx = new Prefix_stmtContext(_ctx, getState());\r
11448         enterRule(_localctx, 184, RULE_prefix_stmt);\r
11449         try {\r
11450             enterOuterAlt(_localctx, 1);\r
11451             {\r
11452                 setState(1098);\r
11453                 match(PREFIX_KEYWORD);\r
11454                 setState(1099);\r
11455                 string();\r
11456                 setState(1100);\r
11457                 stmtend();\r
11458             }\r
11459         } catch (RecognitionException re) {\r
11460             _localctx.exception = re;\r
11461             _errHandler.reportError(this, re);\r
11462             _errHandler.recover(this, re);\r
11463         } finally {\r
11464             exitRule();\r
11465         }\r
11466         return _localctx;\r
11467     }\r
11468 \r
11469     public static class Namespace_stmtContext extends ParserRuleContext {\r
11470         public StringContext string() {\r
11471             return getRuleContext(StringContext.class, 0);\r
11472         }\r
11473 \r
11474         public TerminalNode NAMESPACE_KEYWORD() {\r
11475             return getToken(YangParser.NAMESPACE_KEYWORD, 0);\r
11476         }\r
11477 \r
11478         public StmtendContext stmtend() {\r
11479             return getRuleContext(StmtendContext.class, 0);\r
11480         }\r
11481 \r
11482         public Namespace_stmtContext(ParserRuleContext parent, int invokingState) {\r
11483             super(parent, invokingState);\r
11484         }\r
11485 \r
11486         @Override\r
11487         public int getRuleIndex() {\r
11488             return RULE_namespace_stmt;\r
11489         }\r
11490 \r
11491         @Override\r
11492         public void enterRule(ParseTreeListener listener) {\r
11493             if (listener instanceof YangParserListener)\r
11494                 ((YangParserListener) listener).enterNamespace_stmt(this);\r
11495         }\r
11496 \r
11497         @Override\r
11498         public void exitRule(ParseTreeListener listener) {\r
11499             if (listener instanceof YangParserListener)\r
11500                 ((YangParserListener) listener).exitNamespace_stmt(this);\r
11501         }\r
11502 \r
11503         @Override\r
11504         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
11505             if (visitor instanceof YangParserVisitor)\r
11506                 return ((YangParserVisitor<? extends T>) visitor)\r
11507                         .visitNamespace_stmt(this);\r
11508             else\r
11509                 return visitor.visitChildren(this);\r
11510         }\r
11511     }\r
11512 \r
11513     public final Namespace_stmtContext namespace_stmt()\r
11514             throws RecognitionException {\r
11515         Namespace_stmtContext _localctx = new Namespace_stmtContext(_ctx,\r
11516                 getState());\r
11517         enterRule(_localctx, 186, RULE_namespace_stmt);\r
11518         try {\r
11519             enterOuterAlt(_localctx, 1);\r
11520             {\r
11521                 setState(1102);\r
11522                 match(NAMESPACE_KEYWORD);\r
11523                 setState(1103);\r
11524                 string();\r
11525                 setState(1104);\r
11526                 stmtend();\r
11527             }\r
11528         } catch (RecognitionException re) {\r
11529             _localctx.exception = re;\r
11530             _errHandler.reportError(this, re);\r
11531             _errHandler.recover(this, re);\r
11532         } finally {\r
11533             exitRule();\r
11534         }\r
11535         return _localctx;\r
11536     }\r
11537 \r
11538     public static class Include_stmtContext extends ParserRuleContext {\r
11539         public TerminalNode RIGHT_BRACE() {\r
11540             return getToken(YangParser.RIGHT_BRACE, 0);\r
11541         }\r
11542 \r
11543         public TerminalNode SEMICOLON() {\r
11544             return getToken(YangParser.SEMICOLON, 0);\r
11545         }\r
11546 \r
11547         public StringContext string() {\r
11548             return getRuleContext(StringContext.class, 0);\r
11549         }\r
11550 \r
11551         public TerminalNode INCLUDE_KEYWORD() {\r
11552             return getToken(YangParser.INCLUDE_KEYWORD, 0);\r
11553         }\r
11554 \r
11555         public TerminalNode LEFT_BRACE() {\r
11556             return getToken(YangParser.LEFT_BRACE, 0);\r
11557         }\r
11558 \r
11559         public Revision_date_stmtContext revision_date_stmt() {\r
11560             return getRuleContext(Revision_date_stmtContext.class, 0);\r
11561         }\r
11562 \r
11563         public Include_stmtContext(ParserRuleContext parent, int invokingState) {\r
11564             super(parent, invokingState);\r
11565         }\r
11566 \r
11567         @Override\r
11568         public int getRuleIndex() {\r
11569             return RULE_include_stmt;\r
11570         }\r
11571 \r
11572         @Override\r
11573         public void enterRule(ParseTreeListener listener) {\r
11574             if (listener instanceof YangParserListener)\r
11575                 ((YangParserListener) listener).enterInclude_stmt(this);\r
11576         }\r
11577 \r
11578         @Override\r
11579         public void exitRule(ParseTreeListener listener) {\r
11580             if (listener instanceof YangParserListener)\r
11581                 ((YangParserListener) listener).exitInclude_stmt(this);\r
11582         }\r
11583 \r
11584         @Override\r
11585         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
11586             if (visitor instanceof YangParserVisitor)\r
11587                 return ((YangParserVisitor<? extends T>) visitor)\r
11588                         .visitInclude_stmt(this);\r
11589             else\r
11590                 return visitor.visitChildren(this);\r
11591         }\r
11592     }\r
11593 \r
11594     public final Include_stmtContext include_stmt() throws RecognitionException {\r
11595         Include_stmtContext _localctx = new Include_stmtContext(_ctx,\r
11596                 getState());\r
11597         enterRule(_localctx, 188, RULE_include_stmt);\r
11598         int _la;\r
11599         try {\r
11600             enterOuterAlt(_localctx, 1);\r
11601             {\r
11602                 setState(1106);\r
11603                 match(INCLUDE_KEYWORD);\r
11604                 setState(1107);\r
11605                 string();\r
11606                 setState(1114);\r
11607                 switch (_input.LA(1)) {\r
11608                 case SEMICOLON: {\r
11609                     setState(1108);\r
11610                     match(SEMICOLON);\r
11611                 }\r
11612                     break;\r
11613                 case LEFT_BRACE: {\r
11614                     {\r
11615                         setState(1109);\r
11616                         match(LEFT_BRACE);\r
11617                         setState(1111);\r
11618                         _la = _input.LA(1);\r
11619                         if (_la == REVISION_DATE_KEYWORD) {\r
11620                             {\r
11621                                 setState(1110);\r
11622                                 revision_date_stmt();\r
11623                             }\r
11624                         }\r
11625 \r
11626                         setState(1113);\r
11627                         match(RIGHT_BRACE);\r
11628                     }\r
11629                 }\r
11630                     break;\r
11631                 default:\r
11632                     throw new NoViableAltException(this);\r
11633                 }\r
11634             }\r
11635         } catch (RecognitionException re) {\r
11636             _localctx.exception = re;\r
11637             _errHandler.reportError(this, re);\r
11638             _errHandler.recover(this, re);\r
11639         } finally {\r
11640             exitRule();\r
11641         }\r
11642         return _localctx;\r
11643     }\r
11644 \r
11645     public static class Import_stmtContext extends ParserRuleContext {\r
11646         public TerminalNode RIGHT_BRACE() {\r
11647             return getToken(YangParser.RIGHT_BRACE, 0);\r
11648         }\r
11649 \r
11650         public StringContext string() {\r
11651             return getRuleContext(StringContext.class, 0);\r
11652         }\r
11653 \r
11654         public TerminalNode LEFT_BRACE() {\r
11655             return getToken(YangParser.LEFT_BRACE, 0);\r
11656         }\r
11657 \r
11658         public Prefix_stmtContext prefix_stmt() {\r
11659             return getRuleContext(Prefix_stmtContext.class, 0);\r
11660         }\r
11661 \r
11662         public Revision_date_stmtContext revision_date_stmt() {\r
11663             return getRuleContext(Revision_date_stmtContext.class, 0);\r
11664         }\r
11665 \r
11666         public TerminalNode IMPORT_KEYWORD() {\r
11667             return getToken(YangParser.IMPORT_KEYWORD, 0);\r
11668         }\r
11669 \r
11670         public Import_stmtContext(ParserRuleContext parent, int invokingState) {\r
11671             super(parent, invokingState);\r
11672         }\r
11673 \r
11674         @Override\r
11675         public int getRuleIndex() {\r
11676             return RULE_import_stmt;\r
11677         }\r
11678 \r
11679         @Override\r
11680         public void enterRule(ParseTreeListener listener) {\r
11681             if (listener instanceof YangParserListener)\r
11682                 ((YangParserListener) listener).enterImport_stmt(this);\r
11683         }\r
11684 \r
11685         @Override\r
11686         public void exitRule(ParseTreeListener listener) {\r
11687             if (listener instanceof YangParserListener)\r
11688                 ((YangParserListener) listener).exitImport_stmt(this);\r
11689         }\r
11690 \r
11691         @Override\r
11692         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
11693             if (visitor instanceof YangParserVisitor)\r
11694                 return ((YangParserVisitor<? extends T>) visitor)\r
11695                         .visitImport_stmt(this);\r
11696             else\r
11697                 return visitor.visitChildren(this);\r
11698         }\r
11699     }\r
11700 \r
11701     public final Import_stmtContext import_stmt() throws RecognitionException {\r
11702         Import_stmtContext _localctx = new Import_stmtContext(_ctx, getState());\r
11703         enterRule(_localctx, 190, RULE_import_stmt);\r
11704         int _la;\r
11705         try {\r
11706             enterOuterAlt(_localctx, 1);\r
11707             {\r
11708                 setState(1116);\r
11709                 match(IMPORT_KEYWORD);\r
11710                 setState(1117);\r
11711                 string();\r
11712                 setState(1118);\r
11713                 match(LEFT_BRACE);\r
11714                 setState(1119);\r
11715                 prefix_stmt();\r
11716                 setState(1121);\r
11717                 _la = _input.LA(1);\r
11718                 if (_la == REVISION_DATE_KEYWORD) {\r
11719                     {\r
11720                         setState(1120);\r
11721                         revision_date_stmt();\r
11722                     }\r
11723                 }\r
11724 \r
11725                 setState(1123);\r
11726                 match(RIGHT_BRACE);\r
11727             }\r
11728         } catch (RecognitionException re) {\r
11729             _localctx.exception = re;\r
11730             _errHandler.reportError(this, re);\r
11731             _errHandler.recover(this, re);\r
11732         } finally {\r
11733             exitRule();\r
11734         }\r
11735         return _localctx;\r
11736     }\r
11737 \r
11738     public static class Yang_version_stmtContext extends ParserRuleContext {\r
11739         public StringContext string() {\r
11740             return getRuleContext(StringContext.class, 0);\r
11741         }\r
11742 \r
11743         public StmtendContext stmtend() {\r
11744             return getRuleContext(StmtendContext.class, 0);\r
11745         }\r
11746 \r
11747         public TerminalNode YANG_VERSION_KEYWORD() {\r
11748             return getToken(YangParser.YANG_VERSION_KEYWORD, 0);\r
11749         }\r
11750 \r
11751         public Yang_version_stmtContext(ParserRuleContext parent,\r
11752                 int invokingState) {\r
11753             super(parent, invokingState);\r
11754         }\r
11755 \r
11756         @Override\r
11757         public int getRuleIndex() {\r
11758             return RULE_yang_version_stmt;\r
11759         }\r
11760 \r
11761         @Override\r
11762         public void enterRule(ParseTreeListener listener) {\r
11763             if (listener instanceof YangParserListener)\r
11764                 ((YangParserListener) listener).enterYang_version_stmt(this);\r
11765         }\r
11766 \r
11767         @Override\r
11768         public void exitRule(ParseTreeListener listener) {\r
11769             if (listener instanceof YangParserListener)\r
11770                 ((YangParserListener) listener).exitYang_version_stmt(this);\r
11771         }\r
11772 \r
11773         @Override\r
11774         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
11775             if (visitor instanceof YangParserVisitor)\r
11776                 return ((YangParserVisitor<? extends T>) visitor)\r
11777                         .visitYang_version_stmt(this);\r
11778             else\r
11779                 return visitor.visitChildren(this);\r
11780         }\r
11781     }\r
11782 \r
11783     public final Yang_version_stmtContext yang_version_stmt()\r
11784             throws RecognitionException {\r
11785         Yang_version_stmtContext _localctx = new Yang_version_stmtContext(_ctx,\r
11786                 getState());\r
11787         enterRule(_localctx, 192, RULE_yang_version_stmt);\r
11788         try {\r
11789             enterOuterAlt(_localctx, 1);\r
11790             {\r
11791                 setState(1125);\r
11792                 match(YANG_VERSION_KEYWORD);\r
11793                 setState(1126);\r
11794                 string();\r
11795                 setState(1127);\r
11796                 stmtend();\r
11797             }\r
11798         } catch (RecognitionException re) {\r
11799             _localctx.exception = re;\r
11800             _errHandler.reportError(this, re);\r
11801             _errHandler.recover(this, re);\r
11802         } finally {\r
11803             exitRule();\r
11804         }\r
11805         return _localctx;\r
11806     }\r
11807 \r
11808     public static class Data_def_stmtContext extends ParserRuleContext {\r
11809         public Uses_stmtContext uses_stmt() {\r
11810             return getRuleContext(Uses_stmtContext.class, 0);\r
11811         }\r
11812 \r
11813         public Anyxml_stmtContext anyxml_stmt() {\r
11814             return getRuleContext(Anyxml_stmtContext.class, 0);\r
11815         }\r
11816 \r
11817         public List_stmtContext list_stmt() {\r
11818             return getRuleContext(List_stmtContext.class, 0);\r
11819         }\r
11820 \r
11821         public Leaf_stmtContext leaf_stmt() {\r
11822             return getRuleContext(Leaf_stmtContext.class, 0);\r
11823         }\r
11824 \r
11825         public Container_stmtContext container_stmt() {\r
11826             return getRuleContext(Container_stmtContext.class, 0);\r
11827         }\r
11828 \r
11829         public Choice_stmtContext choice_stmt() {\r
11830             return getRuleContext(Choice_stmtContext.class, 0);\r
11831         }\r
11832 \r
11833         public Leaf_list_stmtContext leaf_list_stmt() {\r
11834             return getRuleContext(Leaf_list_stmtContext.class, 0);\r
11835         }\r
11836 \r
11837         public Data_def_stmtContext(ParserRuleContext parent, int invokingState) {\r
11838             super(parent, invokingState);\r
11839         }\r
11840 \r
11841         @Override\r
11842         public int getRuleIndex() {\r
11843             return RULE_data_def_stmt;\r
11844         }\r
11845 \r
11846         @Override\r
11847         public void enterRule(ParseTreeListener listener) {\r
11848             if (listener instanceof YangParserListener)\r
11849                 ((YangParserListener) listener).enterData_def_stmt(this);\r
11850         }\r
11851 \r
11852         @Override\r
11853         public void exitRule(ParseTreeListener listener) {\r
11854             if (listener instanceof YangParserListener)\r
11855                 ((YangParserListener) listener).exitData_def_stmt(this);\r
11856         }\r
11857 \r
11858         @Override\r
11859         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
11860             if (visitor instanceof YangParserVisitor)\r
11861                 return ((YangParserVisitor<? extends T>) visitor)\r
11862                         .visitData_def_stmt(this);\r
11863             else\r
11864                 return visitor.visitChildren(this);\r
11865         }\r
11866     }\r
11867 \r
11868     public final Data_def_stmtContext data_def_stmt()\r
11869             throws RecognitionException {\r
11870         Data_def_stmtContext _localctx = new Data_def_stmtContext(_ctx,\r
11871                 getState());\r
11872         enterRule(_localctx, 194, RULE_data_def_stmt);\r
11873         try {\r
11874             setState(1136);\r
11875             switch (_input.LA(1)) {\r
11876             case CONTAINER_KEYWORD:\r
11877                 enterOuterAlt(_localctx, 1);\r
11878                 {\r
11879                     setState(1129);\r
11880                     container_stmt();\r
11881                 }\r
11882                 break;\r
11883             case LEAF_KEYWORD:\r
11884                 enterOuterAlt(_localctx, 2);\r
11885                 {\r
11886                     setState(1130);\r
11887                     leaf_stmt();\r
11888                 }\r
11889                 break;\r
11890             case LEAF_LIST_KEYWORD:\r
11891                 enterOuterAlt(_localctx, 3);\r
11892                 {\r
11893                     setState(1131);\r
11894                     leaf_list_stmt();\r
11895                 }\r
11896                 break;\r
11897             case LIST_KEYWORD:\r
11898                 enterOuterAlt(_localctx, 4);\r
11899                 {\r
11900                     setState(1132);\r
11901                     list_stmt();\r
11902                 }\r
11903                 break;\r
11904             case CHOICE_KEYWORD:\r
11905                 enterOuterAlt(_localctx, 5);\r
11906                 {\r
11907                     setState(1133);\r
11908                     choice_stmt();\r
11909                 }\r
11910                 break;\r
11911             case ANYXML_KEYWORD:\r
11912                 enterOuterAlt(_localctx, 6);\r
11913                 {\r
11914                     setState(1134);\r
11915                     anyxml_stmt();\r
11916                 }\r
11917                 break;\r
11918             case USES_KEYWORD:\r
11919                 enterOuterAlt(_localctx, 7);\r
11920                 {\r
11921                     setState(1135);\r
11922                     uses_stmt();\r
11923                 }\r
11924                 break;\r
11925             default:\r
11926                 throw new NoViableAltException(this);\r
11927             }\r
11928         } catch (RecognitionException re) {\r
11929             _localctx.exception = re;\r
11930             _errHandler.reportError(this, re);\r
11931             _errHandler.recover(this, re);\r
11932         } finally {\r
11933             exitRule();\r
11934         }\r
11935         return _localctx;\r
11936     }\r
11937 \r
11938     public static class Body_stmtsContext extends ParserRuleContext {\r
11939         public List<Grouping_stmtContext> grouping_stmt() {\r
11940             return getRuleContexts(Grouping_stmtContext.class);\r
11941         }\r
11942 \r
11943         public List<Feature_stmtContext> feature_stmt() {\r
11944             return getRuleContexts(Feature_stmtContext.class);\r
11945         }\r
11946 \r
11947         public Identity_stmtContext identity_stmt(int i) {\r
11948             return getRuleContext(Identity_stmtContext.class, i);\r
11949         }\r
11950 \r
11951         public Typedef_stmtContext typedef_stmt(int i) {\r
11952             return getRuleContext(Typedef_stmtContext.class, i);\r
11953         }\r
11954 \r
11955         public List<Notification_stmtContext> notification_stmt() {\r
11956             return getRuleContexts(Notification_stmtContext.class);\r
11957         }\r
11958 \r
11959         public Grouping_stmtContext grouping_stmt(int i) {\r
11960             return getRuleContext(Grouping_stmtContext.class, i);\r
11961         }\r
11962 \r
11963         public Deviation_stmtContext deviation_stmt(int i) {\r
11964             return getRuleContext(Deviation_stmtContext.class, i);\r
11965         }\r
11966 \r
11967         public Rpc_stmtContext rpc_stmt(int i) {\r
11968             return getRuleContext(Rpc_stmtContext.class, i);\r
11969         }\r
11970 \r
11971         public Feature_stmtContext feature_stmt(int i) {\r
11972             return getRuleContext(Feature_stmtContext.class, i);\r
11973         }\r
11974 \r
11975         public List<Augment_stmtContext> augment_stmt() {\r
11976             return getRuleContexts(Augment_stmtContext.class);\r
11977         }\r
11978 \r
11979         public List<Rpc_stmtContext> rpc_stmt() {\r
11980             return getRuleContexts(Rpc_stmtContext.class);\r
11981         }\r
11982 \r
11983         public List<Typedef_stmtContext> typedef_stmt() {\r
11984             return getRuleContexts(Typedef_stmtContext.class);\r
11985         }\r
11986 \r
11987         public Data_def_stmtContext data_def_stmt(int i) {\r
11988             return getRuleContext(Data_def_stmtContext.class, i);\r
11989         }\r
11990 \r
11991         public List<Extension_stmtContext> extension_stmt() {\r
11992             return getRuleContexts(Extension_stmtContext.class);\r
11993         }\r
11994 \r
11995         public Extension_stmtContext extension_stmt(int i) {\r
11996             return getRuleContext(Extension_stmtContext.class, i);\r
11997         }\r
11998 \r
11999         public List<Data_def_stmtContext> data_def_stmt() {\r
12000             return getRuleContexts(Data_def_stmtContext.class);\r
12001         }\r
12002 \r
12003         public List<Identity_stmtContext> identity_stmt() {\r
12004             return getRuleContexts(Identity_stmtContext.class);\r
12005         }\r
12006 \r
12007         public List<Deviation_stmtContext> deviation_stmt() {\r
12008             return getRuleContexts(Deviation_stmtContext.class);\r
12009         }\r
12010 \r
12011         public Augment_stmtContext augment_stmt(int i) {\r
12012             return getRuleContext(Augment_stmtContext.class, i);\r
12013         }\r
12014 \r
12015         public Notification_stmtContext notification_stmt(int i) {\r
12016             return getRuleContext(Notification_stmtContext.class, i);\r
12017         }\r
12018 \r
12019         public Body_stmtsContext(ParserRuleContext parent, int invokingState) {\r
12020             super(parent, invokingState);\r
12021         }\r
12022 \r
12023         @Override\r
12024         public int getRuleIndex() {\r
12025             return RULE_body_stmts;\r
12026         }\r
12027 \r
12028         @Override\r
12029         public void enterRule(ParseTreeListener listener) {\r
12030             if (listener instanceof YangParserListener)\r
12031                 ((YangParserListener) listener).enterBody_stmts(this);\r
12032         }\r
12033 \r
12034         @Override\r
12035         public void exitRule(ParseTreeListener listener) {\r
12036             if (listener instanceof YangParserListener)\r
12037                 ((YangParserListener) listener).exitBody_stmts(this);\r
12038         }\r
12039 \r
12040         @Override\r
12041         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
12042             if (visitor instanceof YangParserVisitor)\r
12043                 return ((YangParserVisitor<? extends T>) visitor)\r
12044                         .visitBody_stmts(this);\r
12045             else\r
12046                 return visitor.visitChildren(this);\r
12047         }\r
12048     }\r
12049 \r
12050     public final Body_stmtsContext body_stmts() throws RecognitionException {\r
12051         Body_stmtsContext _localctx = new Body_stmtsContext(_ctx, getState());\r
12052         enterRule(_localctx, 196, RULE_body_stmts);\r
12053         int _la;\r
12054         try {\r
12055             enterOuterAlt(_localctx, 1);\r
12056             {\r
12057                 setState(1152);\r
12058                 _errHandler.sync(this);\r
12059                 _la = _input.LA(1);\r
12060                 while (((((_la - 12)) & ~0x3f) == 0 && ((1L << (_la - 12)) & ((1L << (USES_KEYWORD - 12))\r
12061                         | (1L << (TYPEDEF_KEYWORD - 12))\r
12062                         | (1L << (RPC_KEYWORD - 12))\r
12063                         | (1L << (NOTIFICATION_KEYWORD - 12))\r
12064                         | (1L << (LIST_KEYWORD - 12))\r
12065                         | (1L << (LEAF_LIST_KEYWORD - 12))\r
12066                         | (1L << (LEAF_KEYWORD - 12))\r
12067                         | (1L << (IDENTITY_KEYWORD - 12))\r
12068                         | (1L << (GROUPING_KEYWORD - 12))\r
12069                         | (1L << (FEATURE_KEYWORD - 12))\r
12070                         | (1L << (DEVIATION_KEYWORD - 12))\r
12071                         | (1L << (EXTENSION_KEYWORD - 12))\r
12072                         | (1L << (CONTAINER_KEYWORD - 12))\r
12073                         | (1L << (CHOICE_KEYWORD - 12))\r
12074                         | (1L << (AUGMENT_KEYWORD - 12)) | (1L << (ANYXML_KEYWORD - 12)))) != 0)) {\r
12075                     {\r
12076                         {\r
12077                             setState(1148);\r
12078                             switch (_input.LA(1)) {\r
12079                             case EXTENSION_KEYWORD: {\r
12080                                 setState(1138);\r
12081                                 extension_stmt();\r
12082                             }\r
12083                                 break;\r
12084                             case FEATURE_KEYWORD: {\r
12085                                 setState(1139);\r
12086                                 feature_stmt();\r
12087                             }\r
12088                                 break;\r
12089                             case IDENTITY_KEYWORD: {\r
12090                                 setState(1140);\r
12091                                 identity_stmt();\r
12092                             }\r
12093                                 break;\r
12094                             case TYPEDEF_KEYWORD: {\r
12095                                 setState(1141);\r
12096                                 typedef_stmt();\r
12097                             }\r
12098                                 break;\r
12099                             case GROUPING_KEYWORD: {\r
12100                                 setState(1142);\r
12101                                 grouping_stmt();\r
12102                             }\r
12103                                 break;\r
12104                             case USES_KEYWORD:\r
12105                             case LIST_KEYWORD:\r
12106                             case LEAF_LIST_KEYWORD:\r
12107                             case LEAF_KEYWORD:\r
12108                             case CONTAINER_KEYWORD:\r
12109                             case CHOICE_KEYWORD:\r
12110                             case ANYXML_KEYWORD: {\r
12111                                 setState(1143);\r
12112                                 data_def_stmt();\r
12113                             }\r
12114                                 break;\r
12115                             case AUGMENT_KEYWORD: {\r
12116                                 setState(1144);\r
12117                                 augment_stmt();\r
12118                             }\r
12119                                 break;\r
12120                             case RPC_KEYWORD: {\r
12121                                 setState(1145);\r
12122                                 rpc_stmt();\r
12123                             }\r
12124                                 break;\r
12125                             case NOTIFICATION_KEYWORD: {\r
12126                                 setState(1146);\r
12127                                 notification_stmt();\r
12128                             }\r
12129                                 break;\r
12130                             case DEVIATION_KEYWORD: {\r
12131                                 setState(1147);\r
12132                                 deviation_stmt();\r
12133                             }\r
12134                                 break;\r
12135                             default:\r
12136                                 throw new NoViableAltException(this);\r
12137                             }\r
12138                         }\r
12139                     }\r
12140                     setState(1154);\r
12141                     _errHandler.sync(this);\r
12142                     _la = _input.LA(1);\r
12143                 }\r
12144             }\r
12145         } catch (RecognitionException re) {\r
12146             _localctx.exception = re;\r
12147             _errHandler.reportError(this, re);\r
12148             _errHandler.recover(this, re);\r
12149         } finally {\r
12150             exitRule();\r
12151         }\r
12152         return _localctx;\r
12153     }\r
12154 \r
12155     public static class Revision_stmtsContext extends ParserRuleContext {\r
12156         public List<Revision_stmtContext> revision_stmt() {\r
12157             return getRuleContexts(Revision_stmtContext.class);\r
12158         }\r
12159 \r
12160         public Revision_stmtContext revision_stmt(int i) {\r
12161             return getRuleContext(Revision_stmtContext.class, i);\r
12162         }\r
12163 \r
12164         public Revision_stmtsContext(ParserRuleContext parent, int invokingState) {\r
12165             super(parent, invokingState);\r
12166         }\r
12167 \r
12168         @Override\r
12169         public int getRuleIndex() {\r
12170             return RULE_revision_stmts;\r
12171         }\r
12172 \r
12173         @Override\r
12174         public void enterRule(ParseTreeListener listener) {\r
12175             if (listener instanceof YangParserListener)\r
12176                 ((YangParserListener) listener).enterRevision_stmts(this);\r
12177         }\r
12178 \r
12179         @Override\r
12180         public void exitRule(ParseTreeListener listener) {\r
12181             if (listener instanceof YangParserListener)\r
12182                 ((YangParserListener) listener).exitRevision_stmts(this);\r
12183         }\r
12184 \r
12185         @Override\r
12186         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
12187             if (visitor instanceof YangParserVisitor)\r
12188                 return ((YangParserVisitor<? extends T>) visitor)\r
12189                         .visitRevision_stmts(this);\r
12190             else\r
12191                 return visitor.visitChildren(this);\r
12192         }\r
12193     }\r
12194 \r
12195     public final Revision_stmtsContext revision_stmts()\r
12196             throws RecognitionException {\r
12197         Revision_stmtsContext _localctx = new Revision_stmtsContext(_ctx,\r
12198                 getState());\r
12199         enterRule(_localctx, 198, RULE_revision_stmts);\r
12200         int _la;\r
12201         try {\r
12202             enterOuterAlt(_localctx, 1);\r
12203             {\r
12204                 setState(1158);\r
12205                 _errHandler.sync(this);\r
12206                 _la = _input.LA(1);\r
12207                 while (_la == REVISION_KEYWORD) {\r
12208                     {\r
12209                         {\r
12210                             setState(1155);\r
12211                             revision_stmt();\r
12212                         }\r
12213                     }\r
12214                     setState(1160);\r
12215                     _errHandler.sync(this);\r
12216                     _la = _input.LA(1);\r
12217                 }\r
12218             }\r
12219         } catch (RecognitionException re) {\r
12220             _localctx.exception = re;\r
12221             _errHandler.reportError(this, re);\r
12222             _errHandler.recover(this, re);\r
12223         } finally {\r
12224             exitRule();\r
12225         }\r
12226         return _localctx;\r
12227     }\r
12228 \r
12229     public static class Linkage_stmtsContext extends ParserRuleContext {\r
12230         public List<Include_stmtContext> include_stmt() {\r
12231             return getRuleContexts(Include_stmtContext.class);\r
12232         }\r
12233 \r
12234         public Import_stmtContext import_stmt(int i) {\r
12235             return getRuleContext(Import_stmtContext.class, i);\r
12236         }\r
12237 \r
12238         public Include_stmtContext include_stmt(int i) {\r
12239             return getRuleContext(Include_stmtContext.class, i);\r
12240         }\r
12241 \r
12242         public List<Import_stmtContext> import_stmt() {\r
12243             return getRuleContexts(Import_stmtContext.class);\r
12244         }\r
12245 \r
12246         public Linkage_stmtsContext(ParserRuleContext parent, int invokingState) {\r
12247             super(parent, invokingState);\r
12248         }\r
12249 \r
12250         @Override\r
12251         public int getRuleIndex() {\r
12252             return RULE_linkage_stmts;\r
12253         }\r
12254 \r
12255         @Override\r
12256         public void enterRule(ParseTreeListener listener) {\r
12257             if (listener instanceof YangParserListener)\r
12258                 ((YangParserListener) listener).enterLinkage_stmts(this);\r
12259         }\r
12260 \r
12261         @Override\r
12262         public void exitRule(ParseTreeListener listener) {\r
12263             if (listener instanceof YangParserListener)\r
12264                 ((YangParserListener) listener).exitLinkage_stmts(this);\r
12265         }\r
12266 \r
12267         @Override\r
12268         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
12269             if (visitor instanceof YangParserVisitor)\r
12270                 return ((YangParserVisitor<? extends T>) visitor)\r
12271                         .visitLinkage_stmts(this);\r
12272             else\r
12273                 return visitor.visitChildren(this);\r
12274         }\r
12275     }\r
12276 \r
12277     public final Linkage_stmtsContext linkage_stmts()\r
12278             throws RecognitionException {\r
12279         Linkage_stmtsContext _localctx = new Linkage_stmtsContext(_ctx,\r
12280                 getState());\r
12281         enterRule(_localctx, 200, RULE_linkage_stmts);\r
12282         int _la;\r
12283         try {\r
12284             enterOuterAlt(_localctx, 1);\r
12285             {\r
12286                 setState(1165);\r
12287                 _errHandler.sync(this);\r
12288                 _la = _input.LA(1);\r
12289                 while (_la == INCLUDE_KEYWORD || _la == IMPORT_KEYWORD) {\r
12290                     {\r
12291                         setState(1163);\r
12292                         switch (_input.LA(1)) {\r
12293                         case IMPORT_KEYWORD: {\r
12294                             setState(1161);\r
12295                             import_stmt();\r
12296                         }\r
12297                             break;\r
12298                         case INCLUDE_KEYWORD: {\r
12299                             setState(1162);\r
12300                             include_stmt();\r
12301                         }\r
12302                             break;\r
12303                         default:\r
12304                             throw new NoViableAltException(this);\r
12305                         }\r
12306                     }\r
12307                     setState(1167);\r
12308                     _errHandler.sync(this);\r
12309                     _la = _input.LA(1);\r
12310                 }\r
12311             }\r
12312         } catch (RecognitionException re) {\r
12313             _localctx.exception = re;\r
12314             _errHandler.reportError(this, re);\r
12315             _errHandler.recover(this, re);\r
12316         } finally {\r
12317             exitRule();\r
12318         }\r
12319         return _localctx;\r
12320     }\r
12321 \r
12322     public static class Meta_stmtsContext extends ParserRuleContext {\r
12323         public List<Reference_stmtContext> reference_stmt() {\r
12324             return getRuleContexts(Reference_stmtContext.class);\r
12325         }\r
12326 \r
12327         public Description_stmtContext description_stmt(int i) {\r
12328             return getRuleContext(Description_stmtContext.class, i);\r
12329         }\r
12330 \r
12331         public Organization_stmtContext organization_stmt(int i) {\r
12332             return getRuleContext(Organization_stmtContext.class, i);\r
12333         }\r
12334 \r
12335         public Contact_stmtContext contact_stmt(int i) {\r
12336             return getRuleContext(Contact_stmtContext.class, i);\r
12337         }\r
12338 \r
12339         public List<Contact_stmtContext> contact_stmt() {\r
12340             return getRuleContexts(Contact_stmtContext.class);\r
12341         }\r
12342 \r
12343         public List<Organization_stmtContext> organization_stmt() {\r
12344             return getRuleContexts(Organization_stmtContext.class);\r
12345         }\r
12346 \r
12347         public List<Description_stmtContext> description_stmt() {\r
12348             return getRuleContexts(Description_stmtContext.class);\r
12349         }\r
12350 \r
12351         public Reference_stmtContext reference_stmt(int i) {\r
12352             return getRuleContext(Reference_stmtContext.class, i);\r
12353         }\r
12354 \r
12355         public Meta_stmtsContext(ParserRuleContext parent, int invokingState) {\r
12356             super(parent, invokingState);\r
12357         }\r
12358 \r
12359         @Override\r
12360         public int getRuleIndex() {\r
12361             return RULE_meta_stmts;\r
12362         }\r
12363 \r
12364         @Override\r
12365         public void enterRule(ParseTreeListener listener) {\r
12366             if (listener instanceof YangParserListener)\r
12367                 ((YangParserListener) listener).enterMeta_stmts(this);\r
12368         }\r
12369 \r
12370         @Override\r
12371         public void exitRule(ParseTreeListener listener) {\r
12372             if (listener instanceof YangParserListener)\r
12373                 ((YangParserListener) listener).exitMeta_stmts(this);\r
12374         }\r
12375 \r
12376         @Override\r
12377         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
12378             if (visitor instanceof YangParserVisitor)\r
12379                 return ((YangParserVisitor<? extends T>) visitor)\r
12380                         .visitMeta_stmts(this);\r
12381             else\r
12382                 return visitor.visitChildren(this);\r
12383         }\r
12384     }\r
12385 \r
12386     public final Meta_stmtsContext meta_stmts() throws RecognitionException {\r
12387         Meta_stmtsContext _localctx = new Meta_stmtsContext(_ctx, getState());\r
12388         enterRule(_localctx, 202, RULE_meta_stmts);\r
12389         int _la;\r
12390         try {\r
12391             enterOuterAlt(_localctx, 1);\r
12392             {\r
12393                 setState(1174);\r
12394                 _errHandler.sync(this);\r
12395                 _la = _input.LA(1);\r
12396                 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << REFERENCE_KEYWORD)\r
12397                         | (1L << ORGANIZATION_KEYWORD)\r
12398                         | (1L << DESCRIPTION_KEYWORD) | (1L << CONTACT_KEYWORD))) != 0)) {\r
12399                     {\r
12400                         setState(1172);\r
12401                         switch (_input.LA(1)) {\r
12402                         case ORGANIZATION_KEYWORD: {\r
12403                             setState(1168);\r
12404                             organization_stmt();\r
12405                         }\r
12406                             break;\r
12407                         case CONTACT_KEYWORD: {\r
12408                             setState(1169);\r
12409                             contact_stmt();\r
12410                         }\r
12411                             break;\r
12412                         case DESCRIPTION_KEYWORD: {\r
12413                             setState(1170);\r
12414                             description_stmt();\r
12415                         }\r
12416                             break;\r
12417                         case REFERENCE_KEYWORD: {\r
12418                             setState(1171);\r
12419                             reference_stmt();\r
12420                         }\r
12421                             break;\r
12422                         default:\r
12423                             throw new NoViableAltException(this);\r
12424                         }\r
12425                     }\r
12426                     setState(1176);\r
12427                     _errHandler.sync(this);\r
12428                     _la = _input.LA(1);\r
12429                 }\r
12430             }\r
12431         } catch (RecognitionException re) {\r
12432             _localctx.exception = re;\r
12433             _errHandler.reportError(this, re);\r
12434             _errHandler.recover(this, re);\r
12435         } finally {\r
12436             exitRule();\r
12437         }\r
12438         return _localctx;\r
12439     }\r
12440 \r
12441     public static class Submodule_header_stmtsContext extends ParserRuleContext {\r
12442         public Belongs_to_stmtContext belongs_to_stmt(int i) {\r
12443             return getRuleContext(Belongs_to_stmtContext.class, i);\r
12444         }\r
12445 \r
12446         public List<Belongs_to_stmtContext> belongs_to_stmt() {\r
12447             return getRuleContexts(Belongs_to_stmtContext.class);\r
12448         }\r
12449 \r
12450         public Yang_version_stmtContext yang_version_stmt(int i) {\r
12451             return getRuleContext(Yang_version_stmtContext.class, i);\r
12452         }\r
12453 \r
12454         public List<Yang_version_stmtContext> yang_version_stmt() {\r
12455             return getRuleContexts(Yang_version_stmtContext.class);\r
12456         }\r
12457 \r
12458         public Submodule_header_stmtsContext(ParserRuleContext parent,\r
12459                 int invokingState) {\r
12460             super(parent, invokingState);\r
12461         }\r
12462 \r
12463         @Override\r
12464         public int getRuleIndex() {\r
12465             return RULE_submodule_header_stmts;\r
12466         }\r
12467 \r
12468         @Override\r
12469         public void enterRule(ParseTreeListener listener) {\r
12470             if (listener instanceof YangParserListener)\r
12471                 ((YangParserListener) listener)\r
12472                         .enterSubmodule_header_stmts(this);\r
12473         }\r
12474 \r
12475         @Override\r
12476         public void exitRule(ParseTreeListener listener) {\r
12477             if (listener instanceof YangParserListener)\r
12478                 ((YangParserListener) listener)\r
12479                         .exitSubmodule_header_stmts(this);\r
12480         }\r
12481 \r
12482         @Override\r
12483         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
12484             if (visitor instanceof YangParserVisitor)\r
12485                 return ((YangParserVisitor<? extends T>) visitor)\r
12486                         .visitSubmodule_header_stmts(this);\r
12487             else\r
12488                 return visitor.visitChildren(this);\r
12489         }\r
12490     }\r
12491 \r
12492     public final Submodule_header_stmtsContext submodule_header_stmts()\r
12493             throws RecognitionException {\r
12494         Submodule_header_stmtsContext _localctx = new Submodule_header_stmtsContext(\r
12495                 _ctx, getState());\r
12496         enterRule(_localctx, 204, RULE_submodule_header_stmts);\r
12497         int _la;\r
12498         try {\r
12499             enterOuterAlt(_localctx, 1);\r
12500             {\r
12501                 setState(1179);\r
12502                 _errHandler.sync(this);\r
12503                 _la = _input.LA(1);\r
12504                 do {\r
12505                     {\r
12506                         setState(1179);\r
12507                         switch (_input.LA(1)) {\r
12508                         case YANG_VERSION_KEYWORD: {\r
12509                             setState(1177);\r
12510                             yang_version_stmt();\r
12511                         }\r
12512                             break;\r
12513                         case BELONGS_TO_KEYWORD: {\r
12514                             setState(1178);\r
12515                             belongs_to_stmt();\r
12516                         }\r
12517                             break;\r
12518                         default:\r
12519                             throw new NoViableAltException(this);\r
12520                         }\r
12521                     }\r
12522                     setState(1181);\r
12523                     _errHandler.sync(this);\r
12524                     _la = _input.LA(1);\r
12525                 } while (_la == YANG_VERSION_KEYWORD\r
12526                         || _la == BELONGS_TO_KEYWORD);\r
12527             }\r
12528         } catch (RecognitionException re) {\r
12529             _localctx.exception = re;\r
12530             _errHandler.reportError(this, re);\r
12531             _errHandler.recover(this, re);\r
12532         } finally {\r
12533             exitRule();\r
12534         }\r
12535         return _localctx;\r
12536     }\r
12537 \r
12538     public static class Module_header_stmtsContext extends ParserRuleContext {\r
12539         public List<Namespace_stmtContext> namespace_stmt() {\r
12540             return getRuleContexts(Namespace_stmtContext.class);\r
12541         }\r
12542 \r
12543         public Namespace_stmtContext namespace_stmt(int i) {\r
12544             return getRuleContext(Namespace_stmtContext.class, i);\r
12545         }\r
12546 \r
12547         public Yang_version_stmtContext yang_version_stmt(int i) {\r
12548             return getRuleContext(Yang_version_stmtContext.class, i);\r
12549         }\r
12550 \r
12551         public Prefix_stmtContext prefix_stmt(int i) {\r
12552             return getRuleContext(Prefix_stmtContext.class, i);\r
12553         }\r
12554 \r
12555         public List<Prefix_stmtContext> prefix_stmt() {\r
12556             return getRuleContexts(Prefix_stmtContext.class);\r
12557         }\r
12558 \r
12559         public List<Yang_version_stmtContext> yang_version_stmt() {\r
12560             return getRuleContexts(Yang_version_stmtContext.class);\r
12561         }\r
12562 \r
12563         public Module_header_stmtsContext(ParserRuleContext parent,\r
12564                 int invokingState) {\r
12565             super(parent, invokingState);\r
12566         }\r
12567 \r
12568         @Override\r
12569         public int getRuleIndex() {\r
12570             return RULE_module_header_stmts;\r
12571         }\r
12572 \r
12573         @Override\r
12574         public void enterRule(ParseTreeListener listener) {\r
12575             if (listener instanceof YangParserListener)\r
12576                 ((YangParserListener) listener).enterModule_header_stmts(this);\r
12577         }\r
12578 \r
12579         @Override\r
12580         public void exitRule(ParseTreeListener listener) {\r
12581             if (listener instanceof YangParserListener)\r
12582                 ((YangParserListener) listener).exitModule_header_stmts(this);\r
12583         }\r
12584 \r
12585         @Override\r
12586         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
12587             if (visitor instanceof YangParserVisitor)\r
12588                 return ((YangParserVisitor<? extends T>) visitor)\r
12589                         .visitModule_header_stmts(this);\r
12590             else\r
12591                 return visitor.visitChildren(this);\r
12592         }\r
12593     }\r
12594 \r
12595     public final Module_header_stmtsContext module_header_stmts()\r
12596             throws RecognitionException {\r
12597         Module_header_stmtsContext _localctx = new Module_header_stmtsContext(\r
12598                 _ctx, getState());\r
12599         enterRule(_localctx, 206, RULE_module_header_stmts);\r
12600         int _la;\r
12601         try {\r
12602             enterOuterAlt(_localctx, 1);\r
12603             {\r
12604                 setState(1186);\r
12605                 _errHandler.sync(this);\r
12606                 _la = _input.LA(1);\r
12607                 do {\r
12608                     {\r
12609                         setState(1186);\r
12610                         switch (_input.LA(1)) {\r
12611                         case YANG_VERSION_KEYWORD: {\r
12612                             setState(1183);\r
12613                             yang_version_stmt();\r
12614                         }\r
12615                             break;\r
12616                         case NAMESPACE_KEYWORD: {\r
12617                             setState(1184);\r
12618                             namespace_stmt();\r
12619                         }\r
12620                             break;\r
12621                         case PREFIX_KEYWORD: {\r
12622                             setState(1185);\r
12623                             prefix_stmt();\r
12624                         }\r
12625                             break;\r
12626                         default:\r
12627                             throw new NoViableAltException(this);\r
12628                         }\r
12629                     }\r
12630                     setState(1188);\r
12631                     _errHandler.sync(this);\r
12632                     _la = _input.LA(1);\r
12633                 } while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << YANG_VERSION_KEYWORD)\r
12634                         | (1L << PREFIX_KEYWORD) | (1L << NAMESPACE_KEYWORD))) != 0));\r
12635             }\r
12636         } catch (RecognitionException re) {\r
12637             _localctx.exception = re;\r
12638             _errHandler.reportError(this, re);\r
12639             _errHandler.recover(this, re);\r
12640         } finally {\r
12641             exitRule();\r
12642         }\r
12643         return _localctx;\r
12644     }\r
12645 \r
12646     public static class Submodule_stmtContext extends ParserRuleContext {\r
12647         public TerminalNode RIGHT_BRACE() {\r
12648             return getToken(YangParser.RIGHT_BRACE, 0);\r
12649         }\r
12650 \r
12651         public Linkage_stmtsContext linkage_stmts() {\r
12652             return getRuleContext(Linkage_stmtsContext.class, 0);\r
12653         }\r
12654 \r
12655         public Revision_stmtsContext revision_stmts() {\r
12656             return getRuleContext(Revision_stmtsContext.class, 0);\r
12657         }\r
12658 \r
12659         public StringContext string() {\r
12660             return getRuleContext(StringContext.class, 0);\r
12661         }\r
12662 \r
12663         public Body_stmtsContext body_stmts() {\r
12664             return getRuleContext(Body_stmtsContext.class, 0);\r
12665         }\r
12666 \r
12667         public TerminalNode LEFT_BRACE() {\r
12668             return getToken(YangParser.LEFT_BRACE, 0);\r
12669         }\r
12670 \r
12671         public TerminalNode SUBMODULE_KEYWORD() {\r
12672             return getToken(YangParser.SUBMODULE_KEYWORD, 0);\r
12673         }\r
12674 \r
12675         public Submodule_header_stmtsContext submodule_header_stmts() {\r
12676             return getRuleContext(Submodule_header_stmtsContext.class, 0);\r
12677         }\r
12678 \r
12679         public Meta_stmtsContext meta_stmts() {\r
12680             return getRuleContext(Meta_stmtsContext.class, 0);\r
12681         }\r
12682 \r
12683         public Submodule_stmtContext(ParserRuleContext parent, int invokingState) {\r
12684             super(parent, invokingState);\r
12685         }\r
12686 \r
12687         @Override\r
12688         public int getRuleIndex() {\r
12689             return RULE_submodule_stmt;\r
12690         }\r
12691 \r
12692         @Override\r
12693         public void enterRule(ParseTreeListener listener) {\r
12694             if (listener instanceof YangParserListener)\r
12695                 ((YangParserListener) listener).enterSubmodule_stmt(this);\r
12696         }\r
12697 \r
12698         @Override\r
12699         public void exitRule(ParseTreeListener listener) {\r
12700             if (listener instanceof YangParserListener)\r
12701                 ((YangParserListener) listener).exitSubmodule_stmt(this);\r
12702         }\r
12703 \r
12704         @Override\r
12705         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
12706             if (visitor instanceof YangParserVisitor)\r
12707                 return ((YangParserVisitor<? extends T>) visitor)\r
12708                         .visitSubmodule_stmt(this);\r
12709             else\r
12710                 return visitor.visitChildren(this);\r
12711         }\r
12712     }\r
12713 \r
12714     public final Submodule_stmtContext submodule_stmt()\r
12715             throws RecognitionException {\r
12716         Submodule_stmtContext _localctx = new Submodule_stmtContext(_ctx,\r
12717                 getState());\r
12718         enterRule(_localctx, 208, RULE_submodule_stmt);\r
12719         try {\r
12720             enterOuterAlt(_localctx, 1);\r
12721             {\r
12722                 setState(1190);\r
12723                 match(SUBMODULE_KEYWORD);\r
12724                 setState(1191);\r
12725                 string();\r
12726                 setState(1192);\r
12727                 match(LEFT_BRACE);\r
12728                 setState(1193);\r
12729                 submodule_header_stmts();\r
12730                 setState(1194);\r
12731                 linkage_stmts();\r
12732                 setState(1195);\r
12733                 meta_stmts();\r
12734                 setState(1196);\r
12735                 revision_stmts();\r
12736                 setState(1197);\r
12737                 body_stmts();\r
12738                 setState(1198);\r
12739                 match(RIGHT_BRACE);\r
12740             }\r
12741         } catch (RecognitionException re) {\r
12742             _localctx.exception = re;\r
12743             _errHandler.reportError(this, re);\r
12744             _errHandler.recover(this, re);\r
12745         } finally {\r
12746             exitRule();\r
12747         }\r
12748         return _localctx;\r
12749     }\r
12750 \r
12751     public static class Module_stmtContext extends ParserRuleContext {\r
12752         public TerminalNode RIGHT_BRACE() {\r
12753             return getToken(YangParser.RIGHT_BRACE, 0);\r
12754         }\r
12755 \r
12756         public Linkage_stmtsContext linkage_stmts() {\r
12757             return getRuleContext(Linkage_stmtsContext.class, 0);\r
12758         }\r
12759 \r
12760         public Revision_stmtsContext revision_stmts() {\r
12761             return getRuleContext(Revision_stmtsContext.class, 0);\r
12762         }\r
12763 \r
12764         public StringContext string() {\r
12765             return getRuleContext(StringContext.class, 0);\r
12766         }\r
12767 \r
12768         public Body_stmtsContext body_stmts() {\r
12769             return getRuleContext(Body_stmtsContext.class, 0);\r
12770         }\r
12771 \r
12772         public Module_header_stmtsContext module_header_stmts() {\r
12773             return getRuleContext(Module_header_stmtsContext.class, 0);\r
12774         }\r
12775 \r
12776         public TerminalNode MODULE_KEYWORD() {\r
12777             return getToken(YangParser.MODULE_KEYWORD, 0);\r
12778         }\r
12779 \r
12780         public TerminalNode LEFT_BRACE() {\r
12781             return getToken(YangParser.LEFT_BRACE, 0);\r
12782         }\r
12783 \r
12784         public Meta_stmtsContext meta_stmts() {\r
12785             return getRuleContext(Meta_stmtsContext.class, 0);\r
12786         }\r
12787 \r
12788         public Module_stmtContext(ParserRuleContext parent, int invokingState) {\r
12789             super(parent, invokingState);\r
12790         }\r
12791 \r
12792         @Override\r
12793         public int getRuleIndex() {\r
12794             return RULE_module_stmt;\r
12795         }\r
12796 \r
12797         @Override\r
12798         public void enterRule(ParseTreeListener listener) {\r
12799             if (listener instanceof YangParserListener)\r
12800                 ((YangParserListener) listener).enterModule_stmt(this);\r
12801         }\r
12802 \r
12803         @Override\r
12804         public void exitRule(ParseTreeListener listener) {\r
12805             if (listener instanceof YangParserListener)\r
12806                 ((YangParserListener) listener).exitModule_stmt(this);\r
12807         }\r
12808 \r
12809         @Override\r
12810         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {\r
12811             if (visitor instanceof YangParserVisitor)\r
12812                 return ((YangParserVisitor<? extends T>) visitor)\r
12813                         .visitModule_stmt(this);\r
12814             else\r
12815                 return visitor.visitChildren(this);\r
12816         }\r
12817     }\r
12818 \r
12819     public final Module_stmtContext module_stmt() throws RecognitionException {\r
12820         Module_stmtContext _localctx = new Module_stmtContext(_ctx, getState());\r
12821         enterRule(_localctx, 210, RULE_module_stmt);\r
12822         try {\r
12823             enterOuterAlt(_localctx, 1);\r
12824             {\r
12825                 setState(1200);\r
12826                 match(MODULE_KEYWORD);\r
12827                 setState(1201);\r
12828                 string();\r
12829                 setState(1202);\r
12830                 match(LEFT_BRACE);\r
12831                 setState(1203);\r
12832                 module_header_stmts();\r
12833                 setState(1204);\r
12834                 linkage_stmts();\r
12835                 setState(1205);\r
12836                 meta_stmts();\r
12837                 setState(1206);\r
12838                 revision_stmts();\r
12839                 setState(1207);\r
12840                 body_stmts();\r
12841                 setState(1208);\r
12842                 match(RIGHT_BRACE);\r
12843             }\r
12844         } catch (RecognitionException re) {\r
12845             _localctx.exception = re;\r
12846             _errHandler.reportError(this, re);\r
12847             _errHandler.recover(this, re);\r
12848         } finally {\r
12849             exitRule();\r
12850         }\r
12851         return _localctx;\r
12852     }\r
12853 \r
12854     public static final String _serializedATN = "\2\3N\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
12855             + "\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
12856             + "\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
12857             + "\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
12858             + "\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4"\r
12859             + ")\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
12860             + "\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
12861             + ";\t;\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\t"\r
12862             + "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
12863             + "R\tR\4S\tS\4T\tT\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]"\r
12864             + "\t]\4^\t^\4_\t_\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th"\r
12865             + "\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
12866             + "\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
12867             + "\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
12868             + "\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
12869             + "\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
12870             + "\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
12871             + "\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
12872             + "\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
12873             + "\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
12874             + "\3\13\7\13\u014f\n\13\f\13\16\13\u0152\13\13\3\13\5\13\u0155\n\13\3\f"\r
12875             + "\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
12876             + "\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
12877             + "\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
12878             + "\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
12879             + "\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
12880             + "\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
12881             + "\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
12882             + "\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
12883             + "\22\16\22\u01b9\13\22\3\23\3\23\7\23\u01bd\n\23\f\23\16\23\u01c0\13\23"\r
12884             + "\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
12885             + "\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
12886             + "\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
12887             + "\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
12888             + "\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
12889             + "\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
12890             + "\u0205\n\32\r\32\16\32\u0206\3\32\3\32\5\32\u020b\n\32\3\33\3\33\3\33"\r
12891             + "\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
12892             + "\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
12893             + "\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
12894             + "\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
12895             + "\3\35\7\35\u0241\n\35\f\35\16\35\u0244\13\35\3\35\5\35\u0247\n\35\3\36"\r
12896             + "\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
12897             + "\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
12898             + "\13\37\3\37\5\37\u0265\n\37\3 \3 \3 \3 \3!\3!\3!\3!\3\"\3\"\3\"\3\"\3"\r
12899             + "\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\6\"\u0282\n"\r
12900             + "\"\r\"\16\"\u0283\3\"\3\"\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3"\r
12901             + "#\3#\7#\u0298\n#\f#\16#\u029b\13#\3#\3#\3$\3$\3$\3$\3$\3$\3$\3$\3$\3$"\r
12902             + "\3$\3$\3$\3$\3$\7$\u02ae\n$\f$\16$\u02b1\13$\3$\3$\3%\3%\3%\3%\3%\3%\3"\r
12903             + "%\3%\3%\3%\3%\3%\3%\3%\3%\3%\7%\u02c5\n%\f%\16%\u02c8\13%\3%\5%\u02cb"\r
12904             + "\n%\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\7&\u02d8\n&\f&\16&\u02db\13&\3&\5"\r
12905             + "&\u02de\n&\3\'\3\'\3\'\3\'\3(\3(\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-\7-\u02ff\n-\f-\16-\u0302\13-\3-"\r
12907             + "\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
12908             + "\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
12909             + "\3\67\3\67\3\67\3\67\38\38\38\38\38\38\38\38\38\78\u0330\n8\f8\168\u0333"\r
12910             + "\138\38\58\u0336\n8\39\69\u0339\n9\r9\169\u033a\3:\6:\u033e\n:\r:\16:"\r
12911             + "\u033f\3;\3;\3<\5<\u0345\n<\3=\3=\3>\3>\3>\3>\3?\3?\3?\3?\3@\3@\3A\3A"\r
12912             + "\3A\3A\3A\3A\3A\3A\3A\7A\u035c\nA\fA\16A\u035f\13A\3A\5A\u0362\nA\3B\6"\r
12913             + "B\u0365\nB\rB\16B\u0366\3C\3C\3C\3C\3D\3D\3D\3D\3D\3D\3D\3D\3D\7D\u0376"\r
12914             + "\nD\fD\16D\u0379\13D\3D\5D\u037c\nD\3E\3E\3E\3E\3E\3E\3E\3E\3E\7E\u0387"\r
12915             + "\nE\fE\16E\u038a\13E\3E\5E\u038d\nE\3F\3F\7F\u0391\nF\fF\16F\u0394\13"\r
12916             + "F\3G\3G\3G\3G\3H\5H\u039b\nH\3H\3H\3H\5H\u03a0\nH\5H\u03a2\nH\3I\3I\3"\r
12917             + "I\3I\3I\3I\3I\3I\3I\7I\u03ad\nI\fI\16I\u03b0\13I\3I\5I\u03b3\nI\3J\3J"\r
12918             + "\3K\3K\3K\3K\3K\3K\3K\3K\3K\5K\u03c0\nK\3L\3L\3L\3L\3L\3L\3L\5L\u03c9"\r
12919             + "\nL\3M\3M\3M\3M\3M\3M\3M\3M\3M\6M\u03d4\nM\rM\16M\u03d5\3M\3M\3N\3N\3"\r
12920             + "N\3N\3O\3O\3O\3O\3O\3O\3O\3O\7O\u03e6\nO\fO\16O\u03e9\13O\3O\5O\u03ec"\r
12921             + "\nO\3P\3P\3P\3P\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\7Q\u03fa\nQ\fQ\16Q\u03fd\13Q\3"\r
12922             + "Q\5Q\u0400\nQ\3R\3R\3S\3S\3S\3S\3T\3T\3T\3T\3T\5T\u040d\nT\3T\5T\u0410"\r
12923             + "\nT\3U\3U\3U\3U\3U\3U\3U\3U\7U\u041a\nU\fU\16U\u041d\13U\3U\5U\u0420\n"\r
12924             + "U\3V\3V\3V\3V\3W\3W\3W\3W\3W\5W\u042b\nW\3W\5W\u042e\nW\3W\5W\u0431\n"\r
12925             + "W\3X\3X\3X\3X\3Y\3Y\3Y\3Y\3Z\3Z\3Z\3Z\3[\3[\3[\3[\3\\\3\\\3\\\3\\\3]\3"\r
12926             + "]\3]\3]\3]\3]\3^\3^\3^\3^\3_\3_\3_\3_\3`\3`\3`\3`\3`\5`\u045a\n`\3`\5"\r
12927             + "`\u045d\n`\3a\3a\3a\3a\3a\5a\u0464\na\3a\3a\3b\3b\3b\3b\3c\3c\3c\3c\3"\r
12928             + "c\3c\3c\5c\u0473\nc\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\5d\u047f\nd\7d\u0481"\r
12929             + "\nd\fd\16d\u0484\13d\3e\7e\u0487\ne\fe\16e\u048a\13e\3f\3f\7f\u048e\n"\r
12930             + "f\ff\16f\u0491\13f\3g\3g\3g\3g\7g\u0497\ng\fg\16g\u049a\13g\3h\3h\6h\u049e"\r
12931             + "\nh\rh\16h\u049f\3i\3i\3i\6i\u04a5\ni\ri\16i\u04a6\3j\3j\3j\3j\3j\3j\3"\r
12932             + "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
12933             + "\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtv"\r
12934             + "xz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094"\r
12935             + "\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac"\r
12936             + "\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u00be\u00c0\u00c2\u00c4"\r
12937             + "\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4\2\2\u05a3\2\u00d8\3\2"\r
12938             + "\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
12939             + "\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
12940             + "\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
12941             + "\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
12942             + "&\u01c8\3\2\2\2(\u01d3\3\2\2\2*\u01de\3\2\2\2,\u01e9\3\2\2\2.\u01f3\3"\r
12943             + "\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
12944             + "\2\28\u0235\3\2\2\2:\u024d\3\2\2\2<\u024f\3\2\2\2>\u0266\3\2\2\2@\u026a"\r
12945             + "\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
12946             + "\u02cc\3\2\2\2L\u02df\3\2\2\2N\u02e3\3\2\2\2P\u02e5\3\2\2\2R\u02e9\3\2"\r
12947             + "\2\2T\u02ed\3\2\2\2V\u02f1\3\2\2\2X\u02f5\3\2\2\2Z\u0306\3\2\2\2\\\u0308"\r
12948             + "\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
12949             + "\u0318\3\2\2\2h\u031c\3\2\2\2j\u031e\3\2\2\2l\u0322\3\2\2\2n\u0326\3\2"\r
12950             + "\2\2p\u0338\3\2\2\2r\u033d\3\2\2\2t\u0341\3\2\2\2v\u0344\3\2\2\2x\u0346"\r
12951             + "\3\2\2\2z\u0348\3\2\2\2|\u034c\3\2\2\2~\u0350\3\2\2\2\u0080\u0352\3\2"\r
12952             + "\2\2\u0082\u0364\3\2\2\2\u0084\u0368\3\2\2\2\u0086\u036c\3\2\2\2\u0088"\r
12953             + "\u037d\3\2\2\2\u008a\u0392\3\2\2\2\u008c\u0395\3\2\2\2\u008e\u03a1\3\2"\r
12954             + "\2\2\u0090\u03a3\3\2\2\2\u0092\u03b4\3\2\2\2\u0094\u03bf\3\2\2\2\u0096"\r
12955             + "\u03c1\3\2\2\2\u0098\u03ca\3\2\2\2\u009a\u03d9\3\2\2\2\u009c\u03dd\3\2"\r
12956             + "\2\2\u009e\u03ed\3\2\2\2\u00a0\u03f1\3\2\2\2\u00a2\u0401\3\2\2\2\u00a4"\r
12957             + "\u0403\3\2\2\2\u00a6\u0407\3\2\2\2\u00a8\u0411\3\2\2\2\u00aa\u0421\3\2"\r
12958             + "\2\2\u00ac\u0425\3\2\2\2\u00ae\u0432\3\2\2\2\u00b0\u0436\3\2\2\2\u00b2"\r
12959             + "\u043a\3\2\2\2\u00b4\u043e\3\2\2\2\u00b6\u0442\3\2\2\2\u00b8\u0446\3\2"\r
12960             + "\2\2\u00ba\u044c\3\2\2\2\u00bc\u0450\3\2\2\2\u00be\u0454\3\2\2\2\u00c0"\r
12961             + "\u045e\3\2\2\2\u00c2\u0467\3\2\2\2\u00c4\u0472\3\2\2\2\u00c6\u0482\3\2"\r
12962             + "\2\2\u00c8\u0488\3\2\2\2\u00ca\u048f\3\2\2\2\u00cc\u0498\3\2\2\2\u00ce"\r
12963             + "\u049d\3\2\2\2\u00d0\u04a4\3\2\2\2\u00d2\u04a8\3\2\2\2\u00d4\u04b2\3\2"\r
12964             + "\2\2\u00d6\u00d9\5\u00d4k\2\u00d7\u00d9\5\u00d2j\2\u00d8\u00d6\3\2\2\2"\r
12965             + "\u00d8\u00d7\3\2\2\2\u00d9\3\3\2\2\2\u00da\u00df\7L\2\2\u00db\u00dc\7"\r
12966             + "\6\2\2\u00dc\u00de\7L\2\2\u00dd\u00db\3\2\2\2\u00de\u00e1\3\2\2\2\u00df"\r
12967             + "\u00dd\3\2\2\2\u00df\u00e0\3\2\2\2\u00e0\5\3\2\2\2\u00e1\u00df\3\2\2\2"\r
12968             + "\u00e2\u00e4\7K\2\2\u00e3\u00e5\5\4\3\2\u00e4\u00e3\3\2\2\2\u00e4\u00e5"\r
12969             + "\3\2\2\2\u00e5\u00e6\3\2\2\2\u00e6\u00e7\5\b\5\2\u00e7\7\3\2\2\2\u00e8"\r
12970             + "\u00ea\7\3\2\2\u00e9\u00eb\5\6\4\2\u00ea\u00e9\3\2\2\2\u00ea\u00eb\3\2"\r
12971             + "\2\2\u00eb\u00f2\3\2\2\2\u00ec\u00ee\7\4\2\2\u00ed\u00ef\5\6\4\2\u00ee"\r
12972             + "\u00ed\3\2\2\2\u00ee\u00ef\3\2\2\2\u00ef\u00f0\3\2\2\2\u00f0\u00f2\7\5"\r
12973             + "\2\2\u00f1\u00e8\3\2\2\2\u00f1\u00ec\3\2\2\2\u00f2\t\3\2\2\2\u00f3\u00f4"\r
12974             + "\78\2\2\u00f4\u0104\5\4\3\2\u00f5\u0105\7\3\2\2\u00f6\u0100\7\4\2\2\u00f7"\r
12975             + "\u00ff\5\u0096L\2\u00f8\u00ff\5\u00aeX\2\u00f9\u00ff\5\u0084C\2\u00fa"\r
12976             + "\u00ff\5f\64\2\u00fb\u00ff\5b\62\2\u00fc\u00ff\5R*\2\u00fd\u00ff\5P)\2"\r
12977             + "\u00fe\u00f7\3\2\2\2\u00fe\u00f8\3\2\2\2\u00fe\u00f9\3\2\2\2\u00fe\u00fa"\r
12978             + "\3\2\2\2\u00fe\u00fb\3\2\2\2\u00fe\u00fc\3\2\2\2\u00fe\u00fd\3\2\2\2\u00ff"\r
12979             + "\u0102\3\2\2\2\u0100\u00fe\3\2\2\2\u0100\u0101\3\2\2\2\u0101\u0103\3\2"\r
12980             + "\2\2\u0102\u0100\3\2\2\2\u0103\u0105\7\5\2\2\u0104\u00f5\3\2\2\2\u0104"\r
12981             + "\u00f6\3\2\2\2\u0105\13\3\2\2\2\u0106\u0107\78\2\2\u0107\u0114\5\4\3\2"\r
12982             + "\u0108\u0115\7\3\2\2\u0109\u0110\7\4\2\2\u010a\u010f\5\u00aeX\2\u010b"\r
12983             + "\u010f\5X-\2\u010c\u010f\5> \2\u010d\u010f\5\u0084C\2\u010e\u010a\3\2"\r
12984             + "\2\2\u010e\u010b\3\2\2\2\u010e\u010c\3\2\2\2\u010e\u010d\3\2\2\2\u010f"\r
12985             + "\u0112\3\2\2\2\u0110\u010e\3\2\2\2\u0110\u0111\3\2\2\2\u0111\u0113\3\2"\r
12986             + "\2\2\u0112\u0110\3\2\2\2\u0113\u0115\7\5\2\2\u0114\u0108\3\2\2\2\u0114"\r
12987             + "\u0109\3\2\2\2\u0115\r\3\2\2\2\u0116\u0117\78\2\2\u0117\u0128\5\4\3\2"\r
12988             + "\u0118\u0129\7\3\2\2\u0119\u0124\7\4\2\2\u011a\u0123\5\u00aeX\2\u011b"\r
12989             + "\u0123\5X-\2\u011c\u0123\5> \2\u011d\u0123\5\u0084C\2\u011e\u0123\5f\64"\r
12990             + "\2\u011f\u0123\5b\62\2\u0120\u0123\5R*\2\u0121\u0123\5P)\2\u0122\u011a"\r
12991             + "\3\2\2\2\u0122\u011b\3\2\2\2\u0122\u011c\3\2\2\2\u0122\u011d\3\2\2\2\u0122"\r
12992             + "\u011e\3\2\2\2\u0122\u011f\3\2\2\2\u0122\u0120\3\2\2\2\u0122\u0121\3\2"\r
12993             + "\2\2\u0123\u0126\3\2\2\2\u0124\u0122\3\2\2\2\u0124\u0125\3\2\2\2\u0125"\r
12994             + "\u0127\3\2\2\2\u0126\u0124\3\2\2\2\u0127\u0129\7\5\2\2\u0128\u0118\3\2"\r
12995             + "\2\2\u0128\u0119\3\2\2\2\u0129\17\3\2\2\2\u012a\u012b\78\2\2\u012b\u0132"\r
12996             + "\5\4\3\2\u012c\u0133\7\3\2\2\u012d\u012f\7\4\2\2\u012e\u0130\5\6\4\2\u012f"\r
12997             + "\u012e\3\2\2\2\u012f\u0130\3\2\2\2\u0130\u0131\3\2\2\2\u0131\u0133\7\5"\r
12998             + "\2\2\u0132\u012c\3\2\2\2\u0132\u012d\3\2\2\2\u0133\21\3\2\2\2\u0134\u0135"\r
12999             + "\79\2\2\u0135\u0136\5\4\3\2\u0136\u013d\7\4\2\2\u0137\u013e\5\u00b2Z\2"\r
13000             + "\u0138\u013e\5\u00b0Y\2\u0139\u013e\5\20\t\2\u013a\u013e\5\16\b\2\u013b"\r
13001             + "\u013e\5\n\6\2\u013c\u013e\5\f\7\2\u013d\u0137\3\2\2\2\u013d\u0138\3\2"\r
13002             + "\2\2\u013d\u0139\3\2\2\2\u013d\u013a\3\2\2\2\u013d\u013b\3\2\2\2\u013d"\r
13003             + "\u013c\3\2\2\2\u013e\u013f\3\2\2\2\u013f\u013d\3\2\2\2\u013f\u0140\3\2"\r
13004             + "\2\2\u0140\u0141\3\2\2\2\u0141\u0142\7\5\2\2\u0142\23\3\2\2\2\u0143\u0144"\r
13005             + "\7$\2\2\u0144\u0154\5\4\3\2\u0145\u0155\7\3\2\2\u0146\u0150\7\4\2\2\u0147"\r
13006             + "\u014f\5\u009aN\2\u0148\u014f\5j\66\2\u0149\u014f\5\u00b2Z\2\u014a\u014f"\r
13007             + "\5\u00b0Y\2\u014b\u014f\5\u0098M\2\u014c\u014f\5J&\2\u014d\u014f\5\u00c4"\r
13008             + "c\2\u014e\u0147\3\2\2\2\u014e\u0148\3\2\2\2\u014e\u0149\3\2\2\2\u014e"\r
13009             + "\u014a\3\2\2\2\u014e\u014b\3\2\2\2\u014e\u014c\3\2\2\2\u014e\u014d\3\2"\r
13010             + "\2\2\u014f\u0152\3\2\2\2\u0150\u014e\3\2\2\2\u0150\u0151\3\2\2\2\u0151"\r
13011             + "\u0153\3\2\2\2\u0152\u0150\3\2\2\2\u0153\u0155\7\5\2\2\u0154\u0145\3\2"\r
13012             + "\2\2\u0154\u0146\3\2\2\2\u0155\25\3\2\2\2\u0156\u0157\7!\2\2\u0157\u015b"\r
13013             + "\7\4\2\2\u0158\u015c\5\u0098M\2\u0159\u015c\5J&\2\u015a\u015c\5\u00c4"\r
13014             + "c\2\u015b\u0158\3\2\2\2\u015b\u0159\3\2\2\2\u015b\u015a\3\2\2\2\u015c"\r
13015             + "\u015d\3\2\2\2\u015d\u015b\3\2\2\2\u015d\u015e\3\2\2\2\u015e\u015f\3\2"\r
13016             + "\2\2\u015f\u0160\7\5\2\2\u0160\27\3\2\2\2\u0161\u0162\7\60\2\2\u0162\u0166"\r
13017             + "\7\4\2\2\u0163\u0167\5\u0098M\2\u0164\u0167\5J&\2\u0165\u0167\5\u00c4"\r
13018             + "c\2\u0166\u0163\3\2\2\2\u0166\u0164\3\2\2\2\u0166\u0165\3\2\2\2\u0167"\r
13019             + "\u0168\3\2\2\2\u0168\u0166\3\2\2\2\u0168\u0169\3\2\2\2\u0169\u016a\3\2"\r
13020             + "\2\2\u016a\u016b\7\5\2\2\u016b\31\3\2\2\2\u016c\u016d\7\25\2\2\u016d\u017e"\r
13021             + "\5\4\3\2\u016e\u017f\7\3\2\2\u016f\u017a\7\4\2\2\u0170\u0179\5\u009aN"\r
13022             + "\2\u0171\u0179\5j\66\2\u0172\u0179\5\u00b2Z\2\u0173\u0179\5\u00b0Y\2\u0174"\r
13023             + "\u0179\5\u0098M\2\u0175\u0179\5J&\2\u0176\u0179\5\30\r\2\u0177\u0179\5"\r
13024             + "\26\f\2\u0178\u0170\3\2\2\2\u0178\u0171\3\2\2\2\u0178\u0172\3\2\2\2\u0178"\r
13025             + "\u0173\3\2\2\2\u0178\u0174\3\2\2\2\u0178\u0175\3\2\2\2\u0178\u0176\3\2"\r
13026             + "\2\2\u0178\u0177\3\2\2\2\u0179\u017c\3\2\2\2\u017a\u0178\3\2\2\2\u017a"\r
13027             + "\u017b\3\2\2\2\u017b\u017d\3\2\2\2\u017c\u017a\3\2\2\2\u017d\u017f\7\5"\r
13028             + "\2\2\u017e\u016e\3\2\2\2\u017e\u016f\3\2\2\2\u017f\33\3\2\2\2\u0180\u0181"\r
13029             + "\7\f\2\2\u0181\u018c\5\4\3\2\u0182\u018d\7\3\2\2\u0183\u0188\7\4\2\2\u0184"\r
13030             + "\u0187\5\u00b2Z\2\u0185\u0187\5\u00b0Y\2\u0186\u0184\3\2\2\2\u0186\u0185"\r
13031             + "\3\2\2\2\u0187\u018a\3\2\2\2\u0188\u0186\3\2\2\2\u0188\u0189\3\2\2\2\u0189"\r
13032             + "\u018b\3\2\2\2\u018a\u0188\3\2\2\2\u018b\u018d\7\5\2\2\u018c\u0182\3\2"\r
13033             + "\2\2\u018c\u0183\3\2\2\2\u018d\35\3\2\2\2\u018e\u018f\7H\2\2\u018f\u0190"\r
13034             + "\5\4\3\2\u0190\u0199\7\4\2\2\u0191\u019a\5\6\4\2\u0192\u019a\5\34\17\2"\r
13035             + "\u0193\u019a\5\u009aN\2\u0194\u019a\5j\66\2\u0195\u019a\5\u00b2Z\2\u0196"\r
13036             + "\u019a\5\u00b0Y\2\u0197\u019a\5\u00c4c\2\u0198\u019a\58\35\2\u0199\u0191"\r
13037             + "\3\2\2\2\u0199\u0192\3\2\2\2\u0199\u0193\3\2\2\2\u0199\u0194\3\2\2\2\u0199"\r
13038             + "\u0195\3\2\2\2\u0199\u0196\3\2\2\2\u0199\u0197\3\2\2\2\u0199\u0198\3\2"\r
13039             + "\2\2\u019a\u019b\3\2\2\2\u019b\u0199\3\2\2\2\u019b\u019c\3\2\2\2\u019c"\r
13040             + "\u019d\3\2\2\2\u019d\u019e\7\5\2\2\u019e\37\3\2\2\2\u019f\u01a0\7H\2\2"\r
13041             + "\u01a0\u01a1\5\4\3\2\u01a1\u01aa\7\4\2\2\u01a2\u01ab\5\6\4\2\u01a3\u01ab"\r
13042             + "\5\34\17\2\u01a4\u01ab\5\u009aN\2\u01a5\u01ab\5j\66\2\u01a6\u01ab\5\u00b2"\r
13043             + "Z\2\u01a7\u01ab\5\u00b0Y\2\u01a8\u01ab\5\u00c4c\2\u01a9\u01ab\58\35\2"\r
13044             + "\u01aa\u01a2\3\2\2\2\u01aa\u01a3\3\2\2\2\u01aa\u01a4\3\2\2\2\u01aa\u01a5"\r
13045             + "\3\2\2\2\u01aa\u01a6\3\2\2\2\u01aa\u01a7\3\2\2\2\u01aa\u01a8\3\2\2\2\u01aa"\r
13046             + "\u01a9\3\2\2\2\u01ab\u01ac\3\2\2\2\u01ac\u01aa\3\2\2\2\u01ac\u01ad\3\2"\r
13047             + "\2\2\u01ad\u01ae\3\2\2\2\u01ae\u01af\7\5\2\2\u01af!\3\2\2\2\u01b0\u01b6"\r
13048             + "\5X-\2\u01b1\u01b6\5f\64\2\u01b2\u01b6\5b\62\2\u01b3\u01b6\5\u00b2Z\2"\r
13049             + "\u01b4\u01b6\5\u00b0Y\2\u01b5\u01b0\3\2\2\2\u01b5\u01b1\3\2\2\2\u01b5"\r
13050             + "\u01b2\3\2\2\2\u01b5\u01b3\3\2\2\2\u01b5\u01b4\3\2\2\2\u01b6\u01b9\3\2"\r
13051             + "\2\2\u01b7\u01b5\3\2\2\2\u01b7\u01b8\3\2\2\2\u01b8#\3\2\2\2\u01b9\u01b7"\r
13052             + "\3\2\2\2\u01ba\u01bd\5\u00b2Z\2\u01bb\u01bd\5\u00b0Y\2\u01bc\u01ba\3\2"\r
13053             + "\2\2\u01bc\u01bb\3\2\2\2\u01bd\u01c0\3\2\2\2\u01be\u01bc\3\2\2\2\u01be"\r
13054             + "\u01bf\3\2\2\2\u01bf%\3\2\2\2\u01c0\u01be\3\2\2\2\u01c1\u01c7\5\u0084"\r
13055             + "C\2\u01c2\u01c7\5f\64\2\u01c3\u01c7\5b\62\2\u01c4\u01c7\5\u00b2Z\2\u01c5"\r
13056             + "\u01c7\5\u00b0Y\2\u01c6\u01c1\3\2\2\2\u01c6\u01c2\3\2\2\2\u01c6\u01c3"\r
13057             + "\3\2\2\2\u01c6\u01c4\3\2\2\2\u01c6\u01c5\3\2\2\2\u01c7\u01ca\3\2\2\2\u01c8"\r
13058             + "\u01c6\3\2\2\2\u01c8\u01c9\3\2\2\2\u01c9\'\3\2\2\2\u01ca\u01c8\3\2\2\2"\r
13059             + "\u01cb\u01d2\5X-\2\u01cc\u01d2\5f\64\2\u01cd\u01d2\5R*\2\u01ce\u01d2\5"\r
13060             + "P)\2\u01cf\u01d2\5\u00b2Z\2\u01d0\u01d2\5\u00b0Y\2\u01d1\u01cb\3\2\2\2"\r
13061             + "\u01d1\u01cc\3\2\2\2\u01d1\u01cd\3\2\2\2\u01d1\u01ce\3\2\2\2\u01d1\u01cf"\r
13062             + "\3\2\2\2\u01d1\u01d0\3\2\2\2\u01d2\u01d5\3\2\2\2\u01d3\u01d1\3\2\2\2\u01d3"\r
13063             + "\u01d4\3\2\2\2\u01d4)\3\2\2\2\u01d5\u01d3\3\2\2\2\u01d6\u01dd\5X-\2\u01d7"\r
13064             + "\u01dd\5f\64\2\u01d8\u01dd\5R*\2\u01d9\u01dd\5P)\2\u01da\u01dd\5\u00b2"\r
13065             + "Z\2\u01db\u01dd\5\u00b0Y\2\u01dc\u01d6\3\2\2\2\u01dc\u01d7\3\2\2\2\u01dc"\r
13066             + "\u01d8\3\2\2\2\u01dc\u01d9\3\2\2\2\u01dc\u01da\3\2\2\2\u01dc\u01db\3\2"\r
13067             + "\2\2\u01dd\u01e0\3\2\2\2\u01de\u01dc\3\2\2\2\u01de\u01df\3\2\2\2\u01df"\r
13068             + "+\3\2\2\2\u01e0\u01de\3\2\2\2\u01e1\u01e8\5X-\2\u01e2\u01e8\5\u0084C\2"\r
13069             + "\u01e3\u01e8\5f\64\2\u01e4\u01e8\5b\62\2\u01e5\u01e8\5\u00b2Z\2\u01e6"\r
13070             + "\u01e8\5\u00b0Y\2\u01e7\u01e1\3\2\2\2\u01e7\u01e2\3\2\2\2\u01e7\u01e3"\r
13071             + "\3\2\2\2\u01e7\u01e4\3\2\2\2\u01e7\u01e5\3\2\2\2\u01e7\u01e6\3\2\2\2\u01e8"\r
13072             + "\u01eb\3\2\2\2\u01e9\u01e7\3\2\2\2\u01e9\u01ea\3\2\2\2\u01ea-\3\2\2\2"\r
13073             + "\u01eb\u01e9\3\2\2\2\u01ec\u01f2\5X-\2\u01ed\u01f2\5^\60\2\u01ee\u01f2"\r
13074             + "\5f\64\2\u01ef\u01f2\5\u00b2Z\2\u01f0\u01f2\5\u00b0Y\2\u01f1\u01ec\3\2"\r
13075             + "\2\2\u01f1\u01ed\3\2\2\2\u01f1\u01ee\3\2\2\2\u01f1\u01ef\3\2\2\2\u01f1"\r
13076             + "\u01f0\3\2\2\2\u01f2\u01f5\3\2\2\2\u01f3\u01f1\3\2\2\2\u01f3\u01f4\3\2"\r
13077             + "\2\2\u01f4/\3\2\2\2\u01f5\u01f3\3\2\2\2\u01f6\u01fe\5.\30\2\u01f7\u01fe"\r
13078             + "\5,\27\2\u01f8\u01fe\5*\26\2\u01f9\u01fe\5(\25\2\u01fa\u01fe\5&\24\2\u01fb"\r
13079             + "\u01fe\5$\23\2\u01fc\u01fe\5\"\22\2\u01fd\u01f6\3\2\2\2\u01fd\u01f7\3"\r
13080             + "\2\2\2\u01fd\u01f8\3\2\2\2\u01fd\u01f9\3\2\2\2\u01fd\u01fa\3\2\2\2\u01fd"\r
13081             + "\u01fb\3\2\2\2\u01fd\u01fc\3\2\2\2\u01fe\61\3\2\2\2\u01ff\u0200\7\31\2"\r
13082             + "\2\u0200\u020a\5\4\3\2\u0201\u020b\7\3\2\2\u0202\u0204\7\4\2\2\u0203\u0205"\r
13083             + "\5\60\31\2\u0204\u0203\3\2\2\2\u0205\u0206\3\2\2\2\u0206\u0204\3\2\2\2"\r
13084             + "\u0206\u0207\3\2\2\2\u0207\u0208\3\2\2\2\u0208\u0209\7\5\2\2\u0209\u020b"\r
13085             + "\3\2\2\2\u020a\u0201\3\2\2\2\u020a\u0202\3\2\2\2\u020b\63\3\2\2\2\u020c"\r
13086             + "\u020d\7\16\2\2\u020d\u021e\5\4\3\2\u020e\u021f\7\3\2\2\u020f\u021a\7"\r
13087             + "\4\2\2\u0210\u0219\5\6\4\2\u0211\u0219\5\34\17\2\u0212\u0219\5\u009aN"\r
13088             + "\2\u0213\u0219\5j\66\2\u0214\u0219\5\u00b2Z\2\u0215\u0219\5\u00b0Y\2\u0216"\r
13089             + "\u0219\5\62\32\2\u0217\u0219\5 \21\2\u0218\u0210\3\2\2\2\u0218\u0211\3"\r
13090             + "\2\2\2\u0218\u0212\3\2\2\2\u0218\u0213\3\2\2\2\u0218\u0214\3\2\2\2\u0218"\r
13091             + "\u0215\3\2\2\2\u0218\u0216\3\2\2\2\u0218\u0217\3\2\2\2\u0219\u021c\3\2"\r
13092             + "\2\2\u021a\u0218\3\2\2\2\u021a\u021b\3\2\2\2\u021b\u021d\3\2\2\2\u021c"\r
13093             + "\u021a\3\2\2\2\u021d\u021f\7\5\2\2\u021e\u020e\3\2\2\2\u021e\u020f\3\2"\r
13094             + "\2\2\u021f\65\3\2\2\2\u0220\u0221\7J\2\2\u0221\u0233\5\4\3\2\u0222\u0234"\r
13095             + "\7\3\2\2\u0223\u022f\7\4\2\2\u0224\u022e\5\6\4\2\u0225\u022e\5\34\17\2"\r
13096             + "\u0226\u022e\5\u009aN\2\u0227\u022e\5X-\2\u0228\u022e\5f\64\2\u0229\u022e"\r
13097             + "\5b\62\2\u022a\u022e\5j\66\2\u022b\u022e\5\u00b2Z\2\u022c\u022e\5\u00b0"\r
13098             + "Y\2\u022d\u0224\3\2\2\2\u022d\u0225\3\2\2\2\u022d\u0226\3\2\2\2\u022d"\r
13099             + "\u0227\3\2\2\2\u022d\u0228\3\2\2\2\u022d\u0229\3\2\2\2\u022d\u022a\3\2"\r
13100             + "\2\2\u022d\u022b\3\2\2\2\u022d\u022c\3\2\2\2\u022e\u0231\3\2\2\2\u022f"\r
13101             + "\u022d\3\2\2\2\u022f\u0230\3\2\2\2\u0230\u0232\3\2\2\2\u0231\u022f\3\2"\r
13102             + "\2\2\u0232\u0234\7\5\2\2\u0233\u0222\3\2\2\2\u0233\u0223\3\2\2\2\u0234"\r
13103             + "\67\3\2\2\2\u0235\u0236\7D\2\2\u0236\u0246\5\4\3\2\u0237\u0247\7\3\2\2"\r
13104             + "\u0238\u0242\7\4\2\2\u0239\u0241\5\6\4\2\u023a\u0241\5\34\17\2\u023b\u0241"\r
13105             + "\5\u009aN\2\u023c\u0241\5j\66\2\u023d\u0241\5\u00b2Z\2\u023e\u0241\5\u00b0"\r
13106             + "Y\2\u023f\u0241\5\u00c4c\2\u0240\u0239\3\2\2\2\u0240\u023a\3\2\2\2\u0240"\r
13107             + "\u023b\3\2\2\2\u0240\u023c\3\2\2\2\u0240\u023d\3\2\2\2\u0240\u023e\3\2"\r
13108             + "\2\2\u0240\u023f\3\2\2\2\u0241\u0244\3\2\2\2\u0242\u0240\3\2\2\2\u0242"\r
13109             + "\u0243\3\2\2\2\u0243\u0245\3\2\2\2\u0244\u0242\3\2\2\2\u0245\u0247\7\5"\r
13110             + "\2\2\u0246\u0237\3\2\2\2\u0246\u0238\3\2\2\2\u02479\3\2\2\2\u0248\u024e"\r
13111             + "\5H%\2\u0249\u024e\5F$\2\u024a\u024e\5D#\2\u024b\u024e\5B\"\2\u024c\u024e"\r
13112             + "\5\66\34\2\u024d\u0248\3\2\2\2\u024d\u0249\3\2\2\2\u024d\u024a\3\2\2\2"\r
13113             + "\u024d\u024b\3\2\2\2\u024d\u024c\3\2\2\2\u024e;\3\2\2\2\u024f\u0250\7"\r
13114             + "C\2\2\u0250\u0264\5\4\3\2\u0251\u0265\7\3\2\2\u0252\u0260\7\4\2\2\u0253"\r
13115             + "\u025f\5\6\4\2\u0254\u025f\5\34\17\2\u0255\u025f\5\u009aN\2\u0256\u025f"\r
13116             + "\5\u0084C\2\u0257\u025f\5f\64\2\u0258\u025f\5b\62\2\u0259\u025f\5j\66"\r
13117             + "\2\u025a\u025f\5\u00b2Z\2\u025b\u025f\5\u00b0Y\2\u025c\u025f\5:\36\2\u025d"\r
13118             + "\u025f\58\35\2\u025e\u0253\3\2\2\2\u025e\u0254\3\2\2\2\u025e\u0255\3\2"\r
13119             + "\2\2\u025e\u0256\3\2\2\2\u025e\u0257\3\2\2\2\u025e\u0258\3\2\2\2\u025e"\r
13120             + "\u0259\3\2\2\2\u025e\u025a\3\2\2\2\u025e\u025b\3\2\2\2\u025e\u025c\3\2"\r
13121             + "\2\2\u025e\u025d\3\2\2\2\u025f\u0262\3\2\2\2\u0260\u025e\3\2\2\2\u0260"\r
13122             + "\u0261\3\2\2\2\u0261\u0263\3\2\2\2\u0262\u0260\3\2\2\2\u0263\u0265\7\5"\r
13123             + "\2\2\u0264\u0251\3\2\2\2\u0264\u0252\3\2\2\2\u0265=\3\2\2\2\u0266\u0267"\r
13124             + "\7\20\2\2\u0267\u0268\5\4\3\2\u0268\u0269\5\b\5\2\u0269?\3\2\2\2\u026a"\r
13125             + "\u026b\7/\2\2\u026b\u026c\5\4\3\2\u026c\u026d\5\b\5\2\u026dA\3\2\2\2\u026e"\r
13126             + "\u026f\7+\2\2\u026f\u0270\5\4\3\2\u0270\u0281\7\4\2\2\u0271\u0282\5\6"\r
13127             + "\4\2\u0272\u0282\5\34\17\2\u0273\u0282\5\u009aN\2\u0274\u0282\5X-\2\u0275"\r
13128             + "\u0282\5@!\2\u0276\u0282\5> \2\u0277\u0282\5f\64\2\u0278\u0282\5R*\2\u0279"\r
13129             + "\u0282\5P)\2\u027a\u0282\5\\/\2\u027b\u0282\5j\66\2\u027c\u0282\5\u00b2"\r
13130             + "Z\2\u027d\u0282\5\u00b0Y\2\u027e\u0282\5\u0098M\2\u027f\u0282\5J&\2\u0280"\r
13131             + "\u0282\5\u00c4c\2\u0281\u0271\3\2\2\2\u0281\u0272\3\2\2\2\u0281\u0273"\r
13132             + "\3\2\2\2\u0281\u0274\3\2\2\2\u0281\u0275\3\2\2\2\u0281\u0276\3\2\2\2\u0281"\r
13133             + "\u0277\3\2\2\2\u0281\u0278\3\2\2\2\u0281\u0279\3\2\2\2\u0281\u027a\3\2"\r
13134             + "\2\2\u0281\u027b\3\2\2\2\u0281\u027c\3\2\2\2\u0281\u027d\3\2\2\2\u0281"\r
13135             + "\u027e\3\2\2\2\u0281\u027f\3\2\2\2\u0281\u0280\3\2\2\2\u0282\u0283\3\2"\r
13136             + "\2\2\u0283\u0281\3\2\2\2\u0283\u0284\3\2\2\2\u0284\u0285\3\2\2\2\u0285"\r
13137             + "\u0286\7\5\2\2\u0286C\3\2\2\2\u0287\u0288\7-\2\2\u0288\u0289\5\4\3\2\u0289"\r
13138             + "\u0299\7\4\2\2\u028a\u0298\5\6\4\2\u028b\u0298\5\34\17\2\u028c\u0298\5"\r
13139             + "\u009aN\2\u028d\u0298\5\u0096L\2\u028e\u0298\5\u00aeX\2\u028f\u0298\5"\r
13140             + "X-\2\u0290\u0298\5f\64\2\u0291\u0298\5R*\2\u0292\u0298\5P)\2\u0293\u0298"\r
13141             + "\5\\/\2\u0294\u0298\5j\66\2\u0295\u0298\5\u00b2Z\2\u0296\u0298\5\u00b0"\r
13142             + "Y\2\u0297\u028a\3\2\2\2\u0297\u028b\3\2\2\2\u0297\u028c\3\2\2\2\u0297"\r
13143             + "\u028d\3\2\2\2\u0297\u028e\3\2\2\2\u0297\u028f\3\2\2\2\u0297\u0290\3\2"\r
13144             + "\2\2\u0297\u0291\3\2\2\2\u0297\u0292\3\2\2\2\u0297\u0293\3\2\2\2\u0297"\r
13145             + "\u0294\3\2\2\2\u0297\u0295\3\2\2\2\u0297\u0296\3\2\2\2\u0298\u029b\3\2"\r
13146             + "\2\2\u0299\u0297\3\2\2\2\u0299\u029a\3\2\2\2\u029a\u029c\3\2\2\2\u029b"\r
13147             + "\u0299\3\2\2\2\u029c\u029d\7\5\2\2\u029dE\3\2\2\2\u029e\u029f\7.\2\2\u029f"\r
13148             + "\u02a0\5\4\3\2\u02a0\u02af\7\4\2\2\u02a1\u02ae\5\6\4\2\u02a2\u02ae\5\34"\r
13149             + "\17\2\u02a3\u02ae\5\u009aN\2\u02a4\u02ae\5\u0096L\2\u02a5\u02ae\5\u00ae"\r
13150             + "X\2\u02a6\u02ae\5X-\2\u02a7\u02ae\5\u0084C\2\u02a8\u02ae\5f\64\2\u02a9"\r
13151             + "\u02ae\5b\62\2\u02aa\u02ae\5j\66\2\u02ab\u02ae\5\u00b2Z\2\u02ac\u02ae"\r
13152             + "\5\u00b0Y\2\u02ad\u02a1\3\2\2\2\u02ad\u02a2\3\2\2\2\u02ad\u02a3\3\2\2"\r
13153             + "\2\u02ad\u02a4\3\2\2\2\u02ad\u02a5\3\2\2\2\u02ad\u02a6\3\2\2\2\u02ad\u02a7"\r
13154             + "\3\2\2\2\u02ad\u02a8\3\2\2\2\u02ad\u02a9\3\2\2\2\u02ad\u02aa\3\2\2\2\u02ad"\r
13155             + "\u02ab\3\2\2\2\u02ad\u02ac\3\2\2\2\u02ae\u02b1\3\2\2\2\u02af\u02ad\3\2"\r
13156             + "\2\2\u02af\u02b0\3\2\2\2\u02b0\u02b2\3\2\2\2\u02b1\u02af\3\2\2\2\u02b2"\r
13157             + "\u02b3\7\5\2\2\u02b3G\3\2\2\2\u02b4\u02b5\7@\2\2\u02b5\u02ca\5\4\3\2\u02b6"\r
13158             + "\u02cb\7\3\2\2\u02b7\u02c6\7\4\2\2\u02b8\u02c5\5\6\4\2\u02b9\u02c5\5\34"\r
13159             + "\17\2\u02ba\u02c5\5\u009aN\2\u02bb\u02c5\5X-\2\u02bc\u02c5\5^\60\2\u02bd"\r
13160             + "\u02c5\5f\64\2\u02be\u02c5\5j\66\2\u02bf\u02c5\5\u00b2Z\2\u02c0\u02c5"\r
13161             + "\5\u00b0Y\2\u02c1\u02c5\5\u0098M\2\u02c2\u02c5\5J&\2\u02c3\u02c5\5\u00c4"\r
13162             + "c\2\u02c4\u02b8\3\2\2\2\u02c4\u02b9\3\2\2\2\u02c4\u02ba\3\2\2\2\u02c4"\r
13163             + "\u02bb\3\2\2\2\u02c4\u02bc\3\2\2\2\u02c4\u02bd\3\2\2\2\u02c4\u02be\3\2"\r
13164             + "\2\2\u02c4\u02bf\3\2\2\2\u02c4\u02c0\3\2\2\2\u02c4\u02c1\3\2\2\2\u02c4"\r
13165             + "\u02c2\3\2\2\2\u02c4\u02c3\3\2\2\2\u02c5\u02c8\3\2\2\2\u02c6\u02c4\3\2"\r
13166             + "\2\2\u02c6\u02c7\3\2\2\2\u02c7\u02c9\3\2\2\2\u02c8\u02c6\3\2\2\2\u02c9"\r
13167             + "\u02cb\7\5\2\2\u02ca\u02b6\3\2\2\2\u02ca\u02b7\3\2\2\2\u02cbI\3\2\2\2"\r
13168             + "\u02cc\u02cd\7\65\2\2\u02cd\u02dd\5\4\3\2\u02ce\u02de\7\3\2\2\u02cf\u02d9"\r
13169             + "\7\4\2\2\u02d0\u02d8\5\6\4\2\u02d1\u02d8\5j\66\2\u02d2\u02d8\5\u00b2Z"\r
13170             + "\2\u02d3\u02d8\5\u00b0Y\2\u02d4\u02d8\5\u0098M\2\u02d5\u02d8\5J&\2\u02d6"\r
13171             + "\u02d8\5\u00c4c\2\u02d7\u02d0\3\2\2\2\u02d7\u02d1\3\2\2\2\u02d7\u02d2"\r
13172             + "\3\2\2\2\u02d7\u02d3\3\2\2\2\u02d7\u02d4\3\2\2\2\u02d7\u02d5\3\2\2\2\u02d7"\r
13173             + "\u02d6\3\2\2\2\u02d8\u02db\3\2\2\2\u02d9\u02d7\3\2\2\2\u02d9\u02da\3\2"\r
13174             + "\2\2\u02da\u02dc\3\2\2\2\u02db\u02d9\3\2\2\2\u02dc\u02de\7\5\2\2\u02dd"\r
13175             + "\u02ce\3\2\2\2\u02dd\u02cf\3\2\2\2\u02deK\3\2\2\2\u02df\u02e0\7\r\2\2"\r
13176             + "\u02e0\u02e1\5\4\3\2\u02e1\u02e2\5\b\5\2\u02e2M\3\2\2\2\u02e3\u02e4\5"\r
13177             + "\4\3\2\u02e4O\3\2\2\2\u02e5\u02e6\7)\2\2\u02e6\u02e7\5N(\2\u02e7\u02e8"\r
13178             + "\5\b\5\2\u02e8Q\3\2\2\2\u02e9\u02ea\7(\2\2\u02ea\u02eb\5\4\3\2\u02eb\u02ec"\r
13179             + "\5\b\5\2\u02ecS\3\2\2\2\u02ed\u02ee\7<\2\2\u02ee\u02ef\5\4\3\2\u02ef\u02f0"\r
13180             + "\5\b\5\2\u02f0U\3\2\2\2\u02f1\u02f2\7;\2\2\u02f2\u02f3\5\4\3\2\u02f3\u02f4"\r
13181             + "\5\b\5\2\u02f4W\3\2\2\2\u02f5\u02f6\7&\2\2\u02f6\u0304\5\4\3\2\u02f7\u0305"\r
13182             + "\7\3\2\2\u02f8\u0300\7\4\2\2\u02f9\u02ff\5\6\4\2\u02fa\u02ff\5V,\2\u02fb"\r
13183             + "\u02ff\5T+\2\u02fc\u02ff\5\u00b2Z\2\u02fd\u02ff\5\u00b0Y\2\u02fe\u02f9"\r
13184             + "\3\2\2\2\u02fe\u02fa\3\2\2\2\u02fe\u02fb\3\2\2\2\u02fe\u02fc\3\2\2\2\u02fe"\r
13185             + "\u02fd\3\2\2\2\u02ff\u0302\3\2\2\2\u0300\u02fe\3\2\2\2\u0300\u0301\3\2"\r
13186             + "\2\2\u0301\u0303\3\2\2\2\u0302\u0300\3\2\2\2\u0303\u0305\7\5\2\2\u0304"\r
13187             + "\u02f7\3\2\2\2\u0304\u02f8\3\2\2\2\u0305Y\3\2\2\2\u0306\u0307\5\4\3\2"\r
13188             + "\u0307[\3\2\2\2\u0308\u0309\7#\2\2\u0309\u030a\5Z.\2\u030a\u030b\5\b\5"\r
13189             + "\2\u030b]\3\2\2\2\u030c\u030d\7\34\2\2\u030d\u030e\5\4\3\2\u030e\u030f"\r
13190             + "\5\b\5\2\u030f_\3\2\2\2\u0310\u0311\5\4\3\2\u0311a\3\2\2\2\u0312\u0313"\r
13191             + "\7*\2\2\u0313\u0314\5`\61\2\u0314\u0315\5\b\5\2\u0315c\3\2\2\2\u0316\u0317"\r
13192             + "\5\4\3\2\u0317e\3\2\2\2\u0318\u0319\7B\2\2\u0319\u031a\5d\63\2\u031a\u031b"\r
13193             + "\5\b\5\2\u031bg\3\2\2\2\u031c\u031d\5\4\3\2\u031di\3\2\2\2\u031e\u031f"\r
13194             + "\7\24\2\2\u031f\u0320\5h\65\2\u0320\u0321\5\b\5\2\u0321k\3\2\2\2\u0322"\r
13195             + "\u0323\7\36\2\2\u0323\u0324\5\4\3\2\u0324\u0325\5\b\5\2\u0325m\3\2\2\2"\r
13196             + "\u0326\u0327\7E\2\2\u0327\u0335\5\4\3\2\u0328\u0336\7\3\2\2\u0329\u0331"\r
13197             + "\7\4\2\2\u032a\u0330\5\6\4\2\u032b\u0330\5l\67\2\u032c\u0330\5j\66\2\u032d"\r
13198             + "\u0330\5\u00b2Z\2\u032e\u0330\5\u00b0Y\2\u032f\u032a\3\2\2\2\u032f\u032b"\r
13199             + "\3\2\2\2\u032f\u032c\3\2\2\2\u032f\u032d\3\2\2\2\u032f\u032e\3\2\2\2\u0330"\r
13200             + "\u0333\3\2\2\2\u0331\u032f\3\2\2\2\u0331\u0332\3\2\2\2\u0332\u0334\3\2"\r
13201             + "\2\2\u0333\u0331\3\2\2\2\u0334\u0336\7\5\2\2\u0335\u0328\3\2\2\2\u0335"\r
13202             + "\u0329\3\2\2\2\u0336o\3\2\2\2\u0337\u0339\5n8\2\u0338\u0337\3\2\2\2\u0339"\r
13203             + "\u033a\3\2\2\2\u033a\u0338\3\2\2\2\u033a\u033b\3\2\2\2\u033bq\3\2\2\2"\r
13204             + "\u033c\u033e\5\u0096L\2\u033d\u033c\3\2\2\2\u033e\u033f\3\2\2\2\u033f"\r
13205             + "\u033d\3\2\2\2\u033f\u0340\3\2\2\2\u0340s\3\2\2\2\u0341\u0342\5\u009e"\r
13206             + "P\2\u0342u\3\2\2\2\u0343\u0345\5z>\2\u0344\u0343\3\2\2\2\u0344\u0345\3"\r
13207             + "\2\2\2\u0345w\3\2\2\2\u0346\u0347\5\4\3\2\u0347y\3\2\2\2\u0348\u0349\7"\r
13208             + "\30\2\2\u0349\u034a\5x=\2\u034a\u034b\5\b\5\2\u034b{\3\2\2\2\u034c\u034d"\r
13209             + "\7 \2\2\u034d\u034e\5\4\3\2\u034e\u034f\5\b\5\2\u034f}\3\2\2\2\u0350\u0351"\r
13210             + "\5|?\2\u0351\177\3\2\2\2\u0352\u0353\7=\2\2\u0353\u0361\5\4\3\2\u0354"\r
13211             + "\u0362\7\3\2\2\u0355\u035d\7\4\2\2\u0356\u035c\5\6\4\2\u0357\u035c\5L"\r
13212             + "\'\2\u0358\u035c\5j\66\2\u0359\u035c\5\u00b2Z\2\u035a\u035c\5\u00b0Y\2"\r
13213             + "\u035b\u0356\3\2\2\2\u035b\u0357\3\2\2\2\u035b\u0358\3\2\2\2\u035b\u0359"\r
13214             + "\3\2\2\2\u035b\u035a\3\2\2\2\u035c\u035f\3\2\2\2\u035d\u035b\3\2\2\2\u035d"\r
13215             + "\u035e\3\2\2\2\u035e\u0360\3\2\2\2\u035f\u035d\3\2\2\2\u0360\u0362\7\5"\r
13216             + "\2\2\u0361\u0354\3\2\2\2\u0361\u0355\3\2\2\2\u0362\u0081\3\2\2\2\u0363"\r
13217             + "\u0365\5\u0080A\2\u0364\u0363\3\2\2\2\u0365\u0366\3\2\2\2\u0366\u0364"\r
13218             + "\3\2\2\2\u0366\u0367\3\2\2\2\u0367\u0083\3\2\2\2\u0368\u0369\7?\2\2\u0369"\r
13219             + "\u036a\5\4\3\2\u036a\u036b\5\b\5\2\u036b\u0085\3\2\2\2\u036c\u036d\7\37"\r
13220             + "\2\2\u036d\u037b\5\4\3\2\u036e\u037c\7\3\2\2\u036f\u0377\7\4\2\2\u0370"\r
13221             + "\u0376\5\6\4\2\u0371\u0376\5V,\2\u0372\u0376\5T+\2\u0373\u0376\5\u00b2"\r
13222             + "Z\2\u0374\u0376\5\u00b0Y\2\u0375\u0370\3\2\2\2\u0375\u0371\3\2\2\2\u0375"\r
13223             + "\u0372\3\2\2\2\u0375\u0373\3\2\2\2\u0375\u0374\3\2\2\2\u0376\u0379\3\2"\r
13224             + "\2\2\u0377\u0375\3\2\2\2\u0377\u0378\3\2\2\2\u0378\u037a\3\2\2\2\u0379"\r
13225             + "\u0377\3\2\2\2\u037a\u037c\7\5\2\2\u037b\u036e\3\2\2\2\u037b\u036f\3\2"\r
13226             + "\2\2\u037c\u0087\3\2\2\2\u037d\u037e\7,\2\2\u037e\u038c\5\4\3\2\u037f"\r
13227             + "\u038d\7\3\2\2\u0380\u0388\7\4\2\2\u0381\u0387\5\6\4\2\u0382\u0387\5V"\r
13228             + ",\2\u0383\u0387\5T+\2\u0384\u0387\5\u00b2Z\2\u0385\u0387\5\u00b0Y\2\u0386"\r
13229             + "\u0381\3\2\2\2\u0386\u0382\3\2\2\2\u0386\u0383\3\2\2\2\u0386\u0384\3\2"\r
13230             + "\2\2\u0386\u0385\3\2\2\2\u0387\u038a\3\2\2\2\u0388\u0386\3\2\2\2\u0388"\r
13231             + "\u0389\3\2\2\2\u0389\u038b\3\2\2\2\u038a\u0388\3\2\2\2\u038b\u038d\7\5"\r
13232             + "\2\2\u038c\u037f\3\2\2\2\u038c\u0380\3\2\2\2\u038d\u0089\3\2\2\2\u038e"\r
13233             + "\u0391\5\u0088E\2\u038f\u0391\5\u0086D\2\u0390\u038e\3\2\2\2\u0390\u038f"\r
13234             + "\3\2\2\2\u0391\u0394\3\2\2\2\u0392\u0390\3\2\2\2\u0392\u0393\3\2\2\2\u0393"\r
13235             + "\u008b\3\2\2\2\u0394\u0392\3\2\2\2\u0395\u0396\7\66\2\2\u0396\u0397\5"\r
13236             + "\4\3\2\u0397\u0398\5\b\5\2\u0398\u008d\3\2\2\2\u0399\u039b\5\u0092J\2"\r
13237             + "\u039a\u0399\3\2\2\2\u039a\u039b\3\2\2\2\u039b\u039c\3\2\2\2\u039c\u03a2"\r
13238             + "\5\u008cG\2\u039d\u039f\5\u008cG\2\u039e\u03a0\5\u0092J\2\u039f\u039e"\r
13239             + "\3\2\2\2\u039f\u03a0\3\2\2\2\u03a0\u03a2\3\2\2\2\u03a1\u039a\3\2\2\2\u03a1"\r
13240             + "\u039d\3\2\2\2\u03a2\u008f\3\2\2\2\u03a3\u03a4\7\33\2\2\u03a4\u03b2\5"\r
13241             + "\4\3\2\u03a5\u03b3\7\3\2\2\u03a6\u03ae\7\4\2\2\u03a7\u03ad\5\6\4\2\u03a8"\r
13242             + "\u03ad\5V,\2\u03a9\u03ad\5T+\2\u03aa\u03ad\5\u00b2Z\2\u03ab\u03ad\5\u00b0"\r
13243             + "Y\2\u03ac\u03a7\3\2\2\2\u03ac\u03a8\3\2\2\2\u03ac\u03a9\3\2\2\2\u03ac"\r
13244             + "\u03aa\3\2\2\2\u03ac\u03ab\3\2\2\2\u03ad\u03b0\3\2\2\2\u03ae\u03ac\3\2"\r
13245             + "\2\2\u03ae\u03af\3\2\2\2\u03af\u03b1\3\2\2\2\u03b0\u03ae\3\2\2\2\u03b1"\r
13246             + "\u03b3\7\5\2\2\u03b2\u03a5\3\2\2\2\u03b2\u03a6\3\2\2\2\u03b3\u0091\3\2"\r
13247             + "\2\2\u03b4\u03b5\5\u0090I\2\u03b5\u0093\3\2\2\2\u03b6\u03c0\5\u0092J\2"\r
13248             + "\u03b7\u03c0\5\u008eH\2\u03b8\u03c0\5\u008aF\2\u03b9\u03c0\5\u0082B\2"\r
13249             + "\u03ba\u03c0\5~@\2\u03bb\u03c0\5t;\2\u03bc\u03c0\5v<\2\u03bd\u03c0\5p"\r
13250             + "9\2\u03be\u03c0\5r:\2\u03bf\u03b6\3\2\2\2\u03bf\u03b7\3\2\2\2\u03bf\u03b8"\r
13251             + "\3\2\2\2\u03bf\u03b9\3\2\2\2\u03bf\u03ba\3\2\2\2\u03bf\u03bb\3\2\2\2\u03bf"\r
13252             + "\u03bc\3\2\2\2\u03bf\u03bd\3\2\2\2\u03bf\u03be\3\2\2\2\u03c0\u0095\3\2"\r
13253             + "\2\2\u03c1\u03c2\7\22\2\2\u03c2\u03c8\5\4\3\2\u03c3\u03c9\7\3\2\2\u03c4"\r
13254             + "\u03c5\7\4\2\2\u03c5\u03c6\5\u0094K\2\u03c6\u03c7\7\5\2\2\u03c7\u03c9"\r
13255             + "\3\2\2\2\u03c8\u03c3\3\2\2\2\u03c8\u03c4\3\2\2\2\u03c9\u0097\3\2\2\2\u03ca"\r
13256             + "\u03cb\7\21\2\2\u03cb\u03cc\5\4\3\2\u03cc\u03d3\7\4\2\2\u03cd\u03d4\5"\r
13257             + "\u0096L\2\u03ce\u03d4\5\u00aeX\2\u03cf\u03d4\5\u0084C\2\u03d0\u03d4\5"\r
13258             + "j\66\2\u03d1\u03d4\5\u00b2Z\2\u03d2\u03d4\5\u00b0Y\2\u03d3\u03cd\3\2\2"\r
13259             + "\2\u03d3\u03ce\3\2\2\2\u03d3\u03cf\3\2\2\2\u03d3\u03d0\3\2\2\2\u03d3\u03d1"\r
13260             + "\3\2\2\2\u03d3\u03d2\3\2\2\2\u03d4\u03d5\3\2\2\2\u03d5\u03d3\3\2\2\2\u03d5"\r
13261             + "\u03d6\3\2\2\2\u03d6\u03d7\3\2\2\2\u03d7\u03d8\7\5\2\2\u03d8\u0099\3\2"\r
13262             + "\2\2\u03d9\u03da\7\63\2\2\u03da\u03db\5\4\3\2\u03db\u03dc\5\b\5\2\u03dc"\r
13263             + "\u009b\3\2\2\2\u03dd\u03de\7\67\2\2\u03de\u03eb\5\4\3\2\u03df\u03ec\7"\r
13264             + "\3\2\2\u03e0\u03e7\7\4\2\2\u03e1\u03e6\5\u009aN\2\u03e2\u03e6\5j\66\2"\r
13265             + "\u03e3\u03e6\5\u00b2Z\2\u03e4\u03e6\5\u00b0Y\2\u03e5\u03e1\3\2\2\2\u03e5"\r
13266             + "\u03e2\3\2\2\2\u03e5\u03e3\3\2\2\2\u03e5\u03e4\3\2\2\2\u03e6\u03e9\3\2"\r
13267             + "\2\2\u03e7\u03e5\3\2\2\2\u03e7\u03e8\3\2\2\2\u03e8\u03ea\3\2\2\2\u03e9"\r
13268             + "\u03e7\3\2\2\2\u03ea\u03ec\7\5\2\2\u03eb\u03df\3\2\2\2\u03eb\u03e0\3\2"\r
13269             + "\2\2\u03ec\u009d\3\2\2\2\u03ed\u03ee\7G\2\2\u03ee\u03ef\5\4\3\2\u03ef"\r
13270             + "\u03f0\5\b\5\2\u03f0\u009f\3\2\2\2\u03f1\u03f2\7\64\2\2\u03f2\u03ff\5"\r
13271             + "\4\3\2\u03f3\u0400\7\3\2\2\u03f4\u03fb\7\4\2\2\u03f5\u03fa\5\u009eP\2"\r
13272             + "\u03f6\u03fa\5j\66\2\u03f7\u03fa\5\u00b2Z\2\u03f8\u03fa\5\u00b0Y\2\u03f9"\r
13273             + "\u03f5\3\2\2\2\u03f9\u03f6\3\2\2\2\u03f9\u03f7\3\2\2\2\u03f9\u03f8\3\2"\r
13274             + "\2\2\u03fa\u03fd\3\2\2\2\u03fb\u03f9\3\2\2\2\u03fb\u03fc\3\2\2\2\u03fc"\r
13275             + "\u03fe\3\2\2\2\u03fd\u03fb\3\2\2\2\u03fe\u0400\7\5\2\2\u03ff\u03f3\3\2"\r
13276             + "\2\2\u03ff\u03f4\3\2\2\2\u0400\u00a1\3\2\2\2\u0401\u0402\5\4\3\2\u0402"\r
13277             + "\u00a3\3\2\2\2\u0403\u0404\7\n\2\2\u0404\u0405\5\u00a2R\2\u0405\u0406"\r
13278             + "\5\b\5\2\u0406\u00a5\3\2\2\2\u0407\u0408\7I\2\2\u0408\u040f\5\4\3\2\u0409"\r
13279             + "\u0410\7\3\2\2\u040a\u040c\7\4\2\2\u040b\u040d\5\u00a4S\2\u040c\u040b"\r
13280             + "\3\2\2\2\u040c\u040d\3\2\2\2\u040d\u040e\3\2\2\2\u040e\u0410\7\5\2\2\u040f"\r
13281             + "\u0409\3\2\2\2\u040f\u040a\3\2\2\2\u0410\u00a7\3\2\2\2\u0411\u0412\7:"\r
13282             + "\2\2\u0412\u041f\5\4\3\2\u0413\u0420\7\3\2\2\u0414\u041b\7\4\2\2\u0415"\r
13283             + "\u041a\5\u00a6T\2\u0416\u041a\5j\66\2\u0417\u041a\5\u00b2Z\2\u0418\u041a"\r
13284             + "\5\u00b0Y\2\u0419\u0415\3\2\2\2\u0419\u0416\3\2\2\2\u0419\u0417\3\2\2"\r
13285             + "\2\u0419\u0418\3\2\2\2\u041a\u041d\3\2\2\2\u041b\u0419\3\2\2\2\u041b\u041c"\r
13286             + "\3\2\2\2\u041c\u041e\3\2\2\2\u041d\u041b\3\2\2\2\u041e\u0420\7\5\2\2\u041f"\r
13287             + "\u0413\3\2\2\2\u041f\u0414\3\2\2\2\u0420\u00a9\3\2\2\2\u0421\u0422\7\26"\r
13288             + "\2\2\u0422\u0423\5\4\3\2\u0423\u0424\5\b\5\2\u0424\u00ab\3\2\2\2\u0425"\r
13289             + "\u0426\7\27\2\2\u0426\u0430\5\4\3\2\u0427\u0431\7\3\2\2\u0428\u042a\7"\r
13290             + "\4\2\2\u0429\u042b\5\u00b2Z\2\u042a\u0429\3\2\2\2\u042a\u042b\3\2\2\2"\r
13291             + "\u042b\u042d\3\2\2\2\u042c\u042e\5\u00b0Y\2\u042d\u042c\3\2\2\2\u042d"\r
13292             + "\u042e\3\2\2\2\u042e\u042f\3\2\2\2\u042f\u0431\7\5\2\2\u0430\u0427\3\2"\r
13293             + "\2\2\u0430\u0428\3\2\2\2\u0431\u00ad\3\2\2\2\u0432\u0433\7\17\2\2\u0433"\r
13294             + "\u0434\5\4\3\2\u0434\u0435\5\b\5\2\u0435\u00af\3\2\2\2\u0436\u0437\7\32"\r
13295             + "\2\2\u0437\u0438\5\4\3\2\u0438\u0439\5\b\5\2\u0439\u00b1\3\2\2\2\u043a"\r
13296             + "\u043b\7>\2\2\u043b\u043c\5\4\3\2\u043c\u043d\5\b\5\2\u043d\u00b3\3\2"\r
13297             + "\2\2\u043e\u043f\7A\2\2\u043f\u0440\5\4\3\2\u0440\u0441\5\b\5\2\u0441"\r
13298             + "\u00b5\3\2\2\2\u0442\u0443\7\"\2\2\u0443\u0444\5\4\3\2\u0444\u0445\5\b"\r
13299             + "\5\2\u0445\u00b7\3\2\2\2\u0446\u0447\7F\2\2\u0447\u0448\5\4\3\2\u0448"\r
13300             + "\u0449\7\4\2\2\u0449\u044a\5\u00ba^\2\u044a\u044b\7\5\2\2\u044b\u00b9"\r
13301             + "\3\2\2\2\u044c\u044d\7\35\2\2\u044d\u044e\5\4\3\2\u044e\u044f\5\b\5\2"\r
13302             + "\u044f\u00bb\3\2\2\2\u0450\u0451\7%\2\2\u0451\u0452\5\4\3\2\u0452\u0453"\r
13303             + "\5\b\5\2\u0453\u00bd\3\2\2\2\u0454\u0455\7\61\2\2\u0455\u045c\5\4\3\2"\r
13304             + "\u0456\u045d\7\3\2\2\u0457\u0459\7\4\2\2\u0458\u045a\5\u00aaV\2\u0459"\r
13305             + "\u0458\3\2\2\2\u0459\u045a\3\2\2\2\u045a\u045b\3\2\2\2\u045b\u045d\7\5"\r
13306             + "\2\2\u045c\u0456\3\2\2\2\u045c\u0457\3\2\2\2\u045d\u00bf\3\2\2\2\u045e"\r
13307             + "\u045f\7\62\2\2\u045f\u0460\5\4\3\2\u0460\u0461\7\4\2\2\u0461\u0463\5"\r
13308             + "\u00ba^\2\u0462\u0464\5\u00aaV\2\u0463\u0462\3\2\2\2\u0463\u0464\3\2\2"\r
13309             + "\2\u0464\u0465\3\2\2\2\u0465\u0466\7\5\2\2\u0466\u00c1\3\2\2\2\u0467\u0468"\r
13310             + "\7\13\2\2\u0468\u0469\5\4\3\2\u0469\u046a\5\b\5\2\u046a\u00c3\3\2\2\2"\r
13311             + "\u046b\u0473\5H%\2\u046c\u0473\5F$\2\u046d\u0473\5D#\2\u046e\u0473\5B"\r
13312             + "\"\2\u046f\u0473\5<\37\2\u0470\u0473\5\66\34\2\u0471\u0473\5\64\33\2\u0472"\r
13313             + "\u046b\3\2\2\2\u0472\u046c\3\2\2\2\u0472\u046d\3\2\2\2\u0472\u046e\3\2"\r
13314             + "\2\2\u0472\u046f\3\2\2\2\u0472\u0470\3\2\2\2\u0472\u0471\3\2\2\2\u0473"\r
13315             + "\u00c5\3\2\2\2\u0474\u047f\5\u00a8U\2\u0475\u047f\5\u009cO\2\u0476\u047f"\r
13316             + "\5\u00a0Q\2\u0477\u047f\5\u0098M\2\u0478\u047f\5J&\2\u0479\u047f\5\u00c4"\r
13317             + "c\2\u047a\u047f\5\36\20\2\u047b\u047f\5\32\16\2\u047c\u047f\5\24\13\2"\r
13318             + "\u047d\u047f\5\22\n\2\u047e\u0474\3\2\2\2\u047e\u0475\3\2\2\2\u047e\u0476"\r
13319             + "\3\2\2\2\u047e\u0477\3\2\2\2\u047e\u0478\3\2\2\2\u047e\u0479\3\2\2\2\u047e"\r
13320             + "\u047a\3\2\2\2\u047e\u047b\3\2\2\2\u047e\u047c\3\2\2\2\u047e\u047d\3\2"\r
13321             + "\2\2\u047f\u0481\3\2\2\2\u0480\u047e\3\2\2\2\u0481\u0484\3\2\2\2\u0482"\r
13322             + "\u0480\3\2\2\2\u0482\u0483\3\2\2\2\u0483\u00c7\3\2\2\2\u0484\u0482\3\2"\r
13323             + "\2\2\u0485\u0487\5\u00acW\2\u0486\u0485\3\2\2\2\u0487\u048a\3\2\2\2\u0488"\r
13324             + "\u0486\3\2\2\2\u0488\u0489\3\2\2\2\u0489\u00c9\3\2\2\2\u048a\u0488\3\2"\r
13325             + "\2\2\u048b\u048e\5\u00c0a\2\u048c\u048e\5\u00be`\2\u048d\u048b\3\2\2\2"\r
13326             + "\u048d\u048c\3\2\2\2\u048e\u0491\3\2\2\2\u048f\u048d\3\2\2\2\u048f\u0490"\r
13327             + "\3\2\2\2\u0490\u00cb\3\2\2\2\u0491\u048f\3\2\2\2\u0492\u0497\5\u00b6\\"\r
13328             + "\2\u0493\u0497\5\u00b4[\2\u0494\u0497\5\u00b2Z\2\u0495\u0497\5\u00b0Y"\r
13329             + "\2\u0496\u0492\3\2\2\2\u0496\u0493\3\2\2\2\u0496\u0494\3\2\2\2\u0496\u0495"\r
13330             + "\3\2\2\2\u0497\u049a\3\2\2\2\u0498\u0496\3\2\2\2\u0498\u0499\3\2\2\2\u0499"\r
13331             + "\u00cd\3\2\2\2\u049a\u0498\3\2\2\2\u049b\u049e\5\u00c2b\2\u049c\u049e"\r
13332             + "\5\u00b8]\2\u049d\u049b\3\2\2\2\u049d\u049c\3\2\2\2\u049e\u049f\3\2\2"\r
13333             + "\2\u049f\u049d\3\2\2\2\u049f\u04a0\3\2\2\2\u04a0\u00cf\3\2\2\2\u04a1\u04a5"\r
13334             + "\5\u00c2b\2\u04a2\u04a5\5\u00bc_\2\u04a3\u04a5\5\u00ba^\2\u04a4\u04a1"\r
13335             + "\3\2\2\2\u04a4\u04a2\3\2\2\2\u04a4\u04a3\3\2\2\2\u04a5\u04a6\3\2\2\2\u04a6"\r
13336             + "\u04a4\3\2\2\2\u04a6\u04a7\3\2\2\2\u04a7\u00d1\3\2\2\2\u04a8\u04a9\7\23"\r
13337             + "\2\2\u04a9\u04aa\5\4\3\2\u04aa\u04ab\7\4\2\2\u04ab\u04ac\5\u00ceh\2\u04ac"\r
13338             + "\u04ad\5\u00caf\2\u04ad\u04ae\5\u00ccg\2\u04ae\u04af\5\u00c8e\2\u04af"\r
13339             + "\u04b0\5\u00c6d\2\u04b0\u04b1\7\5\2\2\u04b1\u00d3\3\2\2\2\u04b2\u04b3"\r
13340             + "\7\'\2\2\u04b3\u04b4\5\4\3\2\u04b4\u04b5\7\4\2\2\u04b5\u04b6\5\u00d0i"\r
13341             + "\2\u04b6\u04b7\5\u00caf\2\u04b7\u04b8\5\u00ccg\2\u04b8\u04b9\5\u00c8e"\r
13342             + "\2\u04b9\u04ba\5\u00c6d\2\u04ba\u04bb\7\5\2\2\u04bb\u00d5\3\2\2\2\u008c"\r
13343             + "\u00d8\u00df\u00e4\u00ea\u00ee\u00f1\u00fe\u0100\u0104\u010e\u0110\u0114"\r
13344             + "\u0122\u0124\u0128\u012f\u0132\u013d\u013f\u014e\u0150\u0154\u015b\u015d"\r
13345             + "\u0166\u0168\u0178\u017a\u017e\u0186\u0188\u018c\u0199\u019b\u01aa\u01ac"\r
13346             + "\u01b5\u01b7\u01bc\u01be\u01c6\u01c8\u01d1\u01d3\u01dc\u01de\u01e7\u01e9"\r
13347             + "\u01f1\u01f3\u01fd\u0206\u020a\u0218\u021a\u021e\u022d\u022f\u0233\u0240"\r
13348             + "\u0242\u0246\u024d\u025e\u0260\u0264\u0281\u0283\u0297\u0299\u02ad\u02af"\r
13349             + "\u02c4\u02c6\u02ca\u02d7\u02d9\u02dd\u02fe\u0300\u0304\u032f\u0331\u0335"\r
13350             + "\u033a\u033f\u0344\u035b\u035d\u0361\u0366\u0375\u0377\u037b\u0386\u0388"\r
13351             + "\u038c\u0390\u0392\u039a\u039f\u03a1\u03ac\u03ae\u03b2\u03bf\u03c8\u03d3"\r
13352             + "\u03d5\u03e5\u03e7\u03eb\u03f9\u03fb\u03ff\u040c\u040f\u0419\u041b\u041f"\r
13353             + "\u042a\u042d\u0430\u0459\u045c\u0463\u0472\u047e\u0482\u0488\u048d\u048f"\r
13354             + "\u0496\u0498\u049d\u049f\u04a4\u04a6";\r
13355     public static final ATN _ATN = ATNSimulator.deserialize(_serializedATN\r
13356             .toCharArray());\r
13357     static {\r
13358         _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];\r
13359     }\r
13360 }