BaseTools/Source/Python/Eot/CParser.py

   1 # Generated from C.g4 by ANTLR 4.7.1
   2 # encoding: utf-8
   3 from antlr4 import *
   4 from io import StringIO
   5 from typing.io import TextIO
   6 import sys
   7
   8
   9 ## @file
  10 # The file defines the parser for C source files.
  11 #
  12 # THIS FILE IS AUTO-GENENERATED. PLEASE DON NOT MODIFY THIS FILE.
  13 # This file is generated by running:
  14 # java org.antlr.Tool C.g
  15 #
  16 # Copyright (c) 2009 - 2010, Intel Corporation  All rights reserved.
  17 #
  18 # This program and the accompanying materials are licensed and made available
  19 # under the terms and conditions of the BSD License which accompanies this
  20 # distribution.  The full text of the license may be found at:
  21 #   http://opensource.org/licenses/bsd-license.php
  22 #
  23 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  24 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  25 #
  26 ##
  27
  28 import Ecc.CodeFragment as CodeFragment
  29 import Ecc.FileProfile as FileProfile
  30
  31 def serializedATN():
  32     with StringIO() as buf:
  33         buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3k")
  34         buf.write("\u0380\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
  35         buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
  36         buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
  37         buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
  38         buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
  39         buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
  40         buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
  41         buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64")
  42         buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t")
  43         buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\t")
  44         buf.write("D\4E\tE\4F\tF\4G\tG\4H\tH\3\2\7\2\u0092\n\2\f\2\16\2\u0095")
  45         buf.write("\13\2\3\3\5\3\u0098\n\3\3\3\3\3\7\3\u009c\n\3\f\3\16\3")
  46         buf.write("\u009f\13\3\3\3\3\3\3\3\3\3\3\3\3\3\5\3\u00a7\n\3\5\3")
  47         buf.write("\u00a9\n\3\3\4\5\4\u00ac\n\4\3\4\3\4\6\4\u00b0\n\4\r\4")
  48         buf.write("\16\4\u00b1\3\4\3\4\3\4\5\4\u00b7\n\4\3\4\3\4\3\5\3\5")
  49         buf.write("\3\5\6\5\u00be\n\5\r\5\16\5\u00bf\3\6\3\6\5\6\u00c4\n")
  50         buf.write("\6\3\6\3\6\3\6\3\6\3\6\3\6\5\6\u00cc\n\6\3\6\3\6\3\6\5")
  51         buf.write("\6\u00d1\n\6\3\7\3\7\3\7\7\7\u00d6\n\7\f\7\16\7\u00d9")
  52         buf.write("\13\7\3\b\3\b\3\b\5\b\u00de\n\b\3\t\3\t\3\n\3\n\3\n\3")
  53         buf.write("\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n")
  54         buf.write("\7\n\u00f3\n\n\f\n\16\n\u00f6\13\n\3\n\3\n\5\n\u00fa\n")
  55         buf.write("\n\3\13\3\13\3\f\3\f\5\f\u0100\n\f\3\f\3\f\3\f\3\f\3\f")
  56         buf.write("\3\f\3\f\5\f\u0109\n\f\3\r\3\r\3\16\6\16\u010e\n\16\r")
  57         buf.write("\16\16\16\u010f\3\17\3\17\3\17\3\17\3\20\3\20\6\20\u0118")
  58         buf.write("\n\20\r\20\16\20\u0119\3\21\3\21\3\21\7\21\u011f\n\21")
  59         buf.write("\f\21\16\21\u0122\13\21\3\22\3\22\3\22\5\22\u0127\n\22")
  60         buf.write("\3\22\3\22\5\22\u012b\n\22\3\23\3\23\3\23\3\23\5\23\u0131")
  61         buf.write("\n\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\5\23\u013a\n")
  62         buf.write("\23\3\23\3\23\3\23\3\23\5\23\u0140\n\23\3\24\3\24\3\24")
  63         buf.write("\7\24\u0145\n\24\f\24\16\24\u0148\13\24\3\25\3\25\3\25")
  64         buf.write("\5\25\u014d\n\25\3\26\3\26\3\27\5\27\u0152\n\27\3\27\5")
  65         buf.write("\27\u0155\n\27\3\27\5\27\u0158\n\27\3\27\5\27\u015b\n")
  66         buf.write("\27\3\27\3\27\5\27\u015f\n\27\3\30\3\30\7\30\u0163\n\30")
  67         buf.write("\f\30\16\30\u0166\13\30\3\30\3\30\5\30\u016a\n\30\3\30")
  68         buf.write("\3\30\3\30\6\30\u016f\n\30\r\30\16\30\u0170\5\30\u0173")
  69         buf.write("\n\30\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31")
  70         buf.write("\3\31\3\31\3\31\3\31\3\31\3\31\5\31\u0185\n\31\3\32\3")
  71         buf.write("\32\6\32\u0189\n\32\r\32\16\32\u018a\3\32\5\32\u018e\n")
  72         buf.write("\32\3\32\3\32\3\32\5\32\u0193\n\32\3\33\3\33\3\33\5\33")
  73         buf.write("\u0198\n\33\3\33\5\33\u019b\n\33\3\34\3\34\3\34\5\34\u01a0")
  74         buf.write("\n\34\3\34\7\34\u01a3\n\34\f\34\16\34\u01a6\13\34\3\35")
  75         buf.write("\3\35\3\35\7\35\u01ab\n\35\f\35\16\35\u01ae\13\35\3\35")
  76         buf.write("\5\35\u01b1\n\35\3\35\7\35\u01b4\n\35\f\35\16\35\u01b7")
  77         buf.write("\13\35\3\35\5\35\u01ba\n\35\3\36\3\36\3\36\7\36\u01bf")
  78         buf.write("\n\36\f\36\16\36\u01c2\13\36\3\37\3\37\5\37\u01c6\n\37")
  79         buf.write("\3\37\5\37\u01c9\n\37\3 \3 \5 \u01cd\n \3 \5 \u01d0\n")
  80         buf.write(" \3!\3!\3!\3!\3!\5!\u01d7\n!\3!\7!\u01da\n!\f!\16!\u01dd")
  81         buf.write("\13!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\5")
  82         buf.write("\"\u01eb\n\"\3#\3#\3#\3#\5#\u01f1\n#\3#\3#\5#\u01f5\n")
  83         buf.write("#\3$\3$\3$\7$\u01fa\n$\f$\16$\u01fd\13$\3%\3%\5%\u0201")
  84         buf.write("\n%\3%\3%\3%\5%\u0206\n%\7%\u0208\n%\f%\16%\u020b\13%")
  85         buf.write("\3&\3&\3&\3&\3&\7&\u0212\n&\f&\16&\u0215\13&\3\'\3\'\3")
  86         buf.write("\'\3\'\3\'\3\'\3\'\7\'\u021e\n\'\f\'\16\'\u0221\13\'\3")
  87         buf.write("(\3(\3(\3(\3(\3(\5(\u0229\n(\3)\3)\3)\3)\3)\3)\3)\3)\3")
  88         buf.write(")\3)\3)\3)\3)\3)\3)\5)\u023a\n)\3*\3*\3*\3*\3*\3*\3*\3")
  89         buf.write("*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3")
  90         buf.write("*\3*\3*\3*\7*\u0259\n*\f*\16*\u025c\13*\3+\3+\3+\7+\u0261")
  91         buf.write("\n+\f+\16+\u0264\13+\3,\3,\3-\3-\3-\3-\3-\3-\5-\u026e")
  92         buf.write("\n-\3.\3.\3.\3.\3.\7.\u0275\n.\f.\16.\u0278\13.\3.\6.")
  93         buf.write("\u027b\n.\r.\16.\u027c\6.\u027f\n.\r.\16.\u0280\3.\7.")
  94         buf.write("\u0284\n.\f.\16.\u0287\13.\3.\5.\u028a\n.\3/\3/\3/\7/")
  95         buf.write("\u028f\n/\f/\16/\u0292\13/\3\60\3\60\3\61\3\61\3\61\3")
  96         buf.write("\61\3\61\5\61\u029b\n\61\3\62\3\62\3\63\3\63\3\64\3\64")
  97         buf.write("\3\64\3\64\3\64\3\64\3\64\5\64\u02a8\n\64\3\65\3\65\3")
  98         buf.write("\65\7\65\u02ad\n\65\f\65\16\65\u02b0\13\65\3\66\3\66\3")
  99         buf.write("\66\7\66\u02b5\n\66\f\66\16\66\u02b8\13\66\3\67\3\67\3")
 100         buf.write("\67\7\67\u02bd\n\67\f\67\16\67\u02c0\13\67\38\38\38\7")
 101         buf.write("8\u02c5\n8\f8\168\u02c8\138\39\39\39\79\u02cd\n9\f9\16")
 102         buf.write("9\u02d0\139\3:\3:\3:\7:\u02d5\n:\f:\16:\u02d8\13:\3;\3")
 103         buf.write(";\3;\7;\u02dd\n;\f;\16;\u02e0\13;\3<\3<\3<\7<\u02e5\n")
 104         buf.write("<\f<\16<\u02e8\13<\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\5")
 105         buf.write("=\u02f5\n=\3>\5>\u02f8\n>\3>\3>\3>\7>\u02fd\n>\f>\16>")
 106         buf.write("\u0300\13>\3>\3>\3>\3?\3?\3?\7?\u0308\n?\f?\16?\u030b")
 107         buf.write("\13?\3?\3?\3@\3@\3@\7@\u0312\n@\f@\16@\u0315\13@\3@\3")
 108         buf.write("@\3A\3A\3A\7A\u031c\nA\fA\16A\u031f\13A\3A\5A\u0322\n")
 109         buf.write("A\3A\5A\u0325\nA\3A\3A\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B\3")
 110         buf.write("B\5B\u0334\nB\3C\3C\7C\u0338\nC\fC\16C\u033b\13C\3C\5")
 111         buf.write("C\u033e\nC\3C\3C\3D\6D\u0343\nD\rD\16D\u0344\3E\3E\3E")
 112         buf.write("\3E\5E\u034b\nE\3F\3F\3F\3F\3F\3F\3F\3F\5F\u0355\nF\3")
 113         buf.write("F\3F\3F\3F\3F\3F\5F\u035d\nF\3G\3G\3G\3G\3G\3G\3G\3G\3")
 114         buf.write("G\3G\3G\3G\3G\3G\3G\3G\5G\u036f\nG\3H\3H\3H\3H\3H\3H\3")
 115         buf.write("H\3H\3H\3H\3H\3H\3H\5H\u037e\nH\3H\2\2I\2\4\6\b\n\f\16")
 116         buf.write("\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDF")
 117         buf.write("HJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086")
 118         buf.write("\u0088\u008a\u008c\u008e\2\f\3\2\b\f\3\2\27\30\3\2\33")
 119         buf.write("\'\5\2,,./\679\4\2\7\7:C\3\2IJ\3\2KN\3\2OP\3\2\4\4\3\2")
 120         buf.write("\26\26\2\u03d8\2\u0093\3\2\2\2\4\u00a8\3\2\2\2\6\u00ab")
 121         buf.write("\3\2\2\2\b\u00bd\3\2\2\2\n\u00d0\3\2\2\2\f\u00d2\3\2\2")
 122         buf.write("\2\16\u00da\3\2\2\2\20\u00df\3\2\2\2\22\u00f9\3\2\2\2")
 123         buf.write("\24\u00fb\3\2\2\2\26\u0108\3\2\2\2\30\u010a\3\2\2\2\32")
 124         buf.write("\u010d\3\2\2\2\34\u0111\3\2\2\2\36\u0117\3\2\2\2 \u011b")
 125         buf.write("\3\2\2\2\"\u012a\3\2\2\2$\u013f\3\2\2\2&\u0141\3\2\2\2")
 126         buf.write("(\u0149\3\2\2\2*\u014e\3\2\2\2,\u015e\3\2\2\2.\u0172\3")
 127         buf.write("\2\2\2\60\u0184\3\2\2\2\62\u0192\3\2\2\2\64\u0194\3\2")
 128         buf.write("\2\2\66\u019c\3\2\2\28\u01b9\3\2\2\2:\u01bb\3\2\2\2<\u01c8")
 129         buf.write("\3\2\2\2>\u01cf\3\2\2\2@\u01d6\3\2\2\2B\u01ea\3\2\2\2")
 130         buf.write("D\u01f4\3\2\2\2F\u01f6\3\2\2\2H\u01fe\3\2\2\2J\u020c\3")
 131         buf.write("\2\2\2L\u0216\3\2\2\2N\u0228\3\2\2\2P\u0239\3\2\2\2R\u023b")
 132         buf.write("\3\2\2\2T\u025d\3\2\2\2V\u0265\3\2\2\2X\u026d\3\2\2\2")
 133         buf.write("Z\u0289\3\2\2\2\\\u028b\3\2\2\2^\u0293\3\2\2\2`\u029a")
 134         buf.write("\3\2\2\2b\u029c\3\2\2\2d\u029e\3\2\2\2f\u02a0\3\2\2\2")
 135         buf.write("h\u02a9\3\2\2\2j\u02b1\3\2\2\2l\u02b9\3\2\2\2n\u02c1\3")
 136         buf.write("\2\2\2p\u02c9\3\2\2\2r\u02d1\3\2\2\2t\u02d9\3\2\2\2v\u02e1")
 137         buf.write("\3\2\2\2x\u02f4\3\2\2\2z\u02f7\3\2\2\2|\u0304\3\2\2\2")
 138         buf.write("~\u030e\3\2\2\2\u0080\u0318\3\2\2\2\u0082\u0333\3\2\2")
 139         buf.write("\2\u0084\u0335\3\2\2\2\u0086\u0342\3\2\2\2\u0088\u034a")
 140         buf.write("\3\2\2\2\u008a\u035c\3\2\2\2\u008c\u036e\3\2\2\2\u008e")
 141         buf.write("\u037d\3\2\2\2\u0090\u0092\5\4\3\2\u0091\u0090\3\2\2\2")
 142         buf.write("\u0092\u0095\3\2\2\2\u0093\u0091\3\2\2\2\u0093\u0094\3")
 143         buf.write("\2\2\2\u0094\3\3\2\2\2\u0095\u0093\3\2\2\2\u0096\u0098")
 144         buf.write("\5\b\5\2\u0097\u0096\3\2\2\2\u0097\u0098\3\2\2\2\u0098")
 145         buf.write("\u0099\3\2\2\2\u0099\u009d\5,\27\2\u009a\u009c\5\n\6\2")
 146         buf.write("\u009b\u009a\3\2\2\2\u009c\u009f\3\2\2\2\u009d\u009b\3")
 147         buf.write("\2\2\2\u009d\u009e\3\2\2\2\u009e\u00a0\3\2\2\2\u009f\u009d")
 148         buf.write("\3\2\2\2\u00a0\u00a1\7\3\2\2\u00a1\u00a9\3\2\2\2\u00a2")
 149         buf.write("\u00a9\5\6\4\2\u00a3\u00a9\5\n\6\2\u00a4\u00a6\5\u0080")
 150         buf.write("A\2\u00a5\u00a7\7\4\2\2\u00a6\u00a5\3\2\2\2\u00a6\u00a7")
 151         buf.write("\3\2\2\2\u00a7\u00a9\3\2\2\2\u00a8\u0097\3\2\2\2\u00a8")
 152         buf.write("\u00a2\3\2\2\2\u00a8\u00a3\3\2\2\2\u00a8\u00a4\3\2\2\2")
 153         buf.write("\u00a9\5\3\2\2\2\u00aa\u00ac\5\b\5\2\u00ab\u00aa\3\2\2")
 154         buf.write("\2\u00ab\u00ac\3\2\2\2\u00ac\u00ad\3\2\2\2\u00ad\u00b6")
 155         buf.write("\5,\27\2\u00ae\u00b0\5\n\6\2\u00af\u00ae\3\2\2\2\u00b0")
 156         buf.write("\u00b1\3\2\2\2\u00b1\u00af\3\2\2\2\u00b1\u00b2\3\2\2\2")
 157         buf.write("\u00b2\u00b3\3\2\2\2\u00b3\u00b4\5\u0084C\2\u00b4\u00b7")
 158         buf.write("\3\2\2\2\u00b5\u00b7\5\u0084C\2\u00b6\u00af\3\2\2\2\u00b6")
 159         buf.write("\u00b5\3\2\2\2\u00b7\u00b8\3\2\2\2\u00b8\u00b9\b\4\1\2")
 160         buf.write("\u00b9\7\3\2\2\2\u00ba\u00be\5\20\t\2\u00bb\u00be\5\22")
 161         buf.write("\n\2\u00bc\u00be\5*\26\2\u00bd\u00ba\3\2\2\2\u00bd\u00bb")
 162         buf.write("\3\2\2\2\u00bd\u00bc\3\2\2\2\u00be\u00bf\3\2\2\2\u00bf")
 163         buf.write("\u00bd\3\2\2\2\u00bf\u00c0\3\2\2\2\u00c0\t\3\2\2\2\u00c1")
 164         buf.write("\u00c3\7\5\2\2\u00c2\u00c4\5\b\5\2\u00c3\u00c2\3\2\2\2")
 165         buf.write("\u00c3\u00c4\3\2\2\2\u00c4\u00c5\3\2\2\2\u00c5\u00c6\5")
 166         buf.write("\f\7\2\u00c6\u00c7\7\4\2\2\u00c7\u00c8\b\6\1\2\u00c8\u00d1")
 167         buf.write("\3\2\2\2\u00c9\u00cb\5\b\5\2\u00ca\u00cc\5\f\7\2\u00cb")
 168         buf.write("\u00ca\3\2\2\2\u00cb\u00cc\3\2\2\2\u00cc\u00cd\3\2\2\2")
 169         buf.write("\u00cd\u00ce\7\4\2\2\u00ce\u00cf\b\6\1\2\u00cf\u00d1\3")
 170         buf.write("\2\2\2\u00d0\u00c1\3\2\2\2\u00d0\u00c9\3\2\2\2\u00d1\13")
 171         buf.write("\3\2\2\2\u00d2\u00d7\5\16\b\2\u00d3\u00d4\7\6\2\2\u00d4")
 172         buf.write("\u00d6\5\16\b\2\u00d5\u00d3\3\2\2\2\u00d6\u00d9\3\2\2")
 173         buf.write("\2\u00d7\u00d5\3\2\2\2\u00d7\u00d8\3\2\2\2\u00d8\r\3\2")
 174         buf.write("\2\2\u00d9\u00d7\3\2\2\2\u00da\u00dd\5,\27\2\u00db\u00dc")
 175         buf.write("\7\7\2\2\u00dc\u00de\5D#\2\u00dd\u00db\3\2\2\2\u00dd\u00de")
 176         buf.write("\3\2\2\2\u00de\17\3\2\2\2\u00df\u00e0\t\2\2\2\u00e0\21")
 177         buf.write("\3\2\2\2\u00e1\u00fa\7\r\2\2\u00e2\u00fa\7\16\2\2\u00e3")
 178         buf.write("\u00fa\7\17\2\2\u00e4\u00fa\7\20\2\2\u00e5\u00fa\7\21")
 179         buf.write("\2\2\u00e6\u00fa\7\22\2\2\u00e7\u00fa\7\23\2\2\u00e8\u00fa")
 180         buf.write("\7\24\2\2\u00e9\u00fa\7\25\2\2\u00ea\u00eb\5\26\f\2\u00eb")
 181         buf.write("\u00ec\b\n\1\2\u00ec\u00fa\3\2\2\2\u00ed\u00ee\5$\23\2")
 182         buf.write("\u00ee\u00ef\b\n\1\2\u00ef\u00fa\3\2\2\2\u00f0\u00f4\7")
 183         buf.write("_\2\2\u00f1\u00f3\5*\26\2\u00f2\u00f1\3\2\2\2\u00f3\u00f6")
 184         buf.write("\3\2\2\2\u00f4\u00f2\3\2\2\2\u00f4\u00f5\3\2\2\2\u00f5")
 185         buf.write("\u00f7\3\2\2\2\u00f6\u00f4\3\2\2\2\u00f7\u00fa\5,\27\2")
 186         buf.write("\u00f8\u00fa\5\24\13\2\u00f9\u00e1\3\2\2\2\u00f9\u00e2")
 187         buf.write("\3\2\2\2\u00f9\u00e3\3\2\2\2\u00f9\u00e4\3\2\2\2\u00f9")
 188         buf.write("\u00e5\3\2\2\2\u00f9\u00e6\3\2\2\2\u00f9\u00e7\3\2\2\2")
 189         buf.write("\u00f9\u00e8\3\2\2\2\u00f9\u00e9\3\2\2\2\u00f9\u00ea\3")
 190         buf.write("\2\2\2\u00f9\u00ed\3\2\2\2\u00f9\u00f0\3\2\2\2\u00f9\u00f8")
 191         buf.write("\3\2\2\2\u00fa\23\3\2\2\2\u00fb\u00fc\7_\2\2\u00fc\25")
 192         buf.write("\3\2\2\2\u00fd\u00ff\5\30\r\2\u00fe\u0100\7_\2\2\u00ff")
 193         buf.write("\u00fe\3\2\2\2\u00ff\u0100\3\2\2\2\u0100\u0101\3\2\2\2")
 194         buf.write("\u0101\u0102\7\3\2\2\u0102\u0103\5\32\16\2\u0103\u0104")
 195         buf.write("\7\26\2\2\u0104\u0109\3\2\2\2\u0105\u0106\5\30\r\2\u0106")
 196         buf.write("\u0107\7_\2\2\u0107\u0109\3\2\2\2\u0108\u00fd\3\2\2\2")
 197         buf.write("\u0108\u0105\3\2\2\2\u0109\27\3\2\2\2\u010a\u010b\t\3")
 198         buf.write("\2\2\u010b\31\3\2\2\2\u010c\u010e\5\34\17\2\u010d\u010c")
 199         buf.write("\3\2\2\2\u010e\u010f\3\2\2\2\u010f\u010d\3\2\2\2\u010f")
 200         buf.write("\u0110\3\2\2\2\u0110\33\3\2\2\2\u0111\u0112\5\36\20\2")
 201         buf.write("\u0112\u0113\5 \21\2\u0113\u0114\7\4\2\2\u0114\35\3\2")
 202         buf.write("\2\2\u0115\u0118\5*\26\2\u0116\u0118\5\22\n\2\u0117\u0115")
 203         buf.write("\3\2\2\2\u0117\u0116\3\2\2\2\u0118\u0119\3\2\2\2\u0119")
 204         buf.write("\u0117\3\2\2\2\u0119\u011a\3\2\2\2\u011a\37\3\2\2\2\u011b")
 205         buf.write("\u0120\5\"\22\2\u011c\u011d\7\6\2\2\u011d\u011f\5\"\22")
 206         buf.write("\2\u011e\u011c\3\2\2\2\u011f\u0122\3\2\2\2\u0120\u011e")
 207         buf.write("\3\2\2\2\u0120\u0121\3\2\2\2\u0121!\3\2\2\2\u0122\u0120")
 208         buf.write("\3\2\2\2\u0123\u0126\5,\27\2\u0124\u0125\7\31\2\2\u0125")
 209         buf.write("\u0127\5^\60\2\u0126\u0124\3\2\2\2\u0126\u0127\3\2\2\2")
 210         buf.write("\u0127\u012b\3\2\2\2\u0128\u0129\7\31\2\2\u0129\u012b")
 211         buf.write("\5^\60\2\u012a\u0123\3\2\2\2\u012a\u0128\3\2\2\2\u012b")
 212         buf.write("#\3\2\2\2\u012c\u012d\7\32\2\2\u012d\u012e\7\3\2\2\u012e")
 213         buf.write("\u0130\5&\24\2\u012f\u0131\7\6\2\2\u0130\u012f\3\2\2\2")
 214         buf.write("\u0130\u0131\3\2\2\2\u0131\u0132\3\2\2\2\u0132\u0133\7")
 215         buf.write("\26\2\2\u0133\u0140\3\2\2\2\u0134\u0135\7\32\2\2\u0135")
 216         buf.write("\u0136\7_\2\2\u0136\u0137\7\3\2\2\u0137\u0139\5&\24\2")
 217         buf.write("\u0138\u013a\7\6\2\2\u0139\u0138\3\2\2\2\u0139\u013a\3")
 218         buf.write("\2\2\2\u013a\u013b\3\2\2\2\u013b\u013c\7\26\2\2\u013c")
 219         buf.write("\u0140\3\2\2\2\u013d\u013e\7\32\2\2\u013e\u0140\7_\2\2")
 220         buf.write("\u013f\u012c\3\2\2\2\u013f\u0134\3\2\2\2\u013f\u013d\3")
 221         buf.write("\2\2\2\u0140%\3\2\2\2\u0141\u0146\5(\25\2\u0142\u0143")
 222         buf.write("\7\6\2\2\u0143\u0145\5(\25\2\u0144\u0142\3\2\2\2\u0145")
 223         buf.write("\u0148\3\2\2\2\u0146\u0144\3\2\2\2\u0146\u0147\3\2\2\2")
 224         buf.write("\u0147\'\3\2\2\2\u0148\u0146\3\2\2\2\u0149\u014c\7_\2")
 225         buf.write("\2\u014a\u014b\7\7\2\2\u014b\u014d\5^\60\2\u014c\u014a")
 226         buf.write("\3\2\2\2\u014c\u014d\3\2\2\2\u014d)\3\2\2\2\u014e\u014f")
 227         buf.write("\t\4\2\2\u014f+\3\2\2\2\u0150\u0152\5\62\32\2\u0151\u0150")
 228         buf.write("\3\2\2\2\u0151\u0152\3\2\2\2\u0152\u0154\3\2\2\2\u0153")
 229         buf.write("\u0155\7$\2\2\u0154\u0153\3\2\2\2\u0154\u0155\3\2\2\2")
 230         buf.write("\u0155\u0157\3\2\2\2\u0156\u0158\7%\2\2\u0157\u0156\3")
 231         buf.write("\2\2\2\u0157\u0158\3\2\2\2\u0158\u015a\3\2\2\2\u0159\u015b")
 232         buf.write("\7&\2\2\u015a\u0159\3\2\2\2\u015a\u015b\3\2\2\2\u015b")
 233         buf.write("\u015c\3\2\2\2\u015c\u015f\5.\30\2\u015d\u015f\5\62\32")
 234         buf.write("\2\u015e\u0151\3\2\2\2\u015e\u015d\3\2\2\2\u015f-\3\2")
 235         buf.write("\2\2\u0160\u0164\7_\2\2\u0161\u0163\5\60\31\2\u0162\u0161")
 236         buf.write("\3\2\2\2\u0163\u0166\3\2\2\2\u0164\u0162\3\2\2\2\u0164")
 237         buf.write("\u0165\3\2\2\2\u0165\u0173\3\2\2\2\u0166\u0164\3\2\2\2")
 238         buf.write("\u0167\u0169\7(\2\2\u0168\u016a\7$\2\2\u0169\u0168\3\2")
 239         buf.write("\2\2\u0169\u016a\3\2\2\2\u016a\u016b\3\2\2\2\u016b\u016c")
 240         buf.write("\5,\27\2\u016c\u016e\7)\2\2\u016d\u016f\5\60\31\2\u016e")
 241         buf.write("\u016d\3\2\2\2\u016f\u0170\3\2\2\2\u0170\u016e\3\2\2\2")
 242         buf.write("\u0170\u0171\3\2\2\2\u0171\u0173\3\2\2\2\u0172\u0160\3")
 243         buf.write("\2\2\2\u0172\u0167\3\2\2\2\u0173/\3\2\2\2\u0174\u0175")
 244         buf.write("\7*\2\2\u0175\u0176\5^\60\2\u0176\u0177\7+\2\2\u0177\u0185")
 245         buf.write("\3\2\2\2\u0178\u0179\7*\2\2\u0179\u0185\7+\2\2\u017a\u017b")
 246         buf.write("\7(\2\2\u017b\u017c\5\64\33\2\u017c\u017d\7)\2\2\u017d")
 247         buf.write("\u0185\3\2\2\2\u017e\u017f\7(\2\2\u017f\u0180\5:\36\2")
 248         buf.write("\u0180\u0181\7)\2\2\u0181\u0185\3\2\2\2\u0182\u0183\7")
 249         buf.write("(\2\2\u0183\u0185\7)\2\2\u0184\u0174\3\2\2\2\u0184\u0178")
 250         buf.write("\3\2\2\2\u0184\u017a\3\2\2\2\u0184\u017e\3\2\2\2\u0184")
 251         buf.write("\u0182\3\2\2\2\u0185\61\3\2\2\2\u0186\u0188\7,\2\2\u0187")
 252         buf.write("\u0189\5*\26\2\u0188\u0187\3\2\2\2\u0189\u018a\3\2\2\2")
 253         buf.write("\u018a\u0188\3\2\2\2\u018a\u018b\3\2\2\2\u018b\u018d\3")
 254         buf.write("\2\2\2\u018c\u018e\5\62\32\2\u018d\u018c\3\2\2\2\u018d")
 255         buf.write("\u018e\3\2\2\2\u018e\u0193\3\2\2\2\u018f\u0190\7,\2\2")
 256         buf.write("\u0190\u0193\5\62\32\2\u0191\u0193\7,\2\2\u0192\u0186")
 257         buf.write("\3\2\2\2\u0192\u018f\3\2\2\2\u0192\u0191\3\2\2\2\u0193")
 258         buf.write("\63\3\2\2\2\u0194\u019a\5\66\34\2\u0195\u0197\7\6\2\2")
 259         buf.write("\u0196\u0198\7\37\2\2\u0197\u0196\3\2\2\2\u0197\u0198")
 260         buf.write("\3\2\2\2\u0198\u0199\3\2\2\2\u0199\u019b\7-\2\2\u019a")
 261         buf.write("\u0195\3\2\2\2\u019a\u019b\3\2\2\2\u019b\65\3\2\2\2\u019c")
 262         buf.write("\u01a4\58\35\2\u019d\u019f\7\6\2\2\u019e\u01a0\7\37\2")
 263         buf.write("\2\u019f\u019e\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0\u01a1")
 264         buf.write("\3\2\2\2\u01a1\u01a3\58\35\2\u01a2\u019d\3\2\2\2\u01a3")
 265         buf.write("\u01a6\3\2\2\2\u01a4\u01a2\3\2\2\2\u01a4\u01a5\3\2\2\2")
 266         buf.write("\u01a5\67\3\2\2\2\u01a6\u01a4\3\2\2\2\u01a7\u01ac\5\b")
 267         buf.write("\5\2\u01a8\u01ab\5,\27\2\u01a9\u01ab\5> \2\u01aa\u01a8")
 268         buf.write("\3\2\2\2\u01aa\u01a9\3\2\2\2\u01ab\u01ae\3\2\2\2\u01ac")
 269         buf.write("\u01aa\3\2\2\2\u01ac\u01ad\3\2\2\2\u01ad\u01b0\3\2\2\2")
 270         buf.write("\u01ae\u01ac\3\2\2\2\u01af\u01b1\7\37\2\2\u01b0\u01af")
 271         buf.write("\3\2\2\2\u01b0\u01b1\3\2\2\2\u01b1\u01ba\3\2\2\2\u01b2")
 272         buf.write("\u01b4\5\62\32\2\u01b3\u01b2\3\2\2\2\u01b4\u01b7\3\2\2")
 273         buf.write("\2\u01b5\u01b3\3\2\2\2\u01b5\u01b6\3\2\2\2\u01b6\u01b8")
 274         buf.write("\3\2\2\2\u01b7\u01b5\3\2\2\2\u01b8\u01ba\7_\2\2\u01b9")
 275         buf.write("\u01a7\3\2\2\2\u01b9\u01b5\3\2\2\2\u01ba9\3\2\2\2\u01bb")
 276         buf.write("\u01c0\7_\2\2\u01bc\u01bd\7\6\2\2\u01bd\u01bf\7_\2\2\u01be")
 277         buf.write("\u01bc\3\2\2\2\u01bf\u01c2\3\2\2\2\u01c0\u01be\3\2\2\2")
 278         buf.write("\u01c0\u01c1\3\2\2\2\u01c1;\3\2\2\2\u01c2\u01c0\3\2\2")
 279         buf.write("\2\u01c3\u01c5\5\36\20\2\u01c4\u01c6\5> \2\u01c5\u01c4")
 280         buf.write("\3\2\2\2\u01c5\u01c6\3\2\2\2\u01c6\u01c9\3\2\2\2\u01c7")
 281         buf.write("\u01c9\5\24\13\2\u01c8\u01c3\3\2\2\2\u01c8\u01c7\3\2\2")
 282         buf.write("\2\u01c9=\3\2\2\2\u01ca\u01cc\5\62\32\2\u01cb\u01cd\5")
 283         buf.write("@!\2\u01cc\u01cb\3\2\2\2\u01cc\u01cd\3\2\2\2\u01cd\u01d0")
 284         buf.write("\3\2\2\2\u01ce\u01d0\5@!\2\u01cf\u01ca\3\2\2\2\u01cf\u01ce")
 285         buf.write("\3\2\2\2\u01d0?\3\2\2\2\u01d1\u01d2\7(\2\2\u01d2\u01d3")
 286         buf.write("\5> \2\u01d3\u01d4\7)\2\2\u01d4\u01d7\3\2\2\2\u01d5\u01d7")
 287         buf.write("\5B\"\2\u01d6\u01d1\3\2\2\2\u01d6\u01d5\3\2\2\2\u01d7")
 288         buf.write("\u01db\3\2\2\2\u01d8\u01da\5B\"\2\u01d9\u01d8\3\2\2\2")
 289         buf.write("\u01da\u01dd\3\2\2\2\u01db\u01d9\3\2\2\2\u01db\u01dc\3")
 290         buf.write("\2\2\2\u01dcA\3\2\2\2\u01dd\u01db\3\2\2\2\u01de\u01df")
 291         buf.write("\7*\2\2\u01df\u01eb\7+\2\2\u01e0\u01e1\7*\2\2\u01e1\u01e2")
 292         buf.write("\5^\60\2\u01e2\u01e3\7+\2\2\u01e3\u01eb\3\2\2\2\u01e4")
 293         buf.write("\u01e5\7(\2\2\u01e5\u01eb\7)\2\2\u01e6\u01e7\7(\2\2\u01e7")
 294         buf.write("\u01e8\5\64\33\2\u01e8\u01e9\7)\2\2\u01e9\u01eb\3\2\2")
 295         buf.write("\2\u01ea\u01de\3\2\2\2\u01ea\u01e0\3\2\2\2\u01ea\u01e4")
 296         buf.write("\3\2\2\2\u01ea\u01e6\3\2\2\2\u01ebC\3\2\2\2\u01ec\u01f5")
 297         buf.write("\5`\61\2\u01ed\u01ee\7\3\2\2\u01ee\u01f0\5F$\2\u01ef\u01f1")
 298         buf.write("\7\6\2\2\u01f0\u01ef\3\2\2\2\u01f0\u01f1\3\2\2\2\u01f1")
 299         buf.write("\u01f2\3\2\2\2\u01f2\u01f3\7\26\2\2\u01f3\u01f5\3\2\2")
 300         buf.write("\2\u01f4\u01ec\3\2\2\2\u01f4\u01ed\3\2\2\2\u01f5E\3\2")
 301         buf.write("\2\2\u01f6\u01fb\5D#\2\u01f7\u01f8\7\6\2\2\u01f8\u01fa")
 302         buf.write("\5D#\2\u01f9\u01f7\3\2\2\2\u01fa\u01fd\3\2\2\2\u01fb\u01f9")
 303         buf.write("\3\2\2\2\u01fb\u01fc\3\2\2\2\u01fcG\3\2\2\2\u01fd\u01fb")
 304         buf.write("\3\2\2\2\u01fe\u0200\5`\61\2\u01ff\u0201\7\37\2\2\u0200")
 305         buf.write("\u01ff\3\2\2\2\u0200\u0201\3\2\2\2\u0201\u0209\3\2\2\2")
 306         buf.write("\u0202\u0203\7\6\2\2\u0203\u0205\5`\61\2\u0204\u0206\7")
 307         buf.write("\37\2\2\u0205\u0204\3\2\2\2\u0205\u0206\3\2\2\2\u0206")
 308         buf.write("\u0208\3\2\2\2\u0207\u0202\3\2\2\2\u0208\u020b\3\2\2\2")
 309         buf.write("\u0209\u0207\3\2\2\2\u0209\u020a\3\2\2\2\u020aI\3\2\2")
 310         buf.write("\2\u020b\u0209\3\2\2\2\u020c\u0213\5L\'\2\u020d\u020e")
 311         buf.write("\7.\2\2\u020e\u0212\5L\'\2\u020f\u0210\7/\2\2\u0210\u0212")
 312         buf.write("\5L\'\2\u0211\u020d\3\2\2\2\u0211\u020f\3\2\2\2\u0212")
 313         buf.write("\u0215\3\2\2\2\u0213\u0211\3\2\2\2\u0213\u0214\3\2\2\2")
 314         buf.write("\u0214K\3\2\2\2\u0215\u0213\3\2\2\2\u0216\u021f\5N(\2")
 315         buf.write("\u0217\u0218\7,\2\2\u0218\u021e\5N(\2\u0219\u021a\7\60")
 316         buf.write("\2\2\u021a\u021e\5N(\2\u021b\u021c\7\61\2\2\u021c\u021e")
 317         buf.write("\5N(\2\u021d\u0217\3\2\2\2\u021d\u0219\3\2\2\2\u021d\u021b")
 318         buf.write("\3\2\2\2\u021e\u0221\3\2\2\2\u021f\u021d\3\2\2\2\u021f")
 319         buf.write("\u0220\3\2\2\2\u0220M\3\2\2\2\u0221\u021f\3\2\2\2\u0222")
 320         buf.write("\u0223\7(\2\2\u0223\u0224\5<\37\2\u0224\u0225\7)\2\2\u0225")
 321         buf.write("\u0226\5N(\2\u0226\u0229\3\2\2\2\u0227\u0229\5P)\2\u0228")
 322         buf.write("\u0222\3\2\2\2\u0228\u0227\3\2\2\2\u0229O\3\2\2\2\u022a")
 323         buf.write("\u023a\5R*\2\u022b\u022c\7\62\2\2\u022c\u023a\5P)\2\u022d")
 324         buf.write("\u022e\7\63\2\2\u022e\u023a\5P)\2\u022f\u0230\5V,\2\u0230")
 325         buf.write("\u0231\5N(\2\u0231\u023a\3\2\2\2\u0232\u0233\7\64\2\2")
 326         buf.write("\u0233\u023a\5P)\2\u0234\u0235\7\64\2\2\u0235\u0236\7")
 327         buf.write("(\2\2\u0236\u0237\5<\37\2\u0237\u0238\7)\2\2\u0238\u023a")
 328         buf.write("\3\2\2\2\u0239\u022a\3\2\2\2\u0239\u022b\3\2\2\2\u0239")
 329         buf.write("\u022d\3\2\2\2\u0239\u022f\3\2\2\2\u0239\u0232\3\2\2\2")
 330         buf.write("\u0239\u0234\3\2\2\2\u023aQ\3\2\2\2\u023b\u023c\5X-\2")
 331         buf.write("\u023c\u025a\b*\1\2\u023d\u023e\7*\2\2\u023e\u023f\5\\")
 332         buf.write("/\2\u023f\u0240\7+\2\2\u0240\u0259\3\2\2\2\u0241\u0242")
 333         buf.write("\7(\2\2\u0242\u0243\7)\2\2\u0243\u0259\b*\1\2\u0244\u0245")
 334         buf.write("\7(\2\2\u0245\u0246\5H%\2\u0246\u0247\7)\2\2\u0247\u0248")
 335         buf.write("\b*\1\2\u0248\u0259\3\2\2\2\u0249\u024a\7(\2\2\u024a\u024b")
 336         buf.write("\5T+\2\u024b\u024c\7)\2\2\u024c\u0259\3\2\2\2\u024d\u024e")
 337         buf.write("\7\65\2\2\u024e\u024f\7_\2\2\u024f\u0259\b*\1\2\u0250")
 338         buf.write("\u0251\7,\2\2\u0251\u0252\7_\2\2\u0252\u0259\b*\1\2\u0253")
 339         buf.write("\u0254\7\66\2\2\u0254\u0255\7_\2\2\u0255\u0259\b*\1\2")
 340         buf.write("\u0256\u0259\7\62\2\2\u0257\u0259\7\63\2\2\u0258\u023d")
 341         buf.write("\3\2\2\2\u0258\u0241\3\2\2\2\u0258\u0244\3\2\2\2\u0258")
 342         buf.write("\u0249\3\2\2\2\u0258\u024d\3\2\2\2\u0258\u0250\3\2\2\2")
 343         buf.write("\u0258\u0253\3\2\2\2\u0258\u0256\3\2\2\2\u0258\u0257\3")
 344         buf.write("\2\2\2\u0259\u025c\3\2\2\2\u025a\u0258\3\2\2\2\u025a\u025b")
 345         buf.write("\3\2\2\2\u025bS\3\2\2\2\u025c\u025a\3\2\2\2\u025d\u0262")
 346         buf.write("\58\35\2\u025e\u025f\7\6\2\2\u025f\u0261\58\35\2\u0260")
 347         buf.write("\u025e\3\2\2\2\u0261\u0264\3\2\2\2\u0262\u0260\3\2\2\2")
 348         buf.write("\u0262\u0263\3\2\2\2\u0263U\3\2\2\2\u0264\u0262\3\2\2")
 349         buf.write("\2\u0265\u0266\t\5\2\2\u0266W\3\2\2\2\u0267\u026e\7_\2")
 350         buf.write("\2\u0268\u026e\5Z.\2\u0269\u026a\7(\2\2\u026a\u026b\5")
 351         buf.write("\\/\2\u026b\u026c\7)\2\2\u026c\u026e\3\2\2\2\u026d\u0267")
 352         buf.write("\3\2\2\2\u026d\u0268\3\2\2\2\u026d\u0269\3\2\2\2\u026e")
 353         buf.write("Y\3\2\2\2\u026f\u028a\7b\2\2\u0270\u028a\7d\2\2\u0271")
 354         buf.write("\u028a\7c\2\2\u0272\u028a\7`\2\2\u0273\u0275\7_\2\2\u0274")
 355         buf.write("\u0273\3\2\2\2\u0275\u0278\3\2\2\2\u0276\u0274\3\2\2\2")
 356         buf.write("\u0276\u0277\3\2\2\2\u0277\u027a\3\2\2\2\u0278\u0276\3")
 357         buf.write("\2\2\2\u0279\u027b\7a\2\2\u027a\u0279\3\2\2\2\u027b\u027c")
 358         buf.write("\3\2\2\2\u027c\u027a\3\2\2\2\u027c\u027d\3\2\2\2\u027d")
 359         buf.write("\u027f\3\2\2\2\u027e\u0276\3\2\2\2\u027f\u0280\3\2\2\2")
 360         buf.write("\u0280\u027e\3\2\2\2\u0280\u0281\3\2\2\2\u0281\u0285\3")
 361         buf.write("\2\2\2\u0282\u0284\7_\2\2\u0283\u0282\3\2\2\2\u0284\u0287")
 362         buf.write("\3\2\2\2\u0285\u0283\3\2\2\2\u0285\u0286\3\2\2\2\u0286")
 363         buf.write("\u028a\3\2\2\2\u0287\u0285\3\2\2\2\u0288\u028a\7e\2\2")
 364         buf.write("\u0289\u026f\3\2\2\2\u0289\u0270\3\2\2\2\u0289\u0271\3")
 365         buf.write("\2\2\2\u0289\u0272\3\2\2\2\u0289\u027e\3\2\2\2\u0289\u0288")
 366         buf.write("\3\2\2\2\u028a[\3\2\2\2\u028b\u0290\5`\61\2\u028c\u028d")
 367         buf.write("\7\6\2\2\u028d\u028f\5`\61\2\u028e\u028c\3\2\2\2\u028f")
 368         buf.write("\u0292\3\2\2\2\u0290\u028e\3\2\2\2\u0290\u0291\3\2\2\2")
 369         buf.write("\u0291]\3\2\2\2\u0292\u0290\3\2\2\2\u0293\u0294\5f\64")
 370         buf.write("\2\u0294_\3\2\2\2\u0295\u0296\5b\62\2\u0296\u0297\5d\63")
 371         buf.write("\2\u0297\u0298\5`\61\2\u0298\u029b\3\2\2\2\u0299\u029b")
 372         buf.write("\5f\64\2\u029a\u0295\3\2\2\2\u029a\u0299\3\2\2\2\u029b")
 373         buf.write("a\3\2\2\2\u029c\u029d\5P)\2\u029dc\3\2\2\2\u029e\u029f")
 374         buf.write("\t\6\2\2\u029fe\3\2\2\2\u02a0\u02a7\5h\65\2\u02a1\u02a2")
 375         buf.write("\7D\2\2\u02a2\u02a3\5\\/\2\u02a3\u02a4\7\31\2\2\u02a4")
 376         buf.write("\u02a5\5f\64\2\u02a5\u02a6\b\64\1\2\u02a6\u02a8\3\2\2")
 377         buf.write("\2\u02a7\u02a1\3\2\2\2\u02a7\u02a8\3\2\2\2\u02a8g\3\2")
 378         buf.write("\2\2\u02a9\u02ae\5j\66\2\u02aa\u02ab\7E\2\2\u02ab\u02ad")
 379         buf.write("\5j\66\2\u02ac\u02aa\3\2\2\2\u02ad\u02b0\3\2\2\2\u02ae")
 380         buf.write("\u02ac\3\2\2\2\u02ae\u02af\3\2\2\2\u02afi\3\2\2\2\u02b0")
 381         buf.write("\u02ae\3\2\2\2\u02b1\u02b6\5l\67\2\u02b2\u02b3\7F\2\2")
 382         buf.write("\u02b3\u02b5\5l\67\2\u02b4\u02b2\3\2\2\2\u02b5\u02b8\3")
 383         buf.write("\2\2\2\u02b6\u02b4\3\2\2\2\u02b6\u02b7\3\2\2\2\u02b7k")
 384         buf.write("\3\2\2\2\u02b8\u02b6\3\2\2\2\u02b9\u02be\5n8\2\u02ba\u02bb")
 385         buf.write("\7G\2\2\u02bb\u02bd\5n8\2\u02bc\u02ba\3\2\2\2\u02bd\u02c0")
 386         buf.write("\3\2\2\2\u02be\u02bc\3\2\2\2\u02be\u02bf\3\2\2\2\u02bf")
 387         buf.write("m\3\2\2\2\u02c0\u02be\3\2\2\2\u02c1\u02c6\5p9\2\u02c2")
 388         buf.write("\u02c3\7H\2\2\u02c3\u02c5\5p9\2\u02c4\u02c2\3\2\2\2\u02c5")
 389         buf.write("\u02c8\3\2\2\2\u02c6\u02c4\3\2\2\2\u02c6\u02c7\3\2\2\2")
 390         buf.write("\u02c7o\3\2\2\2\u02c8\u02c6\3\2\2\2\u02c9\u02ce\5r:\2")
 391         buf.write("\u02ca\u02cb\7\67\2\2\u02cb\u02cd\5r:\2\u02cc\u02ca\3")
 392         buf.write("\2\2\2\u02cd\u02d0\3\2\2\2\u02ce\u02cc\3\2\2\2\u02ce\u02cf")
 393         buf.write("\3\2\2\2\u02cfq\3\2\2\2\u02d0\u02ce\3\2\2\2\u02d1\u02d6")
 394         buf.write("\5t;\2\u02d2\u02d3\t\7\2\2\u02d3\u02d5\5t;\2\u02d4\u02d2")
 395         buf.write("\3\2\2\2\u02d5\u02d8\3\2\2\2\u02d6\u02d4\3\2\2\2\u02d6")
 396         buf.write("\u02d7\3\2\2\2\u02d7s\3\2\2\2\u02d8\u02d6\3\2\2\2\u02d9")
 397         buf.write("\u02de\5v<\2\u02da\u02db\t\b\2\2\u02db\u02dd\5v<\2\u02dc")
 398         buf.write("\u02da\3\2\2\2\u02dd\u02e0\3\2\2\2\u02de\u02dc\3\2\2\2")
 399         buf.write("\u02de\u02df\3\2\2\2\u02dfu\3\2\2\2\u02e0\u02de\3\2\2")
 400         buf.write("\2\u02e1\u02e6\5J&\2\u02e2\u02e3\t\t\2\2\u02e3\u02e5\5")
 401         buf.write("J&\2\u02e4\u02e2\3\2\2\2\u02e5\u02e8\3\2\2\2\u02e6\u02e4")
 402         buf.write("\3\2\2\2\u02e6\u02e7\3\2\2\2\u02e7w\3\2\2\2\u02e8\u02e6")
 403         buf.write("\3\2\2\2\u02e9\u02f5\5\u0082B\2\u02ea\u02f5\5\u0084C\2")
 404         buf.write("\u02eb\u02f5\5\u0088E\2\u02ec\u02f5\5\u008aF\2\u02ed\u02f5")
 405         buf.write("\5\u008cG\2\u02ee\u02f5\5\u008eH\2\u02ef\u02f5\5\u0080")
 406         buf.write("A\2\u02f0\u02f5\5z>\2\u02f1\u02f5\5|?\2\u02f2\u02f5\5")
 407         buf.write("~@\2\u02f3\u02f5\5\n\6\2\u02f4\u02e9\3\2\2\2\u02f4\u02ea")
 408         buf.write("\3\2\2\2\u02f4\u02eb\3\2\2\2\u02f4\u02ec\3\2\2\2\u02f4")
 409         buf.write("\u02ed\3\2\2\2\u02f4\u02ee\3\2\2\2\u02f4\u02ef\3\2\2\2")
 410         buf.write("\u02f4\u02f0\3\2\2\2\u02f4\u02f1\3\2\2\2\u02f4\u02f2\3")
 411         buf.write("\2\2\2\u02f4\u02f3\3\2\2\2\u02f5y\3\2\2\2\u02f6\u02f8")
 412         buf.write("\7Q\2\2\u02f7\u02f6\3\2\2\2\u02f7\u02f8\3\2\2\2\u02f8")
 413         buf.write("\u02f9\3\2\2\2\u02f9\u02fa\7_\2\2\u02fa\u02fe\7(\2\2\u02fb")
 414         buf.write("\u02fd\n\n\2\2\u02fc\u02fb\3\2\2\2\u02fd\u0300\3\2\2\2")
 415         buf.write("\u02fe\u02fc\3\2\2\2\u02fe\u02ff\3\2\2\2\u02ff\u0301\3")
 416         buf.write("\2\2\2\u0300\u02fe\3\2\2\2\u0301\u0302\7)\2\2\u0302\u0303")
 417         buf.write("\7\4\2\2\u0303{\3\2\2\2\u0304\u0305\7R\2\2\u0305\u0309")
 418         buf.write("\7\3\2\2\u0306\u0308\n\13\2\2\u0307\u0306\3\2\2\2\u0308")
 419         buf.write("\u030b\3\2\2\2\u0309\u0307\3\2\2\2\u0309\u030a\3\2\2\2")
 420         buf.write("\u030a\u030c\3\2\2\2\u030b\u0309\3\2\2\2\u030c\u030d\7")
 421         buf.write("\26\2\2\u030d}\3\2\2\2\u030e\u030f\7S\2\2\u030f\u0313")
 422         buf.write("\7\3\2\2\u0310\u0312\n\13\2\2\u0311\u0310\3\2\2\2\u0312")
 423         buf.write("\u0315\3\2\2\2\u0313\u0311\3\2\2\2\u0313\u0314\3\2\2\2")
 424         buf.write("\u0314\u0316\3\2\2\2\u0315\u0313\3\2\2\2\u0316\u0317\7")
 425         buf.write("\26\2\2\u0317\177\3\2\2\2\u0318\u0319\7_\2\2\u0319\u031d")
 426         buf.write("\7(\2\2\u031a\u031c\5\n\6\2\u031b\u031a\3\2\2\2\u031c")
 427         buf.write("\u031f\3\2\2\2\u031d\u031b\3\2\2\2\u031d\u031e\3\2\2\2")
 428         buf.write("\u031e\u0321\3\2\2\2\u031f\u031d\3\2\2\2\u0320\u0322\5")
 429         buf.write("\u0086D\2\u0321\u0320\3\2\2\2\u0321\u0322\3\2\2\2\u0322")
 430         buf.write("\u0324\3\2\2\2\u0323\u0325\5\\/\2\u0324\u0323\3\2\2\2")
 431         buf.write("\u0324\u0325\3\2\2\2\u0325\u0326\3\2\2\2\u0326\u0327\7")
 432         buf.write(")\2\2\u0327\u0081\3\2\2\2\u0328\u0329\7_\2\2\u0329\u032a")
 433         buf.write("\7\31\2\2\u032a\u0334\5x=\2\u032b\u032c\7T\2\2\u032c\u032d")
 434         buf.write("\5^\60\2\u032d\u032e\7\31\2\2\u032e\u032f\5x=\2\u032f")
 435         buf.write("\u0334\3\2\2\2\u0330\u0331\7U\2\2\u0331\u0332\7\31\2\2")
 436         buf.write("\u0332\u0334\5x=\2\u0333\u0328\3\2\2\2\u0333\u032b\3\2")
 437         buf.write("\2\2\u0333\u0330\3\2\2\2\u0334\u0083\3\2\2\2\u0335\u0339")
 438         buf.write("\7\3\2\2\u0336\u0338\5\n\6\2\u0337\u0336\3\2\2\2\u0338")
 439         buf.write("\u033b\3\2\2\2\u0339\u0337\3\2\2\2\u0339\u033a\3\2\2\2")
 440         buf.write("\u033a\u033d\3\2\2\2\u033b\u0339\3\2\2\2\u033c\u033e\5")
 441         buf.write("\u0086D\2\u033d\u033c\3\2\2\2\u033d\u033e\3\2\2\2\u033e")
 442         buf.write("\u033f\3\2\2\2\u033f\u0340\7\26\2\2\u0340\u0085\3\2\2")
 443         buf.write("\2\u0341\u0343\5x=\2\u0342\u0341\3\2\2\2\u0343\u0344\3")
 444         buf.write("\2\2\2\u0344\u0342\3\2\2\2\u0344\u0345\3\2\2\2\u0345\u0087")
 445         buf.write("\3\2\2\2\u0346\u034b\7\4\2\2\u0347\u0348\5\\/\2\u0348")
 446         buf.write("\u0349\7\4\2\2\u0349\u034b\3\2\2\2\u034a\u0346\3\2\2\2")
 447         buf.write("\u034a\u0347\3\2\2\2\u034b\u0089\3\2\2\2\u034c\u034d\7")
 448         buf.write("V\2\2\u034d\u034e\7(\2\2\u034e\u034f\5\\/\2\u034f\u0350")
 449         buf.write("\7)\2\2\u0350\u0351\bF\1\2\u0351\u0354\5x=\2\u0352\u0353")
 450         buf.write("\7W\2\2\u0353\u0355\5x=\2\u0354\u0352\3\2\2\2\u0354\u0355")
 451         buf.write("\3\2\2\2\u0355\u035d\3\2\2\2\u0356\u0357\7X\2\2\u0357")
 452         buf.write("\u0358\7(\2\2\u0358\u0359\5\\/\2\u0359\u035a\7)\2\2\u035a")
 453         buf.write("\u035b\5x=\2\u035b\u035d\3\2\2\2\u035c\u034c\3\2\2\2\u035c")
 454         buf.write("\u0356\3\2\2\2\u035d\u008b\3\2\2\2\u035e\u035f\7Y\2\2")
 455         buf.write("\u035f\u0360\7(\2\2\u0360\u0361\5\\/\2\u0361\u0362\7)")
 456         buf.write("\2\2\u0362\u0363\5x=\2\u0363\u0364\bG\1\2\u0364\u036f")
 457         buf.write("\3\2\2\2\u0365\u0366\7Z\2\2\u0366\u0367\5x=\2\u0367\u0368")
 458         buf.write("\7Y\2\2\u0368\u0369\7(\2\2\u0369\u036a\5\\/\2\u036a\u036b")
 459         buf.write("\7)\2\2\u036b\u036c\7\4\2\2\u036c\u036d\bG\1\2\u036d\u036f")
 460         buf.write("\3\2\2\2\u036e\u035e\3\2\2\2\u036e\u0365\3\2\2\2\u036f")
 461         buf.write("\u008d\3\2\2\2\u0370\u0371\7[\2\2\u0371\u0372\7_\2\2\u0372")
 462         buf.write("\u037e\7\4\2\2\u0373\u0374\7\\\2\2\u0374\u037e\7\4\2\2")
 463         buf.write("\u0375\u0376\7]\2\2\u0376\u037e\7\4\2\2\u0377\u0378\7")
 464         buf.write("^\2\2\u0378\u037e\7\4\2\2\u0379\u037a\7^\2\2\u037a\u037b")
 465         buf.write("\5\\/\2\u037b\u037c\7\4\2\2\u037c\u037e\3\2\2\2\u037d")
 466         buf.write("\u0370\3\2\2\2\u037d\u0373\3\2\2\2\u037d\u0375\3\2\2\2")
 467         buf.write("\u037d\u0377\3\2\2\2\u037d\u0379\3\2\2\2\u037e\u008f\3")
 468         buf.write("\2\2\2o\u0093\u0097\u009d\u00a6\u00a8\u00ab\u00b1\u00b6")
 469         buf.write("\u00bd\u00bf\u00c3\u00cb\u00d0\u00d7\u00dd\u00f4\u00f9")
 470         buf.write("\u00ff\u0108\u010f\u0117\u0119\u0120\u0126\u012a\u0130")
 471         buf.write("\u0139\u013f\u0146\u014c\u0151\u0154\u0157\u015a\u015e")
 472         buf.write("\u0164\u0169\u0170\u0172\u0184\u018a\u018d\u0192\u0197")
 473         buf.write("\u019a\u019f\u01a4\u01aa\u01ac\u01b0\u01b5\u01b9\u01c0")
 474         buf.write("\u01c5\u01c8\u01cc\u01cf\u01d6\u01db\u01ea\u01f0\u01f4")
 475         buf.write("\u01fb\u0200\u0205\u0209\u0211\u0213\u021d\u021f\u0228")
 476         buf.write("\u0239\u0258\u025a\u0262\u026d\u0276\u027c\u0280\u0285")
 477         buf.write("\u0289\u0290\u029a\u02a7\u02ae\u02b6\u02be\u02c6\u02ce")
 478         buf.write("\u02d6\u02de\u02e6\u02f4\u02f7\u02fe\u0309\u0313\u031d")
 479         buf.write("\u0321\u0324\u0333\u0339\u033d\u0344\u034a\u0354\u035c")
 480         buf.write("\u036e\u037d")
 481         return buf.getvalue()
 482
 483
 484 class CParser ( Parser ):
 485
 486     grammarFileName = "C.g4"
 487
 488     atn = ATNDeserializer().deserialize(serializedATN())
 489
 490     decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
 491
 492     sharedContextCache = PredictionContextCache()
 493
 494     literalNames = [ "<INVALID>", "'{'", "';'", "'typedef'", "','", "'='",
 495                      "'extern'", "'static'", "'auto'", "'register'", "'STATIC'",
 496                      "'void'", "'char'", "'short'", "'int'", "'long'", "'float'",
 497                      "'double'", "'signed'", "'unsigned'", "'}'", "'struct'",
 498                      "'union'", "':'", "'enum'", "'const'", "'volatile'",
 499                      "'IN'", "'OUT'", "'OPTIONAL'", "'CONST'", "'UNALIGNED'",
 500                      "'VOLATILE'", "'GLOBAL_REMOVE_IF_UNREFERENCED'", "'EFIAPI'",
 501                      "'EFI_BOOTSERVICE'", "'EFI_RUNTIMESERVICE'", "'PACKED'",
 502                      "'('", "')'", "'['", "']'", "'*'", "'...'", "'+'",
 503                      "'-'", "'/'", "'%'", "'++'", "'--'", "'sizeof'", "'.'",
 504                      "'->'", "'&'", "'~'", "'!'", "'*='", "'/='", "'%='",
 505                      "'+='", "'-='", "'<<='", "'>>='", "'&='", "'^='", "'|='",
 506                      "'?'", "'||'", "'&&'", "'|'", "'^'", "'=='", "'!='",
 507                      "'<'", "'>'", "'<='", "'>='", "'<<'", "'>>'", "'__asm__'",
 508                      "'_asm'", "'__asm'", "'case'", "'default'", "'if'",
 509                      "'else'", "'switch'", "'while'", "'do'", "'goto'",
 510                      "'continue'", "'break'", "'return'" ]
 511
 512     symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
 513                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
 514                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
 515                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
 516                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
 517                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
 518                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
 519                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
 520                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
 521                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
 522                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
 523                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
 524                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
 525                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
 526                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
 527                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
 528                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
 529                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
 530                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
 531                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
 532                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
 533                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
 534                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
 535                       "<INVALID>", "IDENTIFIER", "CHARACTER_LITERAL", "STRING_LITERAL",
 536                       "HEX_LITERAL", "DECIMAL_LITERAL", "OCTAL_LITERAL",
 537                       "FLOATING_POINT_LITERAL", "WS", "BS", "UnicodeVocabulary",
 538                       "COMMENT", "LINE_COMMENT", "LINE_COMMAND" ]
 539
 540     RULE_translation_unit = 0
 541     RULE_external_declaration = 1
 542     RULE_function_definition = 2
 543     RULE_declaration_specifiers = 3
 544     RULE_declaration = 4
 545     RULE_init_declarator_list = 5
 546     RULE_init_declarator = 6
 547     RULE_storage_class_specifier = 7
 548     RULE_type_specifier = 8
 549     RULE_type_id = 9
 550     RULE_struct_or_union_specifier = 10
 551     RULE_struct_or_union = 11
 552     RULE_struct_declaration_list = 12
 553     RULE_struct_declaration = 13
 554     RULE_specifier_qualifier_list = 14
 555     RULE_struct_declarator_list = 15
 556     RULE_struct_declarator = 16
 557     RULE_enum_specifier = 17
 558     RULE_enumerator_list = 18
 559     RULE_enumerator = 19
 560     RULE_type_qualifier = 20
 561     RULE_declarator = 21
 562     RULE_direct_declarator = 22
 563     RULE_declarator_suffix = 23
 564     RULE_pointer = 24
 565     RULE_parameter_type_list = 25
 566     RULE_parameter_list = 26
 567     RULE_parameter_declaration = 27
 568     RULE_identifier_list = 28
 569     RULE_type_name = 29
 570     RULE_abstract_declarator = 30
 571     RULE_direct_abstract_declarator = 31
 572     RULE_abstract_declarator_suffix = 32
 573     RULE_initializer = 33
 574     RULE_initializer_list = 34
 575     RULE_argument_expression_list = 35
 576     RULE_additive_expression = 36
 577     RULE_multiplicative_expression = 37
 578     RULE_cast_expression = 38
 579     RULE_unary_expression = 39
 580     RULE_postfix_expression = 40
 581     RULE_macro_parameter_list = 41
 582     RULE_unary_operator = 42
 583     RULE_primary_expression = 43
 584     RULE_constant = 44
 585     RULE_expression = 45
 586     RULE_constant_expression = 46
 587     RULE_assignment_expression = 47
 588     RULE_lvalue = 48
 589     RULE_assignment_operator = 49
 590     RULE_conditional_expression = 50
 591     RULE_logical_or_expression = 51
 592     RULE_logical_and_expression = 52
 593     RULE_inclusive_or_expression = 53
 594     RULE_exclusive_or_expression = 54
 595     RULE_and_expression = 55
 596     RULE_equality_expression = 56
 597     RULE_relational_expression = 57
 598     RULE_shift_expression = 58
 599     RULE_statement = 59
 600     RULE_asm2_statement = 60
 601     RULE_asm1_statement = 61
 602     RULE_asm_statement = 62
 603     RULE_macro_statement = 63
 604     RULE_labeled_statement = 64
 605     RULE_compound_statement = 65
 606     RULE_statement_list = 66
 607     RULE_expression_statement = 67
 608     RULE_selection_statement = 68
 609     RULE_iteration_statement = 69
 610     RULE_jump_statement = 70
 611
 612     ruleNames =  [ "translation_unit", "external_declaration", "function_definition",
 613                    "declaration_specifiers", "declaration", "init_declarator_list",
 614                    "init_declarator", "storage_class_specifier", "type_specifier",
 615                    "type_id", "struct_or_union_specifier", "struct_or_union",
 616                    "struct_declaration_list", "struct_declaration", "specifier_qualifier_list",
 617                    "struct_declarator_list", "struct_declarator", "enum_specifier",
 618                    "enumerator_list", "enumerator", "type_qualifier", "declarator",
 619                    "direct_declarator", "declarator_suffix", "pointer",
 620                    "parameter_type_list", "parameter_list", "parameter_declaration",
 621                    "identifier_list", "type_name", "abstract_declarator",
 622                    "direct_abstract_declarator", "abstract_declarator_suffix",
 623                    "initializer", "initializer_list", "argument_expression_list",
 624                    "additive_expression", "multiplicative_expression", "cast_expression",
 625                    "unary_expression", "postfix_expression", "macro_parameter_list",
 626                    "unary_operator", "primary_expression", "constant", "expression",
 627                    "constant_expression", "assignment_expression", "lvalue",
 628                    "assignment_operator", "conditional_expression", "logical_or_expression",
 629                    "logical_and_expression", "inclusive_or_expression",
 630                    "exclusive_or_expression", "and_expression", "equality_expression",
 631                    "relational_expression", "shift_expression", "statement",
 632                    "asm2_statement", "asm1_statement", "asm_statement",
 633                    "macro_statement", "labeled_statement", "compound_statement",
 634                    "statement_list", "expression_statement", "selection_statement",
 635                    "iteration_statement", "jump_statement" ]
 636
 637     EOF = Token.EOF
 638     T__0=1
 639     T__1=2
 640     T__2=3
 641     T__3=4
 642     T__4=5
 643     T__5=6
 644     T__6=7
 645     T__7=8
 646     T__8=9
 647     T__9=10
 648     T__10=11
 649     T__11=12
 650     T__12=13
 651     T__13=14
 652     T__14=15
 653     T__15=16
 654     T__16=17
 655     T__17=18
 656     T__18=19
 657     T__19=20
 658     T__20=21
 659     T__21=22
 660     T__22=23
 661     T__23=24
 662     T__24=25
 663     T__25=26
 664     T__26=27
 665     T__27=28
 666     T__28=29
 667     T__29=30
 668     T__30=31
 669     T__31=32
 670     T__32=33
 671     T__33=34
 672     T__34=35
 673     T__35=36
 674     T__36=37
 675     T__37=38
 676     T__38=39
 677     T__39=40
 678     T__40=41
 679     T__41=42
 680     T__42=43
 681     T__43=44
 682     T__44=45
 683     T__45=46
 684     T__46=47
 685     T__47=48
 686     T__48=49
 687     T__49=50
 688     T__50=51
 689     T__51=52
 690     T__52=53
 691     T__53=54
 692     T__54=55
 693     T__55=56
 694     T__56=57
 695     T__57=58
 696     T__58=59
 697     T__59=60
 698     T__60=61
 699     T__61=62
 700     T__62=63
 701     T__63=64
 702     T__64=65
 703     T__65=66
 704     T__66=67
 705     T__67=68
 706     T__68=69
 707     T__69=70
 708     T__70=71
 709     T__71=72
 710     T__72=73
 711     T__73=74
 712     T__74=75
 713     T__75=76
 714     T__76=77
 715     T__77=78
 716     T__78=79
 717     T__79=80
 718     T__80=81
 719     T__81=82
 720     T__82=83
 721     T__83=84
 722     T__84=85
 723     T__85=86
 724     T__86=87
 725     T__87=88
 726     T__88=89
 727     T__89=90
 728     T__90=91
 729     T__91=92
 730     IDENTIFIER=93
 731     CHARACTER_LITERAL=94
 732     STRING_LITERAL=95
 733     HEX_LITERAL=96
 734     DECIMAL_LITERAL=97
 735     OCTAL_LITERAL=98
 736     FLOATING_POINT_LITERAL=99
 737     WS=100
 738     BS=101
 739     UnicodeVocabulary=102
 740     COMMENT=103
 741     LINE_COMMENT=104
 742     LINE_COMMAND=105
 743
 744     def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
 745         super().__init__(input, output)
 746         self.checkVersion("4.7.1")
 747         self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
 748         self._predicates = None
 749
 750
 751
 752
 753     def printTokenInfo(self, line, offset, tokenText):
 754         print(str(line)+ ',' + str(offset) + ':' + str(tokenText))
 755
 756     def StorePredicateExpression(self, StartLine, StartOffset, EndLine, EndOffset, Text):
 757         PredExp = CodeFragment.PredicateExpression(Text, (StartLine, StartOffset), (EndLine, EndOffset))
 758         FileProfile.PredicateExpressionList.append(PredExp)
 759
 760     def StoreEnumerationDefinition(self, StartLine, StartOffset, EndLine, EndOffset, Text):
 761         EnumDef = CodeFragment.EnumerationDefinition(Text, (StartLine, StartOffset), (EndLine, EndOffset))
 762         FileProfile.EnumerationDefinitionList.append(EnumDef)
 763
 764     def StoreStructUnionDefinition(self, StartLine, StartOffset, EndLine, EndOffset, Text):
 765         SUDef = CodeFragment.StructUnionDefinition(Text, (StartLine, StartOffset), (EndLine, EndOffset))
 766         FileProfile.StructUnionDefinitionList.append(SUDef)
 767
 768     def StoreTypedefDefinition(self, StartLine, StartOffset, EndLine, EndOffset, FromText, ToText):
 769         Tdef = CodeFragment.TypedefDefinition(FromText, ToText, (StartLine, StartOffset), (EndLine, EndOffset))
 770         FileProfile.TypedefDefinitionList.append(Tdef)
 771
 772     def StoreFunctionDefinition(self, StartLine, StartOffset, EndLine, EndOffset, ModifierText, DeclText, LeftBraceLine, LeftBraceOffset, DeclLine, DeclOffset):
 773         FuncDef = CodeFragment.FunctionDefinition(ModifierText, DeclText, (StartLine, StartOffset), (EndLine, EndOffset), (LeftBraceLine, LeftBraceOffset), (DeclLine, DeclOffset))
 774         FileProfile.FunctionDefinitionList.append(FuncDef)
 775
 776     def StoreVariableDeclaration(self, StartLine, StartOffset, EndLine, EndOffset, ModifierText, DeclText):
 777         VarDecl = CodeFragment.VariableDeclaration(ModifierText, DeclText, (StartLine, StartOffset), (EndLine, EndOffset))
 778         FileProfile.VariableDeclarationList.append(VarDecl)
 779
 780     def StoreFunctionCalling(self, StartLine, StartOffset, EndLine, EndOffset, FuncName, ParamList):
 781         FuncCall = CodeFragment.FunctionCalling(FuncName, ParamList, (StartLine, StartOffset), (EndLine, EndOffset))
 782         FileProfile.FunctionCallingList.append(FuncCall)
 783
 784
 785
 786     class Translation_unitContext(ParserRuleContext):
 787
 788         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
 789             super().__init__(parent, invokingState)
 790             self.parser = parser
 791
 792         def external_declaration(self, i:int=None):
 793             if i is None:
 794                 return self.getTypedRuleContexts(CParser.External_declarationContext)
 795             else:
 796                 return self.getTypedRuleContext(CParser.External_declarationContext,i)
 797
 798
 799         def getRuleIndex(self):
 800             return CParser.RULE_translation_unit
 801
 802         def enterRule(self, listener:ParseTreeListener):
 803             if hasattr( listener, "enterTranslation_unit" ):
 804                 listener.enterTranslation_unit(self)
 805
 806         def exitRule(self, listener:ParseTreeListener):
 807             if hasattr( listener, "exitTranslation_unit" ):
 808                 listener.exitTranslation_unit(self)
 809
 810
 811
 812
 813     def translation_unit(self):
 814
 815         localctx = CParser.Translation_unitContext(self, self._ctx, self.state)
 816         self.enterRule(localctx, 0, self.RULE_translation_unit)
 817         self._la = 0 # Token type
 818         try:
 819             self.enterOuterAlt(localctx, 1)
 820             self.state = 145
 821             self._errHandler.sync(self)
 822             _la = self._input.LA(1)
 823             while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__2) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9) | (1 << CParser.T__10) | (1 << CParser.T__11) | (1 << CParser.T__12) | (1 << CParser.T__13) | (1 << CParser.T__14) | (1 << CParser.T__15) | (1 << CParser.T__16) | (1 << CParser.T__17) | (1 << CParser.T__18) | (1 << CParser.T__20) | (1 << CParser.T__21) | (1 << CParser.T__23) | (1 << CParser.T__24) | (1 << CParser.T__25) | (1 << CParser.T__26) | (1 << CParser.T__27) | (1 << CParser.T__28) | (1 << CParser.T__29) | (1 << CParser.T__30) | (1 << CParser.T__31) | (1 << CParser.T__32) | (1 << CParser.T__33) | (1 << CParser.T__34) | (1 << CParser.T__35) | (1 << CParser.T__36) | (1 << CParser.T__37) | (1 << CParser.T__41))) != 0) or _la==CParser.IDENTIFIER:
 824                 self.state = 142
 825                 self.external_declaration()
 826                 self.state = 147
 827                 self._errHandler.sync(self)
 828                 _la = self._input.LA(1)
 829
 830         except RecognitionException as re:
 831             localctx.exception = re
 832             self._errHandler.reportError(self, re)
 833             self._errHandler.recover(self, re)
 834         finally:
 835             self.exitRule()
 836         return localctx
 837
 838     class External_declarationContext(ParserRuleContext):
 839
 840         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
 841             super().__init__(parent, invokingState)
 842             self.parser = parser
 843
 844         def declarator(self):
 845             return self.getTypedRuleContext(CParser.DeclaratorContext,0)
 846
 847
 848         def declaration_specifiers(self):
 849             return self.getTypedRuleContext(CParser.Declaration_specifiersContext,0)
 850
 851
 852         def declaration(self, i:int=None):
 853             if i is None:
 854                 return self.getTypedRuleContexts(CParser.DeclarationContext)
 855             else:
 856                 return self.getTypedRuleContext(CParser.DeclarationContext,i)
 857
 858
 859         def function_definition(self):
 860             return self.getTypedRuleContext(CParser.Function_definitionContext,0)
 861
 862
 863         def macro_statement(self):
 864             return self.getTypedRuleContext(CParser.Macro_statementContext,0)
 865
 866
 867         def getRuleIndex(self):
 868             return CParser.RULE_external_declaration
 869
 870         def enterRule(self, listener:ParseTreeListener):
 871             if hasattr( listener, "enterExternal_declaration" ):
 872                 listener.enterExternal_declaration(self)
 873
 874         def exitRule(self, listener:ParseTreeListener):
 875             if hasattr( listener, "exitExternal_declaration" ):
 876                 listener.exitExternal_declaration(self)
 877
 878
 879
 880
 881     def external_declaration(self):
 882
 883         localctx = CParser.External_declarationContext(self, self._ctx, self.state)
 884         self.enterRule(localctx, 2, self.RULE_external_declaration)
 885         self._la = 0 # Token type
 886         try:
 887             self.state = 166
 888             self._errHandler.sync(self)
 889             la_ = self._interp.adaptivePredict(self._input,4,self._ctx)
 890             if la_ == 1:
 891                 self.enterOuterAlt(localctx, 1)
 892                 self.state = 149
 893                 self._errHandler.sync(self)
 894                 la_ = self._interp.adaptivePredict(self._input,1,self._ctx)
 895                 if la_ == 1:
 896                     self.state = 148
 897                     self.declaration_specifiers()
 898
 899
 900                 self.state = 151
 901                 self.declarator()
 902                 self.state = 155
 903                 self._errHandler.sync(self)
 904                 _la = self._input.LA(1)
 905                 while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__2) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9) | (1 << CParser.T__10) | (1 << CParser.T__11) | (1 << CParser.T__12) | (1 << CParser.T__13) | (1 << CParser.T__14) | (1 << CParser.T__15) | (1 << CParser.T__16) | (1 << CParser.T__17) | (1 << CParser.T__18) | (1 << CParser.T__20) | (1 << CParser.T__21) | (1 << CParser.T__23) | (1 << CParser.T__24) | (1 << CParser.T__25) | (1 << CParser.T__26) | (1 << CParser.T__27) | (1 << CParser.T__28) | (1 << CParser.T__29) | (1 << CParser.T__30) | (1 << CParser.T__31) | (1 << CParser.T__32) | (1 << CParser.T__33) | (1 << CParser.T__34) | (1 << CParser.T__35) | (1 << CParser.T__36))) != 0) or _la==CParser.IDENTIFIER:
 906                     self.state = 152
 907                     self.declaration()
 908                     self.state = 157
 909                     self._errHandler.sync(self)
 910                     _la = self._input.LA(1)
 911
 912                 self.state = 158
 913                 self.match(CParser.T__0)
 914                 pass
 915
 916             elif la_ == 2:
 917                 self.enterOuterAlt(localctx, 2)
 918                 self.state = 160
 919                 self.function_definition()
 920                 pass
 921
 922             elif la_ == 3:
 923                 self.enterOuterAlt(localctx, 3)
 924                 self.state = 161
 925                 self.declaration()
 926                 pass
 927
 928             elif la_ == 4:
 929                 self.enterOuterAlt(localctx, 4)
 930                 self.state = 162
 931                 self.macro_statement()
 932                 self.state = 164
 933                 self._errHandler.sync(self)
 934                 _la = self._input.LA(1)
 935                 if _la==CParser.T__1:
 936                     self.state = 163
 937                     self.match(CParser.T__1)
 938
 939
 940                 pass
 941
 942
 943         except RecognitionException as re:
 944             localctx.exception = re
 945             self._errHandler.reportError(self, re)
 946             self._errHandler.recover(self, re)
 947         finally:
 948             self.exitRule()
 949         return localctx
 950
 951     class Function_definitionContext(ParserRuleContext):
 952
 953         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
 954             super().__init__(parent, invokingState)
 955             self.parser = parser
 956             self.ModifierText = ''
 957             self.DeclText = ''
 958             self.LBLine = 0
 959             self.LBOffset = 0
 960             self.DeclLine = 0
 961             self.DeclOffset = 0
 962             self.d = None # Declaration_specifiersContext
 963             self._declaration_specifiers = None # Declaration_specifiersContext
 964             self._declarator = None # DeclaratorContext
 965             self.a = None # Compound_statementContext
 966             self.b = None # Compound_statementContext
 967
 968         def declarator(self):
 969             return self.getTypedRuleContext(CParser.DeclaratorContext,0)
 970
 971
 972         def compound_statement(self):
 973             return self.getTypedRuleContext(CParser.Compound_statementContext,0)
 974
 975
 976         def declaration_specifiers(self):
 977             return self.getTypedRuleContext(CParser.Declaration_specifiersContext,0)
 978
 979
 980         def declaration(self, i:int=None):
 981             if i is None:
 982                 return self.getTypedRuleContexts(CParser.DeclarationContext)
 983             else:
 984                 return self.getTypedRuleContext(CParser.DeclarationContext,i)
 985
 986
 987         def getRuleIndex(self):
 988             return CParser.RULE_function_definition
 989
 990         def enterRule(self, listener:ParseTreeListener):
 991             if hasattr( listener, "enterFunction_definition" ):
 992                 listener.enterFunction_definition(self)
 993
 994         def exitRule(self, listener:ParseTreeListener):
 995             if hasattr( listener, "exitFunction_definition" ):
 996                 listener.exitFunction_definition(self)
 997
 998
 999
1000
1001     def function_definition(self):
1002
1003         localctx = CParser.Function_definitionContext(self, self._ctx, self.state)
1004         self.enterRule(localctx, 4, self.RULE_function_definition)
1005
1006         ModifierText = '';
1007         DeclText = '';
1008         LBLine = 0;
1009         LBOffset = 0;
1010         DeclLine = 0;
1011         DeclOffset = 0;
1012
1013         self._la = 0 # Token type
1014         try:
1015             self.enterOuterAlt(localctx, 1)
1016             self.state = 169
1017             self._errHandler.sync(self)
1018             la_ = self._interp.adaptivePredict(self._input,5,self._ctx)
1019             if la_ == 1:
1020                 self.state = 168
1021                 localctx.d = localctx._declaration_specifiers = self.declaration_specifiers()
1022
1023
1024             self.state = 171
1025             localctx._declarator = self.declarator()
1026             self.state = 180
1027             self._errHandler.sync(self)
1028             token = self._input.LA(1)
1029             if token in [CParser.T__2, CParser.T__5, CParser.T__6, CParser.T__7, CParser.T__8, CParser.T__9, CParser.T__10, CParser.T__11, CParser.T__12, CParser.T__13, CParser.T__14, CParser.T__15, CParser.T__16, CParser.T__17, CParser.T__18, CParser.T__20, CParser.T__21, CParser.T__23, CParser.T__24, CParser.T__25, CParser.T__26, CParser.T__27, CParser.T__28, CParser.T__29, CParser.T__30, CParser.T__31, CParser.T__32, CParser.T__33, CParser.T__34, CParser.T__35, CParser.T__36, CParser.IDENTIFIER]:
1030                 self.state = 173
1031                 self._errHandler.sync(self)
1032                 _la = self._input.LA(1)
1033                 while True:
1034                     self.state = 172
1035                     self.declaration()
1036                     self.state = 175
1037                     self._errHandler.sync(self)
1038                     _la = self._input.LA(1)
1039                     if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__2) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9) | (1 << CParser.T__10) | (1 << CParser.T__11) | (1 << CParser.T__12) | (1 << CParser.T__13) | (1 << CParser.T__14) | (1 << CParser.T__15) | (1 << CParser.T__16) | (1 << CParser.T__17) | (1 << CParser.T__18) | (1 << CParser.T__20) | (1 << CParser.T__21) | (1 << CParser.T__23) | (1 << CParser.T__24) | (1 << CParser.T__25) | (1 << CParser.T__26) | (1 << CParser.T__27) | (1 << CParser.T__28) | (1 << CParser.T__29) | (1 << CParser.T__30) | (1 << CParser.T__31) | (1 << CParser.T__32) | (1 << CParser.T__33) | (1 << CParser.T__34) | (1 << CParser.T__35) | (1 << CParser.T__36))) != 0) or _la==CParser.IDENTIFIER):
1040                         break
1041
1042                 self.state = 177
1043                 localctx.a = self.compound_statement()
1044                 pass
1045             elif token in [CParser.T__0]:
1046                 self.state = 179
1047                 localctx.b = self.compound_statement()
1048                 pass
1049             else:
1050                 raise NoViableAltException(self)
1051
1052
1053             if localctx.d != None:
1054                 ModifierText = (None if localctx._declaration_specifiers is None else self._input.getText((localctx._declaration_specifiers.start,localctx._declaration_specifiers.stop)))
1055             else:
1056                 ModifierText = ''
1057             DeclText = (None if localctx._declarator is None else self._input.getText((localctx._declarator.start,localctx._declarator.stop)))
1058             DeclLine = (None if localctx._declarator is None else localctx._declarator.start).line
1059             DeclOffset = (None if localctx._declarator is None else localctx._declarator.start).column
1060             if localctx.a != None:
1061                 LBLine = (None if localctx.a is None else localctx.a.start).line
1062                 LBOffset = (None if localctx.a is None else localctx.a.start).column
1063             else:
1064                 LBLine = (None if localctx.b is None else localctx.b.start).line
1065                 LBOffset = (None if localctx.b is None else localctx.b.start).column
1066
1067             self._ctx.stop = self._input.LT(-1)
1068
1069             self.StoreFunctionDefinition(localctx.start.line, localctx.start.column, localctx.stop.line, localctx.stop.column, ModifierText, DeclText, LBLine, LBOffset, DeclLine, DeclOffset)
1070
1071         except RecognitionException as re:
1072             localctx.exception = re
1073             self._errHandler.reportError(self, re)
1074             self._errHandler.recover(self, re)
1075         finally:
1076             self.exitRule()
1077         return localctx
1078
1079     class Declaration_specifiersContext(ParserRuleContext):
1080
1081         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1082             super().__init__(parent, invokingState)
1083             self.parser = parser
1084
1085         def storage_class_specifier(self, i:int=None):
1086             if i is None:
1087                 return self.getTypedRuleContexts(CParser.Storage_class_specifierContext)
1088             else:
1089                 return self.getTypedRuleContext(CParser.Storage_class_specifierContext,i)
1090
1091
1092         def type_specifier(self, i:int=None):
1093             if i is None:
1094                 return self.getTypedRuleContexts(CParser.Type_specifierContext)
1095             else:
1096                 return self.getTypedRuleContext(CParser.Type_specifierContext,i)
1097
1098
1099         def type_qualifier(self, i:int=None):
1100             if i is None:
1101                 return self.getTypedRuleContexts(CParser.Type_qualifierContext)
1102             else:
1103                 return self.getTypedRuleContext(CParser.Type_qualifierContext,i)
1104
1105
1106         def getRuleIndex(self):
1107             return CParser.RULE_declaration_specifiers
1108
1109         def enterRule(self, listener:ParseTreeListener):
1110             if hasattr( listener, "enterDeclaration_specifiers" ):
1111                 listener.enterDeclaration_specifiers(self)
1112
1113         def exitRule(self, listener:ParseTreeListener):
1114             if hasattr( listener, "exitDeclaration_specifiers" ):
1115                 listener.exitDeclaration_specifiers(self)
1116
1117
1118
1119
1120     def declaration_specifiers(self):
1121
1122         localctx = CParser.Declaration_specifiersContext(self, self._ctx, self.state)
1123         self.enterRule(localctx, 6, self.RULE_declaration_specifiers)
1124         try:
1125             self.enterOuterAlt(localctx, 1)
1126             self.state = 187
1127             self._errHandler.sync(self)
1128             _alt = 1
1129             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
1130                 if _alt == 1:
1131                     self.state = 187
1132                     self._errHandler.sync(self)
1133                     token = self._input.LA(1)
1134                     if token in [CParser.T__5, CParser.T__6, CParser.T__7, CParser.T__8, CParser.T__9]:
1135                         self.state = 184
1136                         self.storage_class_specifier()
1137                         pass
1138                     elif token in [CParser.T__10, CParser.T__11, CParser.T__12, CParser.T__13, CParser.T__14, CParser.T__15, CParser.T__16, CParser.T__17, CParser.T__18, CParser.T__20, CParser.T__21, CParser.T__23, CParser.IDENTIFIER]:
1139                         self.state = 185
1140                         self.type_specifier()
1141                         pass
1142                     elif token in [CParser.T__24, CParser.T__25, CParser.T__26, CParser.T__27, CParser.T__28, CParser.T__29, CParser.T__30, CParser.T__31, CParser.T__32, CParser.T__33, CParser.T__34, CParser.T__35, CParser.T__36]:
1143                         self.state = 186
1144                         self.type_qualifier()
1145                         pass
1146                     else:
1147                         raise NoViableAltException(self)
1148
1149
1150                 else:
1151                     raise NoViableAltException(self)
1152                 self.state = 189
1153                 self._errHandler.sync(self)
1154                 _alt = self._interp.adaptivePredict(self._input,9,self._ctx)
1155
1156         except RecognitionException as re:
1157             localctx.exception = re
1158             self._errHandler.reportError(self, re)
1159             self._errHandler.recover(self, re)
1160         finally:
1161             self.exitRule()
1162         return localctx
1163
1164     class DeclarationContext(ParserRuleContext):
1165
1166         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1167             super().__init__(parent, invokingState)
1168             self.parser = parser
1169             self.a = None # Token
1170             self.b = None # Declaration_specifiersContext
1171             self.c = None # Init_declarator_listContext
1172             self.d = None # Token
1173             self.s = None # Declaration_specifiersContext
1174             self.t = None # Init_declarator_listContext
1175             self.e = None # Token
1176
1177         def init_declarator_list(self):
1178             return self.getTypedRuleContext(CParser.Init_declarator_listContext,0)
1179
1180
1181         def declaration_specifiers(self):
1182             return self.getTypedRuleContext(CParser.Declaration_specifiersContext,0)
1183
1184
1185         def getRuleIndex(self):
1186             return CParser.RULE_declaration
1187
1188         def enterRule(self, listener:ParseTreeListener):
1189             if hasattr( listener, "enterDeclaration" ):
1190                 listener.enterDeclaration(self)
1191
1192         def exitRule(self, listener:ParseTreeListener):
1193             if hasattr( listener, "exitDeclaration" ):
1194                 listener.exitDeclaration(self)
1195
1196
1197
1198
1199     def declaration(self):
1200
1201         localctx = CParser.DeclarationContext(self, self._ctx, self.state)
1202         self.enterRule(localctx, 8, self.RULE_declaration)
1203         self._la = 0 # Token type
1204         try:
1205             self.state = 206
1206             self._errHandler.sync(self)
1207             token = self._input.LA(1)
1208             if token in [CParser.T__2]:
1209                 self.enterOuterAlt(localctx, 1)
1210                 self.state = 191
1211                 localctx.a = self.match(CParser.T__2)
1212                 self.state = 193
1213                 self._errHandler.sync(self)
1214                 la_ = self._interp.adaptivePredict(self._input,10,self._ctx)
1215                 if la_ == 1:
1216                     self.state = 192
1217                     localctx.b = self.declaration_specifiers()
1218
1219
1220                 self.state = 195
1221                 localctx.c = self.init_declarator_list()
1222                 self.state = 196
1223                 localctx.d = self.match(CParser.T__1)
1224
1225                 if localctx.b is not None:
1226                     self.StoreTypedefDefinition(localctx.a.line, localctx.a.column, (0 if localctx.d is None else localctx.d.line), localctx.d.column, (None if localctx.b is None else self._input.getText((localctx.b.start,localctx.b.stop))), (None if localctx.c is None else self._input.getText((localctx.c.start,localctx.c.stop))))
1227                 else:
1228                     self.StoreTypedefDefinition(localctx.a.line, localctx.a.column, (0 if localctx.d is None else localctx.d.line), localctx.d.column, '', (None if localctx.c is None else self._input.getText((localctx.c.start,localctx.c.stop))))
1229
1230                 pass
1231             elif token in [CParser.T__5, CParser.T__6, CParser.T__7, CParser.T__8, CParser.T__9, CParser.T__10, CParser.T__11, CParser.T__12, CParser.T__13, CParser.T__14, CParser.T__15, CParser.T__16, CParser.T__17, CParser.T__18, CParser.T__20, CParser.T__21, CParser.T__23, CParser.T__24, CParser.T__25, CParser.T__26, CParser.T__27, CParser.T__28, CParser.T__29, CParser.T__30, CParser.T__31, CParser.T__32, CParser.T__33, CParser.T__34, CParser.T__35, CParser.T__36, CParser.IDENTIFIER]:
1232                 self.enterOuterAlt(localctx, 2)
1233                 self.state = 199
1234                 localctx.s = self.declaration_specifiers()
1235                 self.state = 201
1236                 self._errHandler.sync(self)
1237                 _la = self._input.LA(1)
1238                 if ((((_la - 34)) & ~0x3f) == 0 and ((1 << (_la - 34)) & ((1 << (CParser.T__33 - 34)) | (1 << (CParser.T__34 - 34)) | (1 << (CParser.T__35 - 34)) | (1 << (CParser.T__37 - 34)) | (1 << (CParser.T__41 - 34)) | (1 << (CParser.IDENTIFIER - 34)))) != 0):
1239                     self.state = 200
1240                     localctx.t = self.init_declarator_list()
1241
1242
1243                 self.state = 203
1244                 localctx.e = self.match(CParser.T__1)
1245
1246                 if localctx.t is not None:
1247                     self.StoreVariableDeclaration((None if localctx.s is None else localctx.s.start).line, (None if localctx.s is None else localctx.s.start).column, (None if localctx.t is None else localctx.t.start).line, (None if localctx.t is None else localctx.t.start).column, (None if localctx.s is None else self._input.getText((localctx.s.start,localctx.s.stop))), (None if localctx.t is None else self._input.getText((localctx.t.start,localctx.t.stop))))
1248
1249                 pass
1250             else:
1251                 raise NoViableAltException(self)
1252
1253         except RecognitionException as re:
1254             localctx.exception = re
1255             self._errHandler.reportError(self, re)
1256             self._errHandler.recover(self, re)
1257         finally:
1258             self.exitRule()
1259         return localctx
1260
1261     class Init_declarator_listContext(ParserRuleContext):
1262
1263         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1264             super().__init__(parent, invokingState)
1265             self.parser = parser
1266
1267         def init_declarator(self, i:int=None):
1268             if i is None:
1269                 return self.getTypedRuleContexts(CParser.Init_declaratorContext)
1270             else:
1271                 return self.getTypedRuleContext(CParser.Init_declaratorContext,i)
1272
1273
1274         def getRuleIndex(self):
1275             return CParser.RULE_init_declarator_list
1276
1277         def enterRule(self, listener:ParseTreeListener):
1278             if hasattr( listener, "enterInit_declarator_list" ):
1279                 listener.enterInit_declarator_list(self)
1280
1281         def exitRule(self, listener:ParseTreeListener):
1282             if hasattr( listener, "exitInit_declarator_list" ):
1283                 listener.exitInit_declarator_list(self)
1284
1285
1286
1287
1288     def init_declarator_list(self):
1289
1290         localctx = CParser.Init_declarator_listContext(self, self._ctx, self.state)
1291         self.enterRule(localctx, 10, self.RULE_init_declarator_list)
1292         self._la = 0 # Token type
1293         try:
1294             self.enterOuterAlt(localctx, 1)
1295             self.state = 208
1296             self.init_declarator()
1297             self.state = 213
1298             self._errHandler.sync(self)
1299             _la = self._input.LA(1)
1300             while _la==CParser.T__3:
1301                 self.state = 209
1302                 self.match(CParser.T__3)
1303                 self.state = 210
1304                 self.init_declarator()
1305                 self.state = 215
1306                 self._errHandler.sync(self)
1307                 _la = self._input.LA(1)
1308
1309         except RecognitionException as re:
1310             localctx.exception = re
1311             self._errHandler.reportError(self, re)
1312             self._errHandler.recover(self, re)
1313         finally:
1314             self.exitRule()
1315         return localctx
1316
1317     class Init_declaratorContext(ParserRuleContext):
1318
1319         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1320             super().__init__(parent, invokingState)
1321             self.parser = parser
1322
1323         def declarator(self):
1324             return self.getTypedRuleContext(CParser.DeclaratorContext,0)
1325
1326
1327         def initializer(self):
1328             return self.getTypedRuleContext(CParser.InitializerContext,0)
1329
1330
1331         def getRuleIndex(self):
1332             return CParser.RULE_init_declarator
1333
1334         def enterRule(self, listener:ParseTreeListener):
1335             if hasattr( listener, "enterInit_declarator" ):
1336                 listener.enterInit_declarator(self)
1337
1338         def exitRule(self, listener:ParseTreeListener):
1339             if hasattr( listener, "exitInit_declarator" ):
1340                 listener.exitInit_declarator(self)
1341
1342
1343
1344
1345     def init_declarator(self):
1346
1347         localctx = CParser.Init_declaratorContext(self, self._ctx, self.state)
1348         self.enterRule(localctx, 12, self.RULE_init_declarator)
1349         self._la = 0 # Token type
1350         try:
1351             self.enterOuterAlt(localctx, 1)
1352             self.state = 216
1353             self.declarator()
1354             self.state = 219
1355             self._errHandler.sync(self)
1356             _la = self._input.LA(1)
1357             if _la==CParser.T__4:
1358                 self.state = 217
1359                 self.match(CParser.T__4)
1360                 self.state = 218
1361                 self.initializer()
1362
1363
1364         except RecognitionException as re:
1365             localctx.exception = re
1366             self._errHandler.reportError(self, re)
1367             self._errHandler.recover(self, re)
1368         finally:
1369             self.exitRule()
1370         return localctx
1371
1372     class Storage_class_specifierContext(ParserRuleContext):
1373
1374         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1375             super().__init__(parent, invokingState)
1376             self.parser = parser
1377
1378
1379         def getRuleIndex(self):
1380             return CParser.RULE_storage_class_specifier
1381
1382         def enterRule(self, listener:ParseTreeListener):
1383             if hasattr( listener, "enterStorage_class_specifier" ):
1384                 listener.enterStorage_class_specifier(self)
1385
1386         def exitRule(self, listener:ParseTreeListener):
1387             if hasattr( listener, "exitStorage_class_specifier" ):
1388                 listener.exitStorage_class_specifier(self)
1389
1390
1391
1392
1393     def storage_class_specifier(self):
1394
1395         localctx = CParser.Storage_class_specifierContext(self, self._ctx, self.state)
1396         self.enterRule(localctx, 14, self.RULE_storage_class_specifier)
1397         self._la = 0 # Token type
1398         try:
1399             self.enterOuterAlt(localctx, 1)
1400             self.state = 221
1401             _la = self._input.LA(1)
1402             if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9))) != 0)):
1403                 self._errHandler.recoverInline(self)
1404             else:
1405                 self._errHandler.reportMatch(self)
1406                 self.consume()
1407         except RecognitionException as re:
1408             localctx.exception = re
1409             self._errHandler.reportError(self, re)
1410             self._errHandler.recover(self, re)
1411         finally:
1412             self.exitRule()
1413         return localctx
1414
1415     class Type_specifierContext(ParserRuleContext):
1416
1417         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1418             super().__init__(parent, invokingState)
1419             self.parser = parser
1420             self.s = None # Struct_or_union_specifierContext
1421             self.e = None # Enum_specifierContext
1422
1423         def struct_or_union_specifier(self):
1424             return self.getTypedRuleContext(CParser.Struct_or_union_specifierContext,0)
1425
1426
1427         def enum_specifier(self):
1428             return self.getTypedRuleContext(CParser.Enum_specifierContext,0)
1429
1430
1431         def IDENTIFIER(self):
1432             return self.getToken(CParser.IDENTIFIER, 0)
1433
1434         def declarator(self):
1435             return self.getTypedRuleContext(CParser.DeclaratorContext,0)
1436
1437
1438         def type_qualifier(self, i:int=None):
1439             if i is None:
1440                 return self.getTypedRuleContexts(CParser.Type_qualifierContext)
1441             else:
1442                 return self.getTypedRuleContext(CParser.Type_qualifierContext,i)
1443
1444
1445         def type_id(self):
1446             return self.getTypedRuleContext(CParser.Type_idContext,0)
1447
1448
1449         def getRuleIndex(self):
1450             return CParser.RULE_type_specifier
1451
1452         def enterRule(self, listener:ParseTreeListener):
1453             if hasattr( listener, "enterType_specifier" ):
1454                 listener.enterType_specifier(self)
1455
1456         def exitRule(self, listener:ParseTreeListener):
1457             if hasattr( listener, "exitType_specifier" ):
1458                 listener.exitType_specifier(self)
1459
1460
1461
1462
1463     def type_specifier(self):
1464
1465         localctx = CParser.Type_specifierContext(self, self._ctx, self.state)
1466         self.enterRule(localctx, 16, self.RULE_type_specifier)
1467         try:
1468             self.state = 247
1469             self._errHandler.sync(self)
1470             la_ = self._interp.adaptivePredict(self._input,16,self._ctx)
1471             if la_ == 1:
1472                 self.enterOuterAlt(localctx, 1)
1473                 self.state = 223
1474                 self.match(CParser.T__10)
1475                 pass
1476
1477             elif la_ == 2:
1478                 self.enterOuterAlt(localctx, 2)
1479                 self.state = 224
1480                 self.match(CParser.T__11)
1481                 pass
1482
1483             elif la_ == 3:
1484                 self.enterOuterAlt(localctx, 3)
1485                 self.state = 225
1486                 self.match(CParser.T__12)
1487                 pass
1488
1489             elif la_ == 4:
1490                 self.enterOuterAlt(localctx, 4)
1491                 self.state = 226
1492                 self.match(CParser.T__13)
1493                 pass
1494
1495             elif la_ == 5:
1496                 self.enterOuterAlt(localctx, 5)
1497                 self.state = 227
1498                 self.match(CParser.T__14)
1499                 pass
1500
1501             elif la_ == 6:
1502                 self.enterOuterAlt(localctx, 6)
1503                 self.state = 228
1504                 self.match(CParser.T__15)
1505                 pass
1506
1507             elif la_ == 7:
1508                 self.enterOuterAlt(localctx, 7)
1509                 self.state = 229
1510                 self.match(CParser.T__16)
1511                 pass
1512
1513             elif la_ == 8:
1514                 self.enterOuterAlt(localctx, 8)
1515                 self.state = 230
1516                 self.match(CParser.T__17)
1517                 pass
1518
1519             elif la_ == 9:
1520                 self.enterOuterAlt(localctx, 9)
1521                 self.state = 231
1522                 self.match(CParser.T__18)
1523                 pass
1524
1525             elif la_ == 10:
1526                 self.enterOuterAlt(localctx, 10)
1527                 self.state = 232
1528                 localctx.s = self.struct_or_union_specifier()
1529
1530                 if localctx.s.stop is not None:
1531                     self.StoreStructUnionDefinition((None if localctx.s is None else localctx.s.start).line, (None if localctx.s is None else localctx.s.start).column, (None if localctx.s is None else localctx.s.stop).line, (None if localctx.s is None else localctx.s.stop).column, (None if localctx.s is None else self._input.getText((localctx.s.start,localctx.s.stop))))
1532
1533                 pass
1534
1535             elif la_ == 11:
1536                 self.enterOuterAlt(localctx, 11)
1537                 self.state = 235
1538                 localctx.e = self.enum_specifier()
1539
1540                 if localctx.e.stop is not None:
1541                     self.StoreEnumerationDefinition((None if localctx.e is None else localctx.e.start).line, (None if localctx.e is None else localctx.e.start).column, (None if localctx.e is None else localctx.e.stop).line, (None if localctx.e is None else localctx.e.stop).column, (None if localctx.e is None else self._input.getText((localctx.e.start,localctx.e.stop))))
1542
1543                 pass
1544
1545             elif la_ == 12:
1546                 self.enterOuterAlt(localctx, 12)
1547                 self.state = 238
1548                 self.match(CParser.IDENTIFIER)
1549                 self.state = 242
1550                 self._errHandler.sync(self)
1551                 _alt = self._interp.adaptivePredict(self._input,15,self._ctx)
1552                 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
1553                     if _alt==1:
1554                         self.state = 239
1555                         self.type_qualifier()
1556                     self.state = 244
1557                     self._errHandler.sync(self)
1558                     _alt = self._interp.adaptivePredict(self._input,15,self._ctx)
1559
1560                 self.state = 245
1561                 self.declarator()
1562                 pass
1563
1564             elif la_ == 13:
1565                 self.enterOuterAlt(localctx, 13)
1566                 self.state = 246
1567                 self.type_id()
1568                 pass
1569
1570
1571         except RecognitionException as re:
1572             localctx.exception = re
1573             self._errHandler.reportError(self, re)
1574             self._errHandler.recover(self, re)
1575         finally:
1576             self.exitRule()
1577         return localctx
1578
1579     class Type_idContext(ParserRuleContext):
1580
1581         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1582             super().__init__(parent, invokingState)
1583             self.parser = parser
1584
1585         def IDENTIFIER(self):
1586             return self.getToken(CParser.IDENTIFIER, 0)
1587
1588         def getRuleIndex(self):
1589             return CParser.RULE_type_id
1590
1591         def enterRule(self, listener:ParseTreeListener):
1592             if hasattr( listener, "enterType_id" ):
1593                 listener.enterType_id(self)
1594
1595         def exitRule(self, listener:ParseTreeListener):
1596             if hasattr( listener, "exitType_id" ):
1597                 listener.exitType_id(self)
1598
1599
1600
1601
1602     def type_id(self):
1603
1604         localctx = CParser.Type_idContext(self, self._ctx, self.state)
1605         self.enterRule(localctx, 18, self.RULE_type_id)
1606         try:
1607             self.enterOuterAlt(localctx, 1)
1608             self.state = 249
1609             self.match(CParser.IDENTIFIER)
1610         except RecognitionException as re:
1611             localctx.exception = re
1612             self._errHandler.reportError(self, re)
1613             self._errHandler.recover(self, re)
1614         finally:
1615             self.exitRule()
1616         return localctx
1617
1618     class Struct_or_union_specifierContext(ParserRuleContext):
1619
1620         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1621             super().__init__(parent, invokingState)
1622             self.parser = parser
1623
1624         def struct_or_union(self):
1625             return self.getTypedRuleContext(CParser.Struct_or_unionContext,0)
1626
1627
1628         def struct_declaration_list(self):
1629             return self.getTypedRuleContext(CParser.Struct_declaration_listContext,0)
1630
1631
1632         def IDENTIFIER(self):
1633             return self.getToken(CParser.IDENTIFIER, 0)
1634
1635         def getRuleIndex(self):
1636             return CParser.RULE_struct_or_union_specifier
1637
1638         def enterRule(self, listener:ParseTreeListener):
1639             if hasattr( listener, "enterStruct_or_union_specifier" ):
1640                 listener.enterStruct_or_union_specifier(self)
1641
1642         def exitRule(self, listener:ParseTreeListener):
1643             if hasattr( listener, "exitStruct_or_union_specifier" ):
1644                 listener.exitStruct_or_union_specifier(self)
1645
1646
1647
1648
1649     def struct_or_union_specifier(self):
1650
1651         localctx = CParser.Struct_or_union_specifierContext(self, self._ctx, self.state)
1652         self.enterRule(localctx, 20, self.RULE_struct_or_union_specifier)
1653         self._la = 0 # Token type
1654         try:
1655             self.state = 262
1656             self._errHandler.sync(self)
1657             la_ = self._interp.adaptivePredict(self._input,18,self._ctx)
1658             if la_ == 1:
1659                 self.enterOuterAlt(localctx, 1)
1660                 self.state = 251
1661                 self.struct_or_union()
1662                 self.state = 253
1663                 self._errHandler.sync(self)
1664                 _la = self._input.LA(1)
1665                 if _la==CParser.IDENTIFIER:
1666                     self.state = 252
1667                     self.match(CParser.IDENTIFIER)
1668
1669
1670                 self.state = 255
1671                 self.match(CParser.T__0)
1672                 self.state = 256
1673                 self.struct_declaration_list()
1674                 self.state = 257
1675                 self.match(CParser.T__19)
1676                 pass
1677
1678             elif la_ == 2:
1679                 self.enterOuterAlt(localctx, 2)
1680                 self.state = 259
1681                 self.struct_or_union()
1682                 self.state = 260
1683                 self.match(CParser.IDENTIFIER)
1684                 pass
1685
1686
1687         except RecognitionException as re:
1688             localctx.exception = re
1689             self._errHandler.reportError(self, re)
1690             self._errHandler.recover(self, re)
1691         finally:
1692             self.exitRule()
1693         return localctx
1694
1695     class Struct_or_unionContext(ParserRuleContext):
1696
1697         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1698             super().__init__(parent, invokingState)
1699             self.parser = parser
1700
1701
1702         def getRuleIndex(self):
1703             return CParser.RULE_struct_or_union
1704
1705         def enterRule(self, listener:ParseTreeListener):
1706             if hasattr( listener, "enterStruct_or_union" ):
1707                 listener.enterStruct_or_union(self)
1708
1709         def exitRule(self, listener:ParseTreeListener):
1710             if hasattr( listener, "exitStruct_or_union" ):
1711                 listener.exitStruct_or_union(self)
1712
1713
1714
1715
1716     def struct_or_union(self):
1717
1718         localctx = CParser.Struct_or_unionContext(self, self._ctx, self.state)
1719         self.enterRule(localctx, 22, self.RULE_struct_or_union)
1720         self._la = 0 # Token type
1721         try:
1722             self.enterOuterAlt(localctx, 1)
1723             self.state = 264
1724             _la = self._input.LA(1)
1725             if not(_la==CParser.T__20 or _la==CParser.T__21):
1726                 self._errHandler.recoverInline(self)
1727             else:
1728                 self._errHandler.reportMatch(self)
1729                 self.consume()
1730         except RecognitionException as re:
1731             localctx.exception = re
1732             self._errHandler.reportError(self, re)
1733             self._errHandler.recover(self, re)
1734         finally:
1735             self.exitRule()
1736         return localctx
1737
1738     class Struct_declaration_listContext(ParserRuleContext):
1739
1740         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1741             super().__init__(parent, invokingState)
1742             self.parser = parser
1743
1744         def struct_declaration(self, i:int=None):
1745             if i is None:
1746                 return self.getTypedRuleContexts(CParser.Struct_declarationContext)
1747             else:
1748                 return self.getTypedRuleContext(CParser.Struct_declarationContext,i)
1749
1750
1751         def getRuleIndex(self):
1752             return CParser.RULE_struct_declaration_list
1753
1754         def enterRule(self, listener:ParseTreeListener):
1755             if hasattr( listener, "enterStruct_declaration_list" ):
1756                 listener.enterStruct_declaration_list(self)
1757
1758         def exitRule(self, listener:ParseTreeListener):
1759             if hasattr( listener, "exitStruct_declaration_list" ):
1760                 listener.exitStruct_declaration_list(self)
1761
1762
1763
1764
1765     def struct_declaration_list(self):
1766
1767         localctx = CParser.Struct_declaration_listContext(self, self._ctx, self.state)
1768         self.enterRule(localctx, 24, self.RULE_struct_declaration_list)
1769         self._la = 0 # Token type
1770         try:
1771             self.enterOuterAlt(localctx, 1)
1772             self.state = 267
1773             self._errHandler.sync(self)
1774             _la = self._input.LA(1)
1775             while True:
1776                 self.state = 266
1777                 self.struct_declaration()
1778                 self.state = 269
1779                 self._errHandler.sync(self)
1780                 _la = self._input.LA(1)
1781                 if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__10) | (1 << CParser.T__11) | (1 << CParser.T__12) | (1 << CParser.T__13) | (1 << CParser.T__14) | (1 << CParser.T__15) | (1 << CParser.T__16) | (1 << CParser.T__17) | (1 << CParser.T__18) | (1 << CParser.T__20) | (1 << CParser.T__21) | (1 << CParser.T__23) | (1 << CParser.T__24) | (1 << CParser.T__25) | (1 << CParser.T__26) | (1 << CParser.T__27) | (1 << CParser.T__28) | (1 << CParser.T__29) | (1 << CParser.T__30) | (1 << CParser.T__31) | (1 << CParser.T__32) | (1 << CParser.T__33) | (1 << CParser.T__34) | (1 << CParser.T__35) | (1 << CParser.T__36))) != 0) or _la==CParser.IDENTIFIER):
1782                     break
1783
1784         except RecognitionException as re:
1785             localctx.exception = re
1786             self._errHandler.reportError(self, re)
1787             self._errHandler.recover(self, re)
1788         finally:
1789             self.exitRule()
1790         return localctx
1791
1792     class Struct_declarationContext(ParserRuleContext):
1793
1794         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1795             super().__init__(parent, invokingState)
1796             self.parser = parser
1797
1798         def specifier_qualifier_list(self):
1799             return self.getTypedRuleContext(CParser.Specifier_qualifier_listContext,0)
1800
1801
1802         def struct_declarator_list(self):
1803             return self.getTypedRuleContext(CParser.Struct_declarator_listContext,0)
1804
1805
1806         def getRuleIndex(self):
1807             return CParser.RULE_struct_declaration
1808
1809         def enterRule(self, listener:ParseTreeListener):
1810             if hasattr( listener, "enterStruct_declaration" ):
1811                 listener.enterStruct_declaration(self)
1812
1813         def exitRule(self, listener:ParseTreeListener):
1814             if hasattr( listener, "exitStruct_declaration" ):
1815                 listener.exitStruct_declaration(self)
1816
1817
1818
1819
1820     def struct_declaration(self):
1821
1822         localctx = CParser.Struct_declarationContext(self, self._ctx, self.state)
1823         self.enterRule(localctx, 26, self.RULE_struct_declaration)
1824         try:
1825             self.enterOuterAlt(localctx, 1)
1826             self.state = 271
1827             self.specifier_qualifier_list()
1828             self.state = 272
1829             self.struct_declarator_list()
1830             self.state = 273
1831             self.match(CParser.T__1)
1832         except RecognitionException as re:
1833             localctx.exception = re
1834             self._errHandler.reportError(self, re)
1835             self._errHandler.recover(self, re)
1836         finally:
1837             self.exitRule()
1838         return localctx
1839
1840     class Specifier_qualifier_listContext(ParserRuleContext):
1841
1842         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1843             super().__init__(parent, invokingState)
1844             self.parser = parser
1845
1846         def type_qualifier(self, i:int=None):
1847             if i is None:
1848                 return self.getTypedRuleContexts(CParser.Type_qualifierContext)
1849             else:
1850                 return self.getTypedRuleContext(CParser.Type_qualifierContext,i)
1851
1852
1853         def type_specifier(self, i:int=None):
1854             if i is None:
1855                 return self.getTypedRuleContexts(CParser.Type_specifierContext)
1856             else:
1857                 return self.getTypedRuleContext(CParser.Type_specifierContext,i)
1858
1859
1860         def getRuleIndex(self):
1861             return CParser.RULE_specifier_qualifier_list
1862
1863         def enterRule(self, listener:ParseTreeListener):
1864             if hasattr( listener, "enterSpecifier_qualifier_list" ):
1865                 listener.enterSpecifier_qualifier_list(self)
1866
1867         def exitRule(self, listener:ParseTreeListener):
1868             if hasattr( listener, "exitSpecifier_qualifier_list" ):
1869                 listener.exitSpecifier_qualifier_list(self)
1870
1871
1872
1873
1874     def specifier_qualifier_list(self):
1875
1876         localctx = CParser.Specifier_qualifier_listContext(self, self._ctx, self.state)
1877         self.enterRule(localctx, 28, self.RULE_specifier_qualifier_list)
1878         try:
1879             self.enterOuterAlt(localctx, 1)
1880             self.state = 277
1881             self._errHandler.sync(self)
1882             _alt = 1
1883             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
1884                 if _alt == 1:
1885                     self.state = 277
1886                     self._errHandler.sync(self)
1887                     token = self._input.LA(1)
1888                     if token in [CParser.T__24, CParser.T__25, CParser.T__26, CParser.T__27, CParser.T__28, CParser.T__29, CParser.T__30, CParser.T__31, CParser.T__32, CParser.T__33, CParser.T__34, CParser.T__35, CParser.T__36]:
1889                         self.state = 275
1890                         self.type_qualifier()
1891                         pass
1892                     elif token in [CParser.T__10, CParser.T__11, CParser.T__12, CParser.T__13, CParser.T__14, CParser.T__15, CParser.T__16, CParser.T__17, CParser.T__18, CParser.T__20, CParser.T__21, CParser.T__23, CParser.IDENTIFIER]:
1893                         self.state = 276
1894                         self.type_specifier()
1895                         pass
1896                     else:
1897                         raise NoViableAltException(self)
1898
1899
1900                 else:
1901                     raise NoViableAltException(self)
1902                 self.state = 279
1903                 self._errHandler.sync(self)
1904                 _alt = self._interp.adaptivePredict(self._input,21,self._ctx)
1905
1906         except RecognitionException as re:
1907             localctx.exception = re
1908             self._errHandler.reportError(self, re)
1909             self._errHandler.recover(self, re)
1910         finally:
1911             self.exitRule()
1912         return localctx
1913
1914     class Struct_declarator_listContext(ParserRuleContext):
1915
1916         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1917             super().__init__(parent, invokingState)
1918             self.parser = parser
1919
1920         def struct_declarator(self, i:int=None):
1921             if i is None:
1922                 return self.getTypedRuleContexts(CParser.Struct_declaratorContext)
1923             else:
1924                 return self.getTypedRuleContext(CParser.Struct_declaratorContext,i)
1925
1926
1927         def getRuleIndex(self):
1928             return CParser.RULE_struct_declarator_list
1929
1930         def enterRule(self, listener:ParseTreeListener):
1931             if hasattr( listener, "enterStruct_declarator_list" ):
1932                 listener.enterStruct_declarator_list(self)
1933
1934         def exitRule(self, listener:ParseTreeListener):
1935             if hasattr( listener, "exitStruct_declarator_list" ):
1936                 listener.exitStruct_declarator_list(self)
1937
1938
1939
1940
1941     def struct_declarator_list(self):
1942
1943         localctx = CParser.Struct_declarator_listContext(self, self._ctx, self.state)
1944         self.enterRule(localctx, 30, self.RULE_struct_declarator_list)
1945         self._la = 0 # Token type
1946         try:
1947             self.enterOuterAlt(localctx, 1)
1948             self.state = 281
1949             self.struct_declarator()
1950             self.state = 286
1951             self._errHandler.sync(self)
1952             _la = self._input.LA(1)
1953             while _la==CParser.T__3:
1954                 self.state = 282
1955                 self.match(CParser.T__3)
1956                 self.state = 283
1957                 self.struct_declarator()
1958                 self.state = 288
1959                 self._errHandler.sync(self)
1960                 _la = self._input.LA(1)
1961
1962         except RecognitionException as re:
1963             localctx.exception = re
1964             self._errHandler.reportError(self, re)
1965             self._errHandler.recover(self, re)
1966         finally:
1967             self.exitRule()
1968         return localctx
1969
1970     class Struct_declaratorContext(ParserRuleContext):
1971
1972         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1973             super().__init__(parent, invokingState)
1974             self.parser = parser
1975
1976         def declarator(self):
1977             return self.getTypedRuleContext(CParser.DeclaratorContext,0)
1978
1979
1980         def constant_expression(self):
1981             return self.getTypedRuleContext(CParser.Constant_expressionContext,0)
1982
1983
1984         def getRuleIndex(self):
1985             return CParser.RULE_struct_declarator
1986
1987         def enterRule(self, listener:ParseTreeListener):
1988             if hasattr( listener, "enterStruct_declarator" ):
1989                 listener.enterStruct_declarator(self)
1990
1991         def exitRule(self, listener:ParseTreeListener):
1992             if hasattr( listener, "exitStruct_declarator" ):
1993                 listener.exitStruct_declarator(self)
1994
1995
1996
1997
1998     def struct_declarator(self):
1999
2000         localctx = CParser.Struct_declaratorContext(self, self._ctx, self.state)
2001         self.enterRule(localctx, 32, self.RULE_struct_declarator)
2002         self._la = 0 # Token type
2003         try:
2004             self.state = 296
2005             self._errHandler.sync(self)
2006             token = self._input.LA(1)
2007             if token in [CParser.T__33, CParser.T__34, CParser.T__35, CParser.T__37, CParser.T__41, CParser.IDENTIFIER]:
2008                 self.enterOuterAlt(localctx, 1)
2009                 self.state = 289
2010                 self.declarator()
2011                 self.state = 292
2012                 self._errHandler.sync(self)
2013                 _la = self._input.LA(1)
2014                 if _la==CParser.T__22:
2015                     self.state = 290
2016                     self.match(CParser.T__22)
2017                     self.state = 291
2018                     self.constant_expression()
2019
2020
2021                 pass
2022             elif token in [CParser.T__22]:
2023                 self.enterOuterAlt(localctx, 2)
2024                 self.state = 294
2025                 self.match(CParser.T__22)
2026                 self.state = 295
2027                 self.constant_expression()
2028                 pass
2029             else:
2030                 raise NoViableAltException(self)
2031
2032         except RecognitionException as re:
2033             localctx.exception = re
2034             self._errHandler.reportError(self, re)
2035             self._errHandler.recover(self, re)
2036         finally:
2037             self.exitRule()
2038         return localctx
2039
2040     class Enum_specifierContext(ParserRuleContext):
2041
2042         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2043             super().__init__(parent, invokingState)
2044             self.parser = parser
2045
2046         def enumerator_list(self):
2047             return self.getTypedRuleContext(CParser.Enumerator_listContext,0)
2048
2049
2050         def IDENTIFIER(self):
2051             return self.getToken(CParser.IDENTIFIER, 0)
2052
2053         def getRuleIndex(self):
2054             return CParser.RULE_enum_specifier
2055
2056         def enterRule(self, listener:ParseTreeListener):
2057             if hasattr( listener, "enterEnum_specifier" ):
2058                 listener.enterEnum_specifier(self)
2059
2060         def exitRule(self, listener:ParseTreeListener):
2061             if hasattr( listener, "exitEnum_specifier" ):
2062                 listener.exitEnum_specifier(self)
2063
2064
2065
2066
2067     def enum_specifier(self):
2068
2069         localctx = CParser.Enum_specifierContext(self, self._ctx, self.state)
2070         self.enterRule(localctx, 34, self.RULE_enum_specifier)
2071         self._la = 0 # Token type
2072         try:
2073             self.state = 317
2074             self._errHandler.sync(self)
2075             la_ = self._interp.adaptivePredict(self._input,27,self._ctx)
2076             if la_ == 1:
2077                 self.enterOuterAlt(localctx, 1)
2078                 self.state = 298
2079                 self.match(CParser.T__23)
2080                 self.state = 299
2081                 self.match(CParser.T__0)
2082                 self.state = 300
2083                 self.enumerator_list()
2084                 self.state = 302
2085                 self._errHandler.sync(self)
2086                 _la = self._input.LA(1)
2087                 if _la==CParser.T__3:
2088                     self.state = 301
2089                     self.match(CParser.T__3)
2090
2091
2092                 self.state = 304
2093                 self.match(CParser.T__19)
2094                 pass
2095
2096             elif la_ == 2:
2097                 self.enterOuterAlt(localctx, 2)
2098                 self.state = 306
2099                 self.match(CParser.T__23)
2100                 self.state = 307
2101                 self.match(CParser.IDENTIFIER)
2102                 self.state = 308
2103                 self.match(CParser.T__0)
2104                 self.state = 309
2105                 self.enumerator_list()
2106                 self.state = 311
2107                 self._errHandler.sync(self)
2108                 _la = self._input.LA(1)
2109                 if _la==CParser.T__3:
2110                     self.state = 310
2111                     self.match(CParser.T__3)
2112
2113
2114                 self.state = 313
2115                 self.match(CParser.T__19)
2116                 pass
2117
2118             elif la_ == 3:
2119                 self.enterOuterAlt(localctx, 3)
2120                 self.state = 315
2121                 self.match(CParser.T__23)
2122                 self.state = 316
2123                 self.match(CParser.IDENTIFIER)
2124                 pass
2125
2126
2127         except RecognitionException as re:
2128             localctx.exception = re
2129             self._errHandler.reportError(self, re)
2130             self._errHandler.recover(self, re)
2131         finally:
2132             self.exitRule()
2133         return localctx
2134
2135     class Enumerator_listContext(ParserRuleContext):
2136
2137         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2138             super().__init__(parent, invokingState)
2139             self.parser = parser
2140
2141         def enumerator(self, i:int=None):
2142             if i is None:
2143                 return self.getTypedRuleContexts(CParser.EnumeratorContext)
2144             else:
2145                 return self.getTypedRuleContext(CParser.EnumeratorContext,i)
2146
2147
2148         def getRuleIndex(self):
2149             return CParser.RULE_enumerator_list
2150
2151         def enterRule(self, listener:ParseTreeListener):
2152             if hasattr( listener, "enterEnumerator_list" ):
2153                 listener.enterEnumerator_list(self)
2154
2155         def exitRule(self, listener:ParseTreeListener):
2156             if hasattr( listener, "exitEnumerator_list" ):
2157                 listener.exitEnumerator_list(self)
2158
2159
2160
2161
2162     def enumerator_list(self):
2163
2164         localctx = CParser.Enumerator_listContext(self, self._ctx, self.state)
2165         self.enterRule(localctx, 36, self.RULE_enumerator_list)
2166         try:
2167             self.enterOuterAlt(localctx, 1)
2168             self.state = 319
2169             self.enumerator()
2170             self.state = 324
2171             self._errHandler.sync(self)
2172             _alt = self._interp.adaptivePredict(self._input,28,self._ctx)
2173             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
2174                 if _alt==1:
2175                     self.state = 320
2176                     self.match(CParser.T__3)
2177                     self.state = 321
2178                     self.enumerator()
2179                 self.state = 326
2180                 self._errHandler.sync(self)
2181                 _alt = self._interp.adaptivePredict(self._input,28,self._ctx)
2182
2183         except RecognitionException as re:
2184             localctx.exception = re
2185             self._errHandler.reportError(self, re)
2186             self._errHandler.recover(self, re)
2187         finally:
2188             self.exitRule()
2189         return localctx
2190
2191     class EnumeratorContext(ParserRuleContext):
2192
2193         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2194             super().__init__(parent, invokingState)
2195             self.parser = parser
2196
2197         def IDENTIFIER(self):
2198             return self.getToken(CParser.IDENTIFIER, 0)
2199
2200         def constant_expression(self):
2201             return self.getTypedRuleContext(CParser.Constant_expressionContext,0)
2202
2203
2204         def getRuleIndex(self):
2205             return CParser.RULE_enumerator
2206
2207         def enterRule(self, listener:ParseTreeListener):
2208             if hasattr( listener, "enterEnumerator" ):
2209                 listener.enterEnumerator(self)
2210
2211         def exitRule(self, listener:ParseTreeListener):
2212             if hasattr( listener, "exitEnumerator" ):
2213                 listener.exitEnumerator(self)
2214
2215
2216
2217
2218     def enumerator(self):
2219
2220         localctx = CParser.EnumeratorContext(self, self._ctx, self.state)
2221         self.enterRule(localctx, 38, self.RULE_enumerator)
2222         self._la = 0 # Token type
2223         try:
2224             self.enterOuterAlt(localctx, 1)
2225             self.state = 327
2226             self.match(CParser.IDENTIFIER)
2227             self.state = 330
2228             self._errHandler.sync(self)
2229             _la = self._input.LA(1)
2230             if _la==CParser.T__4:
2231                 self.state = 328
2232                 self.match(CParser.T__4)
2233                 self.state = 329
2234                 self.constant_expression()
2235
2236
2237         except RecognitionException as re:
2238             localctx.exception = re
2239             self._errHandler.reportError(self, re)
2240             self._errHandler.recover(self, re)
2241         finally:
2242             self.exitRule()
2243         return localctx
2244
2245     class Type_qualifierContext(ParserRuleContext):
2246
2247         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2248             super().__init__(parent, invokingState)
2249             self.parser = parser
2250
2251
2252         def getRuleIndex(self):
2253             return CParser.RULE_type_qualifier
2254
2255         def enterRule(self, listener:ParseTreeListener):
2256             if hasattr( listener, "enterType_qualifier" ):
2257                 listener.enterType_qualifier(self)
2258
2259         def exitRule(self, listener:ParseTreeListener):
2260             if hasattr( listener, "exitType_qualifier" ):
2261                 listener.exitType_qualifier(self)
2262
2263
2264
2265
2266     def type_qualifier(self):
2267
2268         localctx = CParser.Type_qualifierContext(self, self._ctx, self.state)
2269         self.enterRule(localctx, 40, self.RULE_type_qualifier)
2270         self._la = 0 # Token type
2271         try:
2272             self.enterOuterAlt(localctx, 1)
2273             self.state = 332
2274             _la = self._input.LA(1)
2275             if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__24) | (1 << CParser.T__25) | (1 << CParser.T__26) | (1 << CParser.T__27) | (1 << CParser.T__28) | (1 << CParser.T__29) | (1 << CParser.T__30) | (1 << CParser.T__31) | (1 << CParser.T__32) | (1 << CParser.T__33) | (1 << CParser.T__34) | (1 << CParser.T__35) | (1 << CParser.T__36))) != 0)):
2276                 self._errHandler.recoverInline(self)
2277             else:
2278                 self._errHandler.reportMatch(self)
2279                 self.consume()
2280         except RecognitionException as re:
2281             localctx.exception = re
2282             self._errHandler.reportError(self, re)
2283             self._errHandler.recover(self, re)
2284         finally:
2285             self.exitRule()
2286         return localctx
2287
2288     class DeclaratorContext(ParserRuleContext):
2289
2290         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2291             super().__init__(parent, invokingState)
2292             self.parser = parser
2293
2294         def direct_declarator(self):
2295             return self.getTypedRuleContext(CParser.Direct_declaratorContext,0)
2296
2297
2298         def pointer(self):
2299             return self.getTypedRuleContext(CParser.PointerContext,0)
2300
2301
2302         def getRuleIndex(self):
2303             return CParser.RULE_declarator
2304
2305         def enterRule(self, listener:ParseTreeListener):
2306             if hasattr( listener, "enterDeclarator" ):
2307                 listener.enterDeclarator(self)
2308
2309         def exitRule(self, listener:ParseTreeListener):
2310             if hasattr( listener, "exitDeclarator" ):
2311                 listener.exitDeclarator(self)
2312
2313
2314
2315
2316     def declarator(self):
2317
2318         localctx = CParser.DeclaratorContext(self, self._ctx, self.state)
2319         self.enterRule(localctx, 42, self.RULE_declarator)
2320         self._la = 0 # Token type
2321         try:
2322             self.state = 348
2323             self._errHandler.sync(self)
2324             la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
2325             if la_ == 1:
2326                 self.enterOuterAlt(localctx, 1)
2327                 self.state = 335
2328                 self._errHandler.sync(self)
2329                 _la = self._input.LA(1)
2330                 if _la==CParser.T__41:
2331                     self.state = 334
2332                     self.pointer()
2333
2334
2335                 self.state = 338
2336                 self._errHandler.sync(self)
2337                 _la = self._input.LA(1)
2338                 if _la==CParser.T__33:
2339                     self.state = 337
2340                     self.match(CParser.T__33)
2341
2342
2343                 self.state = 341
2344                 self._errHandler.sync(self)
2345                 _la = self._input.LA(1)
2346                 if _la==CParser.T__34:
2347                     self.state = 340
2348                     self.match(CParser.T__34)
2349
2350
2351                 self.state = 344
2352                 self._errHandler.sync(self)
2353                 _la = self._input.LA(1)
2354                 if _la==CParser.T__35:
2355                     self.state = 343
2356                     self.match(CParser.T__35)
2357
2358
2359                 self.state = 346
2360                 self.direct_declarator()
2361                 pass
2362
2363             elif la_ == 2:
2364                 self.enterOuterAlt(localctx, 2)
2365                 self.state = 347
2366                 self.pointer()
2367                 pass
2368
2369
2370         except RecognitionException as re:
2371             localctx.exception = re
2372             self._errHandler.reportError(self, re)
2373             self._errHandler.recover(self, re)
2374         finally:
2375             self.exitRule()
2376         return localctx
2377
2378     class Direct_declaratorContext(ParserRuleContext):
2379
2380         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2381             super().__init__(parent, invokingState)
2382             self.parser = parser
2383
2384         def IDENTIFIER(self):
2385             return self.getToken(CParser.IDENTIFIER, 0)
2386
2387         def declarator_suffix(self, i:int=None):
2388             if i is None:
2389                 return self.getTypedRuleContexts(CParser.Declarator_suffixContext)
2390             else:
2391                 return self.getTypedRuleContext(CParser.Declarator_suffixContext,i)
2392
2393
2394         def declarator(self):
2395             return self.getTypedRuleContext(CParser.DeclaratorContext,0)
2396
2397
2398         def getRuleIndex(self):
2399             return CParser.RULE_direct_declarator
2400
2401         def enterRule(self, listener:ParseTreeListener):
2402             if hasattr( listener, "enterDirect_declarator" ):
2403                 listener.enterDirect_declarator(self)
2404
2405         def exitRule(self, listener:ParseTreeListener):
2406             if hasattr( listener, "exitDirect_declarator" ):
2407                 listener.exitDirect_declarator(self)
2408
2409
2410
2411
2412     def direct_declarator(self):
2413
2414         localctx = CParser.Direct_declaratorContext(self, self._ctx, self.state)
2415         self.enterRule(localctx, 44, self.RULE_direct_declarator)
2416         try:
2417             self.state = 368
2418             self._errHandler.sync(self)
2419             token = self._input.LA(1)
2420             if token in [CParser.IDENTIFIER]:
2421                 self.enterOuterAlt(localctx, 1)
2422                 self.state = 350
2423                 self.match(CParser.IDENTIFIER)
2424                 self.state = 354
2425                 self._errHandler.sync(self)
2426                 _alt = self._interp.adaptivePredict(self._input,35,self._ctx)
2427                 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
2428                     if _alt==1:
2429                         self.state = 351
2430                         self.declarator_suffix()
2431                     self.state = 356
2432                     self._errHandler.sync(self)
2433                     _alt = self._interp.adaptivePredict(self._input,35,self._ctx)
2434
2435                 pass
2436             elif token in [CParser.T__37]:
2437                 self.enterOuterAlt(localctx, 2)
2438                 self.state = 357
2439                 self.match(CParser.T__37)
2440                 self.state = 359
2441                 self._errHandler.sync(self)
2442                 la_ = self._interp.adaptivePredict(self._input,36,self._ctx)
2443                 if la_ == 1:
2444                     self.state = 358
2445                     self.match(CParser.T__33)
2446
2447
2448                 self.state = 361
2449                 self.declarator()
2450                 self.state = 362
2451                 self.match(CParser.T__38)
2452                 self.state = 364
2453                 self._errHandler.sync(self)
2454                 _alt = 1
2455                 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
2456                     if _alt == 1:
2457                         self.state = 363
2458                         self.declarator_suffix()
2459
2460                     else:
2461                         raise NoViableAltException(self)
2462                     self.state = 366
2463                     self._errHandler.sync(self)
2464                     _alt = self._interp.adaptivePredict(self._input,37,self._ctx)
2465
2466                 pass
2467             else:
2468                 raise NoViableAltException(self)
2469
2470         except RecognitionException as re:
2471             localctx.exception = re
2472             self._errHandler.reportError(self, re)
2473             self._errHandler.recover(self, re)
2474         finally:
2475             self.exitRule()
2476         return localctx
2477
2478     class Declarator_suffixContext(ParserRuleContext):
2479
2480         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2481             super().__init__(parent, invokingState)
2482             self.parser = parser
2483
2484         def constant_expression(self):
2485             return self.getTypedRuleContext(CParser.Constant_expressionContext,0)
2486
2487
2488         def parameter_type_list(self):
2489             return self.getTypedRuleContext(CParser.Parameter_type_listContext,0)
2490
2491
2492         def identifier_list(self):
2493             return self.getTypedRuleContext(CParser.Identifier_listContext,0)
2494
2495
2496         def getRuleIndex(self):
2497             return CParser.RULE_declarator_suffix
2498
2499         def enterRule(self, listener:ParseTreeListener):
2500             if hasattr( listener, "enterDeclarator_suffix" ):
2501                 listener.enterDeclarator_suffix(self)
2502
2503         def exitRule(self, listener:ParseTreeListener):
2504             if hasattr( listener, "exitDeclarator_suffix" ):
2505                 listener.exitDeclarator_suffix(self)
2506
2507
2508
2509
2510     def declarator_suffix(self):
2511
2512         localctx = CParser.Declarator_suffixContext(self, self._ctx, self.state)
2513         self.enterRule(localctx, 46, self.RULE_declarator_suffix)
2514         try:
2515             self.state = 386
2516             self._errHandler.sync(self)
2517             la_ = self._interp.adaptivePredict(self._input,39,self._ctx)
2518             if la_ == 1:
2519                 self.enterOuterAlt(localctx, 1)
2520                 self.state = 370
2521                 self.match(CParser.T__39)
2522                 self.state = 371
2523                 self.constant_expression()
2524                 self.state = 372
2525                 self.match(CParser.T__40)
2526                 pass
2527
2528             elif la_ == 2:
2529                 self.enterOuterAlt(localctx, 2)
2530                 self.state = 374
2531                 self.match(CParser.T__39)
2532                 self.state = 375
2533                 self.match(CParser.T__40)
2534                 pass
2535
2536             elif la_ == 3:
2537                 self.enterOuterAlt(localctx, 3)
2538                 self.state = 376
2539                 self.match(CParser.T__37)
2540                 self.state = 377
2541                 self.parameter_type_list()
2542                 self.state = 378
2543                 self.match(CParser.T__38)
2544                 pass
2545
2546             elif la_ == 4:
2547                 self.enterOuterAlt(localctx, 4)
2548                 self.state = 380
2549                 self.match(CParser.T__37)
2550                 self.state = 381
2551                 self.identifier_list()
2552                 self.state = 382
2553                 self.match(CParser.T__38)
2554                 pass
2555
2556             elif la_ == 5:
2557                 self.enterOuterAlt(localctx, 5)
2558                 self.state = 384
2559                 self.match(CParser.T__37)
2560                 self.state = 385
2561                 self.match(CParser.T__38)
2562                 pass
2563
2564
2565         except RecognitionException as re:
2566             localctx.exception = re
2567             self._errHandler.reportError(self, re)
2568             self._errHandler.recover(self, re)
2569         finally:
2570             self.exitRule()
2571         return localctx
2572
2573     class PointerContext(ParserRuleContext):
2574
2575         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2576             super().__init__(parent, invokingState)
2577             self.parser = parser
2578
2579         def type_qualifier(self, i:int=None):
2580             if i is None:
2581                 return self.getTypedRuleContexts(CParser.Type_qualifierContext)
2582             else:
2583                 return self.getTypedRuleContext(CParser.Type_qualifierContext,i)
2584
2585
2586         def pointer(self):
2587             return self.getTypedRuleContext(CParser.PointerContext,0)
2588
2589
2590         def getRuleIndex(self):
2591             return CParser.RULE_pointer
2592
2593         def enterRule(self, listener:ParseTreeListener):
2594             if hasattr( listener, "enterPointer" ):
2595                 listener.enterPointer(self)
2596
2597         def exitRule(self, listener:ParseTreeListener):
2598             if hasattr( listener, "exitPointer" ):
2599                 listener.exitPointer(self)
2600
2601
2602
2603
2604     def pointer(self):
2605
2606         localctx = CParser.PointerContext(self, self._ctx, self.state)
2607         self.enterRule(localctx, 48, self.RULE_pointer)
2608         try:
2609             self.state = 400
2610             self._errHandler.sync(self)
2611             la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
2612             if la_ == 1:
2613                 self.enterOuterAlt(localctx, 1)
2614                 self.state = 388
2615                 self.match(CParser.T__41)
2616                 self.state = 390
2617                 self._errHandler.sync(self)
2618                 _alt = 1
2619                 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
2620                     if _alt == 1:
2621                         self.state = 389
2622                         self.type_qualifier()
2623
2624                     else:
2625                         raise NoViableAltException(self)
2626                     self.state = 392
2627                     self._errHandler.sync(self)
2628                     _alt = self._interp.adaptivePredict(self._input,40,self._ctx)
2629
2630                 self.state = 395
2631                 self._errHandler.sync(self)
2632                 la_ = self._interp.adaptivePredict(self._input,41,self._ctx)
2633                 if la_ == 1:
2634                     self.state = 394
2635                     self.pointer()
2636
2637
2638                 pass
2639
2640             elif la_ == 2:
2641                 self.enterOuterAlt(localctx, 2)
2642                 self.state = 397
2643                 self.match(CParser.T__41)
2644                 self.state = 398
2645                 self.pointer()
2646                 pass
2647
2648             elif la_ == 3:
2649                 self.enterOuterAlt(localctx, 3)
2650                 self.state = 399
2651                 self.match(CParser.T__41)
2652                 pass
2653
2654
2655         except RecognitionException as re:
2656             localctx.exception = re
2657             self._errHandler.reportError(self, re)
2658             self._errHandler.recover(self, re)
2659         finally:
2660             self.exitRule()
2661         return localctx
2662
2663     class Parameter_type_listContext(ParserRuleContext):
2664
2665         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2666             super().__init__(parent, invokingState)
2667             self.parser = parser
2668
2669         def parameter_list(self):
2670             return self.getTypedRuleContext(CParser.Parameter_listContext,0)
2671
2672
2673         def getRuleIndex(self):
2674             return CParser.RULE_parameter_type_list
2675
2676         def enterRule(self, listener:ParseTreeListener):
2677             if hasattr( listener, "enterParameter_type_list" ):
2678                 listener.enterParameter_type_list(self)
2679
2680         def exitRule(self, listener:ParseTreeListener):
2681             if hasattr( listener, "exitParameter_type_list" ):
2682                 listener.exitParameter_type_list(self)
2683
2684
2685
2686
2687     def parameter_type_list(self):
2688
2689         localctx = CParser.Parameter_type_listContext(self, self._ctx, self.state)
2690         self.enterRule(localctx, 50, self.RULE_parameter_type_list)
2691         self._la = 0 # Token type
2692         try:
2693             self.enterOuterAlt(localctx, 1)
2694             self.state = 402
2695             self.parameter_list()
2696             self.state = 408
2697             self._errHandler.sync(self)
2698             _la = self._input.LA(1)
2699             if _la==CParser.T__3:
2700                 self.state = 403
2701                 self.match(CParser.T__3)
2702                 self.state = 405
2703                 self._errHandler.sync(self)
2704                 _la = self._input.LA(1)
2705                 if _la==CParser.T__28:
2706                     self.state = 404
2707                     self.match(CParser.T__28)
2708
2709
2710                 self.state = 407
2711                 self.match(CParser.T__42)
2712
2713
2714         except RecognitionException as re:
2715             localctx.exception = re
2716             self._errHandler.reportError(self, re)
2717             self._errHandler.recover(self, re)
2718         finally:
2719             self.exitRule()
2720         return localctx
2721
2722     class Parameter_listContext(ParserRuleContext):
2723
2724         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2725             super().__init__(parent, invokingState)
2726             self.parser = parser
2727
2728         def parameter_declaration(self, i:int=None):
2729             if i is None:
2730                 return self.getTypedRuleContexts(CParser.Parameter_declarationContext)
2731             else:
2732                 return self.getTypedRuleContext(CParser.Parameter_declarationContext,i)
2733
2734
2735         def getRuleIndex(self):
2736             return CParser.RULE_parameter_list
2737
2738         def enterRule(self, listener:ParseTreeListener):
2739             if hasattr( listener, "enterParameter_list" ):
2740                 listener.enterParameter_list(self)
2741
2742         def exitRule(self, listener:ParseTreeListener):
2743             if hasattr( listener, "exitParameter_list" ):
2744                 listener.exitParameter_list(self)
2745
2746
2747
2748
2749     def parameter_list(self):
2750
2751         localctx = CParser.Parameter_listContext(self, self._ctx, self.state)
2752         self.enterRule(localctx, 52, self.RULE_parameter_list)
2753         try:
2754             self.enterOuterAlt(localctx, 1)
2755             self.state = 410
2756             self.parameter_declaration()
2757             self.state = 418
2758             self._errHandler.sync(self)
2759             _alt = self._interp.adaptivePredict(self._input,46,self._ctx)
2760             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
2761                 if _alt==1:
2762                     self.state = 411
2763                     self.match(CParser.T__3)
2764                     self.state = 413
2765                     self._errHandler.sync(self)
2766                     la_ = self._interp.adaptivePredict(self._input,45,self._ctx)
2767                     if la_ == 1:
2768                         self.state = 412
2769                         self.match(CParser.T__28)
2770
2771
2772                     self.state = 415
2773                     self.parameter_declaration()
2774                 self.state = 420
2775                 self._errHandler.sync(self)
2776                 _alt = self._interp.adaptivePredict(self._input,46,self._ctx)
2777
2778         except RecognitionException as re:
2779             localctx.exception = re
2780             self._errHandler.reportError(self, re)
2781             self._errHandler.recover(self, re)
2782         finally:
2783             self.exitRule()
2784         return localctx
2785
2786     class Parameter_declarationContext(ParserRuleContext):
2787
2788         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2789             super().__init__(parent, invokingState)
2790             self.parser = parser
2791
2792         def declaration_specifiers(self):
2793             return self.getTypedRuleContext(CParser.Declaration_specifiersContext,0)
2794
2795
2796         def declarator(self, i:int=None):
2797             if i is None:
2798                 return self.getTypedRuleContexts(CParser.DeclaratorContext)
2799             else:
2800                 return self.getTypedRuleContext(CParser.DeclaratorContext,i)
2801
2802
2803         def abstract_declarator(self, i:int=None):
2804             if i is None:
2805                 return self.getTypedRuleContexts(CParser.Abstract_declaratorContext)
2806             else:
2807                 return self.getTypedRuleContext(CParser.Abstract_declaratorContext,i)
2808
2809
2810         def IDENTIFIER(self):
2811             return self.getToken(CParser.IDENTIFIER, 0)
2812
2813         def pointer(self, i:int=None):
2814             if i is None:
2815                 return self.getTypedRuleContexts(CParser.PointerContext)
2816             else:
2817                 return self.getTypedRuleContext(CParser.PointerContext,i)
2818
2819
2820         def getRuleIndex(self):
2821             return CParser.RULE_parameter_declaration
2822
2823         def enterRule(self, listener:ParseTreeListener):
2824             if hasattr( listener, "enterParameter_declaration" ):
2825                 listener.enterParameter_declaration(self)
2826
2827         def exitRule(self, listener:ParseTreeListener):
2828             if hasattr( listener, "exitParameter_declaration" ):
2829                 listener.exitParameter_declaration(self)
2830
2831
2832
2833
2834     def parameter_declaration(self):
2835
2836         localctx = CParser.Parameter_declarationContext(self, self._ctx, self.state)
2837         self.enterRule(localctx, 54, self.RULE_parameter_declaration)
2838         self._la = 0 # Token type
2839         try:
2840             self.state = 439
2841             self._errHandler.sync(self)
2842             la_ = self._interp.adaptivePredict(self._input,51,self._ctx)
2843             if la_ == 1:
2844                 self.enterOuterAlt(localctx, 1)
2845                 self.state = 421
2846                 self.declaration_specifiers()
2847                 self.state = 426
2848                 self._errHandler.sync(self)
2849                 _la = self._input.LA(1)
2850                 while ((((_la - 34)) & ~0x3f) == 0 and ((1 << (_la - 34)) & ((1 << (CParser.T__33 - 34)) | (1 << (CParser.T__34 - 34)) | (1 << (CParser.T__35 - 34)) | (1 << (CParser.T__37 - 34)) | (1 << (CParser.T__39 - 34)) | (1 << (CParser.T__41 - 34)) | (1 << (CParser.IDENTIFIER - 34)))) != 0):
2851                     self.state = 424
2852                     self._errHandler.sync(self)
2853                     la_ = self._interp.adaptivePredict(self._input,47,self._ctx)
2854                     if la_ == 1:
2855                         self.state = 422
2856                         self.declarator()
2857                         pass
2858
2859                     elif la_ == 2:
2860                         self.state = 423
2861                         self.abstract_declarator()
2862                         pass
2863
2864
2865                     self.state = 428
2866                     self._errHandler.sync(self)
2867                     _la = self._input.LA(1)
2868
2869                 self.state = 430
2870                 self._errHandler.sync(self)
2871                 _la = self._input.LA(1)
2872                 if _la==CParser.T__28:
2873                     self.state = 429
2874                     self.match(CParser.T__28)
2875
2876
2877                 pass
2878
2879             elif la_ == 2:
2880                 self.enterOuterAlt(localctx, 2)
2881                 self.state = 435
2882                 self._errHandler.sync(self)
2883                 _la = self._input.LA(1)
2884                 while _la==CParser.T__41:
2885                     self.state = 432
2886                     self.pointer()
2887                     self.state = 437
2888                     self._errHandler.sync(self)
2889                     _la = self._input.LA(1)
2890
2891                 self.state = 438
2892                 self.match(CParser.IDENTIFIER)
2893                 pass
2894
2895
2896         except RecognitionException as re:
2897             localctx.exception = re
2898             self._errHandler.reportError(self, re)
2899             self._errHandler.recover(self, re)
2900         finally:
2901             self.exitRule()
2902         return localctx
2903
2904     class Identifier_listContext(ParserRuleContext):
2905
2906         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2907             super().__init__(parent, invokingState)
2908             self.parser = parser
2909
2910         def IDENTIFIER(self, i:int=None):
2911             if i is None:
2912                 return self.getTokens(CParser.IDENTIFIER)
2913             else:
2914                 return self.getToken(CParser.IDENTIFIER, i)
2915
2916         def getRuleIndex(self):
2917             return CParser.RULE_identifier_list
2918
2919         def enterRule(self, listener:ParseTreeListener):
2920             if hasattr( listener, "enterIdentifier_list" ):
2921                 listener.enterIdentifier_list(self)
2922
2923         def exitRule(self, listener:ParseTreeListener):
2924             if hasattr( listener, "exitIdentifier_list" ):
2925                 listener.exitIdentifier_list(self)
2926
2927
2928
2929
2930     def identifier_list(self):
2931
2932         localctx = CParser.Identifier_listContext(self, self._ctx, self.state)
2933         self.enterRule(localctx, 56, self.RULE_identifier_list)
2934         self._la = 0 # Token type
2935         try:
2936             self.enterOuterAlt(localctx, 1)
2937             self.state = 441
2938             self.match(CParser.IDENTIFIER)
2939             self.state = 446
2940             self._errHandler.sync(self)
2941             _la = self._input.LA(1)
2942             while _la==CParser.T__3:
2943                 self.state = 442
2944                 self.match(CParser.T__3)
2945                 self.state = 443
2946                 self.match(CParser.IDENTIFIER)
2947                 self.state = 448
2948                 self._errHandler.sync(self)
2949                 _la = self._input.LA(1)
2950
2951         except RecognitionException as re:
2952             localctx.exception = re
2953             self._errHandler.reportError(self, re)
2954             self._errHandler.recover(self, re)
2955         finally:
2956             self.exitRule()
2957         return localctx
2958
2959     class Type_nameContext(ParserRuleContext):
2960
2961         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2962             super().__init__(parent, invokingState)
2963             self.parser = parser
2964
2965         def specifier_qualifier_list(self):
2966             return self.getTypedRuleContext(CParser.Specifier_qualifier_listContext,0)
2967
2968
2969         def abstract_declarator(self):
2970             return self.getTypedRuleContext(CParser.Abstract_declaratorContext,0)
2971
2972
2973         def type_id(self):
2974             return self.getTypedRuleContext(CParser.Type_idContext,0)
2975
2976
2977         def getRuleIndex(self):
2978             return CParser.RULE_type_name
2979
2980         def enterRule(self, listener:ParseTreeListener):
2981             if hasattr( listener, "enterType_name" ):
2982                 listener.enterType_name(self)
2983
2984         def exitRule(self, listener:ParseTreeListener):
2985             if hasattr( listener, "exitType_name" ):
2986                 listener.exitType_name(self)
2987
2988
2989
2990
2991     def type_name(self):
2992
2993         localctx = CParser.Type_nameContext(self, self._ctx, self.state)
2994         self.enterRule(localctx, 58, self.RULE_type_name)
2995         self._la = 0 # Token type
2996         try:
2997             self.state = 454
2998             self._errHandler.sync(self)
2999             la_ = self._interp.adaptivePredict(self._input,54,self._ctx)
3000             if la_ == 1:
3001                 self.enterOuterAlt(localctx, 1)
3002                 self.state = 449
3003                 self.specifier_qualifier_list()
3004                 self.state = 451
3005                 self._errHandler.sync(self)
3006                 _la = self._input.LA(1)
3007                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__37) | (1 << CParser.T__39) | (1 << CParser.T__41))) != 0):
3008                     self.state = 450
3009                     self.abstract_declarator()
3010
3011
3012                 pass
3013
3014             elif la_ == 2:
3015                 self.enterOuterAlt(localctx, 2)
3016                 self.state = 453
3017                 self.type_id()
3018                 pass
3019
3020
3021         except RecognitionException as re:
3022             localctx.exception = re
3023             self._errHandler.reportError(self, re)
3024             self._errHandler.recover(self, re)
3025         finally:
3026             self.exitRule()
3027         return localctx
3028
3029     class Abstract_declaratorContext(ParserRuleContext):
3030
3031         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3032             super().__init__(parent, invokingState)
3033             self.parser = parser
3034
3035         def pointer(self):
3036             return self.getTypedRuleContext(CParser.PointerContext,0)
3037
3038
3039         def direct_abstract_declarator(self):
3040             return self.getTypedRuleContext(CParser.Direct_abstract_declaratorContext,0)
3041
3042
3043         def getRuleIndex(self):
3044             return CParser.RULE_abstract_declarator
3045
3046         def enterRule(self, listener:ParseTreeListener):
3047             if hasattr( listener, "enterAbstract_declarator" ):
3048                 listener.enterAbstract_declarator(self)
3049
3050         def exitRule(self, listener:ParseTreeListener):
3051             if hasattr( listener, "exitAbstract_declarator" ):
3052                 listener.exitAbstract_declarator(self)
3053
3054
3055
3056
3057     def abstract_declarator(self):
3058
3059         localctx = CParser.Abstract_declaratorContext(self, self._ctx, self.state)
3060         self.enterRule(localctx, 60, self.RULE_abstract_declarator)
3061         try:
3062             self.state = 461
3063             self._errHandler.sync(self)
3064             token = self._input.LA(1)
3065             if token in [CParser.T__41]:
3066                 self.enterOuterAlt(localctx, 1)
3067                 self.state = 456
3068                 self.pointer()
3069                 self.state = 458
3070                 self._errHandler.sync(self)
3071                 la_ = self._interp.adaptivePredict(self._input,55,self._ctx)
3072                 if la_ == 1:
3073                     self.state = 457
3074                     self.direct_abstract_declarator()
3075
3076
3077                 pass
3078             elif token in [CParser.T__37, CParser.T__39]:
3079                 self.enterOuterAlt(localctx, 2)
3080                 self.state = 460
3081                 self.direct_abstract_declarator()
3082                 pass
3083             else:
3084                 raise NoViableAltException(self)
3085
3086         except RecognitionException as re:
3087             localctx.exception = re
3088             self._errHandler.reportError(self, re)
3089             self._errHandler.recover(self, re)
3090         finally:
3091             self.exitRule()
3092         return localctx
3093
3094     class Direct_abstract_declaratorContext(ParserRuleContext):
3095
3096         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3097             super().__init__(parent, invokingState)
3098             self.parser = parser
3099
3100         def abstract_declarator(self):
3101             return self.getTypedRuleContext(CParser.Abstract_declaratorContext,0)
3102
3103
3104         def abstract_declarator_suffix(self, i:int=None):
3105             if i is None:
3106                 return self.getTypedRuleContexts(CParser.Abstract_declarator_suffixContext)
3107             else:
3108                 return self.getTypedRuleContext(CParser.Abstract_declarator_suffixContext,i)
3109
3110
3111         def getRuleIndex(self):
3112             return CParser.RULE_direct_abstract_declarator
3113
3114         def enterRule(self, listener:ParseTreeListener):
3115             if hasattr( listener, "enterDirect_abstract_declarator" ):
3116                 listener.enterDirect_abstract_declarator(self)
3117
3118         def exitRule(self, listener:ParseTreeListener):
3119             if hasattr( listener, "exitDirect_abstract_declarator" ):
3120                 listener.exitDirect_abstract_declarator(self)
3121
3122
3123
3124
3125     def direct_abstract_declarator(self):
3126
3127         localctx = CParser.Direct_abstract_declaratorContext(self, self._ctx, self.state)
3128         self.enterRule(localctx, 62, self.RULE_direct_abstract_declarator)
3129         try:
3130             self.enterOuterAlt(localctx, 1)
3131             self.state = 468
3132             self._errHandler.sync(self)
3133             la_ = self._interp.adaptivePredict(self._input,57,self._ctx)
3134             if la_ == 1:
3135                 self.state = 463
3136                 self.match(CParser.T__37)
3137                 self.state = 464
3138                 self.abstract_declarator()
3139                 self.state = 465
3140                 self.match(CParser.T__38)
3141                 pass
3142
3143             elif la_ == 2:
3144                 self.state = 467
3145                 self.abstract_declarator_suffix()
3146                 pass
3147
3148
3149             self.state = 473
3150             self._errHandler.sync(self)
3151             _alt = self._interp.adaptivePredict(self._input,58,self._ctx)
3152             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
3153                 if _alt==1:
3154                     self.state = 470
3155                     self.abstract_declarator_suffix()
3156                 self.state = 475
3157                 self._errHandler.sync(self)
3158                 _alt = self._interp.adaptivePredict(self._input,58,self._ctx)
3159
3160         except RecognitionException as re:
3161             localctx.exception = re
3162             self._errHandler.reportError(self, re)
3163             self._errHandler.recover(self, re)
3164         finally:
3165             self.exitRule()
3166         return localctx
3167
3168     class Abstract_declarator_suffixContext(ParserRuleContext):
3169
3170         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3171             super().__init__(parent, invokingState)
3172             self.parser = parser
3173
3174         def constant_expression(self):
3175             return self.getTypedRuleContext(CParser.Constant_expressionContext,0)
3176
3177
3178         def parameter_type_list(self):
3179             return self.getTypedRuleContext(CParser.Parameter_type_listContext,0)
3180
3181
3182         def getRuleIndex(self):
3183             return CParser.RULE_abstract_declarator_suffix
3184
3185         def enterRule(self, listener:ParseTreeListener):
3186             if hasattr( listener, "enterAbstract_declarator_suffix" ):
3187                 listener.enterAbstract_declarator_suffix(self)
3188
3189         def exitRule(self, listener:ParseTreeListener):
3190             if hasattr( listener, "exitAbstract_declarator_suffix" ):
3191                 listener.exitAbstract_declarator_suffix(self)
3192
3193
3194
3195
3196     def abstract_declarator_suffix(self):
3197
3198         localctx = CParser.Abstract_declarator_suffixContext(self, self._ctx, self.state)
3199         self.enterRule(localctx, 64, self.RULE_abstract_declarator_suffix)
3200         try:
3201             self.state = 488
3202             self._errHandler.sync(self)
3203             la_ = self._interp.adaptivePredict(self._input,59,self._ctx)
3204             if la_ == 1:
3205                 self.enterOuterAlt(localctx, 1)
3206                 self.state = 476
3207                 self.match(CParser.T__39)
3208                 self.state = 477
3209                 self.match(CParser.T__40)
3210                 pass
3211
3212             elif la_ == 2:
3213                 self.enterOuterAlt(localctx, 2)
3214                 self.state = 478
3215                 self.match(CParser.T__39)
3216                 self.state = 479
3217                 self.constant_expression()
3218                 self.state = 480
3219                 self.match(CParser.T__40)
3220                 pass
3221
3222             elif la_ == 3:
3223                 self.enterOuterAlt(localctx, 3)
3224                 self.state = 482
3225                 self.match(CParser.T__37)
3226                 self.state = 483
3227                 self.match(CParser.T__38)
3228                 pass
3229
3230             elif la_ == 4:
3231                 self.enterOuterAlt(localctx, 4)
3232                 self.state = 484
3233                 self.match(CParser.T__37)
3234                 self.state = 485
3235                 self.parameter_type_list()
3236                 self.state = 486
3237                 self.match(CParser.T__38)
3238                 pass
3239
3240
3241         except RecognitionException as re:
3242             localctx.exception = re
3243             self._errHandler.reportError(self, re)
3244             self._errHandler.recover(self, re)
3245         finally:
3246             self.exitRule()
3247         return localctx
3248
3249     class InitializerContext(ParserRuleContext):
3250
3251         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3252             super().__init__(parent, invokingState)
3253             self.parser = parser
3254
3255         def assignment_expression(self):
3256             return self.getTypedRuleContext(CParser.Assignment_expressionContext,0)
3257
3258
3259         def initializer_list(self):
3260             return self.getTypedRuleContext(CParser.Initializer_listContext,0)
3261
3262
3263         def getRuleIndex(self):
3264             return CParser.RULE_initializer
3265
3266         def enterRule(self, listener:ParseTreeListener):
3267             if hasattr( listener, "enterInitializer" ):
3268                 listener.enterInitializer(self)
3269
3270         def exitRule(self, listener:ParseTreeListener):
3271             if hasattr( listener, "exitInitializer" ):
3272                 listener.exitInitializer(self)
3273
3274
3275
3276
3277     def initializer(self):
3278
3279         localctx = CParser.InitializerContext(self, self._ctx, self.state)
3280         self.enterRule(localctx, 66, self.RULE_initializer)
3281         self._la = 0 # Token type
3282         try:
3283             self.state = 498
3284             self._errHandler.sync(self)
3285             token = self._input.LA(1)
3286             if token in [CParser.T__37, CParser.T__41, CParser.T__43, CParser.T__44, CParser.T__47, CParser.T__48, CParser.T__49, CParser.T__52, CParser.T__53, CParser.T__54, CParser.IDENTIFIER, CParser.CHARACTER_LITERAL, CParser.STRING_LITERAL, CParser.HEX_LITERAL, CParser.DECIMAL_LITERAL, CParser.OCTAL_LITERAL, CParser.FLOATING_POINT_LITERAL]:
3287                 self.enterOuterAlt(localctx, 1)
3288                 self.state = 490
3289                 self.assignment_expression()
3290                 pass
3291             elif token in [CParser.T__0]:
3292                 self.enterOuterAlt(localctx, 2)
3293                 self.state = 491
3294                 self.match(CParser.T__0)
3295                 self.state = 492
3296                 self.initializer_list()
3297                 self.state = 494
3298                 self._errHandler.sync(self)
3299                 _la = self._input.LA(1)
3300                 if _la==CParser.T__3:
3301                     self.state = 493
3302                     self.match(CParser.T__3)
3303
3304
3305                 self.state = 496
3306                 self.match(CParser.T__19)
3307                 pass
3308             else:
3309                 raise NoViableAltException(self)
3310
3311         except RecognitionException as re:
3312             localctx.exception = re
3313             self._errHandler.reportError(self, re)
3314             self._errHandler.recover(self, re)
3315         finally:
3316             self.exitRule()
3317         return localctx
3318
3319     class Initializer_listContext(ParserRuleContext):
3320
3321         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3322             super().__init__(parent, invokingState)
3323             self.parser = parser
3324
3325         def initializer(self, i:int=None):
3326             if i is None:
3327                 return self.getTypedRuleContexts(CParser.InitializerContext)
3328             else:
3329                 return self.getTypedRuleContext(CParser.InitializerContext,i)
3330
3331
3332         def getRuleIndex(self):
3333             return CParser.RULE_initializer_list
3334
3335         def enterRule(self, listener:ParseTreeListener):
3336             if hasattr( listener, "enterInitializer_list" ):
3337                 listener.enterInitializer_list(self)
3338
3339         def exitRule(self, listener:ParseTreeListener):
3340             if hasattr( listener, "exitInitializer_list" ):
3341                 listener.exitInitializer_list(self)
3342
3343
3344
3345
3346     def initializer_list(self):
3347
3348         localctx = CParser.Initializer_listContext(self, self._ctx, self.state)
3349         self.enterRule(localctx, 68, self.RULE_initializer_list)
3350         try:
3351             self.enterOuterAlt(localctx, 1)
3352             self.state = 500
3353             self.initializer()
3354             self.state = 505
3355             self._errHandler.sync(self)
3356             _alt = self._interp.adaptivePredict(self._input,62,self._ctx)
3357             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
3358                 if _alt==1:
3359                     self.state = 501
3360                     self.match(CParser.T__3)
3361                     self.state = 502
3362                     self.initializer()
3363                 self.state = 507
3364                 self._errHandler.sync(self)
3365                 _alt = self._interp.adaptivePredict(self._input,62,self._ctx)
3366
3367         except RecognitionException as re:
3368             localctx.exception = re
3369             self._errHandler.reportError(self, re)
3370             self._errHandler.recover(self, re)
3371         finally:
3372             self.exitRule()
3373         return localctx
3374
3375     class Argument_expression_listContext(ParserRuleContext):
3376
3377         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3378             super().__init__(parent, invokingState)
3379             self.parser = parser
3380
3381         def assignment_expression(self, i:int=None):
3382             if i is None:
3383                 return self.getTypedRuleContexts(CParser.Assignment_expressionContext)
3384             else:
3385                 return self.getTypedRuleContext(CParser.Assignment_expressionContext,i)
3386
3387
3388         def getRuleIndex(self):
3389             return CParser.RULE_argument_expression_list
3390
3391         def enterRule(self, listener:ParseTreeListener):
3392             if hasattr( listener, "enterArgument_expression_list" ):
3393                 listener.enterArgument_expression_list(self)
3394
3395         def exitRule(self, listener:ParseTreeListener):
3396             if hasattr( listener, "exitArgument_expression_list" ):
3397                 listener.exitArgument_expression_list(self)
3398
3399
3400
3401
3402     def argument_expression_list(self):
3403
3404         localctx = CParser.Argument_expression_listContext(self, self._ctx, self.state)
3405         self.enterRule(localctx, 70, self.RULE_argument_expression_list)
3406         self._la = 0 # Token type
3407         try:
3408             self.enterOuterAlt(localctx, 1)
3409             self.state = 508
3410             self.assignment_expression()
3411             self.state = 510
3412             self._errHandler.sync(self)
3413             _la = self._input.LA(1)
3414             if _la==CParser.T__28:
3415                 self.state = 509
3416                 self.match(CParser.T__28)
3417
3418
3419             self.state = 519
3420             self._errHandler.sync(self)
3421             _la = self._input.LA(1)
3422             while _la==CParser.T__3:
3423                 self.state = 512
3424                 self.match(CParser.T__3)
3425                 self.state = 513
3426                 self.assignment_expression()
3427                 self.state = 515
3428                 self._errHandler.sync(self)
3429                 _la = self._input.LA(1)
3430                 if _la==CParser.T__28:
3431                     self.state = 514
3432                     self.match(CParser.T__28)
3433
3434
3435                 self.state = 521
3436                 self._errHandler.sync(self)
3437                 _la = self._input.LA(1)
3438
3439         except RecognitionException as re:
3440             localctx.exception = re
3441             self._errHandler.reportError(self, re)
3442             self._errHandler.recover(self, re)
3443         finally:
3444             self.exitRule()
3445         return localctx
3446
3447     class Additive_expressionContext(ParserRuleContext):
3448
3449         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3450             super().__init__(parent, invokingState)
3451             self.parser = parser
3452
3453         def multiplicative_expression(self, i:int=None):
3454             if i is None:
3455                 return self.getTypedRuleContexts(CParser.Multiplicative_expressionContext)
3456             else:
3457                 return self.getTypedRuleContext(CParser.Multiplicative_expressionContext,i)
3458
3459
3460         def getRuleIndex(self):
3461             return CParser.RULE_additive_expression
3462
3463         def enterRule(self, listener:ParseTreeListener):
3464             if hasattr( listener, "enterAdditive_expression" ):
3465                 listener.enterAdditive_expression(self)
3466
3467         def exitRule(self, listener:ParseTreeListener):
3468             if hasattr( listener, "exitAdditive_expression" ):
3469                 listener.exitAdditive_expression(self)
3470
3471
3472
3473
3474     def additive_expression(self):
3475
3476         localctx = CParser.Additive_expressionContext(self, self._ctx, self.state)
3477         self.enterRule(localctx, 72, self.RULE_additive_expression)
3478         self._la = 0 # Token type
3479         try:
3480             self.enterOuterAlt(localctx, 1)
3481             self.state = 522
3482             self.multiplicative_expression()
3483             self.state = 529
3484             self._errHandler.sync(self)
3485             _la = self._input.LA(1)
3486             while _la==CParser.T__43 or _la==CParser.T__44:
3487                 self.state = 527
3488                 self._errHandler.sync(self)
3489                 token = self._input.LA(1)
3490                 if token in [CParser.T__43]:
3491                     self.state = 523
3492                     self.match(CParser.T__43)
3493                     self.state = 524
3494                     self.multiplicative_expression()
3495                     pass
3496                 elif token in [CParser.T__44]:
3497                     self.state = 525
3498                     self.match(CParser.T__44)
3499                     self.state = 526
3500                     self.multiplicative_expression()
3501                     pass
3502                 else:
3503                     raise NoViableAltException(self)
3504
3505                 self.state = 531
3506                 self._errHandler.sync(self)
3507                 _la = self._input.LA(1)
3508
3509         except RecognitionException as re:
3510             localctx.exception = re
3511             self._errHandler.reportError(self, re)
3512             self._errHandler.recover(self, re)
3513         finally:
3514             self.exitRule()
3515         return localctx
3516
3517     class Multiplicative_expressionContext(ParserRuleContext):
3518
3519         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3520             super().__init__(parent, invokingState)
3521             self.parser = parser
3522
3523         def cast_expression(self, i:int=None):
3524             if i is None:
3525                 return self.getTypedRuleContexts(CParser.Cast_expressionContext)
3526             else:
3527                 return self.getTypedRuleContext(CParser.Cast_expressionContext,i)
3528
3529
3530         def getRuleIndex(self):
3531             return CParser.RULE_multiplicative_expression
3532
3533         def enterRule(self, listener:ParseTreeListener):
3534             if hasattr( listener, "enterMultiplicative_expression" ):
3535                 listener.enterMultiplicative_expression(self)
3536
3537         def exitRule(self, listener:ParseTreeListener):
3538             if hasattr( listener, "exitMultiplicative_expression" ):
3539                 listener.exitMultiplicative_expression(self)
3540
3541
3542
3543
3544     def multiplicative_expression(self):
3545
3546         localctx = CParser.Multiplicative_expressionContext(self, self._ctx, self.state)
3547         self.enterRule(localctx, 74, self.RULE_multiplicative_expression)
3548         self._la = 0 # Token type
3549         try:
3550             self.enterOuterAlt(localctx, 1)
3551             self.state = 532
3552             self.cast_expression()
3553             self.state = 541
3554             self._errHandler.sync(self)
3555             _la = self._input.LA(1)
3556             while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__41) | (1 << CParser.T__45) | (1 << CParser.T__46))) != 0):
3557                 self.state = 539
3558                 self._errHandler.sync(self)
3559                 token = self._input.LA(1)
3560                 if token in [CParser.T__41]:
3561                     self.state = 533
3562                     self.match(CParser.T__41)
3563                     self.state = 534
3564                     self.cast_expression()
3565                     pass
3566                 elif token in [CParser.T__45]:
3567                     self.state = 535
3568                     self.match(CParser.T__45)
3569                     self.state = 536
3570                     self.cast_expression()
3571                     pass
3572                 elif token in [CParser.T__46]:
3573                     self.state = 537
3574                     self.match(CParser.T__46)
3575                     self.state = 538
3576                     self.cast_expression()
3577                     pass
3578                 else:
3579                     raise NoViableAltException(self)
3580
3581                 self.state = 543
3582                 self._errHandler.sync(self)
3583                 _la = self._input.LA(1)
3584
3585         except RecognitionException as re:
3586             localctx.exception = re
3587             self._errHandler.reportError(self, re)
3588             self._errHandler.recover(self, re)
3589         finally:
3590             self.exitRule()
3591         return localctx
3592
3593     class Cast_expressionContext(ParserRuleContext):
3594
3595         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3596             super().__init__(parent, invokingState)
3597             self.parser = parser
3598
3599         def type_name(self):
3600             return self.getTypedRuleContext(CParser.Type_nameContext,0)
3601
3602
3603         def cast_expression(self):
3604             return self.getTypedRuleContext(CParser.Cast_expressionContext,0)
3605
3606
3607         def unary_expression(self):
3608             return self.getTypedRuleContext(CParser.Unary_expressionContext,0)
3609
3610
3611         def getRuleIndex(self):
3612             return CParser.RULE_cast_expression
3613
3614         def enterRule(self, listener:ParseTreeListener):
3615             if hasattr( listener, "enterCast_expression" ):
3616                 listener.enterCast_expression(self)
3617
3618         def exitRule(self, listener:ParseTreeListener):
3619             if hasattr( listener, "exitCast_expression" ):
3620                 listener.exitCast_expression(self)
3621
3622
3623
3624
3625     def cast_expression(self):
3626
3627         localctx = CParser.Cast_expressionContext(self, self._ctx, self.state)
3628         self.enterRule(localctx, 76, self.RULE_cast_expression)
3629         try:
3630             self.state = 550
3631             self._errHandler.sync(self)
3632             la_ = self._interp.adaptivePredict(self._input,70,self._ctx)
3633             if la_ == 1:
3634                 self.enterOuterAlt(localctx, 1)
3635                 self.state = 544
3636                 self.match(CParser.T__37)
3637                 self.state = 545
3638                 self.type_name()
3639                 self.state = 546
3640                 self.match(CParser.T__38)
3641                 self.state = 547
3642                 self.cast_expression()
3643                 pass
3644
3645             elif la_ == 2:
3646                 self.enterOuterAlt(localctx, 2)
3647                 self.state = 549
3648                 self.unary_expression()
3649                 pass
3650
3651
3652         except RecognitionException as re:
3653             localctx.exception = re
3654             self._errHandler.reportError(self, re)
3655             self._errHandler.recover(self, re)
3656         finally:
3657             self.exitRule()
3658         return localctx
3659
3660     class Unary_expressionContext(ParserRuleContext):
3661
3662         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3663             super().__init__(parent, invokingState)
3664             self.parser = parser
3665
3666         def postfix_expression(self):
3667             return self.getTypedRuleContext(CParser.Postfix_expressionContext,0)
3668
3669
3670         def unary_expression(self):
3671             return self.getTypedRuleContext(CParser.Unary_expressionContext,0)
3672
3673
3674         def unary_operator(self):
3675             return self.getTypedRuleContext(CParser.Unary_operatorContext,0)
3676
3677
3678         def cast_expression(self):
3679             return self.getTypedRuleContext(CParser.Cast_expressionContext,0)
3680
3681
3682         def type_name(self):
3683             return self.getTypedRuleContext(CParser.Type_nameContext,0)
3684
3685
3686         def getRuleIndex(self):
3687             return CParser.RULE_unary_expression
3688
3689         def enterRule(self, listener:ParseTreeListener):
3690             if hasattr( listener, "enterUnary_expression" ):
3691                 listener.enterUnary_expression(self)
3692
3693         def exitRule(self, listener:ParseTreeListener):
3694             if hasattr( listener, "exitUnary_expression" ):
3695                 listener.exitUnary_expression(self)
3696
3697
3698
3699
3700     def unary_expression(self):
3701
3702         localctx = CParser.Unary_expressionContext(self, self._ctx, self.state)
3703         self.enterRule(localctx, 78, self.RULE_unary_expression)
3704         try:
3705             self.state = 567
3706             self._errHandler.sync(self)
3707             la_ = self._interp.adaptivePredict(self._input,71,self._ctx)
3708             if la_ == 1:
3709                 self.enterOuterAlt(localctx, 1)
3710                 self.state = 552
3711                 self.postfix_expression()
3712                 pass
3713
3714             elif la_ == 2:
3715                 self.enterOuterAlt(localctx, 2)
3716                 self.state = 553
3717                 self.match(CParser.T__47)
3718                 self.state = 554
3719                 self.unary_expression()
3720                 pass
3721
3722             elif la_ == 3:
3723                 self.enterOuterAlt(localctx, 3)
3724                 self.state = 555
3725                 self.match(CParser.T__48)
3726                 self.state = 556
3727                 self.unary_expression()
3728                 pass
3729
3730             elif la_ == 4:
3731                 self.enterOuterAlt(localctx, 4)
3732                 self.state = 557
3733                 self.unary_operator()
3734                 self.state = 558
3735                 self.cast_expression()
3736                 pass
3737
3738             elif la_ == 5:
3739                 self.enterOuterAlt(localctx, 5)
3740                 self.state = 560
3741                 self.match(CParser.T__49)
3742                 self.state = 561
3743                 self.unary_expression()
3744                 pass
3745
3746             elif la_ == 6:
3747                 self.enterOuterAlt(localctx, 6)
3748                 self.state = 562
3749                 self.match(CParser.T__49)
3750                 self.state = 563
3751                 self.match(CParser.T__37)
3752                 self.state = 564
3753                 self.type_name()
3754                 self.state = 565
3755                 self.match(CParser.T__38)
3756                 pass
3757
3758
3759         except RecognitionException as re:
3760             localctx.exception = re
3761             self._errHandler.reportError(self, re)
3762             self._errHandler.recover(self, re)
3763         finally:
3764             self.exitRule()
3765         return localctx
3766
3767     class Postfix_expressionContext(ParserRuleContext):
3768
3769         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3770             super().__init__(parent, invokingState)
3771             self.parser = parser
3772             self.FuncCallText = ''
3773             self.p = None # Primary_expressionContext
3774             self.a = None # Token
3775             self.c = None # Argument_expression_listContext
3776             self.b = None # Token
3777             self.x = None # Token
3778             self.y = None # Token
3779             self.z = None # Token
3780
3781         def primary_expression(self):
3782             return self.getTypedRuleContext(CParser.Primary_expressionContext,0)
3783
3784
3785         def expression(self, i:int=None):
3786             if i is None:
3787                 return self.getTypedRuleContexts(CParser.ExpressionContext)
3788             else:
3789                 return self.getTypedRuleContext(CParser.ExpressionContext,i)
3790
3791
3792         def macro_parameter_list(self, i:int=None):
3793             if i is None:
3794                 return self.getTypedRuleContexts(CParser.Macro_parameter_listContext)
3795             else:
3796                 return self.getTypedRuleContext(CParser.Macro_parameter_listContext,i)
3797
3798
3799         def argument_expression_list(self, i:int=None):
3800             if i is None:
3801                 return self.getTypedRuleContexts(CParser.Argument_expression_listContext)
3802             else:
3803                 return self.getTypedRuleContext(CParser.Argument_expression_listContext,i)
3804
3805
3806         def IDENTIFIER(self, i:int=None):
3807             if i is None:
3808                 return self.getTokens(CParser.IDENTIFIER)
3809             else:
3810                 return self.getToken(CParser.IDENTIFIER, i)
3811
3812         def getRuleIndex(self):
3813             return CParser.RULE_postfix_expression
3814
3815         def enterRule(self, listener:ParseTreeListener):
3816             if hasattr( listener, "enterPostfix_expression" ):
3817                 listener.enterPostfix_expression(self)
3818
3819         def exitRule(self, listener:ParseTreeListener):
3820             if hasattr( listener, "exitPostfix_expression" ):
3821                 listener.exitPostfix_expression(self)
3822
3823
3824
3825
3826     def postfix_expression(self):
3827
3828         localctx = CParser.Postfix_expressionContext(self, self._ctx, self.state)
3829         self.enterRule(localctx, 80, self.RULE_postfix_expression)
3830
3831         self.FuncCallText=''
3832
3833         try:
3834             self.enterOuterAlt(localctx, 1)
3835             self.state = 569
3836             localctx.p = self.primary_expression()
3837             self.FuncCallText += (None if localctx.p is None else self._input.getText((localctx.p.start,localctx.p.stop)))
3838             self.state = 600
3839             self._errHandler.sync(self)
3840             _alt = self._interp.adaptivePredict(self._input,73,self._ctx)
3841             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
3842                 if _alt==1:
3843                     self.state = 598
3844                     self._errHandler.sync(self)
3845                     la_ = self._interp.adaptivePredict(self._input,72,self._ctx)
3846                     if la_ == 1:
3847                         self.state = 571
3848                         self.match(CParser.T__39)
3849                         self.state = 572
3850                         self.expression()
3851                         self.state = 573
3852                         self.match(CParser.T__40)
3853                         pass
3854
3855                     elif la_ == 2:
3856                         self.state = 575
3857                         self.match(CParser.T__37)
3858                         self.state = 576
3859                         localctx.a = self.match(CParser.T__38)
3860                         self.StoreFunctionCalling((None if localctx.p is None else localctx.p.start).line, (None if localctx.p is None else localctx.p.start).column, (0 if localctx.a is None else localctx.a.line), localctx.a.start.column, self.FuncCallText, '')
3861                         pass
3862
3863                     elif la_ == 3:
3864                         self.state = 578
3865                         self.match(CParser.T__37)
3866                         self.state = 579
3867                         localctx.c = self.argument_expression_list()
3868                         self.state = 580
3869                         localctx.b = self.match(CParser.T__38)
3870                         self.StoreFunctionCalling((None if localctx.p is None else localctx.p.start).line, (None if localctx.p is None else localctx.p.start).column, (0 if localctx.b is None else localctx.b.line), localctx.b.column, self.FuncCallText, (None if localctx.c is None else self._input.getText((localctx.c.start,localctx.c.stop))))
3871                         pass
3872
3873                     elif la_ == 4:
3874                         self.state = 583
3875                         self.match(CParser.T__37)
3876                         self.state = 584
3877                         self.macro_parameter_list()
3878                         self.state = 585
3879                         self.match(CParser.T__38)
3880                         pass
3881
3882                     elif la_ == 5:
3883                         self.state = 587
3884                         self.match(CParser.T__50)
3885                         self.state = 588
3886                         localctx.x = self.match(CParser.IDENTIFIER)
3887                         self.FuncCallText += '.' + (None if localctx.x is None else localctx.x.text)
3888                         pass
3889
3890                     elif la_ == 6:
3891                         self.state = 590
3892                         self.match(CParser.T__41)
3893                         self.state = 591
3894                         localctx.y = self.match(CParser.IDENTIFIER)
3895                         self.FuncCallText = (None if localctx.y is None else localctx.y.text)
3896                         pass
3897
3898                     elif la_ == 7:
3899                         self.state = 593
3900                         self.match(CParser.T__51)
3901                         self.state = 594
3902                         localctx.z = self.match(CParser.IDENTIFIER)
3903                         self.FuncCallText += '->' + (None if localctx.z is None else localctx.z.text)
3904                         pass
3905
3906                     elif la_ == 8:
3907                         self.state = 596
3908                         self.match(CParser.T__47)
3909                         pass
3910
3911                     elif la_ == 9:
3912                         self.state = 597
3913                         self.match(CParser.T__48)
3914                         pass
3915
3916
3917                 self.state = 602
3918                 self._errHandler.sync(self)
3919                 _alt = self._interp.adaptivePredict(self._input,73,self._ctx)
3920
3921         except RecognitionException as re:
3922             localctx.exception = re
3923             self._errHandler.reportError(self, re)
3924             self._errHandler.recover(self, re)
3925         finally:
3926             self.exitRule()
3927         return localctx
3928
3929     class Macro_parameter_listContext(ParserRuleContext):
3930
3931         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3932             super().__init__(parent, invokingState)
3933             self.parser = parser
3934
3935         def parameter_declaration(self, i:int=None):
3936             if i is None:
3937                 return self.getTypedRuleContexts(CParser.Parameter_declarationContext)
3938             else:
3939                 return self.getTypedRuleContext(CParser.Parameter_declarationContext,i)
3940
3941
3942         def getRuleIndex(self):
3943             return CParser.RULE_macro_parameter_list
3944
3945         def enterRule(self, listener:ParseTreeListener):
3946             if hasattr( listener, "enterMacro_parameter_list" ):
3947                 listener.enterMacro_parameter_list(self)
3948
3949         def exitRule(self, listener:ParseTreeListener):
3950             if hasattr( listener, "exitMacro_parameter_list" ):
3951                 listener.exitMacro_parameter_list(self)
3952
3953
3954
3955
3956     def macro_parameter_list(self):
3957
3958         localctx = CParser.Macro_parameter_listContext(self, self._ctx, self.state)
3959         self.enterRule(localctx, 82, self.RULE_macro_parameter_list)
3960         self._la = 0 # Token type
3961         try:
3962             self.enterOuterAlt(localctx, 1)
3963             self.state = 603
3964             self.parameter_declaration()
3965             self.state = 608
3966             self._errHandler.sync(self)
3967             _la = self._input.LA(1)
3968             while _la==CParser.T__3:
3969                 self.state = 604
3970                 self.match(CParser.T__3)
3971                 self.state = 605
3972                 self.parameter_declaration()
3973                 self.state = 610
3974                 self._errHandler.sync(self)
3975                 _la = self._input.LA(1)
3976
3977         except RecognitionException as re:
3978             localctx.exception = re
3979             self._errHandler.reportError(self, re)
3980             self._errHandler.recover(self, re)
3981         finally:
3982             self.exitRule()
3983         return localctx
3984
3985     class Unary_operatorContext(ParserRuleContext):
3986
3987         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3988             super().__init__(parent, invokingState)
3989             self.parser = parser
3990
3991
3992         def getRuleIndex(self):
3993             return CParser.RULE_unary_operator
3994
3995         def enterRule(self, listener:ParseTreeListener):
3996             if hasattr( listener, "enterUnary_operator" ):
3997                 listener.enterUnary_operator(self)
3998
3999         def exitRule(self, listener:ParseTreeListener):
4000             if hasattr( listener, "exitUnary_operator" ):
4001                 listener.exitUnary_operator(self)
4002
4003
4004
4005
4006     def unary_operator(self):
4007
4008         localctx = CParser.Unary_operatorContext(self, self._ctx, self.state)
4009         self.enterRule(localctx, 84, self.RULE_unary_operator)
4010         self._la = 0 # Token type
4011         try:
4012             self.enterOuterAlt(localctx, 1)
4013             self.state = 611
4014             _la = self._input.LA(1)
4015             if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__41) | (1 << CParser.T__43) | (1 << CParser.T__44) | (1 << CParser.T__52) | (1 << CParser.T__53) | (1 << CParser.T__54))) != 0)):
4016                 self._errHandler.recoverInline(self)
4017             else:
4018                 self._errHandler.reportMatch(self)
4019                 self.consume()
4020         except RecognitionException as re:
4021             localctx.exception = re
4022             self._errHandler.reportError(self, re)
4023             self._errHandler.recover(self, re)
4024         finally:
4025             self.exitRule()
4026         return localctx
4027
4028     class Primary_expressionContext(ParserRuleContext):
4029
4030         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4031             super().__init__(parent, invokingState)
4032             self.parser = parser
4033
4034         def IDENTIFIER(self):
4035             return self.getToken(CParser.IDENTIFIER, 0)
4036
4037         def constant(self):
4038             return self.getTypedRuleContext(CParser.ConstantContext,0)
4039
4040
4041         def expression(self):
4042             return self.getTypedRuleContext(CParser.ExpressionContext,0)
4043
4044
4045         def getRuleIndex(self):
4046             return CParser.RULE_primary_expression
4047
4048         def enterRule(self, listener:ParseTreeListener):
4049             if hasattr( listener, "enterPrimary_expression" ):
4050                 listener.enterPrimary_expression(self)
4051
4052         def exitRule(self, listener:ParseTreeListener):
4053             if hasattr( listener, "exitPrimary_expression" ):
4054                 listener.exitPrimary_expression(self)
4055
4056
4057
4058
4059     def primary_expression(self):
4060
4061         localctx = CParser.Primary_expressionContext(self, self._ctx, self.state)
4062         self.enterRule(localctx, 86, self.RULE_primary_expression)
4063         try:
4064             self.state = 619
4065             self._errHandler.sync(self)
4066             la_ = self._interp.adaptivePredict(self._input,75,self._ctx)
4067             if la_ == 1:
4068                 self.enterOuterAlt(localctx, 1)
4069                 self.state = 613
4070                 self.match(CParser.IDENTIFIER)
4071                 pass
4072
4073             elif la_ == 2:
4074                 self.enterOuterAlt(localctx, 2)
4075                 self.state = 614
4076                 self.constant()
4077                 pass
4078
4079             elif la_ == 3:
4080                 self.enterOuterAlt(localctx, 3)
4081                 self.state = 615
4082                 self.match(CParser.T__37)
4083                 self.state = 616
4084                 self.expression()
4085                 self.state = 617
4086                 self.match(CParser.T__38)
4087                 pass
4088
4089
4090         except RecognitionException as re:
4091             localctx.exception = re
4092             self._errHandler.reportError(self, re)
4093             self._errHandler.recover(self, re)
4094         finally:
4095             self.exitRule()
4096         return localctx
4097
4098     class ConstantContext(ParserRuleContext):
4099
4100         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4101             super().__init__(parent, invokingState)
4102             self.parser = parser
4103
4104         def HEX_LITERAL(self):
4105             return self.getToken(CParser.HEX_LITERAL, 0)
4106
4107         def OCTAL_LITERAL(self):
4108             return self.getToken(CParser.OCTAL_LITERAL, 0)
4109
4110         def DECIMAL_LITERAL(self):
4111             return self.getToken(CParser.DECIMAL_LITERAL, 0)
4112
4113         def CHARACTER_LITERAL(self):
4114             return self.getToken(CParser.CHARACTER_LITERAL, 0)
4115
4116         def IDENTIFIER(self, i:int=None):
4117             if i is None:
4118                 return self.getTokens(CParser.IDENTIFIER)
4119             else:
4120                 return self.getToken(CParser.IDENTIFIER, i)
4121
4122         def STRING_LITERAL(self, i:int=None):
4123             if i is None:
4124                 return self.getTokens(CParser.STRING_LITERAL)
4125             else:
4126                 return self.getToken(CParser.STRING_LITERAL, i)
4127
4128         def FLOATING_POINT_LITERAL(self):
4129             return self.getToken(CParser.FLOATING_POINT_LITERAL, 0)
4130
4131         def getRuleIndex(self):
4132             return CParser.RULE_constant
4133
4134         def enterRule(self, listener:ParseTreeListener):
4135             if hasattr( listener, "enterConstant" ):
4136                 listener.enterConstant(self)
4137
4138         def exitRule(self, listener:ParseTreeListener):
4139             if hasattr( listener, "exitConstant" ):
4140                 listener.exitConstant(self)
4141
4142
4143
4144
4145     def constant(self):
4146
4147         localctx = CParser.ConstantContext(self, self._ctx, self.state)
4148         self.enterRule(localctx, 88, self.RULE_constant)
4149         self._la = 0 # Token type
4150         try:
4151             self.state = 647
4152             self._errHandler.sync(self)
4153             token = self._input.LA(1)
4154             if token in [CParser.HEX_LITERAL]:
4155                 self.enterOuterAlt(localctx, 1)
4156                 self.state = 621
4157                 self.match(CParser.HEX_LITERAL)
4158                 pass
4159             elif token in [CParser.OCTAL_LITERAL]:
4160                 self.enterOuterAlt(localctx, 2)
4161                 self.state = 622
4162                 self.match(CParser.OCTAL_LITERAL)
4163                 pass
4164             elif token in [CParser.DECIMAL_LITERAL]:
4165                 self.enterOuterAlt(localctx, 3)
4166                 self.state = 623
4167                 self.match(CParser.DECIMAL_LITERAL)
4168                 pass
4169             elif token in [CParser.CHARACTER_LITERAL]:
4170                 self.enterOuterAlt(localctx, 4)
4171                 self.state = 624
4172                 self.match(CParser.CHARACTER_LITERAL)
4173                 pass
4174             elif token in [CParser.IDENTIFIER, CParser.STRING_LITERAL]:
4175                 self.enterOuterAlt(localctx, 5)
4176                 self.state = 636
4177                 self._errHandler.sync(self)
4178                 _alt = 1
4179                 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
4180                     if _alt == 1:
4181                         self.state = 628
4182                         self._errHandler.sync(self)
4183                         _la = self._input.LA(1)
4184                         while _la==CParser.IDENTIFIER:
4185                             self.state = 625
4186                             self.match(CParser.IDENTIFIER)
4187                             self.state = 630
4188                             self._errHandler.sync(self)
4189                             _la = self._input.LA(1)
4190
4191                         self.state = 632
4192                         self._errHandler.sync(self)
4193                         _alt = 1
4194                         while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
4195                             if _alt == 1:
4196                                 self.state = 631
4197                                 self.match(CParser.STRING_LITERAL)
4198
4199                             else:
4200                                 raise NoViableAltException(self)
4201                             self.state = 634
4202                             self._errHandler.sync(self)
4203                             _alt = self._interp.adaptivePredict(self._input,77,self._ctx)
4204
4205
4206                     else:
4207                         raise NoViableAltException(self)
4208                     self.state = 638
4209                     self._errHandler.sync(self)
4210                     _alt = self._interp.adaptivePredict(self._input,78,self._ctx)
4211
4212                 self.state = 643
4213                 self._errHandler.sync(self)
4214                 _la = self._input.LA(1)
4215                 while _la==CParser.IDENTIFIER:
4216                     self.state = 640
4217                     self.match(CParser.IDENTIFIER)
4218                     self.state = 645
4219                     self._errHandler.sync(self)
4220                     _la = self._input.LA(1)
4221
4222                 pass
4223             elif token in [CParser.FLOATING_POINT_LITERAL]:
4224                 self.enterOuterAlt(localctx, 6)
4225                 self.state = 646
4226                 self.match(CParser.FLOATING_POINT_LITERAL)
4227                 pass
4228             else:
4229                 raise NoViableAltException(self)
4230
4231         except RecognitionException as re:
4232             localctx.exception = re
4233             self._errHandler.reportError(self, re)
4234             self._errHandler.recover(self, re)
4235         finally:
4236             self.exitRule()
4237         return localctx
4238
4239     class ExpressionContext(ParserRuleContext):
4240
4241         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4242             super().__init__(parent, invokingState)
4243             self.parser = parser
4244
4245         def assignment_expression(self, i:int=None):
4246             if i is None:
4247                 return self.getTypedRuleContexts(CParser.Assignment_expressionContext)
4248             else:
4249                 return self.getTypedRuleContext(CParser.Assignment_expressionContext,i)
4250
4251
4252         def getRuleIndex(self):
4253             return CParser.RULE_expression
4254
4255         def enterRule(self, listener:ParseTreeListener):
4256             if hasattr( listener, "enterExpression" ):
4257                 listener.enterExpression(self)
4258
4259         def exitRule(self, listener:ParseTreeListener):
4260             if hasattr( listener, "exitExpression" ):
4261                 listener.exitExpression(self)
4262
4263
4264
4265
4266     def expression(self):
4267
4268         localctx = CParser.ExpressionContext(self, self._ctx, self.state)
4269         self.enterRule(localctx, 90, self.RULE_expression)
4270         self._la = 0 # Token type
4271         try:
4272             self.enterOuterAlt(localctx, 1)
4273             self.state = 649
4274             self.assignment_expression()
4275             self.state = 654
4276             self._errHandler.sync(self)
4277             _la = self._input.LA(1)
4278             while _la==CParser.T__3:
4279                 self.state = 650
4280                 self.match(CParser.T__3)
4281                 self.state = 651
4282                 self.assignment_expression()
4283                 self.state = 656
4284                 self._errHandler.sync(self)
4285                 _la = self._input.LA(1)
4286
4287         except RecognitionException as re:
4288             localctx.exception = re
4289             self._errHandler.reportError(self, re)
4290             self._errHandler.recover(self, re)
4291         finally:
4292             self.exitRule()
4293         return localctx
4294
4295     class Constant_expressionContext(ParserRuleContext):
4296
4297         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4298             super().__init__(parent, invokingState)
4299             self.parser = parser
4300
4301         def conditional_expression(self):
4302             return self.getTypedRuleContext(CParser.Conditional_expressionContext,0)
4303
4304
4305         def getRuleIndex(self):
4306             return CParser.RULE_constant_expression
4307
4308         def enterRule(self, listener:ParseTreeListener):
4309             if hasattr( listener, "enterConstant_expression" ):
4310                 listener.enterConstant_expression(self)
4311
4312         def exitRule(self, listener:ParseTreeListener):
4313             if hasattr( listener, "exitConstant_expression" ):
4314                 listener.exitConstant_expression(self)
4315
4316
4317
4318
4319     def constant_expression(self):
4320
4321         localctx = CParser.Constant_expressionContext(self, self._ctx, self.state)
4322         self.enterRule(localctx, 92, self.RULE_constant_expression)
4323         try:
4324             self.enterOuterAlt(localctx, 1)
4325             self.state = 657
4326             self.conditional_expression()
4327         except RecognitionException as re:
4328             localctx.exception = re
4329             self._errHandler.reportError(self, re)
4330             self._errHandler.recover(self, re)
4331         finally:
4332             self.exitRule()
4333         return localctx
4334
4335     class Assignment_expressionContext(ParserRuleContext):
4336
4337         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4338             super().__init__(parent, invokingState)
4339             self.parser = parser
4340
4341         def lvalue(self):
4342             return self.getTypedRuleContext(CParser.LvalueContext,0)
4343
4344
4345         def assignment_operator(self):
4346             return self.getTypedRuleContext(CParser.Assignment_operatorContext,0)
4347
4348
4349         def assignment_expression(self):
4350             return self.getTypedRuleContext(CParser.Assignment_expressionContext,0)
4351
4352
4353         def conditional_expression(self):
4354             return self.getTypedRuleContext(CParser.Conditional_expressionContext,0)
4355
4356
4357         def getRuleIndex(self):
4358             return CParser.RULE_assignment_expression
4359
4360         def enterRule(self, listener:ParseTreeListener):
4361             if hasattr( listener, "enterAssignment_expression" ):
4362                 listener.enterAssignment_expression(self)
4363
4364         def exitRule(self, listener:ParseTreeListener):
4365             if hasattr( listener, "exitAssignment_expression" ):
4366                 listener.exitAssignment_expression(self)
4367
4368
4369
4370
4371     def assignment_expression(self):
4372
4373         localctx = CParser.Assignment_expressionContext(self, self._ctx, self.state)
4374         self.enterRule(localctx, 94, self.RULE_assignment_expression)
4375         try:
4376             self.state = 664
4377             self._errHandler.sync(self)
4378             la_ = self._interp.adaptivePredict(self._input,82,self._ctx)
4379             if la_ == 1:
4380                 self.enterOuterAlt(localctx, 1)
4381                 self.state = 659
4382                 self.lvalue()
4383                 self.state = 660
4384                 self.assignment_operator()
4385                 self.state = 661
4386                 self.assignment_expression()
4387                 pass
4388
4389             elif la_ == 2:
4390                 self.enterOuterAlt(localctx, 2)
4391                 self.state = 663
4392                 self.conditional_expression()
4393                 pass
4394
4395
4396         except RecognitionException as re:
4397             localctx.exception = re
4398             self._errHandler.reportError(self, re)
4399             self._errHandler.recover(self, re)
4400         finally:
4401             self.exitRule()
4402         return localctx
4403
4404     class LvalueContext(ParserRuleContext):
4405
4406         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4407             super().__init__(parent, invokingState)
4408             self.parser = parser
4409
4410         def unary_expression(self):
4411             return self.getTypedRuleContext(CParser.Unary_expressionContext,0)
4412
4413
4414         def getRuleIndex(self):
4415             return CParser.RULE_lvalue
4416
4417         def enterRule(self, listener:ParseTreeListener):
4418             if hasattr( listener, "enterLvalue" ):
4419                 listener.enterLvalue(self)
4420
4421         def exitRule(self, listener:ParseTreeListener):
4422             if hasattr( listener, "exitLvalue" ):
4423                 listener.exitLvalue(self)
4424
4425
4426
4427
4428     def lvalue(self):
4429
4430         localctx = CParser.LvalueContext(self, self._ctx, self.state)
4431         self.enterRule(localctx, 96, self.RULE_lvalue)
4432         try:
4433             self.enterOuterAlt(localctx, 1)
4434             self.state = 666
4435             self.unary_expression()
4436         except RecognitionException as re:
4437             localctx.exception = re
4438             self._errHandler.reportError(self, re)
4439             self._errHandler.recover(self, re)
4440         finally:
4441             self.exitRule()
4442         return localctx
4443
4444     class Assignment_operatorContext(ParserRuleContext):
4445
4446         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4447             super().__init__(parent, invokingState)
4448             self.parser = parser
4449
4450
4451         def getRuleIndex(self):
4452             return CParser.RULE_assignment_operator
4453
4454         def enterRule(self, listener:ParseTreeListener):
4455             if hasattr( listener, "enterAssignment_operator" ):
4456                 listener.enterAssignment_operator(self)
4457
4458         def exitRule(self, listener:ParseTreeListener):
4459             if hasattr( listener, "exitAssignment_operator" ):
4460                 listener.exitAssignment_operator(self)
4461
4462
4463
4464
4465     def assignment_operator(self):
4466
4467         localctx = CParser.Assignment_operatorContext(self, self._ctx, self.state)
4468         self.enterRule(localctx, 98, self.RULE_assignment_operator)
4469         self._la = 0 # Token type
4470         try:
4471             self.enterOuterAlt(localctx, 1)
4472             self.state = 668
4473             _la = self._input.LA(1)
4474             if not(((((_la - 5)) & ~0x3f) == 0 and ((1 << (_la - 5)) & ((1 << (CParser.T__4 - 5)) | (1 << (CParser.T__55 - 5)) | (1 << (CParser.T__56 - 5)) | (1 << (CParser.T__57 - 5)) | (1 << (CParser.T__58 - 5)) | (1 << (CParser.T__59 - 5)) | (1 << (CParser.T__60 - 5)) | (1 << (CParser.T__61 - 5)) | (1 << (CParser.T__62 - 5)) | (1 << (CParser.T__63 - 5)) | (1 << (CParser.T__64 - 5)))) != 0)):
4475                 self._errHandler.recoverInline(self)
4476             else:
4477                 self._errHandler.reportMatch(self)
4478                 self.consume()
4479         except RecognitionException as re:
4480             localctx.exception = re
4481             self._errHandler.reportError(self, re)
4482             self._errHandler.recover(self, re)
4483         finally:
4484             self.exitRule()
4485         return localctx
4486
4487     class Conditional_expressionContext(ParserRuleContext):
4488
4489         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4490             super().__init__(parent, invokingState)
4491             self.parser = parser
4492             self.e = None # Logical_or_expressionContext
4493
4494         def logical_or_expression(self):
4495             return self.getTypedRuleContext(CParser.Logical_or_expressionContext,0)
4496
4497
4498         def expression(self):
4499             return self.getTypedRuleContext(CParser.ExpressionContext,0)
4500
4501
4502         def conditional_expression(self):
4503             return self.getTypedRuleContext(CParser.Conditional_expressionContext,0)
4504
4505
4506         def getRuleIndex(self):
4507             return CParser.RULE_conditional_expression
4508
4509         def enterRule(self, listener:ParseTreeListener):
4510             if hasattr( listener, "enterConditional_expression" ):
4511                 listener.enterConditional_expression(self)
4512
4513         def exitRule(self, listener:ParseTreeListener):
4514             if hasattr( listener, "exitConditional_expression" ):
4515                 listener.exitConditional_expression(self)
4516
4517
4518
4519
4520     def conditional_expression(self):
4521
4522         localctx = CParser.Conditional_expressionContext(self, self._ctx, self.state)
4523         self.enterRule(localctx, 100, self.RULE_conditional_expression)
4524         self._la = 0 # Token type
4525         try:
4526             self.enterOuterAlt(localctx, 1)
4527             self.state = 670
4528             localctx.e = self.logical_or_expression()
4529             self.state = 677
4530             self._errHandler.sync(self)
4531             _la = self._input.LA(1)
4532             if _la==CParser.T__65:
4533                 self.state = 671
4534                 self.match(CParser.T__65)
4535                 self.state = 672
4536                 self.expression()
4537                 self.state = 673
4538                 self.match(CParser.T__22)
4539                 self.state = 674
4540                 self.conditional_expression()
4541                 self.StorePredicateExpression((None if localctx.e is None else localctx.e.start).line, (None if localctx.e is None else localctx.e.start).column, (None if localctx.e is None else localctx.e.stop).line, (None if localctx.e is None else localctx.e.stop).column, (None if localctx.e is None else self._input.getText((localctx.e.start,localctx.e.stop))))
4542
4543
4544         except RecognitionException as re:
4545             localctx.exception = re
4546             self._errHandler.reportError(self, re)
4547             self._errHandler.recover(self, re)
4548         finally:
4549             self.exitRule()
4550         return localctx
4551
4552     class Logical_or_expressionContext(ParserRuleContext):
4553
4554         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4555             super().__init__(parent, invokingState)
4556             self.parser = parser
4557
4558         def logical_and_expression(self, i:int=None):
4559             if i is None:
4560                 return self.getTypedRuleContexts(CParser.Logical_and_expressionContext)
4561             else:
4562                 return self.getTypedRuleContext(CParser.Logical_and_expressionContext,i)
4563
4564
4565         def getRuleIndex(self):
4566             return CParser.RULE_logical_or_expression
4567
4568         def enterRule(self, listener:ParseTreeListener):
4569             if hasattr( listener, "enterLogical_or_expression" ):
4570                 listener.enterLogical_or_expression(self)
4571
4572         def exitRule(self, listener:ParseTreeListener):
4573             if hasattr( listener, "exitLogical_or_expression" ):
4574                 listener.exitLogical_or_expression(self)
4575
4576
4577
4578
4579     def logical_or_expression(self):
4580
4581         localctx = CParser.Logical_or_expressionContext(self, self._ctx, self.state)
4582         self.enterRule(localctx, 102, self.RULE_logical_or_expression)
4583         self._la = 0 # Token type
4584         try:
4585             self.enterOuterAlt(localctx, 1)
4586             self.state = 679
4587             self.logical_and_expression()
4588             self.state = 684
4589             self._errHandler.sync(self)
4590             _la = self._input.LA(1)
4591             while _la==CParser.T__66:
4592                 self.state = 680
4593                 self.match(CParser.T__66)
4594                 self.state = 681
4595                 self.logical_and_expression()
4596                 self.state = 686
4597                 self._errHandler.sync(self)
4598                 _la = self._input.LA(1)
4599
4600         except RecognitionException as re:
4601             localctx.exception = re
4602             self._errHandler.reportError(self, re)
4603             self._errHandler.recover(self, re)
4604         finally:
4605             self.exitRule()
4606         return localctx
4607
4608     class Logical_and_expressionContext(ParserRuleContext):
4609
4610         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4611             super().__init__(parent, invokingState)
4612             self.parser = parser
4613
4614         def inclusive_or_expression(self, i:int=None):
4615             if i is None:
4616                 return self.getTypedRuleContexts(CParser.Inclusive_or_expressionContext)
4617             else:
4618                 return self.getTypedRuleContext(CParser.Inclusive_or_expressionContext,i)
4619
4620
4621         def getRuleIndex(self):
4622             return CParser.RULE_logical_and_expression
4623
4624         def enterRule(self, listener:ParseTreeListener):
4625             if hasattr( listener, "enterLogical_and_expression" ):
4626                 listener.enterLogical_and_expression(self)
4627
4628         def exitRule(self, listener:ParseTreeListener):
4629             if hasattr( listener, "exitLogical_and_expression" ):
4630                 listener.exitLogical_and_expression(self)
4631
4632
4633
4634
4635     def logical_and_expression(self):
4636
4637         localctx = CParser.Logical_and_expressionContext(self, self._ctx, self.state)
4638         self.enterRule(localctx, 104, self.RULE_logical_and_expression)
4639         self._la = 0 # Token type
4640         try:
4641             self.enterOuterAlt(localctx, 1)
4642             self.state = 687
4643             self.inclusive_or_expression()
4644             self.state = 692
4645             self._errHandler.sync(self)
4646             _la = self._input.LA(1)
4647             while _la==CParser.T__67:
4648                 self.state = 688
4649                 self.match(CParser.T__67)
4650                 self.state = 689
4651                 self.inclusive_or_expression()
4652                 self.state = 694
4653                 self._errHandler.sync(self)
4654                 _la = self._input.LA(1)
4655
4656         except RecognitionException as re:
4657             localctx.exception = re
4658             self._errHandler.reportError(self, re)
4659             self._errHandler.recover(self, re)
4660         finally:
4661             self.exitRule()
4662         return localctx
4663
4664     class Inclusive_or_expressionContext(ParserRuleContext):
4665
4666         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4667             super().__init__(parent, invokingState)
4668             self.parser = parser
4669
4670         def exclusive_or_expression(self, i:int=None):
4671             if i is None:
4672                 return self.getTypedRuleContexts(CParser.Exclusive_or_expressionContext)
4673             else:
4674                 return self.getTypedRuleContext(CParser.Exclusive_or_expressionContext,i)
4675
4676
4677         def getRuleIndex(self):
4678             return CParser.RULE_inclusive_or_expression
4679
4680         def enterRule(self, listener:ParseTreeListener):
4681             if hasattr( listener, "enterInclusive_or_expression" ):
4682                 listener.enterInclusive_or_expression(self)
4683
4684         def exitRule(self, listener:ParseTreeListener):
4685             if hasattr( listener, "exitInclusive_or_expression" ):
4686                 listener.exitInclusive_or_expression(self)
4687
4688
4689
4690
4691     def inclusive_or_expression(self):
4692
4693         localctx = CParser.Inclusive_or_expressionContext(self, self._ctx, self.state)
4694         self.enterRule(localctx, 106, self.RULE_inclusive_or_expression)
4695         self._la = 0 # Token type
4696         try:
4697             self.enterOuterAlt(localctx, 1)
4698             self.state = 695
4699             self.exclusive_or_expression()
4700             self.state = 700
4701             self._errHandler.sync(self)
4702             _la = self._input.LA(1)
4703             while _la==CParser.T__68:
4704                 self.state = 696
4705                 self.match(CParser.T__68)
4706                 self.state = 697
4707                 self.exclusive_or_expression()
4708                 self.state = 702
4709                 self._errHandler.sync(self)
4710                 _la = self._input.LA(1)
4711
4712         except RecognitionException as re:
4713             localctx.exception = re
4714             self._errHandler.reportError(self, re)
4715             self._errHandler.recover(self, re)
4716         finally:
4717             self.exitRule()
4718         return localctx
4719
4720     class Exclusive_or_expressionContext(ParserRuleContext):
4721
4722         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4723             super().__init__(parent, invokingState)
4724             self.parser = parser
4725
4726         def and_expression(self, i:int=None):
4727             if i is None:
4728                 return self.getTypedRuleContexts(CParser.And_expressionContext)
4729             else:
4730                 return self.getTypedRuleContext(CParser.And_expressionContext,i)
4731
4732
4733         def getRuleIndex(self):
4734             return CParser.RULE_exclusive_or_expression
4735
4736         def enterRule(self, listener:ParseTreeListener):
4737             if hasattr( listener, "enterExclusive_or_expression" ):
4738                 listener.enterExclusive_or_expression(self)
4739
4740         def exitRule(self, listener:ParseTreeListener):
4741             if hasattr( listener, "exitExclusive_or_expression" ):
4742                 listener.exitExclusive_or_expression(self)
4743
4744
4745
4746
4747     def exclusive_or_expression(self):
4748
4749         localctx = CParser.Exclusive_or_expressionContext(self, self._ctx, self.state)
4750         self.enterRule(localctx, 108, self.RULE_exclusive_or_expression)
4751         self._la = 0 # Token type
4752         try:
4753             self.enterOuterAlt(localctx, 1)
4754             self.state = 703
4755             self.and_expression()
4756             self.state = 708
4757             self._errHandler.sync(self)
4758             _la = self._input.LA(1)
4759             while _la==CParser.T__69:
4760                 self.state = 704
4761                 self.match(CParser.T__69)
4762                 self.state = 705
4763                 self.and_expression()
4764                 self.state = 710
4765                 self._errHandler.sync(self)
4766                 _la = self._input.LA(1)
4767
4768         except RecognitionException as re:
4769             localctx.exception = re
4770             self._errHandler.reportError(self, re)
4771             self._errHandler.recover(self, re)
4772         finally:
4773             self.exitRule()
4774         return localctx
4775
4776     class And_expressionContext(ParserRuleContext):
4777
4778         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4779             super().__init__(parent, invokingState)
4780             self.parser = parser
4781
4782         def equality_expression(self, i:int=None):
4783             if i is None:
4784                 return self.getTypedRuleContexts(CParser.Equality_expressionContext)
4785             else:
4786                 return self.getTypedRuleContext(CParser.Equality_expressionContext,i)
4787
4788
4789         def getRuleIndex(self):
4790             return CParser.RULE_and_expression
4791
4792         def enterRule(self, listener:ParseTreeListener):
4793             if hasattr( listener, "enterAnd_expression" ):
4794                 listener.enterAnd_expression(self)
4795
4796         def exitRule(self, listener:ParseTreeListener):
4797             if hasattr( listener, "exitAnd_expression" ):
4798                 listener.exitAnd_expression(self)
4799
4800
4801
4802
4803     def and_expression(self):
4804
4805         localctx = CParser.And_expressionContext(self, self._ctx, self.state)
4806         self.enterRule(localctx, 110, self.RULE_and_expression)
4807         self._la = 0 # Token type
4808         try:
4809             self.enterOuterAlt(localctx, 1)
4810             self.state = 711
4811             self.equality_expression()
4812             self.state = 716
4813             self._errHandler.sync(self)
4814             _la = self._input.LA(1)
4815             while _la==CParser.T__52:
4816                 self.state = 712
4817                 self.match(CParser.T__52)
4818                 self.state = 713
4819                 self.equality_expression()
4820                 self.state = 718
4821                 self._errHandler.sync(self)
4822                 _la = self._input.LA(1)
4823
4824         except RecognitionException as re:
4825             localctx.exception = re
4826             self._errHandler.reportError(self, re)
4827             self._errHandler.recover(self, re)
4828         finally:
4829             self.exitRule()
4830         return localctx
4831
4832     class Equality_expressionContext(ParserRuleContext):
4833
4834         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4835             super().__init__(parent, invokingState)
4836             self.parser = parser
4837
4838         def relational_expression(self, i:int=None):
4839             if i is None:
4840                 return self.getTypedRuleContexts(CParser.Relational_expressionContext)
4841             else:
4842                 return self.getTypedRuleContext(CParser.Relational_expressionContext,i)
4843
4844
4845         def getRuleIndex(self):
4846             return CParser.RULE_equality_expression
4847
4848         def enterRule(self, listener:ParseTreeListener):
4849             if hasattr( listener, "enterEquality_expression" ):
4850                 listener.enterEquality_expression(self)
4851
4852         def exitRule(self, listener:ParseTreeListener):
4853             if hasattr( listener, "exitEquality_expression" ):
4854                 listener.exitEquality_expression(self)
4855
4856
4857
4858
4859     def equality_expression(self):
4860
4861         localctx = CParser.Equality_expressionContext(self, self._ctx, self.state)
4862         self.enterRule(localctx, 112, self.RULE_equality_expression)
4863         self._la = 0 # Token type
4864         try:
4865             self.enterOuterAlt(localctx, 1)
4866             self.state = 719
4867             self.relational_expression()
4868             self.state = 724
4869             self._errHandler.sync(self)
4870             _la = self._input.LA(1)
4871             while _la==CParser.T__70 or _la==CParser.T__71:
4872                 self.state = 720
4873                 _la = self._input.LA(1)
4874                 if not(_la==CParser.T__70 or _la==CParser.T__71):
4875                     self._errHandler.recoverInline(self)
4876                 else:
4877                     self._errHandler.reportMatch(self)
4878                     self.consume()
4879                 self.state = 721
4880                 self.relational_expression()
4881                 self.state = 726
4882                 self._errHandler.sync(self)
4883                 _la = self._input.LA(1)
4884
4885         except RecognitionException as re:
4886             localctx.exception = re
4887             self._errHandler.reportError(self, re)
4888             self._errHandler.recover(self, re)
4889         finally:
4890             self.exitRule()
4891         return localctx
4892
4893     class Relational_expressionContext(ParserRuleContext):
4894
4895         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4896             super().__init__(parent, invokingState)
4897             self.parser = parser
4898
4899         def shift_expression(self, i:int=None):
4900             if i is None:
4901                 return self.getTypedRuleContexts(CParser.Shift_expressionContext)
4902             else:
4903                 return self.getTypedRuleContext(CParser.Shift_expressionContext,i)
4904
4905
4906         def getRuleIndex(self):
4907             return CParser.RULE_relational_expression
4908
4909         def enterRule(self, listener:ParseTreeListener):
4910             if hasattr( listener, "enterRelational_expression" ):
4911                 listener.enterRelational_expression(self)
4912
4913         def exitRule(self, listener:ParseTreeListener):
4914             if hasattr( listener, "exitRelational_expression" ):
4915                 listener.exitRelational_expression(self)
4916
4917
4918
4919
4920     def relational_expression(self):
4921
4922         localctx = CParser.Relational_expressionContext(self, self._ctx, self.state)
4923         self.enterRule(localctx, 114, self.RULE_relational_expression)
4924         self._la = 0 # Token type
4925         try:
4926             self.enterOuterAlt(localctx, 1)
4927             self.state = 727
4928             self.shift_expression()
4929             self.state = 732
4930             self._errHandler.sync(self)
4931             _la = self._input.LA(1)
4932             while ((((_la - 73)) & ~0x3f) == 0 and ((1 << (_la - 73)) & ((1 << (CParser.T__72 - 73)) | (1 << (CParser.T__73 - 73)) | (1 << (CParser.T__74 - 73)) | (1 << (CParser.T__75 - 73)))) != 0):
4933                 self.state = 728
4934                 _la = self._input.LA(1)
4935                 if not(((((_la - 73)) & ~0x3f) == 0 and ((1 << (_la - 73)) & ((1 << (CParser.T__72 - 73)) | (1 << (CParser.T__73 - 73)) | (1 << (CParser.T__74 - 73)) | (1 << (CParser.T__75 - 73)))) != 0)):
4936                     self._errHandler.recoverInline(self)
4937                 else:
4938                     self._errHandler.reportMatch(self)
4939                     self.consume()
4940                 self.state = 729
4941                 self.shift_expression()
4942                 self.state = 734
4943                 self._errHandler.sync(self)
4944                 _la = self._input.LA(1)
4945
4946         except RecognitionException as re:
4947             localctx.exception = re
4948             self._errHandler.reportError(self, re)
4949             self._errHandler.recover(self, re)
4950         finally:
4951             self.exitRule()
4952         return localctx
4953
4954     class Shift_expressionContext(ParserRuleContext):
4955
4956         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4957             super().__init__(parent, invokingState)
4958             self.parser = parser
4959
4960         def additive_expression(self, i:int=None):
4961             if i is None:
4962                 return self.getTypedRuleContexts(CParser.Additive_expressionContext)
4963             else:
4964                 return self.getTypedRuleContext(CParser.Additive_expressionContext,i)
4965
4966
4967         def getRuleIndex(self):
4968             return CParser.RULE_shift_expression
4969
4970         def enterRule(self, listener:ParseTreeListener):
4971             if hasattr( listener, "enterShift_expression" ):
4972                 listener.enterShift_expression(self)
4973
4974         def exitRule(self, listener:ParseTreeListener):
4975             if hasattr( listener, "exitShift_expression" ):
4976                 listener.exitShift_expression(self)
4977
4978
4979
4980
4981     def shift_expression(self):
4982
4983         localctx = CParser.Shift_expressionContext(self, self._ctx, self.state)
4984         self.enterRule(localctx, 116, self.RULE_shift_expression)
4985         self._la = 0 # Token type
4986         try:
4987             self.enterOuterAlt(localctx, 1)
4988             self.state = 735
4989             self.additive_expression()
4990             self.state = 740
4991             self._errHandler.sync(self)
4992             _la = self._input.LA(1)
4993             while _la==CParser.T__76 or _la==CParser.T__77:
4994                 self.state = 736
4995                 _la = self._input.LA(1)
4996                 if not(_la==CParser.T__76 or _la==CParser.T__77):
4997                     self._errHandler.recoverInline(self)
4998                 else:
4999                     self._errHandler.reportMatch(self)
5000                     self.consume()
5001                 self.state = 737
5002                 self.additive_expression()
5003                 self.state = 742
5004                 self._errHandler.sync(self)
5005                 _la = self._input.LA(1)
5006
5007         except RecognitionException as re:
5008             localctx.exception = re
5009             self._errHandler.reportError(self, re)
5010             self._errHandler.recover(self, re)
5011         finally:
5012             self.exitRule()
5013         return localctx
5014
5015     class StatementContext(ParserRuleContext):
5016
5017         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5018             super().__init__(parent, invokingState)
5019             self.parser = parser
5020
5021         def labeled_statement(self):
5022             return self.getTypedRuleContext(CParser.Labeled_statementContext,0)
5023
5024
5025         def compound_statement(self):
5026             return self.getTypedRuleContext(CParser.Compound_statementContext,0)
5027
5028
5029         def expression_statement(self):
5030             return self.getTypedRuleContext(CParser.Expression_statementContext,0)
5031
5032
5033         def selection_statement(self):
5034             return self.getTypedRuleContext(CParser.Selection_statementContext,0)
5035
5036
5037         def iteration_statement(self):
5038             return self.getTypedRuleContext(CParser.Iteration_statementContext,0)
5039
5040
5041         def jump_statement(self):
5042             return self.getTypedRuleContext(CParser.Jump_statementContext,0)
5043
5044
5045         def macro_statement(self):
5046             return self.getTypedRuleContext(CParser.Macro_statementContext,0)
5047
5048
5049         def asm2_statement(self):
5050             return self.getTypedRuleContext(CParser.Asm2_statementContext,0)
5051
5052
5053         def asm1_statement(self):
5054             return self.getTypedRuleContext(CParser.Asm1_statementContext,0)
5055
5056
5057         def asm_statement(self):
5058             return self.getTypedRuleContext(CParser.Asm_statementContext,0)
5059
5060
5061         def declaration(self):
5062             return self.getTypedRuleContext(CParser.DeclarationContext,0)
5063
5064
5065         def getRuleIndex(self):
5066             return CParser.RULE_statement
5067
5068         def enterRule(self, listener:ParseTreeListener):
5069             if hasattr( listener, "enterStatement" ):
5070                 listener.enterStatement(self)
5071
5072         def exitRule(self, listener:ParseTreeListener):
5073             if hasattr( listener, "exitStatement" ):
5074                 listener.exitStatement(self)
5075
5076
5077
5078
5079     def statement(self):
5080
5081         localctx = CParser.StatementContext(self, self._ctx, self.state)
5082         self.enterRule(localctx, 118, self.RULE_statement)
5083         try:
5084             self.state = 754
5085             self._errHandler.sync(self)
5086             la_ = self._interp.adaptivePredict(self._input,92,self._ctx)
5087             if la_ == 1:
5088                 self.enterOuterAlt(localctx, 1)
5089                 self.state = 743
5090                 self.labeled_statement()
5091                 pass
5092
5093             elif la_ == 2:
5094                 self.enterOuterAlt(localctx, 2)
5095                 self.state = 744
5096                 self.compound_statement()
5097                 pass
5098
5099             elif la_ == 3:
5100                 self.enterOuterAlt(localctx, 3)
5101                 self.state = 745
5102                 self.expression_statement()
5103                 pass
5104
5105             elif la_ == 4:
5106                 self.enterOuterAlt(localctx, 4)
5107                 self.state = 746
5108                 self.selection_statement()
5109                 pass
5110
5111             elif la_ == 5:
5112                 self.enterOuterAlt(localctx, 5)
5113                 self.state = 747
5114                 self.iteration_statement()
5115                 pass
5116
5117             elif la_ == 6:
5118                 self.enterOuterAlt(localctx, 6)
5119                 self.state = 748
5120                 self.jump_statement()
5121                 pass
5122
5123             elif la_ == 7:
5124                 self.enterOuterAlt(localctx, 7)
5125                 self.state = 749
5126                 self.macro_statement()
5127                 pass
5128
5129             elif la_ == 8:
5130                 self.enterOuterAlt(localctx, 8)
5131                 self.state = 750
5132                 self.asm2_statement()
5133                 pass
5134
5135             elif la_ == 9:
5136                 self.enterOuterAlt(localctx, 9)
5137                 self.state = 751
5138                 self.asm1_statement()
5139                 pass
5140
5141             elif la_ == 10:
5142                 self.enterOuterAlt(localctx, 10)
5143                 self.state = 752
5144                 self.asm_statement()
5145                 pass
5146
5147             elif la_ == 11:
5148                 self.enterOuterAlt(localctx, 11)
5149                 self.state = 753
5150                 self.declaration()
5151                 pass
5152
5153
5154         except RecognitionException as re:
5155             localctx.exception = re
5156             self._errHandler.reportError(self, re)
5157             self._errHandler.recover(self, re)
5158         finally:
5159             self.exitRule()
5160         return localctx
5161
5162     class Asm2_statementContext(ParserRuleContext):
5163
5164         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5165             super().__init__(parent, invokingState)
5166             self.parser = parser
5167
5168         def IDENTIFIER(self):
5169             return self.getToken(CParser.IDENTIFIER, 0)
5170
5171         def getRuleIndex(self):
5172             return CParser.RULE_asm2_statement
5173
5174         def enterRule(self, listener:ParseTreeListener):
5175             if hasattr( listener, "enterAsm2_statement" ):
5176                 listener.enterAsm2_statement(self)
5177
5178         def exitRule(self, listener:ParseTreeListener):
5179             if hasattr( listener, "exitAsm2_statement" ):
5180                 listener.exitAsm2_statement(self)
5181
5182
5183
5184
5185     def asm2_statement(self):
5186
5187         localctx = CParser.Asm2_statementContext(self, self._ctx, self.state)
5188         self.enterRule(localctx, 120, self.RULE_asm2_statement)
5189         self._la = 0 # Token type
5190         try:
5191             self.enterOuterAlt(localctx, 1)
5192             self.state = 757
5193             self._errHandler.sync(self)
5194             _la = self._input.LA(1)
5195             if _la==CParser.T__78:
5196                 self.state = 756
5197                 self.match(CParser.T__78)
5198
5199
5200             self.state = 759
5201             self.match(CParser.IDENTIFIER)
5202             self.state = 760
5203             self.match(CParser.T__37)
5204             self.state = 764
5205             self._errHandler.sync(self)
5206             _alt = self._interp.adaptivePredict(self._input,94,self._ctx)
5207             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
5208                 if _alt==1:
5209                     self.state = 761
5210                     _la = self._input.LA(1)
5211                     if _la <= 0 or _la==CParser.T__1:
5212                         self._errHandler.recoverInline(self)
5213                     else:
5214                         self._errHandler.reportMatch(self)
5215                         self.consume()
5216                 self.state = 766
5217                 self._errHandler.sync(self)
5218                 _alt = self._interp.adaptivePredict(self._input,94,self._ctx)
5219
5220             self.state = 767
5221             self.match(CParser.T__38)
5222             self.state = 768
5223             self.match(CParser.T__1)
5224         except RecognitionException as re:
5225             localctx.exception = re
5226             self._errHandler.reportError(self, re)
5227             self._errHandler.recover(self, re)
5228         finally:
5229             self.exitRule()
5230         return localctx
5231
5232     class Asm1_statementContext(ParserRuleContext):
5233
5234         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5235             super().__init__(parent, invokingState)
5236             self.parser = parser
5237
5238
5239         def getRuleIndex(self):
5240             return CParser.RULE_asm1_statement
5241
5242         def enterRule(self, listener:ParseTreeListener):
5243             if hasattr( listener, "enterAsm1_statement" ):
5244                 listener.enterAsm1_statement(self)
5245
5246         def exitRule(self, listener:ParseTreeListener):
5247             if hasattr( listener, "exitAsm1_statement" ):
5248                 listener.exitAsm1_statement(self)
5249
5250
5251
5252
5253     def asm1_statement(self):
5254
5255         localctx = CParser.Asm1_statementContext(self, self._ctx, self.state)
5256         self.enterRule(localctx, 122, self.RULE_asm1_statement)
5257         self._la = 0 # Token type
5258         try:
5259             self.enterOuterAlt(localctx, 1)
5260             self.state = 770
5261             self.match(CParser.T__79)
5262             self.state = 771
5263             self.match(CParser.T__0)
5264             self.state = 775
5265             self._errHandler.sync(self)
5266             _la = self._input.LA(1)
5267             while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9) | (1 << CParser.T__10) | (1 << CParser.T__11) | (1 << CParser.T__12) | (1 << CParser.T__13) | (1 << CParser.T__14) | (1 << CParser.T__15) | (1 << CParser.T__16) | (1 << CParser.T__17) | (1 << CParser.T__18) | (1 << CParser.T__20) | (1 << CParser.T__21) | (1 << CParser.T__22) | (1 << CParser.T__23) | (1 << CParser.T__24) | (1 << CParser.T__25) | (1 << CParser.T__26) | (1 << CParser.T__27) | (1 << CParser.T__28) | (1 << CParser.T__29) | (1 << CParser.T__30) | (1 << CParser.T__31) | (1 << CParser.T__32) | (1 << CParser.T__33) | (1 << CParser.T__34) | (1 << CParser.T__35) | (1 << CParser.T__36) | (1 << CParser.T__37) | (1 << CParser.T__38) | (1 << CParser.T__39) | (1 << CParser.T__40) | (1 << CParser.T__41) | (1 << CParser.T__42) | (1 << CParser.T__43) | (1 << CParser.T__44) | (1 << CParser.T__45) | (1 << CParser.T__46) | (1 << CParser.T__47) | (1 << CParser.T__48) | (1 << CParser.T__49) | (1 << CParser.T__50) | (1 << CParser.T__51) | (1 << CParser.T__52) | (1 << CParser.T__53) | (1 << CParser.T__54) | (1 << CParser.T__55) | (1 << CParser.T__56) | (1 << CParser.T__57) | (1 << CParser.T__58) | (1 << CParser.T__59) | (1 << CParser.T__60) | (1 << CParser.T__61) | (1 << CParser.T__62))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CParser.T__63 - 64)) | (1 << (CParser.T__64 - 64)) | (1 << (CParser.T__65 - 64)) | (1 << (CParser.T__66 - 64)) | (1 << (CParser.T__67 - 64)) | (1 << (CParser.T__68 - 64)) | (1 << (CParser.T__69 - 64)) | (1 << (CParser.T__70 - 64)) | (1 << (CParser.T__71 - 64)) | (1 << (CParser.T__72 - 64)) | (1 << (CParser.T__73 - 64)) | (1 << (CParser.T__74 - 64)) | (1 << (CParser.T__75 - 64)) | (1 << (CParser.T__76 - 64)) | (1 << (CParser.T__77 - 64)) | (1 << (CParser.T__78 - 64)) | (1 << (CParser.T__79 - 64)) | (1 << (CParser.T__80 - 64)) | (1 << (CParser.T__81 - 64)) | (1 << (CParser.T__82 - 64)) | (1 << (CParser.T__83 - 64)) | (1 << (CParser.T__84 - 64)) | (1 << (CParser.T__85 - 64)) | (1 << (CParser.T__86 - 64)) | (1 << (CParser.T__87 - 64)) | (1 << (CParser.T__88 - 64)) | (1 << (CParser.T__89 - 64)) | (1 << (CParser.T__90 - 64)) | (1 << (CParser.T__91 - 64)) | (1 << (CParser.IDENTIFIER - 64)) | (1 << (CParser.CHARACTER_LITERAL - 64)) | (1 << (CParser.STRING_LITERAL - 64)) | (1 << (CParser.HEX_LITERAL - 64)) | (1 << (CParser.DECIMAL_LITERAL - 64)) | (1 << (CParser.OCTAL_LITERAL - 64)) | (1 << (CParser.FLOATING_POINT_LITERAL - 64)) | (1 << (CParser.WS - 64)) | (1 << (CParser.BS - 64)) | (1 << (CParser.UnicodeVocabulary - 64)) | (1 << (CParser.COMMENT - 64)) | (1 << (CParser.LINE_COMMENT - 64)) | (1 << (CParser.LINE_COMMAND - 64)))) != 0):
5268                 self.state = 772
5269                 _la = self._input.LA(1)
5270                 if _la <= 0 or _la==CParser.T__19:
5271                     self._errHandler.recoverInline(self)
5272                 else:
5273                     self._errHandler.reportMatch(self)
5274                     self.consume()
5275                 self.state = 777
5276                 self._errHandler.sync(self)
5277                 _la = self._input.LA(1)
5278
5279             self.state = 778
5280             self.match(CParser.T__19)
5281         except RecognitionException as re:
5282             localctx.exception = re
5283             self._errHandler.reportError(self, re)
5284             self._errHandler.recover(self, re)
5285         finally:
5286             self.exitRule()
5287         return localctx
5288
5289     class Asm_statementContext(ParserRuleContext):
5290
5291         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5292             super().__init__(parent, invokingState)
5293             self.parser = parser
5294
5295
5296         def getRuleIndex(self):
5297             return CParser.RULE_asm_statement
5298
5299         def enterRule(self, listener:ParseTreeListener):
5300             if hasattr( listener, "enterAsm_statement" ):
5301                 listener.enterAsm_statement(self)
5302
5303         def exitRule(self, listener:ParseTreeListener):
5304             if hasattr( listener, "exitAsm_statement" ):
5305                 listener.exitAsm_statement(self)
5306
5307
5308
5309
5310     def asm_statement(self):
5311
5312         localctx = CParser.Asm_statementContext(self, self._ctx, self.state)
5313         self.enterRule(localctx, 124, self.RULE_asm_statement)
5314         self._la = 0 # Token type
5315         try:
5316             self.enterOuterAlt(localctx, 1)
5317             self.state = 780
5318             self.match(CParser.T__80)
5319             self.state = 781
5320             self.match(CParser.T__0)
5321             self.state = 785
5322             self._errHandler.sync(self)
5323             _la = self._input.LA(1)
5324             while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9) | (1 << CParser.T__10) | (1 << CParser.T__11) | (1 << CParser.T__12) | (1 << CParser.T__13) | (1 << CParser.T__14) | (1 << CParser.T__15) | (1 << CParser.T__16) | (1 << CParser.T__17) | (1 << CParser.T__18) | (1 << CParser.T__20) | (1 << CParser.T__21) | (1 << CParser.T__22) | (1 << CParser.T__23) | (1 << CParser.T__24) | (1 << CParser.T__25) | (1 << CParser.T__26) | (1 << CParser.T__27) | (1 << CParser.T__28) | (1 << CParser.T__29) | (1 << CParser.T__30) | (1 << CParser.T__31) | (1 << CParser.T__32) | (1 << CParser.T__33) | (1 << CParser.T__34) | (1 << CParser.T__35) | (1 << CParser.T__36) | (1 << CParser.T__37) | (1 << CParser.T__38) | (1 << CParser.T__39) | (1 << CParser.T__40) | (1 << CParser.T__41) | (1 << CParser.T__42) | (1 << CParser.T__43) | (1 << CParser.T__44) | (1 << CParser.T__45) | (1 << CParser.T__46) | (1 << CParser.T__47) | (1 << CParser.T__48) | (1 << CParser.T__49) | (1 << CParser.T__50) | (1 << CParser.T__51) | (1 << CParser.T__52) | (1 << CParser.T__53) | (1 << CParser.T__54) | (1 << CParser.T__55) | (1 << CParser.T__56) | (1 << CParser.T__57) | (1 << CParser.T__58) | (1 << CParser.T__59) | (1 << CParser.T__60) | (1 << CParser.T__61) | (1 << CParser.T__62))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CParser.T__63 - 64)) | (1 << (CParser.T__64 - 64)) | (1 << (CParser.T__65 - 64)) | (1 << (CParser.T__66 - 64)) | (1 << (CParser.T__67 - 64)) | (1 << (CParser.T__68 - 64)) | (1 << (CParser.T__69 - 64)) | (1 << (CParser.T__70 - 64)) | (1 << (CParser.T__71 - 64)) | (1 << (CParser.T__72 - 64)) | (1 << (CParser.T__73 - 64)) | (1 << (CParser.T__74 - 64)) | (1 << (CParser.T__75 - 64)) | (1 << (CParser.T__76 - 64)) | (1 << (CParser.T__77 - 64)) | (1 << (CParser.T__78 - 64)) | (1 << (CParser.T__79 - 64)) | (1 << (CParser.T__80 - 64)) | (1 << (CParser.T__81 - 64)) | (1 << (CParser.T__82 - 64)) | (1 << (CParser.T__83 - 64)) | (1 << (CParser.T__84 - 64)) | (1 << (CParser.T__85 - 64)) | (1 << (CParser.T__86 - 64)) | (1 << (CParser.T__87 - 64)) | (1 << (CParser.T__88 - 64)) | (1 << (CParser.T__89 - 64)) | (1 << (CParser.T__90 - 64)) | (1 << (CParser.T__91 - 64)) | (1 << (CParser.IDENTIFIER - 64)) | (1 << (CParser.CHARACTER_LITERAL - 64)) | (1 << (CParser.STRING_LITERAL - 64)) | (1 << (CParser.HEX_LITERAL - 64)) | (1 << (CParser.DECIMAL_LITERAL - 64)) | (1 << (CParser.OCTAL_LITERAL - 64)) | (1 << (CParser.FLOATING_POINT_LITERAL - 64)) | (1 << (CParser.WS - 64)) | (1 << (CParser.BS - 64)) | (1 << (CParser.UnicodeVocabulary - 64)) | (1 << (CParser.COMMENT - 64)) | (1 << (CParser.LINE_COMMENT - 64)) | (1 << (CParser.LINE_COMMAND - 64)))) != 0):
5325                 self.state = 782
5326                 _la = self._input.LA(1)
5327                 if _la <= 0 or _la==CParser.T__19:
5328                     self._errHandler.recoverInline(self)
5329                 else:
5330                     self._errHandler.reportMatch(self)
5331                     self.consume()
5332                 self.state = 787
5333                 self._errHandler.sync(self)
5334                 _la = self._input.LA(1)
5335
5336             self.state = 788
5337             self.match(CParser.T__19)
5338         except RecognitionException as re:
5339             localctx.exception = re
5340             self._errHandler.reportError(self, re)
5341             self._errHandler.recover(self, re)
5342         finally:
5343             self.exitRule()
5344         return localctx
5345
5346     class Macro_statementContext(ParserRuleContext):
5347
5348         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5349             super().__init__(parent, invokingState)
5350             self.parser = parser
5351
5352         def IDENTIFIER(self):
5353             return self.getToken(CParser.IDENTIFIER, 0)
5354
5355         def declaration(self, i:int=None):
5356             if i is None:
5357                 return self.getTypedRuleContexts(CParser.DeclarationContext)
5358             else:
5359                 return self.getTypedRuleContext(CParser.DeclarationContext,i)
5360
5361
5362         def statement_list(self):
5363             return self.getTypedRuleContext(CParser.Statement_listContext,0)
5364
5365
5366         def expression(self):
5367             return self.getTypedRuleContext(CParser.ExpressionContext,0)
5368
5369
5370         def getRuleIndex(self):
5371             return CParser.RULE_macro_statement
5372
5373         def enterRule(self, listener:ParseTreeListener):
5374             if hasattr( listener, "enterMacro_statement" ):
5375                 listener.enterMacro_statement(self)
5376
5377         def exitRule(self, listener:ParseTreeListener):
5378             if hasattr( listener, "exitMacro_statement" ):
5379                 listener.exitMacro_statement(self)
5380
5381
5382
5383
5384     def macro_statement(self):
5385
5386         localctx = CParser.Macro_statementContext(self, self._ctx, self.state)
5387         self.enterRule(localctx, 126, self.RULE_macro_statement)
5388         self._la = 0 # Token type
5389         try:
5390             self.enterOuterAlt(localctx, 1)
5391             self.state = 790
5392             self.match(CParser.IDENTIFIER)
5393             self.state = 791
5394             self.match(CParser.T__37)
5395             self.state = 795
5396             self._errHandler.sync(self)
5397             _alt = self._interp.adaptivePredict(self._input,97,self._ctx)
5398             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
5399                 if _alt==1:
5400                     self.state = 792
5401                     self.declaration()
5402                 self.state = 797
5403                 self._errHandler.sync(self)
5404                 _alt = self._interp.adaptivePredict(self._input,97,self._ctx)
5405
5406             self.state = 799
5407             self._errHandler.sync(self)
5408             la_ = self._interp.adaptivePredict(self._input,98,self._ctx)
5409             if la_ == 1:
5410                 self.state = 798
5411                 self.statement_list()
5412
5413
5414             self.state = 802
5415             self._errHandler.sync(self)
5416             _la = self._input.LA(1)
5417             if ((((_la - 38)) & ~0x3f) == 0 and ((1 << (_la - 38)) & ((1 << (CParser.T__37 - 38)) | (1 << (CParser.T__41 - 38)) | (1 << (CParser.T__43 - 38)) | (1 << (CParser.T__44 - 38)) | (1 << (CParser.T__47 - 38)) | (1 << (CParser.T__48 - 38)) | (1 << (CParser.T__49 - 38)) | (1 << (CParser.T__52 - 38)) | (1 << (CParser.T__53 - 38)) | (1 << (CParser.T__54 - 38)) | (1 << (CParser.IDENTIFIER - 38)) | (1 << (CParser.CHARACTER_LITERAL - 38)) | (1 << (CParser.STRING_LITERAL - 38)) | (1 << (CParser.HEX_LITERAL - 38)) | (1 << (CParser.DECIMAL_LITERAL - 38)) | (1 << (CParser.OCTAL_LITERAL - 38)) | (1 << (CParser.FLOATING_POINT_LITERAL - 38)))) != 0):
5418                 self.state = 801
5419                 self.expression()
5420
5421
5422             self.state = 804
5423             self.match(CParser.T__38)
5424         except RecognitionException as re:
5425             localctx.exception = re
5426             self._errHandler.reportError(self, re)
5427             self._errHandler.recover(self, re)
5428         finally:
5429             self.exitRule()
5430         return localctx
5431
5432     class Labeled_statementContext(ParserRuleContext):
5433
5434         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5435             super().__init__(parent, invokingState)
5436             self.parser = parser
5437
5438         def IDENTIFIER(self):
5439             return self.getToken(CParser.IDENTIFIER, 0)
5440
5441         def statement(self):
5442             return self.getTypedRuleContext(CParser.StatementContext,0)
5443
5444
5445         def constant_expression(self):
5446             return self.getTypedRuleContext(CParser.Constant_expressionContext,0)
5447
5448
5449         def getRuleIndex(self):
5450             return CParser.RULE_labeled_statement
5451
5452         def enterRule(self, listener:ParseTreeListener):
5453             if hasattr( listener, "enterLabeled_statement" ):
5454                 listener.enterLabeled_statement(self)
5455
5456         def exitRule(self, listener:ParseTreeListener):
5457             if hasattr( listener, "exitLabeled_statement" ):
5458                 listener.exitLabeled_statement(self)
5459
5460
5461
5462
5463     def labeled_statement(self):
5464
5465         localctx = CParser.Labeled_statementContext(self, self._ctx, self.state)
5466         self.enterRule(localctx, 128, self.RULE_labeled_statement)
5467         try:
5468             self.state = 817
5469             self._errHandler.sync(self)
5470             token = self._input.LA(1)
5471             if token in [CParser.IDENTIFIER]:
5472                 self.enterOuterAlt(localctx, 1)
5473                 self.state = 806
5474                 self.match(CParser.IDENTIFIER)
5475                 self.state = 807
5476                 self.match(CParser.T__22)
5477                 self.state = 808
5478                 self.statement()
5479                 pass
5480             elif token in [CParser.T__81]:
5481                 self.enterOuterAlt(localctx, 2)
5482                 self.state = 809
5483                 self.match(CParser.T__81)
5484                 self.state = 810
5485                 self.constant_expression()
5486                 self.state = 811
5487                 self.match(CParser.T__22)
5488                 self.state = 812
5489                 self.statement()
5490                 pass
5491             elif token in [CParser.T__82]:
5492                 self.enterOuterAlt(localctx, 3)
5493                 self.state = 814
5494                 self.match(CParser.T__82)
5495                 self.state = 815
5496                 self.match(CParser.T__22)
5497                 self.state = 816
5498                 self.statement()
5499                 pass
5500             else:
5501                 raise NoViableAltException(self)
5502
5503         except RecognitionException as re:
5504             localctx.exception = re
5505             self._errHandler.reportError(self, re)
5506             self._errHandler.recover(self, re)
5507         finally:
5508             self.exitRule()
5509         return localctx
5510
5511     class Compound_statementContext(ParserRuleContext):
5512
5513         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5514             super().__init__(parent, invokingState)
5515             self.parser = parser
5516
5517         def declaration(self, i:int=None):
5518             if i is None:
5519                 return self.getTypedRuleContexts(CParser.DeclarationContext)
5520             else:
5521                 return self.getTypedRuleContext(CParser.DeclarationContext,i)
5522
5523
5524         def statement_list(self):
5525             return self.getTypedRuleContext(CParser.Statement_listContext,0)
5526
5527
5528         def getRuleIndex(self):
5529             return CParser.RULE_compound_statement
5530
5531         def enterRule(self, listener:ParseTreeListener):
5532             if hasattr( listener, "enterCompound_statement" ):
5533                 listener.enterCompound_statement(self)
5534
5535         def exitRule(self, listener:ParseTreeListener):
5536             if hasattr( listener, "exitCompound_statement" ):
5537                 listener.exitCompound_statement(self)
5538
5539
5540
5541
5542     def compound_statement(self):
5543
5544         localctx = CParser.Compound_statementContext(self, self._ctx, self.state)
5545         self.enterRule(localctx, 130, self.RULE_compound_statement)
5546         self._la = 0 # Token type
5547         try:
5548             self.enterOuterAlt(localctx, 1)
5549             self.state = 819
5550             self.match(CParser.T__0)
5551             self.state = 823
5552             self._errHandler.sync(self)
5553             _alt = self._interp.adaptivePredict(self._input,101,self._ctx)
5554             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
5555                 if _alt==1:
5556                     self.state = 820
5557                     self.declaration()
5558                 self.state = 825
5559                 self._errHandler.sync(self)
5560                 _alt = self._interp.adaptivePredict(self._input,101,self._ctx)
5561
5562             self.state = 827
5563             self._errHandler.sync(self)
5564             _la = self._input.LA(1)
5565             if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9) | (1 << CParser.T__10) | (1 << CParser.T__11) | (1 << CParser.T__12) | (1 << CParser.T__13) | (1 << CParser.T__14) | (1 << CParser.T__15) | (1 << CParser.T__16) | (1 << CParser.T__17) | (1 << CParser.T__18) | (1 << CParser.T__20) | (1 << CParser.T__21) | (1 << CParser.T__23) | (1 << CParser.T__24) | (1 << CParser.T__25) | (1 << CParser.T__26) | (1 << CParser.T__27) | (1 << CParser.T__28) | (1 << CParser.T__29) | (1 << CParser.T__30) | (1 << CParser.T__31) | (1 << CParser.T__32) | (1 << CParser.T__33) | (1 << CParser.T__34) | (1 << CParser.T__35) | (1 << CParser.T__36) | (1 << CParser.T__37) | (1 << CParser.T__41) | (1 << CParser.T__43) | (1 << CParser.T__44) | (1 << CParser.T__47) | (1 << CParser.T__48) | (1 << CParser.T__49) | (1 << CParser.T__52) | (1 << CParser.T__53) | (1 << CParser.T__54))) != 0) or ((((_la - 79)) & ~0x3f) == 0 and ((1 << (_la - 79)) & ((1 << (CParser.T__78 - 79)) | (1 << (CParser.T__79 - 79)) | (1 << (CParser.T__80 - 79)) | (1 << (CParser.T__81 - 79)) | (1 << (CParser.T__82 - 79)) | (1 << (CParser.T__83 - 79)) | (1 << (CParser.T__85 - 79)) | (1 << (CParser.T__86 - 79)) | (1 << (CParser.T__87 - 79)) | (1 << (CParser.T__88 - 79)) | (1 << (CParser.T__89 - 79)) | (1 << (CParser.T__90 - 79)) | (1 << (CParser.T__91 - 79)) | (1 << (CParser.IDENTIFIER - 79)) | (1 << (CParser.CHARACTER_LITERAL - 79)) | (1 << (CParser.STRING_LITERAL - 79)) | (1 << (CParser.HEX_LITERAL - 79)) | (1 << (CParser.DECIMAL_LITERAL - 79)) | (1 << (CParser.OCTAL_LITERAL - 79)) | (1 << (CParser.FLOATING_POINT_LITERAL - 79)))) != 0):
5566                 self.state = 826
5567                 self.statement_list()
5568
5569
5570             self.state = 829
5571             self.match(CParser.T__19)
5572         except RecognitionException as re:
5573             localctx.exception = re
5574             self._errHandler.reportError(self, re)
5575             self._errHandler.recover(self, re)
5576         finally:
5577             self.exitRule()
5578         return localctx
5579
5580     class Statement_listContext(ParserRuleContext):
5581
5582         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5583             super().__init__(parent, invokingState)
5584             self.parser = parser
5585
5586         def statement(self, i:int=None):
5587             if i is None:
5588                 return self.getTypedRuleContexts(CParser.StatementContext)
5589             else:
5590                 return self.getTypedRuleContext(CParser.StatementContext,i)
5591
5592
5593         def getRuleIndex(self):
5594             return CParser.RULE_statement_list
5595
5596         def enterRule(self, listener:ParseTreeListener):
5597             if hasattr( listener, "enterStatement_list" ):
5598                 listener.enterStatement_list(self)
5599
5600         def exitRule(self, listener:ParseTreeListener):
5601             if hasattr( listener, "exitStatement_list" ):
5602                 listener.exitStatement_list(self)
5603
5604
5605
5606
5607     def statement_list(self):
5608
5609         localctx = CParser.Statement_listContext(self, self._ctx, self.state)
5610         self.enterRule(localctx, 132, self.RULE_statement_list)
5611         try:
5612             self.enterOuterAlt(localctx, 1)
5613             self.state = 832
5614             self._errHandler.sync(self)
5615             _alt = 1
5616             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
5617                 if _alt == 1:
5618                     self.state = 831
5619                     self.statement()
5620
5621                 else:
5622                     raise NoViableAltException(self)
5623                 self.state = 834
5624                 self._errHandler.sync(self)
5625                 _alt = self._interp.adaptivePredict(self._input,103,self._ctx)
5626
5627         except RecognitionException as re:
5628             localctx.exception = re
5629             self._errHandler.reportError(self, re)
5630             self._errHandler.recover(self, re)
5631         finally:
5632             self.exitRule()
5633         return localctx
5634
5635     class Expression_statementContext(ParserRuleContext):
5636
5637         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5638             super().__init__(parent, invokingState)
5639             self.parser = parser
5640
5641         def expression(self):
5642             return self.getTypedRuleContext(CParser.ExpressionContext,0)
5643
5644
5645         def getRuleIndex(self):
5646             return CParser.RULE_expression_statement
5647
5648         def enterRule(self, listener:ParseTreeListener):
5649             if hasattr( listener, "enterExpression_statement" ):
5650                 listener.enterExpression_statement(self)
5651
5652         def exitRule(self, listener:ParseTreeListener):
5653             if hasattr( listener, "exitExpression_statement" ):
5654                 listener.exitExpression_statement(self)
5655
5656
5657
5658
5659     def expression_statement(self):
5660
5661         localctx = CParser.Expression_statementContext(self, self._ctx, self.state)
5662         self.enterRule(localctx, 134, self.RULE_expression_statement)
5663         try:
5664             self.state = 840
5665             self._errHandler.sync(self)
5666             token = self._input.LA(1)
5667             if token in [CParser.T__1]:
5668                 self.enterOuterAlt(localctx, 1)
5669                 self.state = 836
5670                 self.match(CParser.T__1)
5671                 pass
5672             elif token in [CParser.T__37, CParser.T__41, CParser.T__43, CParser.T__44, CParser.T__47, CParser.T__48, CParser.T__49, CParser.T__52, CParser.T__53, CParser.T__54, CParser.IDENTIFIER, CParser.CHARACTER_LITERAL, CParser.STRING_LITERAL, CParser.HEX_LITERAL, CParser.DECIMAL_LITERAL, CParser.OCTAL_LITERAL, CParser.FLOATING_POINT_LITERAL]:
5673                 self.enterOuterAlt(localctx, 2)
5674                 self.state = 837
5675                 self.expression()
5676                 self.state = 838
5677                 self.match(CParser.T__1)
5678                 pass
5679             else:
5680                 raise NoViableAltException(self)
5681
5682         except RecognitionException as re:
5683             localctx.exception = re
5684             self._errHandler.reportError(self, re)
5685             self._errHandler.recover(self, re)
5686         finally:
5687             self.exitRule()
5688         return localctx
5689
5690     class Selection_statementContext(ParserRuleContext):
5691
5692         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5693             super().__init__(parent, invokingState)
5694             self.parser = parser
5695             self.e = None # ExpressionContext
5696
5697         def statement(self, i:int=None):
5698             if i is None:
5699                 return self.getTypedRuleContexts(CParser.StatementContext)
5700             else:
5701                 return self.getTypedRuleContext(CParser.StatementContext,i)
5702
5703
5704         def expression(self):
5705             return self.getTypedRuleContext(CParser.ExpressionContext,0)
5706
5707
5708         def getRuleIndex(self):
5709             return CParser.RULE_selection_statement
5710
5711         def enterRule(self, listener:ParseTreeListener):
5712             if hasattr( listener, "enterSelection_statement" ):
5713                 listener.enterSelection_statement(self)
5714
5715         def exitRule(self, listener:ParseTreeListener):
5716             if hasattr( listener, "exitSelection_statement" ):
5717                 listener.exitSelection_statement(self)
5718
5719
5720
5721
5722     def selection_statement(self):
5723
5724         localctx = CParser.Selection_statementContext(self, self._ctx, self.state)
5725         self.enterRule(localctx, 136, self.RULE_selection_statement)
5726         try:
5727             self.state = 858
5728             self._errHandler.sync(self)
5729             token = self._input.LA(1)
5730             if token in [CParser.T__83]:
5731                 self.enterOuterAlt(localctx, 1)
5732                 self.state = 842
5733                 self.match(CParser.T__83)
5734                 self.state = 843
5735                 self.match(CParser.T__37)
5736                 self.state = 844
5737                 localctx.e = self.expression()
5738                 self.state = 845
5739                 self.match(CParser.T__38)
5740                 self.StorePredicateExpression((None if localctx.e is None else localctx.e.start).line, (None if localctx.e is None else localctx.e.start).column, (None if localctx.e is None else localctx.e.stop).line, (None if localctx.e is None else localctx.e.stop).column, (None if localctx.e is None else self._input.getText((localctx.e.start,localctx.e.stop))))
5741                 self.state = 847
5742                 self.statement()
5743                 self.state = 850
5744                 self._errHandler.sync(self)
5745                 la_ = self._interp.adaptivePredict(self._input,105,self._ctx)
5746                 if la_ == 1:
5747                     self.state = 848
5748                     self.match(CParser.T__84)
5749                     self.state = 849
5750                     self.statement()
5751
5752
5753                 pass
5754             elif token in [CParser.T__85]:
5755                 self.enterOuterAlt(localctx, 2)
5756                 self.state = 852
5757                 self.match(CParser.T__85)
5758                 self.state = 853
5759                 self.match(CParser.T__37)
5760                 self.state = 854
5761                 self.expression()
5762                 self.state = 855
5763                 self.match(CParser.T__38)
5764                 self.state = 856
5765                 self.statement()
5766                 pass
5767             else:
5768                 raise NoViableAltException(self)
5769
5770         except RecognitionException as re:
5771             localctx.exception = re
5772             self._errHandler.reportError(self, re)
5773             self._errHandler.recover(self, re)
5774         finally:
5775             self.exitRule()
5776         return localctx
5777
5778     class Iteration_statementContext(ParserRuleContext):
5779
5780         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5781             super().__init__(parent, invokingState)
5782             self.parser = parser
5783             self.e = None # ExpressionContext
5784
5785         def statement(self):
5786             return self.getTypedRuleContext(CParser.StatementContext,0)
5787
5788
5789         def expression(self):
5790             return self.getTypedRuleContext(CParser.ExpressionContext,0)
5791
5792
5793         def getRuleIndex(self):
5794             return CParser.RULE_iteration_statement
5795
5796         def enterRule(self, listener:ParseTreeListener):
5797             if hasattr( listener, "enterIteration_statement" ):
5798                 listener.enterIteration_statement(self)
5799
5800         def exitRule(self, listener:ParseTreeListener):
5801             if hasattr( listener, "exitIteration_statement" ):
5802                 listener.exitIteration_statement(self)
5803
5804
5805
5806
5807     def iteration_statement(self):
5808
5809         localctx = CParser.Iteration_statementContext(self, self._ctx, self.state)
5810         self.enterRule(localctx, 138, self.RULE_iteration_statement)
5811         try:
5812             self.state = 876
5813             self._errHandler.sync(self)
5814             token = self._input.LA(1)
5815             if token in [CParser.T__86]:
5816                 self.enterOuterAlt(localctx, 1)
5817                 self.state = 860
5818                 self.match(CParser.T__86)
5819                 self.state = 861
5820                 self.match(CParser.T__37)
5821                 self.state = 862
5822                 localctx.e = self.expression()
5823                 self.state = 863
5824                 self.match(CParser.T__38)
5825                 self.state = 864
5826                 self.statement()
5827                 self.StorePredicateExpression((None if localctx.e is None else localctx.e.start).line, (None if localctx.e is None else localctx.e.start).column, (None if localctx.e is None else localctx.e.stop).line, (None if localctx.e is None else localctx.e.stop).column, (None if localctx.e is None else self._input.getText((localctx.e.start,localctx.e.stop))))
5828                 pass
5829             elif token in [CParser.T__87]:
5830                 self.enterOuterAlt(localctx, 2)
5831                 self.state = 867
5832                 self.match(CParser.T__87)
5833                 self.state = 868
5834                 self.statement()
5835                 self.state = 869
5836                 self.match(CParser.T__86)
5837                 self.state = 870
5838                 self.match(CParser.T__37)
5839                 self.state = 871
5840                 localctx.e = self.expression()
5841                 self.state = 872
5842                 self.match(CParser.T__38)
5843                 self.state = 873
5844                 self.match(CParser.T__1)
5845                 self.StorePredicateExpression((None if localctx.e is None else localctx.e.start).line, (None if localctx.e is None else localctx.e.start).column, (None if localctx.e is None else localctx.e.stop).line, (None if localctx.e is None else localctx.e.stop).column, (None if localctx.e is None else self._input.getText((localctx.e.start,localctx.e.stop))))
5846                 pass
5847             else:
5848                 raise NoViableAltException(self)
5849
5850         except RecognitionException as re:
5851             localctx.exception = re
5852             self._errHandler.reportError(self, re)
5853             self._errHandler.recover(self, re)
5854         finally:
5855             self.exitRule()
5856         return localctx
5857
5858     class Jump_statementContext(ParserRuleContext):
5859
5860         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5861             super().__init__(parent, invokingState)
5862             self.parser = parser
5863
5864         def IDENTIFIER(self):
5865             return self.getToken(CParser.IDENTIFIER, 0)
5866
5867         def expression(self):
5868             return self.getTypedRuleContext(CParser.ExpressionContext,0)
5869
5870
5871         def getRuleIndex(self):
5872             return CParser.RULE_jump_statement
5873
5874         def enterRule(self, listener:ParseTreeListener):
5875             if hasattr( listener, "enterJump_statement" ):
5876                 listener.enterJump_statement(self)
5877
5878         def exitRule(self, listener:ParseTreeListener):
5879             if hasattr( listener, "exitJump_statement" ):
5880                 listener.exitJump_statement(self)
5881
5882
5883
5884
5885     def jump_statement(self):
5886
5887         localctx = CParser.Jump_statementContext(self, self._ctx, self.state)
5888         self.enterRule(localctx, 140, self.RULE_jump_statement)
5889         try:
5890             self.state = 891
5891             self._errHandler.sync(self)
5892             la_ = self._interp.adaptivePredict(self._input,108,self._ctx)
5893             if la_ == 1:
5894                 self.enterOuterAlt(localctx, 1)
5895                 self.state = 878
5896                 self.match(CParser.T__88)
5897                 self.state = 879
5898                 self.match(CParser.IDENTIFIER)
5899                 self.state = 880
5900                 self.match(CParser.T__1)
5901                 pass
5902
5903             elif la_ == 2:
5904                 self.enterOuterAlt(localctx, 2)
5905                 self.state = 881
5906                 self.match(CParser.T__89)
5907                 self.state = 882
5908                 self.match(CParser.T__1)
5909                 pass
5910
5911             elif la_ == 3:
5912                 self.enterOuterAlt(localctx, 3)
5913                 self.state = 883
5914                 self.match(CParser.T__90)
5915                 self.state = 884
5916                 self.match(CParser.T__1)
5917                 pass
5918
5919             elif la_ == 4:
5920                 self.enterOuterAlt(localctx, 4)
5921                 self.state = 885
5922                 self.match(CParser.T__91)
5923                 self.state = 886
5924                 self.match(CParser.T__1)
5925                 pass
5926
5927             elif la_ == 5:
5928                 self.enterOuterAlt(localctx, 5)
5929                 self.state = 887
5930                 self.match(CParser.T__91)
5931                 self.state = 888
5932                 self.expression()
5933                 self.state = 889
5934                 self.match(CParser.T__1)
5935                 pass
5936
5937
5938         except RecognitionException as re:
5939             localctx.exception = re
5940             self._errHandler.reportError(self, re)
5941             self._errHandler.recover(self, re)
5942         finally:
5943             self.exitRule()
5944         return localctx
5945
5946
5947
5948
5949