Home | History | Annotate | Download | only in smali 
      1 // $ANTLR 3.5.2 smaliParser.g 2017-04-20 15:20:45
      2 
      3 package org.jf.smali;
      4 
      5 import org.jf.dexlib2.Format;
      6 import org.jf.dexlib2.Opcode;
      7 import org.jf.dexlib2.Opcodes;
      8 
      9 
     10 import org.antlr.runtime.*;
     11 import java.util.Stack;
     12 import java.util.List;
     13 import java.util.ArrayList;
     14 
     15 import org.antlr.runtime.tree.*;
     16 
     17 
     18 @SuppressWarnings("all")
     19 public class smaliParser extends Parser {
     20 	public static final String[] tokenNames = new String[] {
     21 		"<invalid>", "<EOR>", "<DOWN>", "<UP>", "ACCESS_SPEC", "ANNOTATION_DIRECTIVE",
     22 		"ANNOTATION_VISIBILITY", "ARRAY_DATA_DIRECTIVE", "ARRAY_TYPE_PREFIX",
     23 		"ARROW", "BOOL_LITERAL", "BYTE_LITERAL", "CATCHALL_DIRECTIVE", "CATCH_DIRECTIVE",
     24 		"CHAR_LITERAL", "CLASS_DESCRIPTOR", "CLASS_DIRECTIVE", "CLOSE_BRACE",
     25 		"CLOSE_PAREN", "COLON", "COMMA", "DOTDOT", "DOUBLE_LITERAL", "DOUBLE_LITERAL_OR_ID",
     26 		"END_ANNOTATION_DIRECTIVE", "END_ARRAY_DATA_DIRECTIVE", "END_FIELD_DIRECTIVE",
     27 		"END_LOCAL_DIRECTIVE", "END_METHOD_DIRECTIVE", "END_PACKED_SWITCH_DIRECTIVE",
     28 		"END_PARAMETER_DIRECTIVE", "END_SPARSE_SWITCH_DIRECTIVE", "END_SUBANNOTATION_DIRECTIVE",
     29 		"ENUM_DIRECTIVE", "EPILOGUE_DIRECTIVE", "EQUAL", "FIELD_DIRECTIVE", "FIELD_OFFSET",
     30 		"FLOAT_LITERAL", "FLOAT_LITERAL_OR_ID", "IMPLEMENTS_DIRECTIVE", "INLINE_INDEX",
     31 		"INSTRUCTION_FORMAT10t", "INSTRUCTION_FORMAT10x", "INSTRUCTION_FORMAT10x_ODEX",
     32 		"INSTRUCTION_FORMAT11n", "INSTRUCTION_FORMAT11x", "INSTRUCTION_FORMAT12x",
     33 		"INSTRUCTION_FORMAT12x_OR_ID", "INSTRUCTION_FORMAT20bc", "INSTRUCTION_FORMAT20t",
     34 		"INSTRUCTION_FORMAT21c_FIELD", "INSTRUCTION_FORMAT21c_FIELD_ODEX", "INSTRUCTION_FORMAT21c_STRING",
     35 		"INSTRUCTION_FORMAT21c_TYPE", "INSTRUCTION_FORMAT21ih", "INSTRUCTION_FORMAT21lh",
     36 		"INSTRUCTION_FORMAT21s", "INSTRUCTION_FORMAT21t", "INSTRUCTION_FORMAT22b",
     37 		"INSTRUCTION_FORMAT22c_FIELD", "INSTRUCTION_FORMAT22c_FIELD_ODEX", "INSTRUCTION_FORMAT22c_TYPE",
     38 		"INSTRUCTION_FORMAT22cs_FIELD", "INSTRUCTION_FORMAT22s", "INSTRUCTION_FORMAT22s_OR_ID",
     39 		"INSTRUCTION_FORMAT22t", "INSTRUCTION_FORMAT22x", "INSTRUCTION_FORMAT23x",
     40 		"INSTRUCTION_FORMAT30t", "INSTRUCTION_FORMAT31c", "INSTRUCTION_FORMAT31i",
     41 		"INSTRUCTION_FORMAT31i_OR_ID", "INSTRUCTION_FORMAT31t", "INSTRUCTION_FORMAT32x",
     42 		"INSTRUCTION_FORMAT35c_METHOD", "INSTRUCTION_FORMAT35c_METHOD_ODEX", "INSTRUCTION_FORMAT35c_TYPE",
     43 		"INSTRUCTION_FORMAT35mi_METHOD", "INSTRUCTION_FORMAT35ms_METHOD", "INSTRUCTION_FORMAT3rc_METHOD",
     44 		"INSTRUCTION_FORMAT3rc_METHOD_ODEX", "INSTRUCTION_FORMAT3rc_TYPE", "INSTRUCTION_FORMAT3rmi_METHOD",
     45 		"INSTRUCTION_FORMAT3rms_METHOD", "INSTRUCTION_FORMAT45cc_METHOD", "INSTRUCTION_FORMAT4rcc_METHOD",
     46 		"INSTRUCTION_FORMAT51l", "INTEGER_LITERAL", "INVALID_TOKEN", "I_ACCESS_LIST",
     47 		"I_ANNOTATION", "I_ANNOTATIONS", "I_ANNOTATION_ELEMENT", "I_ARRAY_ELEMENTS",
     48 		"I_ARRAY_ELEMENT_SIZE", "I_CATCH", "I_CATCHALL", "I_CATCHES", "I_CLASS_DEF",
     49 		"I_ENCODED_ARRAY", "I_ENCODED_ENUM", "I_ENCODED_FIELD", "I_ENCODED_METHOD",
     50 		"I_END_LOCAL", "I_EPILOGUE", "I_FIELD", "I_FIELDS", "I_FIELD_INITIAL_VALUE",
     51 		"I_FIELD_TYPE", "I_IMPLEMENTS", "I_LABEL", "I_LINE", "I_LOCAL", "I_LOCALS",
     52 		"I_METHOD", "I_METHODS", "I_METHOD_PROTOTYPE", "I_METHOD_RETURN_TYPE",
     53 		"I_ORDERED_METHOD_ITEMS", "I_PACKED_SWITCH_ELEMENTS", "I_PACKED_SWITCH_START_KEY",
     54 		"I_PARAMETER", "I_PARAMETERS", "I_PARAMETER_NOT_SPECIFIED", "I_PROLOGUE",
     55 		"I_REGISTERS", "I_REGISTER_LIST", "I_REGISTER_RANGE", "I_RESTART_LOCAL",
     56 		"I_SOURCE", "I_SPARSE_SWITCH_ELEMENTS", "I_STATEMENT_ARRAY_DATA", "I_STATEMENT_FORMAT10t",
     57 		"I_STATEMENT_FORMAT10x", "I_STATEMENT_FORMAT11n", "I_STATEMENT_FORMAT11x",
     58 		"I_STATEMENT_FORMAT12x", "I_STATEMENT_FORMAT20bc", "I_STATEMENT_FORMAT20t",
     59 		"I_STATEMENT_FORMAT21c_FIELD", "I_STATEMENT_FORMAT21c_STRING", "I_STATEMENT_FORMAT21c_TYPE",
     60 		"I_STATEMENT_FORMAT21ih", "I_STATEMENT_FORMAT21lh", "I_STATEMENT_FORMAT21s",
     61 		"I_STATEMENT_FORMAT21t", "I_STATEMENT_FORMAT22b", "I_STATEMENT_FORMAT22c_FIELD",
     62 		"I_STATEMENT_FORMAT22c_TYPE", "I_STATEMENT_FORMAT22s", "I_STATEMENT_FORMAT22t",
     63 		"I_STATEMENT_FORMAT22x", "I_STATEMENT_FORMAT23x", "I_STATEMENT_FORMAT30t",
     64 		"I_STATEMENT_FORMAT31c", "I_STATEMENT_FORMAT31i", "I_STATEMENT_FORMAT31t",
     65 		"I_STATEMENT_FORMAT32x", "I_STATEMENT_FORMAT35c_METHOD", "I_STATEMENT_FORMAT35c_TYPE",
     66 		"I_STATEMENT_FORMAT3rc_METHOD", "I_STATEMENT_FORMAT3rc_TYPE", "I_STATEMENT_FORMAT45cc_METHOD",
     67 		"I_STATEMENT_FORMAT4rcc_METHOD", "I_STATEMENT_FORMAT51l", "I_STATEMENT_PACKED_SWITCH",
     68 		"I_STATEMENT_SPARSE_SWITCH", "I_SUBANNOTATION", "I_SUPER", "LINE_COMMENT",
     69 		"LINE_DIRECTIVE", "LOCALS_DIRECTIVE", "LOCAL_DIRECTIVE", "LONG_LITERAL",
     70 		"MEMBER_NAME", "METHOD_DIRECTIVE", "NEGATIVE_INTEGER_LITERAL", "NULL_LITERAL",
     71 		"OPEN_BRACE", "OPEN_PAREN", "PACKED_SWITCH_DIRECTIVE", "PARAMETER_DIRECTIVE",
     72 		"PARAM_LIST_OR_ID_PRIMITIVE_TYPE", "POSITIVE_INTEGER_LITERAL", "PRIMITIVE_TYPE",
     73 		"PROLOGUE_DIRECTIVE", "REGISTER", "REGISTERS_DIRECTIVE", "RESTART_LOCAL_DIRECTIVE",
     74 		"SHORT_LITERAL", "SIMPLE_NAME", "SOURCE_DIRECTIVE", "SPARSE_SWITCH_DIRECTIVE",
     75 		"STRING_LITERAL", "SUBANNOTATION_DIRECTIVE", "SUPER_DIRECTIVE", "VERIFICATION_ERROR_TYPE",
     76 		"VOID_TYPE", "VTABLE_INDEX", "WHITE_SPACE"
     77 	};
     78 	public static final int EOF=-1;
     79 	public static final int ACCESS_SPEC=4;
     80 	public static final int ANNOTATION_DIRECTIVE=5;
     81 	public static final int ANNOTATION_VISIBILITY=6;
     82 	public static final int ARRAY_DATA_DIRECTIVE=7;
     83 	public static final int ARRAY_TYPE_PREFIX=8;
     84 	public static final int ARROW=9;
     85 	public static final int BOOL_LITERAL=10;
     86 	public static final int BYTE_LITERAL=11;
     87 	public static final int CATCHALL_DIRECTIVE=12;
     88 	public static final int CATCH_DIRECTIVE=13;
     89 	public static final int CHAR_LITERAL=14;
     90 	public static final int CLASS_DESCRIPTOR=15;
     91 	public static final int CLASS_DIRECTIVE=16;
     92 	public static final int CLOSE_BRACE=17;
     93 	public static final int CLOSE_PAREN=18;
     94 	public static final int COLON=19;
     95 	public static final int COMMA=20;
     96 	public static final int DOTDOT=21;
     97 	public static final int DOUBLE_LITERAL=22;
     98 	public static final int DOUBLE_LITERAL_OR_ID=23;
     99 	public static final int END_ANNOTATION_DIRECTIVE=24;
    100 	public static final int END_ARRAY_DATA_DIRECTIVE=25;
    101 	public static final int END_FIELD_DIRECTIVE=26;
    102 	public static final int END_LOCAL_DIRECTIVE=27;
    103 	public static final int END_METHOD_DIRECTIVE=28;
    104 	public static final int END_PACKED_SWITCH_DIRECTIVE=29;
    105 	public static final int END_PARAMETER_DIRECTIVE=30;
    106 	public static final int END_SPARSE_SWITCH_DIRECTIVE=31;
    107 	public static final int END_SUBANNOTATION_DIRECTIVE=32;
    108 	public static final int ENUM_DIRECTIVE=33;
    109 	public static final int EPILOGUE_DIRECTIVE=34;
    110 	public static final int EQUAL=35;
    111 	public static final int FIELD_DIRECTIVE=36;
    112 	public static final int FIELD_OFFSET=37;
    113 	public static final int FLOAT_LITERAL=38;
    114 	public static final int FLOAT_LITERAL_OR_ID=39;
    115 	public static final int IMPLEMENTS_DIRECTIVE=40;
    116 	public static final int INLINE_INDEX=41;
    117 	public static final int INSTRUCTION_FORMAT10t=42;
    118 	public static final int INSTRUCTION_FORMAT10x=43;
    119 	public static final int INSTRUCTION_FORMAT10x_ODEX=44;
    120 	public static final int INSTRUCTION_FORMAT11n=45;
    121 	public static final int INSTRUCTION_FORMAT11x=46;
    122 	public static final int INSTRUCTION_FORMAT12x=47;
    123 	public static final int INSTRUCTION_FORMAT12x_OR_ID=48;
    124 	public static final int INSTRUCTION_FORMAT20bc=49;
    125 	public static final int INSTRUCTION_FORMAT20t=50;
    126 	public static final int INSTRUCTION_FORMAT21c_FIELD=51;
    127 	public static final int INSTRUCTION_FORMAT21c_FIELD_ODEX=52;
    128 	public static final int INSTRUCTION_FORMAT21c_STRING=53;
    129 	public static final int INSTRUCTION_FORMAT21c_TYPE=54;
    130 	public static final int INSTRUCTION_FORMAT21ih=55;
    131 	public static final int INSTRUCTION_FORMAT21lh=56;
    132 	public static final int INSTRUCTION_FORMAT21s=57;
    133 	public static final int INSTRUCTION_FORMAT21t=58;
    134 	public static final int INSTRUCTION_FORMAT22b=59;
    135 	public static final int INSTRUCTION_FORMAT22c_FIELD=60;
    136 	public static final int INSTRUCTION_FORMAT22c_FIELD_ODEX=61;
    137 	public static final int INSTRUCTION_FORMAT22c_TYPE=62;
    138 	public static final int INSTRUCTION_FORMAT22cs_FIELD=63;
    139 	public static final int INSTRUCTION_FORMAT22s=64;
    140 	public static final int INSTRUCTION_FORMAT22s_OR_ID=65;
    141 	public static final int INSTRUCTION_FORMAT22t=66;
    142 	public static final int INSTRUCTION_FORMAT22x=67;
    143 	public static final int INSTRUCTION_FORMAT23x=68;
    144 	public static final int INSTRUCTION_FORMAT30t=69;
    145 	public static final int INSTRUCTION_FORMAT31c=70;
    146 	public static final int INSTRUCTION_FORMAT31i=71;
    147 	public static final int INSTRUCTION_FORMAT31i_OR_ID=72;
    148 	public static final int INSTRUCTION_FORMAT31t=73;
    149 	public static final int INSTRUCTION_FORMAT32x=74;
    150 	public static final int INSTRUCTION_FORMAT35c_METHOD=75;
    151 	public static final int INSTRUCTION_FORMAT35c_METHOD_ODEX=76;
    152 	public static final int INSTRUCTION_FORMAT35c_TYPE=77;
    153 	public static final int INSTRUCTION_FORMAT35mi_METHOD=78;
    154 	public static final int INSTRUCTION_FORMAT35ms_METHOD=79;
    155 	public static final int INSTRUCTION_FORMAT3rc_METHOD=80;
    156 	public static final int INSTRUCTION_FORMAT3rc_METHOD_ODEX=81;
    157 	public static final int INSTRUCTION_FORMAT3rc_TYPE=82;
    158 	public static final int INSTRUCTION_FORMAT3rmi_METHOD=83;
    159 	public static final int INSTRUCTION_FORMAT3rms_METHOD=84;
    160 	public static final int INSTRUCTION_FORMAT45cc_METHOD=85;
    161 	public static final int INSTRUCTION_FORMAT4rcc_METHOD=86;
    162 	public static final int INSTRUCTION_FORMAT51l=87;
    163 	public static final int INTEGER_LITERAL=88;
    164 	public static final int INVALID_TOKEN=89;
    165 	public static final int I_ACCESS_LIST=90;
    166 	public static final int I_ANNOTATION=91;
    167 	public static final int I_ANNOTATIONS=92;
    168 	public static final int I_ANNOTATION_ELEMENT=93;
    169 	public static final int I_ARRAY_ELEMENTS=94;
    170 	public static final int I_ARRAY_ELEMENT_SIZE=95;
    171 	public static final int I_CATCH=96;
    172 	public static final int I_CATCHALL=97;
    173 	public static final int I_CATCHES=98;
    174 	public static final int I_CLASS_DEF=99;
    175 	public static final int I_ENCODED_ARRAY=100;
    176 	public static final int I_ENCODED_ENUM=101;
    177 	public static final int I_ENCODED_FIELD=102;
    178 	public static final int I_ENCODED_METHOD=103;
    179 	public static final int I_END_LOCAL=104;
    180 	public static final int I_EPILOGUE=105;
    181 	public static final int I_FIELD=106;
    182 	public static final int I_FIELDS=107;
    183 	public static final int I_FIELD_INITIAL_VALUE=108;
    184 	public static final int I_FIELD_TYPE=109;
    185 	public static final int I_IMPLEMENTS=110;
    186 	public static final int I_LABEL=111;
    187 	public static final int I_LINE=112;
    188 	public static final int I_LOCAL=113;
    189 	public static final int I_LOCALS=114;
    190 	public static final int I_METHOD=115;
    191 	public static final int I_METHODS=116;
    192 	public static final int I_METHOD_PROTOTYPE=117;
    193 	public static final int I_METHOD_RETURN_TYPE=118;
    194 	public static final int I_ORDERED_METHOD_ITEMS=119;
    195 	public static final int I_PACKED_SWITCH_ELEMENTS=120;
    196 	public static final int I_PACKED_SWITCH_START_KEY=121;
    197 	public static final int I_PARAMETER=122;
    198 	public static final int I_PARAMETERS=123;
    199 	public static final int I_PARAMETER_NOT_SPECIFIED=124;
    200 	public static final int I_PROLOGUE=125;
    201 	public static final int I_REGISTERS=126;
    202 	public static final int I_REGISTER_LIST=127;
    203 	public static final int I_REGISTER_RANGE=128;
    204 	public static final int I_RESTART_LOCAL=129;
    205 	public static final int I_SOURCE=130;
    206 	public static final int I_SPARSE_SWITCH_ELEMENTS=131;
    207 	public static final int I_STATEMENT_ARRAY_DATA=132;
    208 	public static final int I_STATEMENT_FORMAT10t=133;
    209 	public static final int I_STATEMENT_FORMAT10x=134;
    210 	public static final int I_STATEMENT_FORMAT11n=135;
    211 	public static final int I_STATEMENT_FORMAT11x=136;
    212 	public static final int I_STATEMENT_FORMAT12x=137;
    213 	public static final int I_STATEMENT_FORMAT20bc=138;
    214 	public static final int I_STATEMENT_FORMAT20t=139;
    215 	public static final int I_STATEMENT_FORMAT21c_FIELD=140;
    216 	public static final int I_STATEMENT_FORMAT21c_STRING=141;
    217 	public static final int I_STATEMENT_FORMAT21c_TYPE=142;
    218 	public static final int I_STATEMENT_FORMAT21ih=143;
    219 	public static final int I_STATEMENT_FORMAT21lh=144;
    220 	public static final int I_STATEMENT_FORMAT21s=145;
    221 	public static final int I_STATEMENT_FORMAT21t=146;
    222 	public static final int I_STATEMENT_FORMAT22b=147;
    223 	public static final int I_STATEMENT_FORMAT22c_FIELD=148;
    224 	public static final int I_STATEMENT_FORMAT22c_TYPE=149;
    225 	public static final int I_STATEMENT_FORMAT22s=150;
    226 	public static final int I_STATEMENT_FORMAT22t=151;
    227 	public static final int I_STATEMENT_FORMAT22x=152;
    228 	public static final int I_STATEMENT_FORMAT23x=153;
    229 	public static final int I_STATEMENT_FORMAT30t=154;
    230 	public static final int I_STATEMENT_FORMAT31c=155;
    231 	public static final int I_STATEMENT_FORMAT31i=156;
    232 	public static final int I_STATEMENT_FORMAT31t=157;
    233 	public static final int I_STATEMENT_FORMAT32x=158;
    234 	public static final int I_STATEMENT_FORMAT35c_METHOD=159;
    235 	public static final int I_STATEMENT_FORMAT35c_TYPE=160;
    236 	public static final int I_STATEMENT_FORMAT3rc_METHOD=161;
    237 	public static final int I_STATEMENT_FORMAT3rc_TYPE=162;
    238 	public static final int I_STATEMENT_FORMAT45cc_METHOD=163;
    239 	public static final int I_STATEMENT_FORMAT4rcc_METHOD=164;
    240 	public static final int I_STATEMENT_FORMAT51l=165;
    241 	public static final int I_STATEMENT_PACKED_SWITCH=166;
    242 	public static final int I_STATEMENT_SPARSE_SWITCH=167;
    243 	public static final int I_SUBANNOTATION=168;
    244 	public static final int I_SUPER=169;
    245 	public static final int LINE_COMMENT=170;
    246 	public static final int LINE_DIRECTIVE=171;
    247 	public static final int LOCALS_DIRECTIVE=172;
    248 	public static final int LOCAL_DIRECTIVE=173;
    249 	public static final int LONG_LITERAL=174;
    250 	public static final int MEMBER_NAME=175;
    251 	public static final int METHOD_DIRECTIVE=176;
    252 	public static final int NEGATIVE_INTEGER_LITERAL=177;
    253 	public static final int NULL_LITERAL=178;
    254 	public static final int OPEN_BRACE=179;
    255 	public static final int OPEN_PAREN=180;
    256 	public static final int PACKED_SWITCH_DIRECTIVE=181;
    257 	public static final int PARAMETER_DIRECTIVE=182;
    258 	public static final int PARAM_LIST_OR_ID_PRIMITIVE_TYPE=183;
    259 	public static final int POSITIVE_INTEGER_LITERAL=184;
    260 	public static final int PRIMITIVE_TYPE=185;
    261 	public static final int PROLOGUE_DIRECTIVE=186;
    262 	public static final int REGISTER=187;
    263 	public static final int REGISTERS_DIRECTIVE=188;
    264 	public static final int RESTART_LOCAL_DIRECTIVE=189;
    265 	public static final int SHORT_LITERAL=190;
    266 	public static final int SIMPLE_NAME=191;
    267 	public static final int SOURCE_DIRECTIVE=192;
    268 	public static final int SPARSE_SWITCH_DIRECTIVE=193;
    269 	public static final int STRING_LITERAL=194;
    270 	public static final int SUBANNOTATION_DIRECTIVE=195;
    271 	public static final int SUPER_DIRECTIVE=196;
    272 	public static final int VERIFICATION_ERROR_TYPE=197;
    273 	public static final int VOID_TYPE=198;
    274 	public static final int VTABLE_INDEX=199;
    275 	public static final int WHITE_SPACE=200;
    276 
    277 	// delegates
    278 	public Parser[] getDelegates() {
    279 		return new Parser[] {};
    280 	}
    281 
    282 	// delegators
    283 
    284 
    285 	public smaliParser(TokenStream input) {
    286 		this(input, new RecognizerSharedState());
    287 	}
    288 	public smaliParser(TokenStream input, RecognizerSharedState state) {
    289 		super(input, state);
    290 	}
    291 
    292 	protected TreeAdaptor adaptor = new CommonTreeAdaptor();
    293 
    294 	public void setTreeAdaptor(TreeAdaptor adaptor) {
    295 		this.adaptor = adaptor;
    296 	}
    297 	public TreeAdaptor getTreeAdaptor() {
    298 		return adaptor;
    299 	}
    300 	@Override public String[] getTokenNames() { return smaliParser.tokenNames; }
    301 	@Override public String getGrammarFileName() { return "smaliParser.g"; }
    302 
    303 
    304 	  public static final int ERROR_CHANNEL = 100;
    305 
    306 	  private boolean verboseErrors = false;
    307 	  private boolean allowOdex = false;
    308 	  private int apiLevel = 15;
    309 	  private Opcodes opcodes = Opcodes.forApi(apiLevel);
    310 
    311 	  public void setVerboseErrors(boolean verboseErrors) {
    312 	    this.verboseErrors = verboseErrors;
    313 	  }
    314 
    315 	  public void setAllowOdex(boolean allowOdex) {
    316 	      this.allowOdex = allowOdex;
    317 	  }
    318 
    319 	  public void setApiLevel(int apiLevel) {
    320 	      this.opcodes = Opcodes.forApi(apiLevel);
    321 	      this.apiLevel = apiLevel;
    322 	  }
    323 
    324 	  public String getErrorMessage(RecognitionException e,
    325 	    String[] tokenNames) {
    326 
    327 	    if (verboseErrors) {
    328 	      List stack = getRuleInvocationStack(e, this.getClass().getName());
    329 	      String msg = null;
    330 
    331 	      if (e instanceof NoViableAltException) {
    332 	        NoViableAltException nvae = (NoViableAltException)e;
    333 	        msg = " no viable alt; token="+getTokenErrorDisplay(e.token)+
    334 	        " (decision="+nvae.decisionNumber+
    335 	        " state "+nvae.stateNumber+")"+
    336 	        " decision=<<"+nvae.grammarDecisionDescription+">>";
    337 	      } else {
    338 	        msg = super.getErrorMessage(e, tokenNames);
    339 	      }
    340 
    341 	      return stack + " " + msg;
    342 	    } else {
    343 	      return super.getErrorMessage(e, tokenNames);
    344 	    }
    345 	  }
    346 
    347 	  public String getTokenErrorDisplay(Token t) {
    348 	    if (!verboseErrors) {
    349 	      String s = t.getText();
    350 	      if ( s==null ) {
    351 	        if ( t.getType()==Token.EOF ) {
    352 	          s = "<EOF>";
    353 	        }
    354 	        else {
    355 	          s = "<"+tokenNames[t.getType()]+">";
    356 	        }
    357 	      }
    358 	      s = s.replaceAll("\n","\\\\n");
    359 	      s = s.replaceAll("\r","\\\\r");
    360 	      s = s.replaceAll("\t","\\\\t");
    361 	      return "'"+s+"'";
    362 	    }
    363 
    364 	    CommonToken ct = (CommonToken)t;
    365 
    366 	    String channelStr = "";
    367 	    if (t.getChannel()>0) {
    368 	      channelStr=",channel="+t.getChannel();
    369 	    }
    370 	    String txt = t.getText();
    371 	    if ( txt!=null ) {
    372 	      txt = txt.replaceAll("\n","\\\\n");
    373 	      txt = txt.replaceAll("\r","\\\\r");
    374 	      txt = txt.replaceAll("\t","\\\\t");
    375 	    }
    376 	    else {
    377 	      txt = "<no text>";
    378 	    }
    379 	    return "[@"+t.getTokenIndex()+","+ct.getStartIndex()+":"+ct.getStopIndex()+"='"+txt+"',<"+tokenNames[t.getType()]+">"+channelStr+","+t.getLine()+":"+t.getCharPositionInLine()+"]";
    380 	  }
    381 
    382 	  public String getErrorHeader(RecognitionException e) {
    383 	    return getSourceName()+"["+ e.line+","+e.charPositionInLine+"]";
    384 	  }
    385 
    386 	  private CommonTree buildTree(int type, String text, List<CommonTree> children) {
    387 	    CommonTree root = new CommonTree(new CommonToken(type, text));
    388 	    for (CommonTree child: children) {
    389 	      root.addChild(child);
    390 	    }
    391 	    return root;
    392 	  }
    393 
    394 	  private CommonToken getParamListSubToken(CommonToken baseToken, String str, int typeStartIndex) {
    395 	    CommonToken token = new CommonToken(baseToken);
    396 	    token.setStartIndex(baseToken.getStartIndex() + typeStartIndex);
    397 
    398 	    switch (str.charAt(typeStartIndex)) {
    399 	      case 'Z':
    400 	      case 'B':
    401 	      case 'S':
    402 	      case 'C':
    403 	      case 'I':
    404 	      case 'J':
    405 	      case 'F':
    406 	      case 'D':
    407 	      {
    408 	        token.setType(PRIMITIVE_TYPE);
    409 	        token.setText(str.substring(typeStartIndex, typeStartIndex+1));
    410 	        token.setStopIndex(baseToken.getStartIndex() + typeStartIndex);
    411 	        break;
    412 	      }
    413 	      case 'L':
    414 	      {
    415 	        int i = typeStartIndex;
    416 	        while (str.charAt(++i) != ';');
    417 
    418 	        token.setType(CLASS_DESCRIPTOR);
    419 	        token.setText(str.substring(typeStartIndex, i + 1));
    420 	        token.setStopIndex(baseToken.getStartIndex() + i);
    421 	        break;
    422 	      }
    423 	      case '[':
    424 	      {
    425 	        int i = typeStartIndex;
    426 	        while (str.charAt(++i) == '[');
    427 
    428 	        token.setType(ARRAY_TYPE_PREFIX);
    429 	        token.setText(str.substring(typeStartIndex, i));
    430 	        token.setStopIndex(baseToken.getStartIndex() + i - 1);
    431 	        break;
    432 	      }
    433 	      default:
    434 	        throw new RuntimeException(String.format("Invalid character '%c' in param list \"%s\" at position %d", str.charAt(typeStartIndex), str, typeStartIndex));
    435 	    }
    436 
    437 	    return token;
    438 	  }
    439 
    440 	  private CommonTree parseParamList(CommonToken paramListToken) {
    441 	    String paramList = paramListToken.getText();
    442 	    CommonTree root = new CommonTree();
    443 
    444 	    int startIndex = paramListToken.getStartIndex();
    445 
    446 	    int i=0;
    447 	    while (i<paramList.length()) {
    448 	      CommonToken token = getParamListSubToken(paramListToken, paramList, i);
    449 	      root.addChild(new CommonTree(token));
    450 	      i += token.getText().length();
    451 	    }
    452 
    453 	    if (root.getChildCount() == 0) {
    454 	      return null;
    455 	    }
    456 	    return root;
    457 	  }
    458 
    459 	  private void throwOdexedInstructionException(IntStream input, String odexedInstruction)
    460 	      throws OdexedInstructionException {
    461 	    /*this has to be done in a separate method, otherwise java will complain about the
    462 	    auto-generated code in the rule after the throw not being reachable*/
    463 	    throw new OdexedInstructionException(input, odexedInstruction);
    464 	  }
    465 
    466 
    467 	protected static class smali_file_scope {
    468 		boolean hasClassSpec;
    469 		boolean hasSuperSpec;
    470 		boolean hasSourceSpec;
    471 		List<CommonTree> classAnnotations;
    472 	}
    473 	protected Stack<smali_file_scope> smali_file_stack = new Stack<smali_file_scope>();
    474 
    475 	public static class smali_file_return extends ParserRuleReturnScope {
    476 		CommonTree tree;
    477 		@Override
    478 		public CommonTree getTree() { return tree; }
    479 	};
    480 
    481 
    482 	// $ANTLR start "smali_file"
    483 	// smaliParser.g:415:1: smali_file : ({...}? => class_spec |{...}? => super_spec | implements_spec |{...}? => source_spec | method | field | annotation )+ EOF -> ^( I_CLASS_DEF class_spec ( super_spec )? ( implements_spec )* ( source_spec )? ^( I_METHODS ( method )* ) ^( I_FIELDS ( field )* ) ) ;
    484 	public final smaliParser.smali_file_return smali_file() throws RecognitionException {
    485 		smali_file_stack.push(new smali_file_scope());
    486 		smaliParser.smali_file_return retval = new smaliParser.smali_file_return();
    487 		retval.start = input.LT(1);
    488 
    489 		CommonTree root_0 = null;
    490 
    491 		Token EOF8=null;
    492 		ParserRuleReturnScope class_spec1 =null;
    493 		ParserRuleReturnScope super_spec2 =null;
    494 		ParserRuleReturnScope implements_spec3 =null;
    495 		ParserRuleReturnScope source_spec4 =null;
    496 		ParserRuleReturnScope method5 =null;
    497 		ParserRuleReturnScope field6 =null;
    498 		ParserRuleReturnScope annotation7 =null;
    499 
    500 		CommonTree EOF8_tree=null;
    501 		RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF");
    502 		RewriteRuleSubtreeStream stream_class_spec=new RewriteRuleSubtreeStream(adaptor,"rule class_spec");
    503 		RewriteRuleSubtreeStream stream_annotation=new RewriteRuleSubtreeStream(adaptor,"rule annotation");
    504 		RewriteRuleSubtreeStream stream_method=new RewriteRuleSubtreeStream(adaptor,"rule method");
    505 		RewriteRuleSubtreeStream stream_field=new RewriteRuleSubtreeStream(adaptor,"rule field");
    506 		RewriteRuleSubtreeStream stream_super_spec=new RewriteRuleSubtreeStream(adaptor,"rule super_spec");
    507 		RewriteRuleSubtreeStream stream_implements_spec=new RewriteRuleSubtreeStream(adaptor,"rule implements_spec");
    508 		RewriteRuleSubtreeStream stream_source_spec=new RewriteRuleSubtreeStream(adaptor,"rule source_spec");
    509 
    510 		 smali_file_stack.peek().hasClassSpec = smali_file_stack.peek().hasSuperSpec = smali_file_stack.peek().hasSourceSpec = false;
    511 		    smali_file_stack.peek().classAnnotations = new ArrayList<CommonTree>();
    512 
    513 		try {
    514 			// smaliParser.g:427:3: ( ({...}? => class_spec |{...}? => super_spec | implements_spec |{...}? => source_spec | method | field | annotation )+ EOF -> ^( I_CLASS_DEF class_spec ( super_spec )? ( implements_spec )* ( source_spec )? ^( I_METHODS ( method )* ) ^( I_FIELDS ( field )* ) ) )
    515 			// smaliParser.g:428:3: ({...}? => class_spec |{...}? => super_spec | implements_spec |{...}? => source_spec | method | field | annotation )+ EOF
    516 			{
    517 			// smaliParser.g:428:3: ({...}? => class_spec |{...}? => super_spec | implements_spec |{...}? => source_spec | method | field | annotation )+
    518 			int cnt1=0;
    519 			loop1:
    520 			while (true) {
    521 				int alt1=8;
    522 				int LA1_0 = input.LA(1);
    523 				if ( (LA1_0==CLASS_DIRECTIVE) && ((!smali_file_stack.peek().hasClassSpec))) {
    524 					alt1=1;
    525 				}
    526 				else if ( (LA1_0==SUPER_DIRECTIVE) && ((!smali_file_stack.peek().hasSuperSpec))) {
    527 					alt1=2;
    528 				}
    529 				else if ( (LA1_0==IMPLEMENTS_DIRECTIVE) ) {
    530 					alt1=3;
    531 				}
    532 				else if ( (LA1_0==SOURCE_DIRECTIVE) && ((!smali_file_stack.peek().hasSourceSpec))) {
    533 					alt1=4;
    534 				}
    535 				else if ( (LA1_0==METHOD_DIRECTIVE) ) {
    536 					alt1=5;
    537 				}
    538 				else if ( (LA1_0==FIELD_DIRECTIVE) ) {
    539 					alt1=6;
    540 				}
    541 				else if ( (LA1_0==ANNOTATION_DIRECTIVE) ) {
    542 					alt1=7;
    543 				}
    544 
    545 				switch (alt1) {
    546 				case 1 :
    547 					// smaliParser.g:428:5: {...}? => class_spec
    548 					{
    549 					if ( !((!smali_file_stack.peek().hasClassSpec)) ) {
    550 						throw new FailedPredicateException(input, "smali_file", "!$smali_file::hasClassSpec");
    551 					}
    552 					pushFollow(FOLLOW_class_spec_in_smali_file1075);
    553 					class_spec1=class_spec();
    554 					state._fsp--;
    555 
    556 					stream_class_spec.add(class_spec1.getTree());
    557 					smali_file_stack.peek().hasClassSpec = true;
    558 					}
    559 					break;
    560 				case 2 :
    561 					// smaliParser.g:429:5: {...}? => super_spec
    562 					{
    563 					if ( !((!smali_file_stack.peek().hasSuperSpec)) ) {
    564 						throw new FailedPredicateException(input, "smali_file", "!$smali_file::hasSuperSpec");
    565 					}
    566 					pushFollow(FOLLOW_super_spec_in_smali_file1086);
    567 					super_spec2=super_spec();
    568 					state._fsp--;
    569 
    570 					stream_super_spec.add(super_spec2.getTree());
    571 					smali_file_stack.peek().hasSuperSpec = true;
    572 					}
    573 					break;
    574 				case 3 :
    575 					// smaliParser.g:430:5: implements_spec
    576 					{
    577 					pushFollow(FOLLOW_implements_spec_in_smali_file1094);
    578 					implements_spec3=implements_spec();
    579 					state._fsp--;
    580 
    581 					stream_implements_spec.add(implements_spec3.getTree());
    582 					}
    583 					break;
    584 				case 4 :
    585 					// smaliParser.g:431:5: {...}? => source_spec
    586 					{
    587 					if ( !((!smali_file_stack.peek().hasSourceSpec)) ) {
    588 						throw new FailedPredicateException(input, "smali_file", "!$smali_file::hasSourceSpec");
    589 					}
    590 					pushFollow(FOLLOW_source_spec_in_smali_file1103);
    591 					source_spec4=source_spec();
    592 					state._fsp--;
    593 
    594 					stream_source_spec.add(source_spec4.getTree());
    595 					smali_file_stack.peek().hasSourceSpec = true;
    596 					}
    597 					break;
    598 				case 5 :
    599 					// smaliParser.g:432:5: method
    600 					{
    601 					pushFollow(FOLLOW_method_in_smali_file1111);
    602 					method5=method();
    603 					state._fsp--;
    604 
    605 					stream_method.add(method5.getTree());
    606 					}
    607 					break;
    608 				case 6 :
    609 					// smaliParser.g:433:5: field
    610 					{
    611 					pushFollow(FOLLOW_field_in_smali_file1117);
    612 					field6=field();
    613 					state._fsp--;
    614 
    615 					stream_field.add(field6.getTree());
    616 					}
    617 					break;
    618 				case 7 :
    619 					// smaliParser.g:434:5: annotation
    620 					{
    621 					pushFollow(FOLLOW_annotation_in_smali_file1123);
    622 					annotation7=annotation();
    623 					state._fsp--;
    624 
    625 					stream_annotation.add(annotation7.getTree());
    626 					smali_file_stack.peek().classAnnotations.add((annotation7!=null?((CommonTree)annotation7.getTree()):null));
    627 					}
    628 					break;
    629 
    630 				default :
    631 					if ( cnt1 >= 1 ) break loop1;
    632 					EarlyExitException eee = new EarlyExitException(1, input);
    633 					throw eee;
    634 				}
    635 				cnt1++;
    636 			}
    637 
    638 			EOF8=(Token)match(input,EOF,FOLLOW_EOF_in_smali_file1134);
    639 			stream_EOF.add(EOF8);
    640 
    641 
    642 			    if (!smali_file_stack.peek().hasClassSpec) {
    643 			      throw new SemanticException(input, "The file must contain a .class directive");
    644 			    }
    645 
    646 			    if (!smali_file_stack.peek().hasSuperSpec) {
    647 			      if (!(class_spec1!=null?((smaliParser.class_spec_return)class_spec1).className:null).equals("Ljava/lang/Object;")) {
    648 			        throw new SemanticException(input, "The file must contain a .super directive");
    649 			      }
    650 			    }
    651 
    652 			// AST REWRITE
    653 			// elements: super_spec, method, field, implements_spec, class_spec, source_spec
    654 			// token labels:
    655 			// rule labels: retval
    656 			// token list labels:
    657 			// rule list labels:
    658 			// wildcard labels:
    659 			retval.tree = root_0;
    660 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
    661 
    662 			root_0 = (CommonTree)adaptor.nil();
    663 			// 448:3: -> ^( I_CLASS_DEF class_spec ( super_spec )? ( implements_spec )* ( source_spec )? ^( I_METHODS ( method )* ) ^( I_FIELDS ( field )* ) )
    664 			{
    665 				// smaliParser.g:448:6: ^( I_CLASS_DEF class_spec ( super_spec )? ( implements_spec )* ( source_spec )? ^( I_METHODS ( method )* ) ^( I_FIELDS ( field )* ) )
    666 				{
    667 				CommonTree root_1 = (CommonTree)adaptor.nil();
    668 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_CLASS_DEF, "I_CLASS_DEF"), root_1);
    669 				adaptor.addChild(root_1, stream_class_spec.nextTree());
    670 				// smaliParser.g:450:8: ( super_spec )?
    671 				if ( stream_super_spec.hasNext() ) {
    672 					adaptor.addChild(root_1, stream_super_spec.nextTree());
    673 				}
    674 				stream_super_spec.reset();
    675 
    676 				// smaliParser.g:451:8: ( implements_spec )*
    677 				while ( stream_implements_spec.hasNext() ) {
    678 					adaptor.addChild(root_1, stream_implements_spec.nextTree());
    679 				}
    680 				stream_implements_spec.reset();
    681 
    682 				// smaliParser.g:452:8: ( source_spec )?
    683 				if ( stream_source_spec.hasNext() ) {
    684 					adaptor.addChild(root_1, stream_source_spec.nextTree());
    685 				}
    686 				stream_source_spec.reset();
    687 
    688 				// smaliParser.g:453:8: ^( I_METHODS ( method )* )
    689 				{
    690 				CommonTree root_2 = (CommonTree)adaptor.nil();
    691 				root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_METHODS, "I_METHODS"), root_2);
    692 				// smaliParser.g:453:20: ( method )*
    693 				while ( stream_method.hasNext() ) {
    694 					adaptor.addChild(root_2, stream_method.nextTree());
    695 				}
    696 				stream_method.reset();
    697 
    698 				adaptor.addChild(root_1, root_2);
    699 				}
    700 
    701 				// smaliParser.g:453:29: ^( I_FIELDS ( field )* )
    702 				{
    703 				CommonTree root_2 = (CommonTree)adaptor.nil();
    704 				root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_FIELDS, "I_FIELDS"), root_2);
    705 				// smaliParser.g:453:40: ( field )*
    706 				while ( stream_field.hasNext() ) {
    707 					adaptor.addChild(root_2, stream_field.nextTree());
    708 				}
    709 				stream_field.reset();
    710 
    711 				adaptor.addChild(root_1, root_2);
    712 				}
    713 
    714 				adaptor.addChild(root_1, buildTree(I_ANNOTATIONS, "I_ANNOTATIONS", smali_file_stack.peek().classAnnotations));
    715 				adaptor.addChild(root_0, root_1);
    716 				}
    717 
    718 			}
    719 
    720 
    721 			retval.tree = root_0;
    722 
    723 			}
    724 
    725 			retval.stop = input.LT(-1);
    726 
    727 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
    728 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
    729 
    730 		}
    731 		catch (RecognitionException re) {
    732 			reportError(re);
    733 			recover(input,re);
    734 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
    735 		}
    736 		finally {
    737 			// do for sure before leaving
    738 			smali_file_stack.pop();
    739 		}
    740 		return retval;
    741 	}
    742 	// $ANTLR end "smali_file"
    743 
    744 
    745 	public static class class_spec_return extends ParserRuleReturnScope {
    746 		public String className;
    747 		CommonTree tree;
    748 		@Override
    749 		public CommonTree getTree() { return tree; }
    750 	};
    751 
    752 
    753 	// $ANTLR start "class_spec"
    754 	// smaliParser.g:455:1: class_spec returns [String className] : CLASS_DIRECTIVE access_list CLASS_DESCRIPTOR -> CLASS_DESCRIPTOR access_list ;
    755 	public final smaliParser.class_spec_return class_spec() throws RecognitionException {
    756 		smaliParser.class_spec_return retval = new smaliParser.class_spec_return();
    757 		retval.start = input.LT(1);
    758 
    759 		CommonTree root_0 = null;
    760 
    761 		Token CLASS_DIRECTIVE9=null;
    762 		Token CLASS_DESCRIPTOR11=null;
    763 		ParserRuleReturnScope access_list10 =null;
    764 
    765 		CommonTree CLASS_DIRECTIVE9_tree=null;
    766 		CommonTree CLASS_DESCRIPTOR11_tree=null;
    767 		RewriteRuleTokenStream stream_CLASS_DESCRIPTOR=new RewriteRuleTokenStream(adaptor,"token CLASS_DESCRIPTOR");
    768 		RewriteRuleTokenStream stream_CLASS_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token CLASS_DIRECTIVE");
    769 		RewriteRuleSubtreeStream stream_access_list=new RewriteRuleSubtreeStream(adaptor,"rule access_list");
    770 
    771 		try {
    772 			// smaliParser.g:456:3: ( CLASS_DIRECTIVE access_list CLASS_DESCRIPTOR -> CLASS_DESCRIPTOR access_list )
    773 			// smaliParser.g:456:5: CLASS_DIRECTIVE access_list CLASS_DESCRIPTOR
    774 			{
    775 			CLASS_DIRECTIVE9=(Token)match(input,CLASS_DIRECTIVE,FOLLOW_CLASS_DIRECTIVE_in_class_spec1221);
    776 			stream_CLASS_DIRECTIVE.add(CLASS_DIRECTIVE9);
    777 
    778 			pushFollow(FOLLOW_access_list_in_class_spec1223);
    779 			access_list10=access_list();
    780 			state._fsp--;
    781 
    782 			stream_access_list.add(access_list10.getTree());
    783 			CLASS_DESCRIPTOR11=(Token)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_class_spec1225);
    784 			stream_CLASS_DESCRIPTOR.add(CLASS_DESCRIPTOR11);
    785 
    786 			retval.className = (CLASS_DESCRIPTOR11!=null?CLASS_DESCRIPTOR11.getText():null);
    787 			// AST REWRITE
    788 			// elements: access_list, CLASS_DESCRIPTOR
    789 			// token labels:
    790 			// rule labels: retval
    791 			// token list labels:
    792 			// rule list labels:
    793 			// wildcard labels:
    794 			retval.tree = root_0;
    795 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
    796 
    797 			root_0 = (CommonTree)adaptor.nil();
    798 			// 456:89: -> CLASS_DESCRIPTOR access_list
    799 			{
    800 				adaptor.addChild(root_0, stream_CLASS_DESCRIPTOR.nextNode());
    801 				adaptor.addChild(root_0, stream_access_list.nextTree());
    802 			}
    803 
    804 
    805 			retval.tree = root_0;
    806 
    807 			}
    808 
    809 			retval.stop = input.LT(-1);
    810 
    811 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
    812 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
    813 
    814 		}
    815 		catch (RecognitionException re) {
    816 			reportError(re);
    817 			recover(input,re);
    818 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
    819 		}
    820 		finally {
    821 			// do for sure before leaving
    822 		}
    823 		return retval;
    824 	}
    825 	// $ANTLR end "class_spec"
    826 
    827 
    828 	public static class super_spec_return extends ParserRuleReturnScope {
    829 		CommonTree tree;
    830 		@Override
    831 		public CommonTree getTree() { return tree; }
    832 	};
    833 
    834 
    835 	// $ANTLR start "super_spec"
    836 	// smaliParser.g:458:1: super_spec : SUPER_DIRECTIVE CLASS_DESCRIPTOR -> ^( I_SUPER[$start, \"I_SUPER\"] CLASS_DESCRIPTOR ) ;
    837 	public final smaliParser.super_spec_return super_spec() throws RecognitionException {
    838 		smaliParser.super_spec_return retval = new smaliParser.super_spec_return();
    839 		retval.start = input.LT(1);
    840 
    841 		CommonTree root_0 = null;
    842 
    843 		Token SUPER_DIRECTIVE12=null;
    844 		Token CLASS_DESCRIPTOR13=null;
    845 
    846 		CommonTree SUPER_DIRECTIVE12_tree=null;
    847 		CommonTree CLASS_DESCRIPTOR13_tree=null;
    848 		RewriteRuleTokenStream stream_CLASS_DESCRIPTOR=new RewriteRuleTokenStream(adaptor,"token CLASS_DESCRIPTOR");
    849 		RewriteRuleTokenStream stream_SUPER_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token SUPER_DIRECTIVE");
    850 
    851 		try {
    852 			// smaliParser.g:459:3: ( SUPER_DIRECTIVE CLASS_DESCRIPTOR -> ^( I_SUPER[$start, \"I_SUPER\"] CLASS_DESCRIPTOR ) )
    853 			// smaliParser.g:459:5: SUPER_DIRECTIVE CLASS_DESCRIPTOR
    854 			{
    855 			SUPER_DIRECTIVE12=(Token)match(input,SUPER_DIRECTIVE,FOLLOW_SUPER_DIRECTIVE_in_super_spec1243);
    856 			stream_SUPER_DIRECTIVE.add(SUPER_DIRECTIVE12);
    857 
    858 			CLASS_DESCRIPTOR13=(Token)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_super_spec1245);
    859 			stream_CLASS_DESCRIPTOR.add(CLASS_DESCRIPTOR13);
    860 
    861 			// AST REWRITE
    862 			// elements: CLASS_DESCRIPTOR
    863 			// token labels:
    864 			// rule labels: retval
    865 			// token list labels:
    866 			// rule list labels:
    867 			// wildcard labels:
    868 			retval.tree = root_0;
    869 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
    870 
    871 			root_0 = (CommonTree)adaptor.nil();
    872 			// 459:38: -> ^( I_SUPER[$start, \"I_SUPER\"] CLASS_DESCRIPTOR )
    873 			{
    874 				// smaliParser.g:459:41: ^( I_SUPER[$start, \"I_SUPER\"] CLASS_DESCRIPTOR )
    875 				{
    876 				CommonTree root_1 = (CommonTree)adaptor.nil();
    877 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_SUPER, (retval.start), "I_SUPER"), root_1);
    878 				adaptor.addChild(root_1, stream_CLASS_DESCRIPTOR.nextNode());
    879 				adaptor.addChild(root_0, root_1);
    880 				}
    881 
    882 			}
    883 
    884 
    885 			retval.tree = root_0;
    886 
    887 			}
    888 
    889 			retval.stop = input.LT(-1);
    890 
    891 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
    892 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
    893 
    894 		}
    895 		catch (RecognitionException re) {
    896 			reportError(re);
    897 			recover(input,re);
    898 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
    899 		}
    900 		finally {
    901 			// do for sure before leaving
    902 		}
    903 		return retval;
    904 	}
    905 	// $ANTLR end "super_spec"
    906 
    907 
    908 	public static class implements_spec_return extends ParserRuleReturnScope {
    909 		CommonTree tree;
    910 		@Override
    911 		public CommonTree getTree() { return tree; }
    912 	};
    913 
    914 
    915 	// $ANTLR start "implements_spec"
    916 	// smaliParser.g:461:1: implements_spec : IMPLEMENTS_DIRECTIVE CLASS_DESCRIPTOR -> ^( I_IMPLEMENTS[$start, \"I_IMPLEMENTS\"] CLASS_DESCRIPTOR ) ;
    917 	public final smaliParser.implements_spec_return implements_spec() throws RecognitionException {
    918 		smaliParser.implements_spec_return retval = new smaliParser.implements_spec_return();
    919 		retval.start = input.LT(1);
    920 
    921 		CommonTree root_0 = null;
    922 
    923 		Token IMPLEMENTS_DIRECTIVE14=null;
    924 		Token CLASS_DESCRIPTOR15=null;
    925 
    926 		CommonTree IMPLEMENTS_DIRECTIVE14_tree=null;
    927 		CommonTree CLASS_DESCRIPTOR15_tree=null;
    928 		RewriteRuleTokenStream stream_IMPLEMENTS_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token IMPLEMENTS_DIRECTIVE");
    929 		RewriteRuleTokenStream stream_CLASS_DESCRIPTOR=new RewriteRuleTokenStream(adaptor,"token CLASS_DESCRIPTOR");
    930 
    931 		try {
    932 			// smaliParser.g:462:3: ( IMPLEMENTS_DIRECTIVE CLASS_DESCRIPTOR -> ^( I_IMPLEMENTS[$start, \"I_IMPLEMENTS\"] CLASS_DESCRIPTOR ) )
    933 			// smaliParser.g:462:5: IMPLEMENTS_DIRECTIVE CLASS_DESCRIPTOR
    934 			{
    935 			IMPLEMENTS_DIRECTIVE14=(Token)match(input,IMPLEMENTS_DIRECTIVE,FOLLOW_IMPLEMENTS_DIRECTIVE_in_implements_spec1264);
    936 			stream_IMPLEMENTS_DIRECTIVE.add(IMPLEMENTS_DIRECTIVE14);
    937 
    938 			CLASS_DESCRIPTOR15=(Token)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_implements_spec1266);
    939 			stream_CLASS_DESCRIPTOR.add(CLASS_DESCRIPTOR15);
    940 
    941 			// AST REWRITE
    942 			// elements: CLASS_DESCRIPTOR
    943 			// token labels:
    944 			// rule labels: retval
    945 			// token list labels:
    946 			// rule list labels:
    947 			// wildcard labels:
    948 			retval.tree = root_0;
    949 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
    950 
    951 			root_0 = (CommonTree)adaptor.nil();
    952 			// 462:43: -> ^( I_IMPLEMENTS[$start, \"I_IMPLEMENTS\"] CLASS_DESCRIPTOR )
    953 			{
    954 				// smaliParser.g:462:46: ^( I_IMPLEMENTS[$start, \"I_IMPLEMENTS\"] CLASS_DESCRIPTOR )
    955 				{
    956 				CommonTree root_1 = (CommonTree)adaptor.nil();
    957 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_IMPLEMENTS, (retval.start), "I_IMPLEMENTS"), root_1);
    958 				adaptor.addChild(root_1, stream_CLASS_DESCRIPTOR.nextNode());
    959 				adaptor.addChild(root_0, root_1);
    960 				}
    961 
    962 			}
    963 
    964 
    965 			retval.tree = root_0;
    966 
    967 			}
    968 
    969 			retval.stop = input.LT(-1);
    970 
    971 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
    972 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
    973 
    974 		}
    975 		catch (RecognitionException re) {
    976 			reportError(re);
    977 			recover(input,re);
    978 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
    979 		}
    980 		finally {
    981 			// do for sure before leaving
    982 		}
    983 		return retval;
    984 	}
    985 	// $ANTLR end "implements_spec"
    986 
    987 
    988 	public static class source_spec_return extends ParserRuleReturnScope {
    989 		CommonTree tree;
    990 		@Override
    991 		public CommonTree getTree() { return tree; }
    992 	};
    993 
    994 
    995 	// $ANTLR start "source_spec"
    996 	// smaliParser.g:464:1: source_spec : SOURCE_DIRECTIVE STRING_LITERAL -> ^( I_SOURCE[$start, \"I_SOURCE\"] STRING_LITERAL ) ;
    997 	public final smaliParser.source_spec_return source_spec() throws RecognitionException {
    998 		smaliParser.source_spec_return retval = new smaliParser.source_spec_return();
    999 		retval.start = input.LT(1);
   1000 
   1001 		CommonTree root_0 = null;
   1002 
   1003 		Token SOURCE_DIRECTIVE16=null;
   1004 		Token STRING_LITERAL17=null;
   1005 
   1006 		CommonTree SOURCE_DIRECTIVE16_tree=null;
   1007 		CommonTree STRING_LITERAL17_tree=null;
   1008 		RewriteRuleTokenStream stream_SOURCE_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token SOURCE_DIRECTIVE");
   1009 		RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL");
   1010 
   1011 		try {
   1012 			// smaliParser.g:465:3: ( SOURCE_DIRECTIVE STRING_LITERAL -> ^( I_SOURCE[$start, \"I_SOURCE\"] STRING_LITERAL ) )
   1013 			// smaliParser.g:465:5: SOURCE_DIRECTIVE STRING_LITERAL
   1014 			{
   1015 			SOURCE_DIRECTIVE16=(Token)match(input,SOURCE_DIRECTIVE,FOLLOW_SOURCE_DIRECTIVE_in_source_spec1285);
   1016 			stream_SOURCE_DIRECTIVE.add(SOURCE_DIRECTIVE16);
   1017 
   1018 			STRING_LITERAL17=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_source_spec1287);
   1019 			stream_STRING_LITERAL.add(STRING_LITERAL17);
   1020 
   1021 			// AST REWRITE
   1022 			// elements: STRING_LITERAL
   1023 			// token labels:
   1024 			// rule labels: retval
   1025 			// token list labels:
   1026 			// rule list labels:
   1027 			// wildcard labels:
   1028 			retval.tree = root_0;
   1029 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   1030 
   1031 			root_0 = (CommonTree)adaptor.nil();
   1032 			// 465:37: -> ^( I_SOURCE[$start, \"I_SOURCE\"] STRING_LITERAL )
   1033 			{
   1034 				// smaliParser.g:465:40: ^( I_SOURCE[$start, \"I_SOURCE\"] STRING_LITERAL )
   1035 				{
   1036 				CommonTree root_1 = (CommonTree)adaptor.nil();
   1037 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_SOURCE, (retval.start), "I_SOURCE"), root_1);
   1038 				adaptor.addChild(root_1, stream_STRING_LITERAL.nextNode());
   1039 				adaptor.addChild(root_0, root_1);
   1040 				}
   1041 
   1042 			}
   1043 
   1044 
   1045 			retval.tree = root_0;
   1046 
   1047 			}
   1048 
   1049 			retval.stop = input.LT(-1);
   1050 
   1051 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   1052 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   1053 
   1054 		}
   1055 		catch (RecognitionException re) {
   1056 			reportError(re);
   1057 			recover(input,re);
   1058 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   1059 		}
   1060 		finally {
   1061 			// do for sure before leaving
   1062 		}
   1063 		return retval;
   1064 	}
   1065 	// $ANTLR end "source_spec"
   1066 
   1067 
   1068 	public static class access_list_return extends ParserRuleReturnScope {
   1069 		CommonTree tree;
   1070 		@Override
   1071 		public CommonTree getTree() { return tree; }
   1072 	};
   1073 
   1074 
   1075 	// $ANTLR start "access_list"
   1076 	// smaliParser.g:467:1: access_list : ( ACCESS_SPEC )* -> ^( I_ACCESS_LIST[$start,\"I_ACCESS_LIST\"] ( ACCESS_SPEC )* ) ;
   1077 	public final smaliParser.access_list_return access_list() throws RecognitionException {
   1078 		smaliParser.access_list_return retval = new smaliParser.access_list_return();
   1079 		retval.start = input.LT(1);
   1080 
   1081 		CommonTree root_0 = null;
   1082 
   1083 		Token ACCESS_SPEC18=null;
   1084 
   1085 		CommonTree ACCESS_SPEC18_tree=null;
   1086 		RewriteRuleTokenStream stream_ACCESS_SPEC=new RewriteRuleTokenStream(adaptor,"token ACCESS_SPEC");
   1087 
   1088 		try {
   1089 			// smaliParser.g:468:3: ( ( ACCESS_SPEC )* -> ^( I_ACCESS_LIST[$start,\"I_ACCESS_LIST\"] ( ACCESS_SPEC )* ) )
   1090 			// smaliParser.g:468:5: ( ACCESS_SPEC )*
   1091 			{
   1092 			// smaliParser.g:468:5: ( ACCESS_SPEC )*
   1093 			loop2:
   1094 			while (true) {
   1095 				int alt2=2;
   1096 				int LA2_0 = input.LA(1);
   1097 				if ( (LA2_0==ACCESS_SPEC) ) {
   1098 					int LA2_2 = input.LA(2);
   1099 					if ( (LA2_2==ACCESS_SPEC||LA2_2==ANNOTATION_VISIBILITY||LA2_2==BOOL_LITERAL||LA2_2==CLASS_DESCRIPTOR||LA2_2==DOUBLE_LITERAL_OR_ID||LA2_2==FLOAT_LITERAL_OR_ID||(LA2_2 >= INSTRUCTION_FORMAT10t && LA2_2 <= INSTRUCTION_FORMAT10x_ODEX)||LA2_2==INSTRUCTION_FORMAT11x||LA2_2==INSTRUCTION_FORMAT12x_OR_ID||(LA2_2 >= INSTRUCTION_FORMAT21c_FIELD && LA2_2 <= INSTRUCTION_FORMAT21c_TYPE)||LA2_2==INSTRUCTION_FORMAT21t||(LA2_2 >= INSTRUCTION_FORMAT22c_FIELD && LA2_2 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA2_2 >= INSTRUCTION_FORMAT22s_OR_ID && LA2_2 <= INSTRUCTION_FORMAT22t)||LA2_2==INSTRUCTION_FORMAT23x||(LA2_2 >= INSTRUCTION_FORMAT31i_OR_ID && LA2_2 <= INSTRUCTION_FORMAT31t)||(LA2_2 >= INSTRUCTION_FORMAT35c_METHOD && LA2_2 <= INSTRUCTION_FORMAT35ms_METHOD)||(LA2_2 >= INSTRUCTION_FORMAT45cc_METHOD && LA2_2 <= INSTRUCTION_FORMAT51l)||LA2_2==MEMBER_NAME||(LA2_2 >= NEGATIVE_INTEGER_LITERAL && LA2_2 <= NULL_LITERAL)||(LA2_2 >= PARAM_LIST_OR_ID_PRIMITIVE_TYPE && LA2_2 <= PRIMITIVE_TYPE)||LA2_2==REGISTER||LA2_2==SIMPLE_NAME||(LA2_2 >= VERIFICATION_ERROR_TYPE && LA2_2 <= VOID_TYPE)) ) {
   1100 						alt2=1;
   1101 					}
   1102 
   1103 				}
   1104 
   1105 				switch (alt2) {
   1106 				case 1 :
   1107 					// smaliParser.g:468:5: ACCESS_SPEC
   1108 					{
   1109 					ACCESS_SPEC18=(Token)match(input,ACCESS_SPEC,FOLLOW_ACCESS_SPEC_in_access_list1306);
   1110 					stream_ACCESS_SPEC.add(ACCESS_SPEC18);
   1111 
   1112 					}
   1113 					break;
   1114 
   1115 				default :
   1116 					break loop2;
   1117 				}
   1118 			}
   1119 
   1120 			// AST REWRITE
   1121 			// elements: ACCESS_SPEC
   1122 			// token labels:
   1123 			// rule labels: retval
   1124 			// token list labels:
   1125 			// rule list labels:
   1126 			// wildcard labels:
   1127 			retval.tree = root_0;
   1128 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   1129 
   1130 			root_0 = (CommonTree)adaptor.nil();
   1131 			// 468:18: -> ^( I_ACCESS_LIST[$start,\"I_ACCESS_LIST\"] ( ACCESS_SPEC )* )
   1132 			{
   1133 				// smaliParser.g:468:21: ^( I_ACCESS_LIST[$start,\"I_ACCESS_LIST\"] ( ACCESS_SPEC )* )
   1134 				{
   1135 				CommonTree root_1 = (CommonTree)adaptor.nil();
   1136 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ACCESS_LIST, (retval.start), "I_ACCESS_LIST"), root_1);
   1137 				// smaliParser.g:468:61: ( ACCESS_SPEC )*
   1138 				while ( stream_ACCESS_SPEC.hasNext() ) {
   1139 					adaptor.addChild(root_1, stream_ACCESS_SPEC.nextNode());
   1140 				}
   1141 				stream_ACCESS_SPEC.reset();
   1142 
   1143 				adaptor.addChild(root_0, root_1);
   1144 				}
   1145 
   1146 			}
   1147 
   1148 
   1149 			retval.tree = root_0;
   1150 
   1151 			}
   1152 
   1153 			retval.stop = input.LT(-1);
   1154 
   1155 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   1156 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   1157 
   1158 		}
   1159 		catch (RecognitionException re) {
   1160 			reportError(re);
   1161 			recover(input,re);
   1162 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   1163 		}
   1164 		finally {
   1165 			// do for sure before leaving
   1166 		}
   1167 		return retval;
   1168 	}
   1169 	// $ANTLR end "access_list"
   1170 
   1171 
   1172 	public static class field_return extends ParserRuleReturnScope {
   1173 		CommonTree tree;
   1174 		@Override
   1175 		public CommonTree getTree() { return tree; }
   1176 	};
   1177 
   1178 
   1179 	// $ANTLR start "field"
   1180 	// smaliParser.g:475:1: field : FIELD_DIRECTIVE access_list member_name COLON nonvoid_type_descriptor ( EQUAL literal )? ( ({...}? annotation )* ( END_FIELD_DIRECTIVE -> ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ( annotation )* ) ) | -> ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ) ) ) ) ;
   1181 	public final smaliParser.field_return field() throws RecognitionException {
   1182 		smaliParser.field_return retval = new smaliParser.field_return();
   1183 		retval.start = input.LT(1);
   1184 
   1185 		CommonTree root_0 = null;
   1186 
   1187 		Token FIELD_DIRECTIVE19=null;
   1188 		Token COLON22=null;
   1189 		Token EQUAL24=null;
   1190 		Token END_FIELD_DIRECTIVE27=null;
   1191 		ParserRuleReturnScope access_list20 =null;
   1192 		ParserRuleReturnScope member_name21 =null;
   1193 		ParserRuleReturnScope nonvoid_type_descriptor23 =null;
   1194 		ParserRuleReturnScope literal25 =null;
   1195 		ParserRuleReturnScope annotation26 =null;
   1196 
   1197 		CommonTree FIELD_DIRECTIVE19_tree=null;
   1198 		CommonTree COLON22_tree=null;
   1199 		CommonTree EQUAL24_tree=null;
   1200 		CommonTree END_FIELD_DIRECTIVE27_tree=null;
   1201 		RewriteRuleTokenStream stream_END_FIELD_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_FIELD_DIRECTIVE");
   1202 		RewriteRuleTokenStream stream_EQUAL=new RewriteRuleTokenStream(adaptor,"token EQUAL");
   1203 		RewriteRuleTokenStream stream_FIELD_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token FIELD_DIRECTIVE");
   1204 		RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON");
   1205 		RewriteRuleSubtreeStream stream_annotation=new RewriteRuleSubtreeStream(adaptor,"rule annotation");
   1206 		RewriteRuleSubtreeStream stream_access_list=new RewriteRuleSubtreeStream(adaptor,"rule access_list");
   1207 		RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor");
   1208 		RewriteRuleSubtreeStream stream_member_name=new RewriteRuleSubtreeStream(adaptor,"rule member_name");
   1209 		RewriteRuleSubtreeStream stream_literal=new RewriteRuleSubtreeStream(adaptor,"rule literal");
   1210 
   1211 		List<CommonTree> annotations = new ArrayList<CommonTree>();
   1212 		try {
   1213 			// smaliParser.g:477:3: ( FIELD_DIRECTIVE access_list member_name COLON nonvoid_type_descriptor ( EQUAL literal )? ( ({...}? annotation )* ( END_FIELD_DIRECTIVE -> ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ( annotation )* ) ) | -> ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ) ) ) ) )
   1214 			// smaliParser.g:477:5: FIELD_DIRECTIVE access_list member_name COLON nonvoid_type_descriptor ( EQUAL literal )? ( ({...}? annotation )* ( END_FIELD_DIRECTIVE -> ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ( annotation )* ) ) | -> ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ) ) ) )
   1215 			{
   1216 			FIELD_DIRECTIVE19=(Token)match(input,FIELD_DIRECTIVE,FOLLOW_FIELD_DIRECTIVE_in_field1337);
   1217 			stream_FIELD_DIRECTIVE.add(FIELD_DIRECTIVE19);
   1218 
   1219 			pushFollow(FOLLOW_access_list_in_field1339);
   1220 			access_list20=access_list();
   1221 			state._fsp--;
   1222 
   1223 			stream_access_list.add(access_list20.getTree());
   1224 			pushFollow(FOLLOW_member_name_in_field1341);
   1225 			member_name21=member_name();
   1226 			state._fsp--;
   1227 
   1228 			stream_member_name.add(member_name21.getTree());
   1229 			COLON22=(Token)match(input,COLON,FOLLOW_COLON_in_field1343);
   1230 			stream_COLON.add(COLON22);
   1231 
   1232 			pushFollow(FOLLOW_nonvoid_type_descriptor_in_field1345);
   1233 			nonvoid_type_descriptor23=nonvoid_type_descriptor();
   1234 			state._fsp--;
   1235 
   1236 			stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor23.getTree());
   1237 			// smaliParser.g:477:75: ( EQUAL literal )?
   1238 			int alt3=2;
   1239 			int LA3_0 = input.LA(1);
   1240 			if ( (LA3_0==EQUAL) ) {
   1241 				alt3=1;
   1242 			}
   1243 			switch (alt3) {
   1244 				case 1 :
   1245 					// smaliParser.g:477:76: EQUAL literal
   1246 					{
   1247 					EQUAL24=(Token)match(input,EQUAL,FOLLOW_EQUAL_in_field1348);
   1248 					stream_EQUAL.add(EQUAL24);
   1249 
   1250 					pushFollow(FOLLOW_literal_in_field1350);
   1251 					literal25=literal();
   1252 					state._fsp--;
   1253 
   1254 					stream_literal.add(literal25.getTree());
   1255 					}
   1256 					break;
   1257 
   1258 			}
   1259 
   1260 			// smaliParser.g:478:5: ( ({...}? annotation )* ( END_FIELD_DIRECTIVE -> ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ( annotation )* ) ) | -> ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ) ) ) )
   1261 			// smaliParser.g:478:7: ({...}? annotation )* ( END_FIELD_DIRECTIVE -> ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ( annotation )* ) ) | -> ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ) ) )
   1262 			{
   1263 			// smaliParser.g:478:7: ({...}? annotation )*
   1264 			loop4:
   1265 			while (true) {
   1266 				int alt4=2;
   1267 				int LA4_0 = input.LA(1);
   1268 				if ( (LA4_0==ANNOTATION_DIRECTIVE) ) {
   1269 					int LA4_9 = input.LA(2);
   1270 					if ( ((input.LA(1) == ANNOTATION_DIRECTIVE)) ) {
   1271 						alt4=1;
   1272 					}
   1273 
   1274 				}
   1275 
   1276 				switch (alt4) {
   1277 				case 1 :
   1278 					// smaliParser.g:478:8: {...}? annotation
   1279 					{
   1280 					if ( !((input.LA(1) == ANNOTATION_DIRECTIVE)) ) {
   1281 						throw new FailedPredicateException(input, "field", "input.LA(1) == ANNOTATION_DIRECTIVE");
   1282 					}
   1283 					pushFollow(FOLLOW_annotation_in_field1363);
   1284 					annotation26=annotation();
   1285 					state._fsp--;
   1286 
   1287 					stream_annotation.add(annotation26.getTree());
   1288 					annotations.add((annotation26!=null?((CommonTree)annotation26.getTree()):null));
   1289 					}
   1290 					break;
   1291 
   1292 				default :
   1293 					break loop4;
   1294 				}
   1295 			}
   1296 
   1297 			// smaliParser.g:479:7: ( END_FIELD_DIRECTIVE -> ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ( annotation )* ) ) | -> ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ) ) )
   1298 			int alt5=2;
   1299 			int LA5_0 = input.LA(1);
   1300 			if ( (LA5_0==END_FIELD_DIRECTIVE) ) {
   1301 				alt5=1;
   1302 			}
   1303 			else if ( (LA5_0==EOF||LA5_0==ANNOTATION_DIRECTIVE||LA5_0==CLASS_DIRECTIVE||LA5_0==FIELD_DIRECTIVE||LA5_0==IMPLEMENTS_DIRECTIVE||LA5_0==METHOD_DIRECTIVE||LA5_0==SOURCE_DIRECTIVE||LA5_0==SUPER_DIRECTIVE) ) {
   1304 				alt5=2;
   1305 			}
   1306 
   1307 			else {
   1308 				NoViableAltException nvae =
   1309 					new NoViableAltException("", 5, 0, input);
   1310 				throw nvae;
   1311 			}
   1312 
   1313 			switch (alt5) {
   1314 				case 1 :
   1315 					// smaliParser.g:479:9: END_FIELD_DIRECTIVE
   1316 					{
   1317 					END_FIELD_DIRECTIVE27=(Token)match(input,END_FIELD_DIRECTIVE,FOLLOW_END_FIELD_DIRECTIVE_in_field1377);
   1318 					stream_END_FIELD_DIRECTIVE.add(END_FIELD_DIRECTIVE27);
   1319 
   1320 					// AST REWRITE
   1321 					// elements: access_list, nonvoid_type_descriptor, annotation, member_name, literal
   1322 					// token labels:
   1323 					// rule labels: retval
   1324 					// token list labels:
   1325 					// rule list labels:
   1326 					// wildcard labels:
   1327 					retval.tree = root_0;
   1328 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   1329 
   1330 					root_0 = (CommonTree)adaptor.nil();
   1331 					// 480:9: -> ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ( annotation )* ) )
   1332 					{
   1333 						// smaliParser.g:480:12: ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ( annotation )* ) )
   1334 						{
   1335 						CommonTree root_1 = (CommonTree)adaptor.nil();
   1336 						root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_FIELD, (retval.start), "I_FIELD"), root_1);
   1337 						adaptor.addChild(root_1, stream_member_name.nextTree());
   1338 						adaptor.addChild(root_1, stream_access_list.nextTree());
   1339 						// smaliParser.g:480:65: ^( I_FIELD_TYPE nonvoid_type_descriptor )
   1340 						{
   1341 						CommonTree root_2 = (CommonTree)adaptor.nil();
   1342 						root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_FIELD_TYPE, "I_FIELD_TYPE"), root_2);
   1343 						adaptor.addChild(root_2, stream_nonvoid_type_descriptor.nextTree());
   1344 						adaptor.addChild(root_1, root_2);
   1345 						}
   1346 
   1347 						// smaliParser.g:480:105: ( ^( I_FIELD_INITIAL_VALUE literal ) )?
   1348 						if ( stream_literal.hasNext() ) {
   1349 							// smaliParser.g:480:105: ^( I_FIELD_INITIAL_VALUE literal )
   1350 							{
   1351 							CommonTree root_2 = (CommonTree)adaptor.nil();
   1352 							root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_FIELD_INITIAL_VALUE, "I_FIELD_INITIAL_VALUE"), root_2);
   1353 							adaptor.addChild(root_2, stream_literal.nextTree());
   1354 							adaptor.addChild(root_1, root_2);
   1355 							}
   1356 
   1357 						}
   1358 						stream_literal.reset();
   1359 
   1360 						// smaliParser.g:480:139: ^( I_ANNOTATIONS ( annotation )* )
   1361 						{
   1362 						CommonTree root_2 = (CommonTree)adaptor.nil();
   1363 						root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ANNOTATIONS, "I_ANNOTATIONS"), root_2);
   1364 						// smaliParser.g:480:155: ( annotation )*
   1365 						while ( stream_annotation.hasNext() ) {
   1366 							adaptor.addChild(root_2, stream_annotation.nextTree());
   1367 						}
   1368 						stream_annotation.reset();
   1369 
   1370 						adaptor.addChild(root_1, root_2);
   1371 						}
   1372 
   1373 						adaptor.addChild(root_0, root_1);
   1374 						}
   1375 
   1376 					}
   1377 
   1378 
   1379 					retval.tree = root_0;
   1380 
   1381 					}
   1382 					break;
   1383 				case 2 :
   1384 					// smaliParser.g:481:21:
   1385 					{
   1386 					smali_file_stack.peek().classAnnotations.addAll(annotations);
   1387 					// AST REWRITE
   1388 					// elements: member_name, access_list, literal, nonvoid_type_descriptor
   1389 					// token labels:
   1390 					// rule labels: retval
   1391 					// token list labels:
   1392 					// rule list labels:
   1393 					// wildcard labels:
   1394 					retval.tree = root_0;
   1395 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   1396 
   1397 					root_0 = (CommonTree)adaptor.nil();
   1398 					// 482:9: -> ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ) )
   1399 					{
   1400 						// smaliParser.g:482:12: ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ) )
   1401 						{
   1402 						CommonTree root_1 = (CommonTree)adaptor.nil();
   1403 						root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_FIELD, (retval.start), "I_FIELD"), root_1);
   1404 						adaptor.addChild(root_1, stream_member_name.nextTree());
   1405 						adaptor.addChild(root_1, stream_access_list.nextTree());
   1406 						// smaliParser.g:482:65: ^( I_FIELD_TYPE nonvoid_type_descriptor )
   1407 						{
   1408 						CommonTree root_2 = (CommonTree)adaptor.nil();
   1409 						root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_FIELD_TYPE, "I_FIELD_TYPE"), root_2);
   1410 						adaptor.addChild(root_2, stream_nonvoid_type_descriptor.nextTree());
   1411 						adaptor.addChild(root_1, root_2);
   1412 						}
   1413 
   1414 						// smaliParser.g:482:105: ( ^( I_FIELD_INITIAL_VALUE literal ) )?
   1415 						if ( stream_literal.hasNext() ) {
   1416 							// smaliParser.g:482:105: ^( I_FIELD_INITIAL_VALUE literal )
   1417 							{
   1418 							CommonTree root_2 = (CommonTree)adaptor.nil();
   1419 							root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_FIELD_INITIAL_VALUE, "I_FIELD_INITIAL_VALUE"), root_2);
   1420 							adaptor.addChild(root_2, stream_literal.nextTree());
   1421 							adaptor.addChild(root_1, root_2);
   1422 							}
   1423 
   1424 						}
   1425 						stream_literal.reset();
   1426 
   1427 						// smaliParser.g:482:139: ^( I_ANNOTATIONS )
   1428 						{
   1429 						CommonTree root_2 = (CommonTree)adaptor.nil();
   1430 						root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ANNOTATIONS, "I_ANNOTATIONS"), root_2);
   1431 						adaptor.addChild(root_1, root_2);
   1432 						}
   1433 
   1434 						adaptor.addChild(root_0, root_1);
   1435 						}
   1436 
   1437 					}
   1438 
   1439 
   1440 					retval.tree = root_0;
   1441 
   1442 					}
   1443 					break;
   1444 
   1445 			}
   1446 
   1447 			}
   1448 
   1449 			}
   1450 
   1451 			retval.stop = input.LT(-1);
   1452 
   1453 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   1454 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   1455 
   1456 		}
   1457 		catch (RecognitionException re) {
   1458 			reportError(re);
   1459 			recover(input,re);
   1460 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   1461 		}
   1462 		finally {
   1463 			// do for sure before leaving
   1464 		}
   1465 		return retval;
   1466 	}
   1467 	// $ANTLR end "field"
   1468 
   1469 
   1470 	public static class method_return extends ParserRuleReturnScope {
   1471 		CommonTree tree;
   1472 		@Override
   1473 		public CommonTree getTree() { return tree; }
   1474 	};
   1475 
   1476 
   1477 	// $ANTLR start "method"
   1478 	// smaliParser.g:486:1: method : METHOD_DIRECTIVE access_list member_name method_prototype statements_and_directives END_METHOD_DIRECTIVE -> ^( I_METHOD[$start, \"I_METHOD\"] member_name method_prototype access_list statements_and_directives ) ;
   1479 	public final smaliParser.method_return method() throws RecognitionException {
   1480 		smaliParser.method_return retval = new smaliParser.method_return();
   1481 		retval.start = input.LT(1);
   1482 
   1483 		CommonTree root_0 = null;
   1484 
   1485 		Token METHOD_DIRECTIVE28=null;
   1486 		Token END_METHOD_DIRECTIVE33=null;
   1487 		ParserRuleReturnScope access_list29 =null;
   1488 		ParserRuleReturnScope member_name30 =null;
   1489 		ParserRuleReturnScope method_prototype31 =null;
   1490 		ParserRuleReturnScope statements_and_directives32 =null;
   1491 
   1492 		CommonTree METHOD_DIRECTIVE28_tree=null;
   1493 		CommonTree END_METHOD_DIRECTIVE33_tree=null;
   1494 		RewriteRuleTokenStream stream_END_METHOD_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_METHOD_DIRECTIVE");
   1495 		RewriteRuleTokenStream stream_METHOD_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token METHOD_DIRECTIVE");
   1496 		RewriteRuleSubtreeStream stream_method_prototype=new RewriteRuleSubtreeStream(adaptor,"rule method_prototype");
   1497 		RewriteRuleSubtreeStream stream_access_list=new RewriteRuleSubtreeStream(adaptor,"rule access_list");
   1498 		RewriteRuleSubtreeStream stream_member_name=new RewriteRuleSubtreeStream(adaptor,"rule member_name");
   1499 		RewriteRuleSubtreeStream stream_statements_and_directives=new RewriteRuleSubtreeStream(adaptor,"rule statements_and_directives");
   1500 
   1501 		try {
   1502 			// smaliParser.g:487:3: ( METHOD_DIRECTIVE access_list member_name method_prototype statements_and_directives END_METHOD_DIRECTIVE -> ^( I_METHOD[$start, \"I_METHOD\"] member_name method_prototype access_list statements_and_directives ) )
   1503 			// smaliParser.g:487:5: METHOD_DIRECTIVE access_list member_name method_prototype statements_and_directives END_METHOD_DIRECTIVE
   1504 			{
   1505 			METHOD_DIRECTIVE28=(Token)match(input,METHOD_DIRECTIVE,FOLLOW_METHOD_DIRECTIVE_in_method1488);
   1506 			stream_METHOD_DIRECTIVE.add(METHOD_DIRECTIVE28);
   1507 
   1508 			pushFollow(FOLLOW_access_list_in_method1490);
   1509 			access_list29=access_list();
   1510 			state._fsp--;
   1511 
   1512 			stream_access_list.add(access_list29.getTree());
   1513 			pushFollow(FOLLOW_member_name_in_method1492);
   1514 			member_name30=member_name();
   1515 			state._fsp--;
   1516 
   1517 			stream_member_name.add(member_name30.getTree());
   1518 			pushFollow(FOLLOW_method_prototype_in_method1494);
   1519 			method_prototype31=method_prototype();
   1520 			state._fsp--;
   1521 
   1522 			stream_method_prototype.add(method_prototype31.getTree());
   1523 			pushFollow(FOLLOW_statements_and_directives_in_method1496);
   1524 			statements_and_directives32=statements_and_directives();
   1525 			state._fsp--;
   1526 
   1527 			stream_statements_and_directives.add(statements_and_directives32.getTree());
   1528 			END_METHOD_DIRECTIVE33=(Token)match(input,END_METHOD_DIRECTIVE,FOLLOW_END_METHOD_DIRECTIVE_in_method1502);
   1529 			stream_END_METHOD_DIRECTIVE.add(END_METHOD_DIRECTIVE33);
   1530 
   1531 			// AST REWRITE
   1532 			// elements: method_prototype, access_list, member_name, statements_and_directives
   1533 			// token labels:
   1534 			// rule labels: retval
   1535 			// token list labels:
   1536 			// rule list labels:
   1537 			// wildcard labels:
   1538 			retval.tree = root_0;
   1539 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   1540 
   1541 			root_0 = (CommonTree)adaptor.nil();
   1542 			// 489:5: -> ^( I_METHOD[$start, \"I_METHOD\"] member_name method_prototype access_list statements_and_directives )
   1543 			{
   1544 				// smaliParser.g:489:8: ^( I_METHOD[$start, \"I_METHOD\"] member_name method_prototype access_list statements_and_directives )
   1545 				{
   1546 				CommonTree root_1 = (CommonTree)adaptor.nil();
   1547 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_METHOD, (retval.start), "I_METHOD"), root_1);
   1548 				adaptor.addChild(root_1, stream_member_name.nextTree());
   1549 				adaptor.addChild(root_1, stream_method_prototype.nextTree());
   1550 				adaptor.addChild(root_1, stream_access_list.nextTree());
   1551 				adaptor.addChild(root_1, stream_statements_and_directives.nextTree());
   1552 				adaptor.addChild(root_0, root_1);
   1553 				}
   1554 
   1555 			}
   1556 
   1557 
   1558 			retval.tree = root_0;
   1559 
   1560 			}
   1561 
   1562 			retval.stop = input.LT(-1);
   1563 
   1564 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   1565 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   1566 
   1567 		}
   1568 		catch (RecognitionException re) {
   1569 			reportError(re);
   1570 			recover(input,re);
   1571 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   1572 		}
   1573 		finally {
   1574 			// do for sure before leaving
   1575 		}
   1576 		return retval;
   1577 	}
   1578 	// $ANTLR end "method"
   1579 
   1580 
   1581 	protected static class statements_and_directives_scope {
   1582 		boolean hasRegistersDirective;
   1583 		List<CommonTree> methodAnnotations;
   1584 	}
   1585 	protected Stack<statements_and_directives_scope> statements_and_directives_stack = new Stack<statements_and_directives_scope>();
   1586 
   1587 	public static class statements_and_directives_return extends ParserRuleReturnScope {
   1588 		CommonTree tree;
   1589 		@Override
   1590 		public CommonTree getTree() { return tree; }
   1591 	};
   1592 
   1593 
   1594 	// $ANTLR start "statements_and_directives"
   1595 	// smaliParser.g:491:1: statements_and_directives : ( ordered_method_item | registers_directive | catch_directive | catchall_directive | parameter_directive | annotation )* -> ( registers_directive )? ^( I_ORDERED_METHOD_ITEMS ( ordered_method_item )* ) ^( I_CATCHES ( catch_directive )* ( catchall_directive )* ) ^( I_PARAMETERS ( parameter_directive )* ) ;
   1596 	public final smaliParser.statements_and_directives_return statements_and_directives() throws RecognitionException {
   1597 		statements_and_directives_stack.push(new statements_and_directives_scope());
   1598 		smaliParser.statements_and_directives_return retval = new smaliParser.statements_and_directives_return();
   1599 		retval.start = input.LT(1);
   1600 
   1601 		CommonTree root_0 = null;
   1602 
   1603 		ParserRuleReturnScope ordered_method_item34 =null;
   1604 		ParserRuleReturnScope registers_directive35 =null;
   1605 		ParserRuleReturnScope catch_directive36 =null;
   1606 		ParserRuleReturnScope catchall_directive37 =null;
   1607 		ParserRuleReturnScope parameter_directive38 =null;
   1608 		ParserRuleReturnScope annotation39 =null;
   1609 
   1610 		RewriteRuleSubtreeStream stream_annotation=new RewriteRuleSubtreeStream(adaptor,"rule annotation");
   1611 		RewriteRuleSubtreeStream stream_catchall_directive=new RewriteRuleSubtreeStream(adaptor,"rule catchall_directive");
   1612 		RewriteRuleSubtreeStream stream_registers_directive=new RewriteRuleSubtreeStream(adaptor,"rule registers_directive");
   1613 		RewriteRuleSubtreeStream stream_catch_directive=new RewriteRuleSubtreeStream(adaptor,"rule catch_directive");
   1614 		RewriteRuleSubtreeStream stream_ordered_method_item=new RewriteRuleSubtreeStream(adaptor,"rule ordered_method_item");
   1615 		RewriteRuleSubtreeStream stream_parameter_directive=new RewriteRuleSubtreeStream(adaptor,"rule parameter_directive");
   1616 
   1617 		try {
   1618 			// smaliParser.g:497:3: ( ( ordered_method_item | registers_directive | catch_directive | catchall_directive | parameter_directive | annotation )* -> ( registers_directive )? ^( I_ORDERED_METHOD_ITEMS ( ordered_method_item )* ) ^( I_CATCHES ( catch_directive )* ( catchall_directive )* ) ^( I_PARAMETERS ( parameter_directive )* ) )
   1619 			// smaliParser.g:497:5: ( ordered_method_item | registers_directive | catch_directive | catchall_directive | parameter_directive | annotation )*
   1620 			{
   1621 
   1622 			      statements_and_directives_stack.peek().hasRegistersDirective = false;
   1623 			      statements_and_directives_stack.peek().methodAnnotations = new ArrayList<CommonTree>();
   1624 
   1625 			// smaliParser.g:501:5: ( ordered_method_item | registers_directive | catch_directive | catchall_directive | parameter_directive | annotation )*
   1626 			loop6:
   1627 			while (true) {
   1628 				int alt6=7;
   1629 				switch ( input.LA(1) ) {
   1630 				case ARRAY_DATA_DIRECTIVE:
   1631 				case COLON:
   1632 				case END_LOCAL_DIRECTIVE:
   1633 				case EPILOGUE_DIRECTIVE:
   1634 				case INSTRUCTION_FORMAT10t:
   1635 				case INSTRUCTION_FORMAT10x:
   1636 				case INSTRUCTION_FORMAT10x_ODEX:
   1637 				case INSTRUCTION_FORMAT11n:
   1638 				case INSTRUCTION_FORMAT11x:
   1639 				case INSTRUCTION_FORMAT12x:
   1640 				case INSTRUCTION_FORMAT12x_OR_ID:
   1641 				case INSTRUCTION_FORMAT20bc:
   1642 				case INSTRUCTION_FORMAT20t:
   1643 				case INSTRUCTION_FORMAT21c_FIELD:
   1644 				case INSTRUCTION_FORMAT21c_FIELD_ODEX:
   1645 				case INSTRUCTION_FORMAT21c_STRING:
   1646 				case INSTRUCTION_FORMAT21c_TYPE:
   1647 				case INSTRUCTION_FORMAT21ih:
   1648 				case INSTRUCTION_FORMAT21lh:
   1649 				case INSTRUCTION_FORMAT21s:
   1650 				case INSTRUCTION_FORMAT21t:
   1651 				case INSTRUCTION_FORMAT22b:
   1652 				case INSTRUCTION_FORMAT22c_FIELD:
   1653 				case INSTRUCTION_FORMAT22c_FIELD_ODEX:
   1654 				case INSTRUCTION_FORMAT22c_TYPE:
   1655 				case INSTRUCTION_FORMAT22cs_FIELD:
   1656 				case INSTRUCTION_FORMAT22s:
   1657 				case INSTRUCTION_FORMAT22s_OR_ID:
   1658 				case INSTRUCTION_FORMAT22t:
   1659 				case INSTRUCTION_FORMAT22x:
   1660 				case INSTRUCTION_FORMAT23x:
   1661 				case INSTRUCTION_FORMAT30t:
   1662 				case INSTRUCTION_FORMAT31c:
   1663 				case INSTRUCTION_FORMAT31i:
   1664 				case INSTRUCTION_FORMAT31i_OR_ID:
   1665 				case INSTRUCTION_FORMAT31t:
   1666 				case INSTRUCTION_FORMAT32x:
   1667 				case INSTRUCTION_FORMAT35c_METHOD:
   1668 				case INSTRUCTION_FORMAT35c_METHOD_ODEX:
   1669 				case INSTRUCTION_FORMAT35c_TYPE:
   1670 				case INSTRUCTION_FORMAT35mi_METHOD:
   1671 				case INSTRUCTION_FORMAT35ms_METHOD:
   1672 				case INSTRUCTION_FORMAT3rc_METHOD:
   1673 				case INSTRUCTION_FORMAT3rc_METHOD_ODEX:
   1674 				case INSTRUCTION_FORMAT3rc_TYPE:
   1675 				case INSTRUCTION_FORMAT3rmi_METHOD:
   1676 				case INSTRUCTION_FORMAT3rms_METHOD:
   1677 				case INSTRUCTION_FORMAT45cc_METHOD:
   1678 				case INSTRUCTION_FORMAT4rcc_METHOD:
   1679 				case INSTRUCTION_FORMAT51l:
   1680 				case LINE_DIRECTIVE:
   1681 				case LOCAL_DIRECTIVE:
   1682 				case PACKED_SWITCH_DIRECTIVE:
   1683 				case PROLOGUE_DIRECTIVE:
   1684 				case RESTART_LOCAL_DIRECTIVE:
   1685 				case SOURCE_DIRECTIVE:
   1686 				case SPARSE_SWITCH_DIRECTIVE:
   1687 					{
   1688 					alt6=1;
   1689 					}
   1690 					break;
   1691 				case LOCALS_DIRECTIVE:
   1692 				case REGISTERS_DIRECTIVE:
   1693 					{
   1694 					alt6=2;
   1695 					}
   1696 					break;
   1697 				case CATCH_DIRECTIVE:
   1698 					{
   1699 					alt6=3;
   1700 					}
   1701 					break;
   1702 				case CATCHALL_DIRECTIVE:
   1703 					{
   1704 					alt6=4;
   1705 					}
   1706 					break;
   1707 				case PARAMETER_DIRECTIVE:
   1708 					{
   1709 					alt6=5;
   1710 					}
   1711 					break;
   1712 				case ANNOTATION_DIRECTIVE:
   1713 					{
   1714 					alt6=6;
   1715 					}
   1716 					break;
   1717 				}
   1718 				switch (alt6) {
   1719 				case 1 :
   1720 					// smaliParser.g:501:7: ordered_method_item
   1721 					{
   1722 					pushFollow(FOLLOW_ordered_method_item_in_statements_and_directives1547);
   1723 					ordered_method_item34=ordered_method_item();
   1724 					state._fsp--;
   1725 
   1726 					stream_ordered_method_item.add(ordered_method_item34.getTree());
   1727 					}
   1728 					break;
   1729 				case 2 :
   1730 					// smaliParser.g:502:7: registers_directive
   1731 					{
   1732 					pushFollow(FOLLOW_registers_directive_in_statements_and_directives1555);
   1733 					registers_directive35=registers_directive();
   1734 					state._fsp--;
   1735 
   1736 					stream_registers_directive.add(registers_directive35.getTree());
   1737 					}
   1738 					break;
   1739 				case 3 :
   1740 					// smaliParser.g:503:7: catch_directive
   1741 					{
   1742 					pushFollow(FOLLOW_catch_directive_in_statements_and_directives1563);
   1743 					catch_directive36=catch_directive();
   1744 					state._fsp--;
   1745 
   1746 					stream_catch_directive.add(catch_directive36.getTree());
   1747 					}
   1748 					break;
   1749 				case 4 :
   1750 					// smaliParser.g:504:7: catchall_directive
   1751 					{
   1752 					pushFollow(FOLLOW_catchall_directive_in_statements_and_directives1571);
   1753 					catchall_directive37=catchall_directive();
   1754 					state._fsp--;
   1755 
   1756 					stream_catchall_directive.add(catchall_directive37.getTree());
   1757 					}
   1758 					break;
   1759 				case 5 :
   1760 					// smaliParser.g:505:7: parameter_directive
   1761 					{
   1762 					pushFollow(FOLLOW_parameter_directive_in_statements_and_directives1579);
   1763 					parameter_directive38=parameter_directive();
   1764 					state._fsp--;
   1765 
   1766 					stream_parameter_directive.add(parameter_directive38.getTree());
   1767 					}
   1768 					break;
   1769 				case 6 :
   1770 					// smaliParser.g:506:7: annotation
   1771 					{
   1772 					pushFollow(FOLLOW_annotation_in_statements_and_directives1587);
   1773 					annotation39=annotation();
   1774 					state._fsp--;
   1775 
   1776 					stream_annotation.add(annotation39.getTree());
   1777 					statements_and_directives_stack.peek().methodAnnotations.add((annotation39!=null?((CommonTree)annotation39.getTree()):null));
   1778 					}
   1779 					break;
   1780 
   1781 				default :
   1782 					break loop6;
   1783 				}
   1784 			}
   1785 
   1786 			// AST REWRITE
   1787 			// elements: ordered_method_item, catch_directive, catchall_directive, parameter_directive, registers_directive
   1788 			// token labels:
   1789 			// rule labels: retval
   1790 			// token list labels:
   1791 			// rule list labels:
   1792 			// wildcard labels:
   1793 			retval.tree = root_0;
   1794 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   1795 
   1796 			root_0 = (CommonTree)adaptor.nil();
   1797 			// 508:5: -> ( registers_directive )? ^( I_ORDERED_METHOD_ITEMS ( ordered_method_item )* ) ^( I_CATCHES ( catch_directive )* ( catchall_directive )* ) ^( I_PARAMETERS ( parameter_directive )* )
   1798 			{
   1799 				// smaliParser.g:508:8: ( registers_directive )?
   1800 				if ( stream_registers_directive.hasNext() ) {
   1801 					adaptor.addChild(root_0, stream_registers_directive.nextTree());
   1802 				}
   1803 				stream_registers_directive.reset();
   1804 
   1805 				// smaliParser.g:509:8: ^( I_ORDERED_METHOD_ITEMS ( ordered_method_item )* )
   1806 				{
   1807 				CommonTree root_1 = (CommonTree)adaptor.nil();
   1808 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ORDERED_METHOD_ITEMS, "I_ORDERED_METHOD_ITEMS"), root_1);
   1809 				// smaliParser.g:509:33: ( ordered_method_item )*
   1810 				while ( stream_ordered_method_item.hasNext() ) {
   1811 					adaptor.addChild(root_1, stream_ordered_method_item.nextTree());
   1812 				}
   1813 				stream_ordered_method_item.reset();
   1814 
   1815 				adaptor.addChild(root_0, root_1);
   1816 				}
   1817 
   1818 				// smaliParser.g:510:8: ^( I_CATCHES ( catch_directive )* ( catchall_directive )* )
   1819 				{
   1820 				CommonTree root_1 = (CommonTree)adaptor.nil();
   1821 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_CATCHES, "I_CATCHES"), root_1);
   1822 				// smaliParser.g:510:20: ( catch_directive )*
   1823 				while ( stream_catch_directive.hasNext() ) {
   1824 					adaptor.addChild(root_1, stream_catch_directive.nextTree());
   1825 				}
   1826 				stream_catch_directive.reset();
   1827 
   1828 				// smaliParser.g:510:37: ( catchall_directive )*
   1829 				while ( stream_catchall_directive.hasNext() ) {
   1830 					adaptor.addChild(root_1, stream_catchall_directive.nextTree());
   1831 				}
   1832 				stream_catchall_directive.reset();
   1833 
   1834 				adaptor.addChild(root_0, root_1);
   1835 				}
   1836 
   1837 				// smaliParser.g:511:8: ^( I_PARAMETERS ( parameter_directive )* )
   1838 				{
   1839 				CommonTree root_1 = (CommonTree)adaptor.nil();
   1840 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_PARAMETERS, "I_PARAMETERS"), root_1);
   1841 				// smaliParser.g:511:23: ( parameter_directive )*
   1842 				while ( stream_parameter_directive.hasNext() ) {
   1843 					adaptor.addChild(root_1, stream_parameter_directive.nextTree());
   1844 				}
   1845 				stream_parameter_directive.reset();
   1846 
   1847 				adaptor.addChild(root_0, root_1);
   1848 				}
   1849 
   1850 				adaptor.addChild(root_0, buildTree(I_ANNOTATIONS, "I_ANNOTATIONS", statements_and_directives_stack.peek().methodAnnotations));
   1851 			}
   1852 
   1853 
   1854 			retval.tree = root_0;
   1855 
   1856 			}
   1857 
   1858 			retval.stop = input.LT(-1);
   1859 
   1860 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   1861 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   1862 
   1863 		}
   1864 		catch (RecognitionException re) {
   1865 			reportError(re);
   1866 			recover(input,re);
   1867 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   1868 		}
   1869 		finally {
   1870 			// do for sure before leaving
   1871 			statements_and_directives_stack.pop();
   1872 		}
   1873 		return retval;
   1874 	}
   1875 	// $ANTLR end "statements_and_directives"
   1876 
   1877 
   1878 	public static class ordered_method_item_return extends ParserRuleReturnScope {
   1879 		CommonTree tree;
   1880 		@Override
   1881 		public CommonTree getTree() { return tree; }
   1882 	};
   1883 
   1884 
   1885 	// $ANTLR start "ordered_method_item"
   1886 	// smaliParser.g:515:1: ordered_method_item : ( label | instruction | debug_directive );
   1887 	public final smaliParser.ordered_method_item_return ordered_method_item() throws RecognitionException {
   1888 		smaliParser.ordered_method_item_return retval = new smaliParser.ordered_method_item_return();
   1889 		retval.start = input.LT(1);
   1890 
   1891 		CommonTree root_0 = null;
   1892 
   1893 		ParserRuleReturnScope label40 =null;
   1894 		ParserRuleReturnScope instruction41 =null;
   1895 		ParserRuleReturnScope debug_directive42 =null;
   1896 
   1897 
   1898 		try {
   1899 			// smaliParser.g:516:3: ( label | instruction | debug_directive )
   1900 			int alt7=3;
   1901 			switch ( input.LA(1) ) {
   1902 			case COLON:
   1903 				{
   1904 				alt7=1;
   1905 				}
   1906 				break;
   1907 			case ARRAY_DATA_DIRECTIVE:
   1908 			case INSTRUCTION_FORMAT10t:
   1909 			case INSTRUCTION_FORMAT10x:
   1910 			case INSTRUCTION_FORMAT10x_ODEX:
   1911 			case INSTRUCTION_FORMAT11n:
   1912 			case INSTRUCTION_FORMAT11x:
   1913 			case INSTRUCTION_FORMAT12x:
   1914 			case INSTRUCTION_FORMAT12x_OR_ID:
   1915 			case INSTRUCTION_FORMAT20bc:
   1916 			case INSTRUCTION_FORMAT20t:
   1917 			case INSTRUCTION_FORMAT21c_FIELD:
   1918 			case INSTRUCTION_FORMAT21c_FIELD_ODEX:
   1919 			case INSTRUCTION_FORMAT21c_STRING:
   1920 			case INSTRUCTION_FORMAT21c_TYPE:
   1921 			case INSTRUCTION_FORMAT21ih:
   1922 			case INSTRUCTION_FORMAT21lh:
   1923 			case INSTRUCTION_FORMAT21s:
   1924 			case INSTRUCTION_FORMAT21t:
   1925 			case INSTRUCTION_FORMAT22b:
   1926 			case INSTRUCTION_FORMAT22c_FIELD:
   1927 			case INSTRUCTION_FORMAT22c_FIELD_ODEX:
   1928 			case INSTRUCTION_FORMAT22c_TYPE:
   1929 			case INSTRUCTION_FORMAT22cs_FIELD:
   1930 			case INSTRUCTION_FORMAT22s:
   1931 			case INSTRUCTION_FORMAT22s_OR_ID:
   1932 			case INSTRUCTION_FORMAT22t:
   1933 			case INSTRUCTION_FORMAT22x:
   1934 			case INSTRUCTION_FORMAT23x:
   1935 			case INSTRUCTION_FORMAT30t:
   1936 			case INSTRUCTION_FORMAT31c:
   1937 			case INSTRUCTION_FORMAT31i:
   1938 			case INSTRUCTION_FORMAT31i_OR_ID:
   1939 			case INSTRUCTION_FORMAT31t:
   1940 			case INSTRUCTION_FORMAT32x:
   1941 			case INSTRUCTION_FORMAT35c_METHOD:
   1942 			case INSTRUCTION_FORMAT35c_METHOD_ODEX:
   1943 			case INSTRUCTION_FORMAT35c_TYPE:
   1944 			case INSTRUCTION_FORMAT35mi_METHOD:
   1945 			case INSTRUCTION_FORMAT35ms_METHOD:
   1946 			case INSTRUCTION_FORMAT3rc_METHOD:
   1947 			case INSTRUCTION_FORMAT3rc_METHOD_ODEX:
   1948 			case INSTRUCTION_FORMAT3rc_TYPE:
   1949 			case INSTRUCTION_FORMAT3rmi_METHOD:
   1950 			case INSTRUCTION_FORMAT3rms_METHOD:
   1951 			case INSTRUCTION_FORMAT45cc_METHOD:
   1952 			case INSTRUCTION_FORMAT4rcc_METHOD:
   1953 			case INSTRUCTION_FORMAT51l:
   1954 			case PACKED_SWITCH_DIRECTIVE:
   1955 			case SPARSE_SWITCH_DIRECTIVE:
   1956 				{
   1957 				alt7=2;
   1958 				}
   1959 				break;
   1960 			case END_LOCAL_DIRECTIVE:
   1961 			case EPILOGUE_DIRECTIVE:
   1962 			case LINE_DIRECTIVE:
   1963 			case LOCAL_DIRECTIVE:
   1964 			case PROLOGUE_DIRECTIVE:
   1965 			case RESTART_LOCAL_DIRECTIVE:
   1966 			case SOURCE_DIRECTIVE:
   1967 				{
   1968 				alt7=3;
   1969 				}
   1970 				break;
   1971 			default:
   1972 				NoViableAltException nvae =
   1973 					new NoViableAltException("", 7, 0, input);
   1974 				throw nvae;
   1975 			}
   1976 			switch (alt7) {
   1977 				case 1 :
   1978 					// smaliParser.g:516:5: label
   1979 					{
   1980 					root_0 = (CommonTree)adaptor.nil();
   1981 
   1982 
   1983 					pushFollow(FOLLOW_label_in_ordered_method_item1672);
   1984 					label40=label();
   1985 					state._fsp--;
   1986 
   1987 					adaptor.addChild(root_0, label40.getTree());
   1988 
   1989 					}
   1990 					break;
   1991 				case 2 :
   1992 					// smaliParser.g:517:5: instruction
   1993 					{
   1994 					root_0 = (CommonTree)adaptor.nil();
   1995 
   1996 
   1997 					pushFollow(FOLLOW_instruction_in_ordered_method_item1678);
   1998 					instruction41=instruction();
   1999 					state._fsp--;
   2000 
   2001 					adaptor.addChild(root_0, instruction41.getTree());
   2002 
   2003 					}
   2004 					break;
   2005 				case 3 :
   2006 					// smaliParser.g:518:5: debug_directive
   2007 					{
   2008 					root_0 = (CommonTree)adaptor.nil();
   2009 
   2010 
   2011 					pushFollow(FOLLOW_debug_directive_in_ordered_method_item1684);
   2012 					debug_directive42=debug_directive();
   2013 					state._fsp--;
   2014 
   2015 					adaptor.addChild(root_0, debug_directive42.getTree());
   2016 
   2017 					}
   2018 					break;
   2019 
   2020 			}
   2021 			retval.stop = input.LT(-1);
   2022 
   2023 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   2024 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   2025 
   2026 		}
   2027 		catch (RecognitionException re) {
   2028 			reportError(re);
   2029 			recover(input,re);
   2030 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   2031 		}
   2032 		finally {
   2033 			// do for sure before leaving
   2034 		}
   2035 		return retval;
   2036 	}
   2037 	// $ANTLR end "ordered_method_item"
   2038 
   2039 
   2040 	public static class registers_directive_return extends ParserRuleReturnScope {
   2041 		CommonTree tree;
   2042 		@Override
   2043 		public CommonTree getTree() { return tree; }
   2044 	};
   2045 
   2046 
   2047 	// $ANTLR start "registers_directive"
   2048 	// smaliParser.g:520:1: registers_directive : (directive= REGISTERS_DIRECTIVE regCount= integral_literal -> ^( I_REGISTERS[$REGISTERS_DIRECTIVE, \"I_REGISTERS\"] $regCount) |directive= LOCALS_DIRECTIVE regCount2= integral_literal -> ^( I_LOCALS[$LOCALS_DIRECTIVE, \"I_LOCALS\"] $regCount2) ) ;
   2049 	public final smaliParser.registers_directive_return registers_directive() throws RecognitionException {
   2050 		smaliParser.registers_directive_return retval = new smaliParser.registers_directive_return();
   2051 		retval.start = input.LT(1);
   2052 
   2053 		CommonTree root_0 = null;
   2054 
   2055 		Token directive=null;
   2056 		ParserRuleReturnScope regCount =null;
   2057 		ParserRuleReturnScope regCount2 =null;
   2058 
   2059 		CommonTree directive_tree=null;
   2060 		RewriteRuleTokenStream stream_LOCALS_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token LOCALS_DIRECTIVE");
   2061 		RewriteRuleTokenStream stream_REGISTERS_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token REGISTERS_DIRECTIVE");
   2062 		RewriteRuleSubtreeStream stream_integral_literal=new RewriteRuleSubtreeStream(adaptor,"rule integral_literal");
   2063 
   2064 		try {
   2065 			// smaliParser.g:521:3: ( (directive= REGISTERS_DIRECTIVE regCount= integral_literal -> ^( I_REGISTERS[$REGISTERS_DIRECTIVE, \"I_REGISTERS\"] $regCount) |directive= LOCALS_DIRECTIVE regCount2= integral_literal -> ^( I_LOCALS[$LOCALS_DIRECTIVE, \"I_LOCALS\"] $regCount2) ) )
   2066 			// smaliParser.g:521:5: (directive= REGISTERS_DIRECTIVE regCount= integral_literal -> ^( I_REGISTERS[$REGISTERS_DIRECTIVE, \"I_REGISTERS\"] $regCount) |directive= LOCALS_DIRECTIVE regCount2= integral_literal -> ^( I_LOCALS[$LOCALS_DIRECTIVE, \"I_LOCALS\"] $regCount2) )
   2067 			{
   2068 			// smaliParser.g:521:5: (directive= REGISTERS_DIRECTIVE regCount= integral_literal -> ^( I_REGISTERS[$REGISTERS_DIRECTIVE, \"I_REGISTERS\"] $regCount) |directive= LOCALS_DIRECTIVE regCount2= integral_literal -> ^( I_LOCALS[$LOCALS_DIRECTIVE, \"I_LOCALS\"] $regCount2) )
   2069 			int alt8=2;
   2070 			int LA8_0 = input.LA(1);
   2071 			if ( (LA8_0==REGISTERS_DIRECTIVE) ) {
   2072 				alt8=1;
   2073 			}
   2074 			else if ( (LA8_0==LOCALS_DIRECTIVE) ) {
   2075 				alt8=2;
   2076 			}
   2077 
   2078 			else {
   2079 				NoViableAltException nvae =
   2080 					new NoViableAltException("", 8, 0, input);
   2081 				throw nvae;
   2082 			}
   2083 
   2084 			switch (alt8) {
   2085 				case 1 :
   2086 					// smaliParser.g:522:7: directive= REGISTERS_DIRECTIVE regCount= integral_literal
   2087 					{
   2088 					directive=(Token)match(input,REGISTERS_DIRECTIVE,FOLLOW_REGISTERS_DIRECTIVE_in_registers_directive1704);
   2089 					stream_REGISTERS_DIRECTIVE.add(directive);
   2090 
   2091 					pushFollow(FOLLOW_integral_literal_in_registers_directive1708);
   2092 					regCount=integral_literal();
   2093 					state._fsp--;
   2094 
   2095 					stream_integral_literal.add(regCount.getTree());
   2096 					// AST REWRITE
   2097 					// elements: regCount
   2098 					// token labels:
   2099 					// rule labels: regCount, retval
   2100 					// token list labels:
   2101 					// rule list labels:
   2102 					// wildcard labels:
   2103 					retval.tree = root_0;
   2104 					RewriteRuleSubtreeStream stream_regCount=new RewriteRuleSubtreeStream(adaptor,"rule regCount",regCount!=null?regCount.getTree():null);
   2105 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   2106 
   2107 					root_0 = (CommonTree)adaptor.nil();
   2108 					// 522:63: -> ^( I_REGISTERS[$REGISTERS_DIRECTIVE, \"I_REGISTERS\"] $regCount)
   2109 					{
   2110 						// smaliParser.g:522:66: ^( I_REGISTERS[$REGISTERS_DIRECTIVE, \"I_REGISTERS\"] $regCount)
   2111 						{
   2112 						CommonTree root_1 = (CommonTree)adaptor.nil();
   2113 						root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_REGISTERS, directive, "I_REGISTERS"), root_1);
   2114 						adaptor.addChild(root_1, stream_regCount.nextTree());
   2115 						adaptor.addChild(root_0, root_1);
   2116 						}
   2117 
   2118 					}
   2119 
   2120 
   2121 					retval.tree = root_0;
   2122 
   2123 					}
   2124 					break;
   2125 				case 2 :
   2126 					// smaliParser.g:523:7: directive= LOCALS_DIRECTIVE regCount2= integral_literal
   2127 					{
   2128 					directive=(Token)match(input,LOCALS_DIRECTIVE,FOLLOW_LOCALS_DIRECTIVE_in_registers_directive1728);
   2129 					stream_LOCALS_DIRECTIVE.add(directive);
   2130 
   2131 					pushFollow(FOLLOW_integral_literal_in_registers_directive1732);
   2132 					regCount2=integral_literal();
   2133 					state._fsp--;
   2134 
   2135 					stream_integral_literal.add(regCount2.getTree());
   2136 					// AST REWRITE
   2137 					// elements: regCount2
   2138 					// token labels:
   2139 					// rule labels: regCount2, retval
   2140 					// token list labels:
   2141 					// rule list labels:
   2142 					// wildcard labels:
   2143 					retval.tree = root_0;
   2144 					RewriteRuleSubtreeStream stream_regCount2=new RewriteRuleSubtreeStream(adaptor,"rule regCount2",regCount2!=null?regCount2.getTree():null);
   2145 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   2146 
   2147 					root_0 = (CommonTree)adaptor.nil();
   2148 					// 523:61: -> ^( I_LOCALS[$LOCALS_DIRECTIVE, \"I_LOCALS\"] $regCount2)
   2149 					{
   2150 						// smaliParser.g:523:64: ^( I_LOCALS[$LOCALS_DIRECTIVE, \"I_LOCALS\"] $regCount2)
   2151 						{
   2152 						CommonTree root_1 = (CommonTree)adaptor.nil();
   2153 						root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_LOCALS, directive, "I_LOCALS"), root_1);
   2154 						adaptor.addChild(root_1, stream_regCount2.nextTree());
   2155 						adaptor.addChild(root_0, root_1);
   2156 						}
   2157 
   2158 					}
   2159 
   2160 
   2161 					retval.tree = root_0;
   2162 
   2163 					}
   2164 					break;
   2165 
   2166 			}
   2167 
   2168 
   2169 			      if (statements_and_directives_stack.peek().hasRegistersDirective) {
   2170 			        throw new SemanticException(input, directive, "There can only be a single .registers or .locals directive in a method");
   2171 			      }
   2172 			      statements_and_directives_stack.peek().hasRegistersDirective =true;
   2173 
   2174 			}
   2175 
   2176 			retval.stop = input.LT(-1);
   2177 
   2178 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   2179 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   2180 
   2181 		}
   2182 		catch (RecognitionException re) {
   2183 			reportError(re);
   2184 			recover(input,re);
   2185 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   2186 		}
   2187 		finally {
   2188 			// do for sure before leaving
   2189 		}
   2190 		return retval;
   2191 	}
   2192 	// $ANTLR end "registers_directive"
   2193 
   2194 
   2195 	public static class param_list_or_id_return extends ParserRuleReturnScope {
   2196 		CommonTree tree;
   2197 		@Override
   2198 		public CommonTree getTree() { return tree; }
   2199 	};
   2200 
   2201 
   2202 	// $ANTLR start "param_list_or_id"
   2203 	// smaliParser.g:532:1: param_list_or_id : ( PARAM_LIST_OR_ID_PRIMITIVE_TYPE )+ ;
   2204 	public final smaliParser.param_list_or_id_return param_list_or_id() throws RecognitionException {
   2205 		smaliParser.param_list_or_id_return retval = new smaliParser.param_list_or_id_return();
   2206 		retval.start = input.LT(1);
   2207 
   2208 		CommonTree root_0 = null;
   2209 
   2210 		Token PARAM_LIST_OR_ID_PRIMITIVE_TYPE43=null;
   2211 
   2212 		CommonTree PARAM_LIST_OR_ID_PRIMITIVE_TYPE43_tree=null;
   2213 
   2214 		try {
   2215 			// smaliParser.g:533:3: ( ( PARAM_LIST_OR_ID_PRIMITIVE_TYPE )+ )
   2216 			// smaliParser.g:533:5: ( PARAM_LIST_OR_ID_PRIMITIVE_TYPE )+
   2217 			{
   2218 			root_0 = (CommonTree)adaptor.nil();
   2219 
   2220 
   2221 			// smaliParser.g:533:5: ( PARAM_LIST_OR_ID_PRIMITIVE_TYPE )+
   2222 			int cnt9=0;
   2223 			loop9:
   2224 			while (true) {
   2225 				int alt9=2;
   2226 				int LA9_0 = input.LA(1);
   2227 				if ( (LA9_0==PARAM_LIST_OR_ID_PRIMITIVE_TYPE) ) {
   2228 					alt9=1;
   2229 				}
   2230 
   2231 				switch (alt9) {
   2232 				case 1 :
   2233 					// smaliParser.g:533:5: PARAM_LIST_OR_ID_PRIMITIVE_TYPE
   2234 					{
   2235 					PARAM_LIST_OR_ID_PRIMITIVE_TYPE43=(Token)match(input,PARAM_LIST_OR_ID_PRIMITIVE_TYPE,FOLLOW_PARAM_LIST_OR_ID_PRIMITIVE_TYPE_in_param_list_or_id1764);
   2236 					PARAM_LIST_OR_ID_PRIMITIVE_TYPE43_tree = (CommonTree)adaptor.create(PARAM_LIST_OR_ID_PRIMITIVE_TYPE43);
   2237 					adaptor.addChild(root_0, PARAM_LIST_OR_ID_PRIMITIVE_TYPE43_tree);
   2238 
   2239 					}
   2240 					break;
   2241 
   2242 				default :
   2243 					if ( cnt9 >= 1 ) break loop9;
   2244 					EarlyExitException eee = new EarlyExitException(9, input);
   2245 					throw eee;
   2246 				}
   2247 				cnt9++;
   2248 			}
   2249 
   2250 			}
   2251 
   2252 			retval.stop = input.LT(-1);
   2253 
   2254 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   2255 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   2256 
   2257 		}
   2258 		catch (RecognitionException re) {
   2259 			reportError(re);
   2260 			recover(input,re);
   2261 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   2262 		}
   2263 		finally {
   2264 			// do for sure before leaving
   2265 		}
   2266 		return retval;
   2267 	}
   2268 	// $ANTLR end "param_list_or_id"
   2269 
   2270 
   2271 	public static class simple_name_return extends ParserRuleReturnScope {
   2272 		CommonTree tree;
   2273 		@Override
   2274 		public CommonTree getTree() { return tree; }
   2275 	};
   2276 
   2277 
   2278 	// $ANTLR start "simple_name"
   2279 	// smaliParser.g:537:1: simple_name : ( SIMPLE_NAME | ACCESS_SPEC -> SIMPLE_NAME[$ACCESS_SPEC] | VERIFICATION_ERROR_TYPE -> SIMPLE_NAME[$VERIFICATION_ERROR_TYPE] | POSITIVE_INTEGER_LITERAL -> SIMPLE_NAME[$POSITIVE_INTEGER_LITERAL] | NEGATIVE_INTEGER_LITERAL -> SIMPLE_NAME[$NEGATIVE_INTEGER_LITERAL] | FLOAT_LITERAL_OR_ID -> SIMPLE_NAME[$FLOAT_LITERAL_OR_ID] | DOUBLE_LITERAL_OR_ID -> SIMPLE_NAME[$DOUBLE_LITERAL_OR_ID] | BOOL_LITERAL -> SIMPLE_NAME[$BOOL_LITERAL] | NULL_LITERAL -> SIMPLE_NAME[$NULL_LITERAL] | REGISTER -> SIMPLE_NAME[$REGISTER] | param_list_or_id ->| PRIMITIVE_TYPE -> SIMPLE_NAME[$PRIMITIVE_TYPE] | VOID_TYPE -> SIMPLE_NAME[$VOID_TYPE] | ANNOTATION_VISIBILITY -> SIMPLE_NAME[$ANNOTATION_VISIBILITY] | INSTRUCTION_FORMAT10t -> SIMPLE_NAME[$INSTRUCTION_FORMAT10t] | INSTRUCTION_FORMAT10x -> SIMPLE_NAME[$INSTRUCTION_FORMAT10x] | INSTRUCTION_FORMAT10x_ODEX -> SIMPLE_NAME[$INSTRUCTION_FORMAT10x_ODEX] | INSTRUCTION_FORMAT11x -> SIMPLE_NAME[$INSTRUCTION_FORMAT11x] | INSTRUCTION_FORMAT12x_OR_ID -> SIMPLE_NAME[$INSTRUCTION_FORMAT12x_OR_ID] | INSTRUCTION_FORMAT21c_FIELD -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_FIELD] | INSTRUCTION_FORMAT21c_FIELD_ODEX -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_FIELD_ODEX] | INSTRUCTION_FORMAT21c_STRING -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_STRING] | INSTRUCTION_FORMAT21c_TYPE -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_TYPE] | INSTRUCTION_FORMAT21t -> SIMPLE_NAME[$INSTRUCTION_FORMAT21t] | INSTRUCTION_FORMAT22c_FIELD -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_FIELD] | INSTRUCTION_FORMAT22c_FIELD_ODEX -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_FIELD_ODEX] | INSTRUCTION_FORMAT22c_TYPE -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_TYPE] | INSTRUCTION_FORMAT22cs_FIELD -> SIMPLE_NAME[$INSTRUCTION_FORMAT22cs_FIELD] | INSTRUCTION_FORMAT22s_OR_ID -> SIMPLE_NAME[$INSTRUCTION_FORMAT22s_OR_ID] | INSTRUCTION_FORMAT22t -> SIMPLE_NAME[$INSTRUCTION_FORMAT22t] | INSTRUCTION_FORMAT23x -> SIMPLE_NAME[$INSTRUCTION_FORMAT23x] | INSTRUCTION_FORMAT31i_OR_ID -> SIMPLE_NAME[$INSTRUCTION_FORMAT31i_OR_ID] | INSTRUCTION_FORMAT31t -> SIMPLE_NAME[$INSTRUCTION_FORMAT31t] | INSTRUCTION_FORMAT35c_METHOD -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_METHOD] | INSTRUCTION_FORMAT35c_METHOD_ODEX -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_METHOD_ODEX] | INSTRUCTION_FORMAT35c_TYPE -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_TYPE] | INSTRUCTION_FORMAT35mi_METHOD -> SIMPLE_NAME[$INSTRUCTION_FORMAT35mi_METHOD] | INSTRUCTION_FORMAT35ms_METHOD -> SIMPLE_NAME[$INSTRUCTION_FORMAT35ms_METHOD] | INSTRUCTION_FORMAT45cc_METHOD -> SIMPLE_NAME[$INSTRUCTION_FORMAT45cc_METHOD] | INSTRUCTION_FORMAT4rcc_METHOD -> SIMPLE_NAME[$INSTRUCTION_FORMAT4rcc_METHOD] | INSTRUCTION_FORMAT51l -> SIMPLE_NAME[$INSTRUCTION_FORMAT51l] );
   2280 	public final smaliParser.simple_name_return simple_name() throws RecognitionException {
   2281 		smaliParser.simple_name_return retval = new smaliParser.simple_name_return();
   2282 		retval.start = input.LT(1);
   2283 
   2284 		CommonTree root_0 = null;
   2285 
   2286 		Token SIMPLE_NAME44=null;
   2287 		Token ACCESS_SPEC45=null;
   2288 		Token VERIFICATION_ERROR_TYPE46=null;
   2289 		Token POSITIVE_INTEGER_LITERAL47=null;
   2290 		Token NEGATIVE_INTEGER_LITERAL48=null;
   2291 		Token FLOAT_LITERAL_OR_ID49=null;
   2292 		Token DOUBLE_LITERAL_OR_ID50=null;
   2293 		Token BOOL_LITERAL51=null;
   2294 		Token NULL_LITERAL52=null;
   2295 		Token REGISTER53=null;
   2296 		Token PRIMITIVE_TYPE55=null;
   2297 		Token VOID_TYPE56=null;
   2298 		Token ANNOTATION_VISIBILITY57=null;
   2299 		Token INSTRUCTION_FORMAT10t58=null;
   2300 		Token INSTRUCTION_FORMAT10x59=null;
   2301 		Token INSTRUCTION_FORMAT10x_ODEX60=null;
   2302 		Token INSTRUCTION_FORMAT11x61=null;
   2303 		Token INSTRUCTION_FORMAT12x_OR_ID62=null;
   2304 		Token INSTRUCTION_FORMAT21c_FIELD63=null;
   2305 		Token INSTRUCTION_FORMAT21c_FIELD_ODEX64=null;
   2306 		Token INSTRUCTION_FORMAT21c_STRING65=null;
   2307 		Token INSTRUCTION_FORMAT21c_TYPE66=null;
   2308 		Token INSTRUCTION_FORMAT21t67=null;
   2309 		Token INSTRUCTION_FORMAT22c_FIELD68=null;
   2310 		Token INSTRUCTION_FORMAT22c_FIELD_ODEX69=null;
   2311 		Token INSTRUCTION_FORMAT22c_TYPE70=null;
   2312 		Token INSTRUCTION_FORMAT22cs_FIELD71=null;
   2313 		Token INSTRUCTION_FORMAT22s_OR_ID72=null;
   2314 		Token INSTRUCTION_FORMAT22t73=null;
   2315 		Token INSTRUCTION_FORMAT23x74=null;
   2316 		Token INSTRUCTION_FORMAT31i_OR_ID75=null;
   2317 		Token INSTRUCTION_FORMAT31t76=null;
   2318 		Token INSTRUCTION_FORMAT35c_METHOD77=null;
   2319 		Token INSTRUCTION_FORMAT35c_METHOD_ODEX78=null;
   2320 		Token INSTRUCTION_FORMAT35c_TYPE79=null;
   2321 		Token INSTRUCTION_FORMAT35mi_METHOD80=null;
   2322 		Token INSTRUCTION_FORMAT35ms_METHOD81=null;
   2323 		Token INSTRUCTION_FORMAT45cc_METHOD82=null;
   2324 		Token INSTRUCTION_FORMAT4rcc_METHOD83=null;
   2325 		Token INSTRUCTION_FORMAT51l84=null;
   2326 		ParserRuleReturnScope param_list_or_id54 =null;
   2327 
   2328 		CommonTree SIMPLE_NAME44_tree=null;
   2329 		CommonTree ACCESS_SPEC45_tree=null;
   2330 		CommonTree VERIFICATION_ERROR_TYPE46_tree=null;
   2331 		CommonTree POSITIVE_INTEGER_LITERAL47_tree=null;
   2332 		CommonTree NEGATIVE_INTEGER_LITERAL48_tree=null;
   2333 		CommonTree FLOAT_LITERAL_OR_ID49_tree=null;
   2334 		CommonTree DOUBLE_LITERAL_OR_ID50_tree=null;
   2335 		CommonTree BOOL_LITERAL51_tree=null;
   2336 		CommonTree NULL_LITERAL52_tree=null;
   2337 		CommonTree REGISTER53_tree=null;
   2338 		CommonTree PRIMITIVE_TYPE55_tree=null;
   2339 		CommonTree VOID_TYPE56_tree=null;
   2340 		CommonTree ANNOTATION_VISIBILITY57_tree=null;
   2341 		CommonTree INSTRUCTION_FORMAT10t58_tree=null;
   2342 		CommonTree INSTRUCTION_FORMAT10x59_tree=null;
   2343 		CommonTree INSTRUCTION_FORMAT10x_ODEX60_tree=null;
   2344 		CommonTree INSTRUCTION_FORMAT11x61_tree=null;
   2345 		CommonTree INSTRUCTION_FORMAT12x_OR_ID62_tree=null;
   2346 		CommonTree INSTRUCTION_FORMAT21c_FIELD63_tree=null;
   2347 		CommonTree INSTRUCTION_FORMAT21c_FIELD_ODEX64_tree=null;
   2348 		CommonTree INSTRUCTION_FORMAT21c_STRING65_tree=null;
   2349 		CommonTree INSTRUCTION_FORMAT21c_TYPE66_tree=null;
   2350 		CommonTree INSTRUCTION_FORMAT21t67_tree=null;
   2351 		CommonTree INSTRUCTION_FORMAT22c_FIELD68_tree=null;
   2352 		CommonTree INSTRUCTION_FORMAT22c_FIELD_ODEX69_tree=null;
   2353 		CommonTree INSTRUCTION_FORMAT22c_TYPE70_tree=null;
   2354 		CommonTree INSTRUCTION_FORMAT22cs_FIELD71_tree=null;
   2355 		CommonTree INSTRUCTION_FORMAT22s_OR_ID72_tree=null;
   2356 		CommonTree INSTRUCTION_FORMAT22t73_tree=null;
   2357 		CommonTree INSTRUCTION_FORMAT23x74_tree=null;
   2358 		CommonTree INSTRUCTION_FORMAT31i_OR_ID75_tree=null;
   2359 		CommonTree INSTRUCTION_FORMAT31t76_tree=null;
   2360 		CommonTree INSTRUCTION_FORMAT35c_METHOD77_tree=null;
   2361 		CommonTree INSTRUCTION_FORMAT35c_METHOD_ODEX78_tree=null;
   2362 		CommonTree INSTRUCTION_FORMAT35c_TYPE79_tree=null;
   2363 		CommonTree INSTRUCTION_FORMAT35mi_METHOD80_tree=null;
   2364 		CommonTree INSTRUCTION_FORMAT35ms_METHOD81_tree=null;
   2365 		CommonTree INSTRUCTION_FORMAT45cc_METHOD82_tree=null;
   2366 		CommonTree INSTRUCTION_FORMAT4rcc_METHOD83_tree=null;
   2367 		CommonTree INSTRUCTION_FORMAT51l84_tree=null;
   2368 		RewriteRuleTokenStream stream_ANNOTATION_VISIBILITY=new RewriteRuleTokenStream(adaptor,"token ANNOTATION_VISIBILITY");
   2369 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_TYPE=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_TYPE");
   2370 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22t");
   2371 		RewriteRuleTokenStream stream_VOID_TYPE=new RewriteRuleTokenStream(adaptor,"token VOID_TYPE");
   2372 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT10t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT10t");
   2373 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT35mi_METHOD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT35mi_METHOD");
   2374 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22s_OR_ID=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22s_OR_ID");
   2375 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22cs_FIELD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22cs_FIELD");
   2376 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT12x_OR_ID=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT12x_OR_ID");
   2377 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT35ms_METHOD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT35ms_METHOD");
   2378 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT35c_METHOD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT35c_METHOD");
   2379 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT45cc_METHOD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT45cc_METHOD");
   2380 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT35c_TYPE=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT35c_TYPE");
   2381 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT10x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT10x");
   2382 		RewriteRuleTokenStream stream_FLOAT_LITERAL_OR_ID=new RewriteRuleTokenStream(adaptor,"token FLOAT_LITERAL_OR_ID");
   2383 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22c_TYPE=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22c_TYPE");
   2384 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_STRING=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_STRING");
   2385 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT35c_METHOD_ODEX=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT35c_METHOD_ODEX");
   2386 		RewriteRuleTokenStream stream_NEGATIVE_INTEGER_LITERAL=new RewriteRuleTokenStream(adaptor,"token NEGATIVE_INTEGER_LITERAL");
   2387 		RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER");
   2388 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22c_FIELD_ODEX=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22c_FIELD_ODEX");
   2389 		RewriteRuleTokenStream stream_DOUBLE_LITERAL_OR_ID=new RewriteRuleTokenStream(adaptor,"token DOUBLE_LITERAL_OR_ID");
   2390 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT31i_OR_ID=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT31i_OR_ID");
   2391 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21t");
   2392 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT31t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT31t");
   2393 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT23x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT23x");
   2394 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT51l=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT51l");
   2395 		RewriteRuleTokenStream stream_POSITIVE_INTEGER_LITERAL=new RewriteRuleTokenStream(adaptor,"token POSITIVE_INTEGER_LITERAL");
   2396 		RewriteRuleTokenStream stream_BOOL_LITERAL=new RewriteRuleTokenStream(adaptor,"token BOOL_LITERAL");
   2397 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT10x_ODEX=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT10x_ODEX");
   2398 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_FIELD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_FIELD");
   2399 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22c_FIELD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22c_FIELD");
   2400 		RewriteRuleTokenStream stream_VERIFICATION_ERROR_TYPE=new RewriteRuleTokenStream(adaptor,"token VERIFICATION_ERROR_TYPE");
   2401 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT11x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT11x");
   2402 		RewriteRuleTokenStream stream_ACCESS_SPEC=new RewriteRuleTokenStream(adaptor,"token ACCESS_SPEC");
   2403 		RewriteRuleTokenStream stream_NULL_LITERAL=new RewriteRuleTokenStream(adaptor,"token NULL_LITERAL");
   2404 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT4rcc_METHOD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT4rcc_METHOD");
   2405 		RewriteRuleTokenStream stream_PRIMITIVE_TYPE=new RewriteRuleTokenStream(adaptor,"token PRIMITIVE_TYPE");
   2406 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_FIELD_ODEX=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_FIELD_ODEX");
   2407 		RewriteRuleSubtreeStream stream_param_list_or_id=new RewriteRuleSubtreeStream(adaptor,"rule param_list_or_id");
   2408 
   2409 		try {
   2410 			// smaliParser.g:538:3: ( SIMPLE_NAME | ACCESS_SPEC -> SIMPLE_NAME[$ACCESS_SPEC] | VERIFICATION_ERROR_TYPE -> SIMPLE_NAME[$VERIFICATION_ERROR_TYPE] | POSITIVE_INTEGER_LITERAL -> SIMPLE_NAME[$POSITIVE_INTEGER_LITERAL] | NEGATIVE_INTEGER_LITERAL -> SIMPLE_NAME[$NEGATIVE_INTEGER_LITERAL] | FLOAT_LITERAL_OR_ID -> SIMPLE_NAME[$FLOAT_LITERAL_OR_ID] | DOUBLE_LITERAL_OR_ID -> SIMPLE_NAME[$DOUBLE_LITERAL_OR_ID] | BOOL_LITERAL -> SIMPLE_NAME[$BOOL_LITERAL] | NULL_LITERAL -> SIMPLE_NAME[$NULL_LITERAL] | REGISTER -> SIMPLE_NAME[$REGISTER] | param_list_or_id ->| PRIMITIVE_TYPE -> SIMPLE_NAME[$PRIMITIVE_TYPE] | VOID_TYPE -> SIMPLE_NAME[$VOID_TYPE] | ANNOTATION_VISIBILITY -> SIMPLE_NAME[$ANNOTATION_VISIBILITY] | INSTRUCTION_FORMAT10t -> SIMPLE_NAME[$INSTRUCTION_FORMAT10t] | INSTRUCTION_FORMAT10x -> SIMPLE_NAME[$INSTRUCTION_FORMAT10x] | INSTRUCTION_FORMAT10x_ODEX -> SIMPLE_NAME[$INSTRUCTION_FORMAT10x_ODEX] | INSTRUCTION_FORMAT11x -> SIMPLE_NAME[$INSTRUCTION_FORMAT11x] | INSTRUCTION_FORMAT12x_OR_ID -> SIMPLE_NAME[$INSTRUCTION_FORMAT12x_OR_ID] | INSTRUCTION_FORMAT21c_FIELD -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_FIELD] | INSTRUCTION_FORMAT21c_FIELD_ODEX -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_FIELD_ODEX] | INSTRUCTION_FORMAT21c_STRING -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_STRING] | INSTRUCTION_FORMAT21c_TYPE -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_TYPE] | INSTRUCTION_FORMAT21t -> SIMPLE_NAME[$INSTRUCTION_FORMAT21t] | INSTRUCTION_FORMAT22c_FIELD -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_FIELD] | INSTRUCTION_FORMAT22c_FIELD_ODEX -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_FIELD_ODEX] | INSTRUCTION_FORMAT22c_TYPE -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_TYPE] | INSTRUCTION_FORMAT22cs_FIELD -> SIMPLE_NAME[$INSTRUCTION_FORMAT22cs_FIELD] | INSTRUCTION_FORMAT22s_OR_ID -> SIMPLE_NAME[$INSTRUCTION_FORMAT22s_OR_ID] | INSTRUCTION_FORMAT22t -> SIMPLE_NAME[$INSTRUCTION_FORMAT22t] | INSTRUCTION_FORMAT23x -> SIMPLE_NAME[$INSTRUCTION_FORMAT23x] | INSTRUCTION_FORMAT31i_OR_ID -> SIMPLE_NAME[$INSTRUCTION_FORMAT31i_OR_ID] | INSTRUCTION_FORMAT31t -> SIMPLE_NAME[$INSTRUCTION_FORMAT31t] | INSTRUCTION_FORMAT35c_METHOD -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_METHOD] | INSTRUCTION_FORMAT35c_METHOD_ODEX -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_METHOD_ODEX] | INSTRUCTION_FORMAT35c_TYPE -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_TYPE] | INSTRUCTION_FORMAT35mi_METHOD -> SIMPLE_NAME[$INSTRUCTION_FORMAT35mi_METHOD] | INSTRUCTION_FORMAT35ms_METHOD -> SIMPLE_NAME[$INSTRUCTION_FORMAT35ms_METHOD] | INSTRUCTION_FORMAT45cc_METHOD -> SIMPLE_NAME[$INSTRUCTION_FORMAT45cc_METHOD] | INSTRUCTION_FORMAT4rcc_METHOD -> SIMPLE_NAME[$INSTRUCTION_FORMAT4rcc_METHOD] | INSTRUCTION_FORMAT51l -> SIMPLE_NAME[$INSTRUCTION_FORMAT51l] )
   2411 			int alt10=41;
   2412 			switch ( input.LA(1) ) {
   2413 			case SIMPLE_NAME:
   2414 				{
   2415 				alt10=1;
   2416 				}
   2417 				break;
   2418 			case ACCESS_SPEC:
   2419 				{
   2420 				alt10=2;
   2421 				}
   2422 				break;
   2423 			case VERIFICATION_ERROR_TYPE:
   2424 				{
   2425 				alt10=3;
   2426 				}
   2427 				break;
   2428 			case POSITIVE_INTEGER_LITERAL:
   2429 				{
   2430 				alt10=4;
   2431 				}
   2432 				break;
   2433 			case NEGATIVE_INTEGER_LITERAL:
   2434 				{
   2435 				alt10=5;
   2436 				}
   2437 				break;
   2438 			case FLOAT_LITERAL_OR_ID:
   2439 				{
   2440 				alt10=6;
   2441 				}
   2442 				break;
   2443 			case DOUBLE_LITERAL_OR_ID:
   2444 				{
   2445 				alt10=7;
   2446 				}
   2447 				break;
   2448 			case BOOL_LITERAL:
   2449 				{
   2450 				alt10=8;
   2451 				}
   2452 				break;
   2453 			case NULL_LITERAL:
   2454 				{
   2455 				alt10=9;
   2456 				}
   2457 				break;
   2458 			case REGISTER:
   2459 				{
   2460 				alt10=10;
   2461 				}
   2462 				break;
   2463 			case PARAM_LIST_OR_ID_PRIMITIVE_TYPE:
   2464 				{
   2465 				alt10=11;
   2466 				}
   2467 				break;
   2468 			case PRIMITIVE_TYPE:
   2469 				{
   2470 				alt10=12;
   2471 				}
   2472 				break;
   2473 			case VOID_TYPE:
   2474 				{
   2475 				alt10=13;
   2476 				}
   2477 				break;
   2478 			case ANNOTATION_VISIBILITY:
   2479 				{
   2480 				alt10=14;
   2481 				}
   2482 				break;
   2483 			case INSTRUCTION_FORMAT10t:
   2484 				{
   2485 				alt10=15;
   2486 				}
   2487 				break;
   2488 			case INSTRUCTION_FORMAT10x:
   2489 				{
   2490 				alt10=16;
   2491 				}
   2492 				break;
   2493 			case INSTRUCTION_FORMAT10x_ODEX:
   2494 				{
   2495 				alt10=17;
   2496 				}
   2497 				break;
   2498 			case INSTRUCTION_FORMAT11x:
   2499 				{
   2500 				alt10=18;
   2501 				}
   2502 				break;
   2503 			case INSTRUCTION_FORMAT12x_OR_ID:
   2504 				{
   2505 				alt10=19;
   2506 				}
   2507 				break;
   2508 			case INSTRUCTION_FORMAT21c_FIELD:
   2509 				{
   2510 				alt10=20;
   2511 				}
   2512 				break;
   2513 			case INSTRUCTION_FORMAT21c_FIELD_ODEX:
   2514 				{
   2515 				alt10=21;
   2516 				}
   2517 				break;
   2518 			case INSTRUCTION_FORMAT21c_STRING:
   2519 				{
   2520 				alt10=22;
   2521 				}
   2522 				break;
   2523 			case INSTRUCTION_FORMAT21c_TYPE:
   2524 				{
   2525 				alt10=23;
   2526 				}
   2527 				break;
   2528 			case INSTRUCTION_FORMAT21t:
   2529 				{
   2530 				alt10=24;
   2531 				}
   2532 				break;
   2533 			case INSTRUCTION_FORMAT22c_FIELD:
   2534 				{
   2535 				alt10=25;
   2536 				}
   2537 				break;
   2538 			case INSTRUCTION_FORMAT22c_FIELD_ODEX:
   2539 				{
   2540 				alt10=26;
   2541 				}
   2542 				break;
   2543 			case INSTRUCTION_FORMAT22c_TYPE:
   2544 				{
   2545 				alt10=27;
   2546 				}
   2547 				break;
   2548 			case INSTRUCTION_FORMAT22cs_FIELD:
   2549 				{
   2550 				alt10=28;
   2551 				}
   2552 				break;
   2553 			case INSTRUCTION_FORMAT22s_OR_ID:
   2554 				{
   2555 				alt10=29;
   2556 				}
   2557 				break;
   2558 			case INSTRUCTION_FORMAT22t:
   2559 				{
   2560 				alt10=30;
   2561 				}
   2562 				break;
   2563 			case INSTRUCTION_FORMAT23x:
   2564 				{
   2565 				alt10=31;
   2566 				}
   2567 				break;
   2568 			case INSTRUCTION_FORMAT31i_OR_ID:
   2569 				{
   2570 				alt10=32;
   2571 				}
   2572 				break;
   2573 			case INSTRUCTION_FORMAT31t:
   2574 				{
   2575 				alt10=33;
   2576 				}
   2577 				break;
   2578 			case INSTRUCTION_FORMAT35c_METHOD:
   2579 				{
   2580 				alt10=34;
   2581 				}
   2582 				break;
   2583 			case INSTRUCTION_FORMAT35c_METHOD_ODEX:
   2584 				{
   2585 				alt10=35;
   2586 				}
   2587 				break;
   2588 			case INSTRUCTION_FORMAT35c_TYPE:
   2589 				{
   2590 				alt10=36;
   2591 				}
   2592 				break;
   2593 			case INSTRUCTION_FORMAT35mi_METHOD:
   2594 				{
   2595 				alt10=37;
   2596 				}
   2597 				break;
   2598 			case INSTRUCTION_FORMAT35ms_METHOD:
   2599 				{
   2600 				alt10=38;
   2601 				}
   2602 				break;
   2603 			case INSTRUCTION_FORMAT45cc_METHOD:
   2604 				{
   2605 				alt10=39;
   2606 				}
   2607 				break;
   2608 			case INSTRUCTION_FORMAT4rcc_METHOD:
   2609 				{
   2610 				alt10=40;
   2611 				}
   2612 				break;
   2613 			case INSTRUCTION_FORMAT51l:
   2614 				{
   2615 				alt10=41;
   2616 				}
   2617 				break;
   2618 			default:
   2619 				NoViableAltException nvae =
   2620 					new NoViableAltException("", 10, 0, input);
   2621 				throw nvae;
   2622 			}
   2623 			switch (alt10) {
   2624 				case 1 :
   2625 					// smaliParser.g:538:5: SIMPLE_NAME
   2626 					{
   2627 					root_0 = (CommonTree)adaptor.nil();
   2628 
   2629 
   2630 					SIMPLE_NAME44=(Token)match(input,SIMPLE_NAME,FOLLOW_SIMPLE_NAME_in_simple_name1777);
   2631 					SIMPLE_NAME44_tree = (CommonTree)adaptor.create(SIMPLE_NAME44);
   2632 					adaptor.addChild(root_0, SIMPLE_NAME44_tree);
   2633 
   2634 					}
   2635 					break;
   2636 				case 2 :
   2637 					// smaliParser.g:539:5: ACCESS_SPEC
   2638 					{
   2639 					ACCESS_SPEC45=(Token)match(input,ACCESS_SPEC,FOLLOW_ACCESS_SPEC_in_simple_name1783);
   2640 					stream_ACCESS_SPEC.add(ACCESS_SPEC45);
   2641 
   2642 					// AST REWRITE
   2643 					// elements:
   2644 					// token labels:
   2645 					// rule labels: retval
   2646 					// token list labels:
   2647 					// rule list labels:
   2648 					// wildcard labels:
   2649 					retval.tree = root_0;
   2650 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   2651 
   2652 					root_0 = (CommonTree)adaptor.nil();
   2653 					// 539:17: -> SIMPLE_NAME[$ACCESS_SPEC]
   2654 					{
   2655 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, ACCESS_SPEC45));
   2656 					}
   2657 
   2658 
   2659 					retval.tree = root_0;
   2660 
   2661 					}
   2662 					break;
   2663 				case 3 :
   2664 					// smaliParser.g:540:5: VERIFICATION_ERROR_TYPE
   2665 					{
   2666 					VERIFICATION_ERROR_TYPE46=(Token)match(input,VERIFICATION_ERROR_TYPE,FOLLOW_VERIFICATION_ERROR_TYPE_in_simple_name1794);
   2667 					stream_VERIFICATION_ERROR_TYPE.add(VERIFICATION_ERROR_TYPE46);
   2668 
   2669 					// AST REWRITE
   2670 					// elements:
   2671 					// token labels:
   2672 					// rule labels: retval
   2673 					// token list labels:
   2674 					// rule list labels:
   2675 					// wildcard labels:
   2676 					retval.tree = root_0;
   2677 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   2678 
   2679 					root_0 = (CommonTree)adaptor.nil();
   2680 					// 540:29: -> SIMPLE_NAME[$VERIFICATION_ERROR_TYPE]
   2681 					{
   2682 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, VERIFICATION_ERROR_TYPE46));
   2683 					}
   2684 
   2685 
   2686 					retval.tree = root_0;
   2687 
   2688 					}
   2689 					break;
   2690 				case 4 :
   2691 					// smaliParser.g:541:5: POSITIVE_INTEGER_LITERAL
   2692 					{
   2693 					POSITIVE_INTEGER_LITERAL47=(Token)match(input,POSITIVE_INTEGER_LITERAL,FOLLOW_POSITIVE_INTEGER_LITERAL_in_simple_name1805);
   2694 					stream_POSITIVE_INTEGER_LITERAL.add(POSITIVE_INTEGER_LITERAL47);
   2695 
   2696 					// AST REWRITE
   2697 					// elements:
   2698 					// token labels:
   2699 					// rule labels: retval
   2700 					// token list labels:
   2701 					// rule list labels:
   2702 					// wildcard labels:
   2703 					retval.tree = root_0;
   2704 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   2705 
   2706 					root_0 = (CommonTree)adaptor.nil();
   2707 					// 541:30: -> SIMPLE_NAME[$POSITIVE_INTEGER_LITERAL]
   2708 					{
   2709 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, POSITIVE_INTEGER_LITERAL47));
   2710 					}
   2711 
   2712 
   2713 					retval.tree = root_0;
   2714 
   2715 					}
   2716 					break;
   2717 				case 5 :
   2718 					// smaliParser.g:542:5: NEGATIVE_INTEGER_LITERAL
   2719 					{
   2720 					NEGATIVE_INTEGER_LITERAL48=(Token)match(input,NEGATIVE_INTEGER_LITERAL,FOLLOW_NEGATIVE_INTEGER_LITERAL_in_simple_name1816);
   2721 					stream_NEGATIVE_INTEGER_LITERAL.add(NEGATIVE_INTEGER_LITERAL48);
   2722 
   2723 					// AST REWRITE
   2724 					// elements:
   2725 					// token labels:
   2726 					// rule labels: retval
   2727 					// token list labels:
   2728 					// rule list labels:
   2729 					// wildcard labels:
   2730 					retval.tree = root_0;
   2731 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   2732 
   2733 					root_0 = (CommonTree)adaptor.nil();
   2734 					// 542:30: -> SIMPLE_NAME[$NEGATIVE_INTEGER_LITERAL]
   2735 					{
   2736 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, NEGATIVE_INTEGER_LITERAL48));
   2737 					}
   2738 
   2739 
   2740 					retval.tree = root_0;
   2741 
   2742 					}
   2743 					break;
   2744 				case 6 :
   2745 					// smaliParser.g:543:5: FLOAT_LITERAL_OR_ID
   2746 					{
   2747 					FLOAT_LITERAL_OR_ID49=(Token)match(input,FLOAT_LITERAL_OR_ID,FOLLOW_FLOAT_LITERAL_OR_ID_in_simple_name1827);
   2748 					stream_FLOAT_LITERAL_OR_ID.add(FLOAT_LITERAL_OR_ID49);
   2749 
   2750 					// AST REWRITE
   2751 					// elements:
   2752 					// token labels:
   2753 					// rule labels: retval
   2754 					// token list labels:
   2755 					// rule list labels:
   2756 					// wildcard labels:
   2757 					retval.tree = root_0;
   2758 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   2759 
   2760 					root_0 = (CommonTree)adaptor.nil();
   2761 					// 543:25: -> SIMPLE_NAME[$FLOAT_LITERAL_OR_ID]
   2762 					{
   2763 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, FLOAT_LITERAL_OR_ID49));
   2764 					}
   2765 
   2766 
   2767 					retval.tree = root_0;
   2768 
   2769 					}
   2770 					break;
   2771 				case 7 :
   2772 					// smaliParser.g:544:5: DOUBLE_LITERAL_OR_ID
   2773 					{
   2774 					DOUBLE_LITERAL_OR_ID50=(Token)match(input,DOUBLE_LITERAL_OR_ID,FOLLOW_DOUBLE_LITERAL_OR_ID_in_simple_name1838);
   2775 					stream_DOUBLE_LITERAL_OR_ID.add(DOUBLE_LITERAL_OR_ID50);
   2776 
   2777 					// AST REWRITE
   2778 					// elements:
   2779 					// token labels:
   2780 					// rule labels: retval
   2781 					// token list labels:
   2782 					// rule list labels:
   2783 					// wildcard labels:
   2784 					retval.tree = root_0;
   2785 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   2786 
   2787 					root_0 = (CommonTree)adaptor.nil();
   2788 					// 544:26: -> SIMPLE_NAME[$DOUBLE_LITERAL_OR_ID]
   2789 					{
   2790 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, DOUBLE_LITERAL_OR_ID50));
   2791 					}
   2792 
   2793 
   2794 					retval.tree = root_0;
   2795 
   2796 					}
   2797 					break;
   2798 				case 8 :
   2799 					// smaliParser.g:545:5: BOOL_LITERAL
   2800 					{
   2801 					BOOL_LITERAL51=(Token)match(input,BOOL_LITERAL,FOLLOW_BOOL_LITERAL_in_simple_name1849);
   2802 					stream_BOOL_LITERAL.add(BOOL_LITERAL51);
   2803 
   2804 					// AST REWRITE
   2805 					// elements:
   2806 					// token labels:
   2807 					// rule labels: retval
   2808 					// token list labels:
   2809 					// rule list labels:
   2810 					// wildcard labels:
   2811 					retval.tree = root_0;
   2812 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   2813 
   2814 					root_0 = (CommonTree)adaptor.nil();
   2815 					// 545:18: -> SIMPLE_NAME[$BOOL_LITERAL]
   2816 					{
   2817 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, BOOL_LITERAL51));
   2818 					}
   2819 
   2820 
   2821 					retval.tree = root_0;
   2822 
   2823 					}
   2824 					break;
   2825 				case 9 :
   2826 					// smaliParser.g:546:5: NULL_LITERAL
   2827 					{
   2828 					NULL_LITERAL52=(Token)match(input,NULL_LITERAL,FOLLOW_NULL_LITERAL_in_simple_name1860);
   2829 					stream_NULL_LITERAL.add(NULL_LITERAL52);
   2830 
   2831 					// AST REWRITE
   2832 					// elements:
   2833 					// token labels:
   2834 					// rule labels: retval
   2835 					// token list labels:
   2836 					// rule list labels:
   2837 					// wildcard labels:
   2838 					retval.tree = root_0;
   2839 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   2840 
   2841 					root_0 = (CommonTree)adaptor.nil();
   2842 					// 546:18: -> SIMPLE_NAME[$NULL_LITERAL]
   2843 					{
   2844 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, NULL_LITERAL52));
   2845 					}
   2846 
   2847 
   2848 					retval.tree = root_0;
   2849 
   2850 					}
   2851 					break;
   2852 				case 10 :
   2853 					// smaliParser.g:547:5: REGISTER
   2854 					{
   2855 					REGISTER53=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_simple_name1871);
   2856 					stream_REGISTER.add(REGISTER53);
   2857 
   2858 					// AST REWRITE
   2859 					// elements:
   2860 					// token labels:
   2861 					// rule labels: retval
   2862 					// token list labels:
   2863 					// rule list labels:
   2864 					// wildcard labels:
   2865 					retval.tree = root_0;
   2866 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   2867 
   2868 					root_0 = (CommonTree)adaptor.nil();
   2869 					// 547:14: -> SIMPLE_NAME[$REGISTER]
   2870 					{
   2871 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, REGISTER53));
   2872 					}
   2873 
   2874 
   2875 					retval.tree = root_0;
   2876 
   2877 					}
   2878 					break;
   2879 				case 11 :
   2880 					// smaliParser.g:548:5: param_list_or_id
   2881 					{
   2882 					pushFollow(FOLLOW_param_list_or_id_in_simple_name1882);
   2883 					param_list_or_id54=param_list_or_id();
   2884 					state._fsp--;
   2885 
   2886 					stream_param_list_or_id.add(param_list_or_id54.getTree());
   2887 					// AST REWRITE
   2888 					// elements:
   2889 					// token labels:
   2890 					// rule labels: retval
   2891 					// token list labels:
   2892 					// rule list labels:
   2893 					// wildcard labels:
   2894 					retval.tree = root_0;
   2895 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   2896 
   2897 					root_0 = (CommonTree)adaptor.nil();
   2898 					// 548:22: ->
   2899 					{
   2900 						adaptor.addChild(root_0,  adaptor.create(SIMPLE_NAME, (param_list_or_id54!=null?input.toString(param_list_or_id54.start,param_list_or_id54.stop):null)) );
   2901 					}
   2902 
   2903 
   2904 					retval.tree = root_0;
   2905 
   2906 					}
   2907 					break;
   2908 				case 12 :
   2909 					// smaliParser.g:549:5: PRIMITIVE_TYPE
   2910 					{
   2911 					PRIMITIVE_TYPE55=(Token)match(input,PRIMITIVE_TYPE,FOLLOW_PRIMITIVE_TYPE_in_simple_name1892);
   2912 					stream_PRIMITIVE_TYPE.add(PRIMITIVE_TYPE55);
   2913 
   2914 					// AST REWRITE
   2915 					// elements:
   2916 					// token labels:
   2917 					// rule labels: retval
   2918 					// token list labels:
   2919 					// rule list labels:
   2920 					// wildcard labels:
   2921 					retval.tree = root_0;
   2922 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   2923 
   2924 					root_0 = (CommonTree)adaptor.nil();
   2925 					// 549:20: -> SIMPLE_NAME[$PRIMITIVE_TYPE]
   2926 					{
   2927 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, PRIMITIVE_TYPE55));
   2928 					}
   2929 
   2930 
   2931 					retval.tree = root_0;
   2932 
   2933 					}
   2934 					break;
   2935 				case 13 :
   2936 					// smaliParser.g:550:5: VOID_TYPE
   2937 					{
   2938 					VOID_TYPE56=(Token)match(input,VOID_TYPE,FOLLOW_VOID_TYPE_in_simple_name1903);
   2939 					stream_VOID_TYPE.add(VOID_TYPE56);
   2940 
   2941 					// AST REWRITE
   2942 					// elements:
   2943 					// token labels:
   2944 					// rule labels: retval
   2945 					// token list labels:
   2946 					// rule list labels:
   2947 					// wildcard labels:
   2948 					retval.tree = root_0;
   2949 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   2950 
   2951 					root_0 = (CommonTree)adaptor.nil();
   2952 					// 550:15: -> SIMPLE_NAME[$VOID_TYPE]
   2953 					{
   2954 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, VOID_TYPE56));
   2955 					}
   2956 
   2957 
   2958 					retval.tree = root_0;
   2959 
   2960 					}
   2961 					break;
   2962 				case 14 :
   2963 					// smaliParser.g:551:5: ANNOTATION_VISIBILITY
   2964 					{
   2965 					ANNOTATION_VISIBILITY57=(Token)match(input,ANNOTATION_VISIBILITY,FOLLOW_ANNOTATION_VISIBILITY_in_simple_name1914);
   2966 					stream_ANNOTATION_VISIBILITY.add(ANNOTATION_VISIBILITY57);
   2967 
   2968 					// AST REWRITE
   2969 					// elements:
   2970 					// token labels:
   2971 					// rule labels: retval
   2972 					// token list labels:
   2973 					// rule list labels:
   2974 					// wildcard labels:
   2975 					retval.tree = root_0;
   2976 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   2977 
   2978 					root_0 = (CommonTree)adaptor.nil();
   2979 					// 551:27: -> SIMPLE_NAME[$ANNOTATION_VISIBILITY]
   2980 					{
   2981 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, ANNOTATION_VISIBILITY57));
   2982 					}
   2983 
   2984 
   2985 					retval.tree = root_0;
   2986 
   2987 					}
   2988 					break;
   2989 				case 15 :
   2990 					// smaliParser.g:552:5: INSTRUCTION_FORMAT10t
   2991 					{
   2992 					INSTRUCTION_FORMAT10t58=(Token)match(input,INSTRUCTION_FORMAT10t,FOLLOW_INSTRUCTION_FORMAT10t_in_simple_name1925);
   2993 					stream_INSTRUCTION_FORMAT10t.add(INSTRUCTION_FORMAT10t58);
   2994 
   2995 					// AST REWRITE
   2996 					// elements:
   2997 					// token labels:
   2998 					// rule labels: retval
   2999 					// token list labels:
   3000 					// rule list labels:
   3001 					// wildcard labels:
   3002 					retval.tree = root_0;
   3003 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   3004 
   3005 					root_0 = (CommonTree)adaptor.nil();
   3006 					// 552:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT10t]
   3007 					{
   3008 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT10t58));
   3009 					}
   3010 
   3011 
   3012 					retval.tree = root_0;
   3013 
   3014 					}
   3015 					break;
   3016 				case 16 :
   3017 					// smaliParser.g:553:5: INSTRUCTION_FORMAT10x
   3018 					{
   3019 					INSTRUCTION_FORMAT10x59=(Token)match(input,INSTRUCTION_FORMAT10x,FOLLOW_INSTRUCTION_FORMAT10x_in_simple_name1936);
   3020 					stream_INSTRUCTION_FORMAT10x.add(INSTRUCTION_FORMAT10x59);
   3021 
   3022 					// AST REWRITE
   3023 					// elements:
   3024 					// token labels:
   3025 					// rule labels: retval
   3026 					// token list labels:
   3027 					// rule list labels:
   3028 					// wildcard labels:
   3029 					retval.tree = root_0;
   3030 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   3031 
   3032 					root_0 = (CommonTree)adaptor.nil();
   3033 					// 553:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT10x]
   3034 					{
   3035 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT10x59));
   3036 					}
   3037 
   3038 
   3039 					retval.tree = root_0;
   3040 
   3041 					}
   3042 					break;
   3043 				case 17 :
   3044 					// smaliParser.g:554:5: INSTRUCTION_FORMAT10x_ODEX
   3045 					{
   3046 					INSTRUCTION_FORMAT10x_ODEX60=(Token)match(input,INSTRUCTION_FORMAT10x_ODEX,FOLLOW_INSTRUCTION_FORMAT10x_ODEX_in_simple_name1947);
   3047 					stream_INSTRUCTION_FORMAT10x_ODEX.add(INSTRUCTION_FORMAT10x_ODEX60);
   3048 
   3049 					// AST REWRITE
   3050 					// elements:
   3051 					// token labels:
   3052 					// rule labels: retval
   3053 					// token list labels:
   3054 					// rule list labels:
   3055 					// wildcard labels:
   3056 					retval.tree = root_0;
   3057 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   3058 
   3059 					root_0 = (CommonTree)adaptor.nil();
   3060 					// 554:32: -> SIMPLE_NAME[$INSTRUCTION_FORMAT10x_ODEX]
   3061 					{
   3062 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT10x_ODEX60));
   3063 					}
   3064 
   3065 
   3066 					retval.tree = root_0;
   3067 
   3068 					}
   3069 					break;
   3070 				case 18 :
   3071 					// smaliParser.g:555:5: INSTRUCTION_FORMAT11x
   3072 					{
   3073 					INSTRUCTION_FORMAT11x61=(Token)match(input,INSTRUCTION_FORMAT11x,FOLLOW_INSTRUCTION_FORMAT11x_in_simple_name1958);
   3074 					stream_INSTRUCTION_FORMAT11x.add(INSTRUCTION_FORMAT11x61);
   3075 
   3076 					// AST REWRITE
   3077 					// elements:
   3078 					// token labels:
   3079 					// rule labels: retval
   3080 					// token list labels:
   3081 					// rule list labels:
   3082 					// wildcard labels:
   3083 					retval.tree = root_0;
   3084 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   3085 
   3086 					root_0 = (CommonTree)adaptor.nil();
   3087 					// 555:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT11x]
   3088 					{
   3089 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT11x61));
   3090 					}
   3091 
   3092 
   3093 					retval.tree = root_0;
   3094 
   3095 					}
   3096 					break;
   3097 				case 19 :
   3098 					// smaliParser.g:556:5: INSTRUCTION_FORMAT12x_OR_ID
   3099 					{
   3100 					INSTRUCTION_FORMAT12x_OR_ID62=(Token)match(input,INSTRUCTION_FORMAT12x_OR_ID,FOLLOW_INSTRUCTION_FORMAT12x_OR_ID_in_simple_name1969);
   3101 					stream_INSTRUCTION_FORMAT12x_OR_ID.add(INSTRUCTION_FORMAT12x_OR_ID62);
   3102 
   3103 					// AST REWRITE
   3104 					// elements:
   3105 					// token labels:
   3106 					// rule labels: retval
   3107 					// token list labels:
   3108 					// rule list labels:
   3109 					// wildcard labels:
   3110 					retval.tree = root_0;
   3111 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   3112 
   3113 					root_0 = (CommonTree)adaptor.nil();
   3114 					// 556:33: -> SIMPLE_NAME[$INSTRUCTION_FORMAT12x_OR_ID]
   3115 					{
   3116 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT12x_OR_ID62));
   3117 					}
   3118 
   3119 
   3120 					retval.tree = root_0;
   3121 
   3122 					}
   3123 					break;
   3124 				case 20 :
   3125 					// smaliParser.g:557:5: INSTRUCTION_FORMAT21c_FIELD
   3126 					{
   3127 					INSTRUCTION_FORMAT21c_FIELD63=(Token)match(input,INSTRUCTION_FORMAT21c_FIELD,FOLLOW_INSTRUCTION_FORMAT21c_FIELD_in_simple_name1980);
   3128 					stream_INSTRUCTION_FORMAT21c_FIELD.add(INSTRUCTION_FORMAT21c_FIELD63);
   3129 
   3130 					// AST REWRITE
   3131 					// elements:
   3132 					// token labels:
   3133 					// rule labels: retval
   3134 					// token list labels:
   3135 					// rule list labels:
   3136 					// wildcard labels:
   3137 					retval.tree = root_0;
   3138 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   3139 
   3140 					root_0 = (CommonTree)adaptor.nil();
   3141 					// 557:33: -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_FIELD]
   3142 					{
   3143 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT21c_FIELD63));
   3144 					}
   3145 
   3146 
   3147 					retval.tree = root_0;
   3148 
   3149 					}
   3150 					break;
   3151 				case 21 :
   3152 					// smaliParser.g:558:5: INSTRUCTION_FORMAT21c_FIELD_ODEX
   3153 					{
   3154 					INSTRUCTION_FORMAT21c_FIELD_ODEX64=(Token)match(input,INSTRUCTION_FORMAT21c_FIELD_ODEX,FOLLOW_INSTRUCTION_FORMAT21c_FIELD_ODEX_in_simple_name1991);
   3155 					stream_INSTRUCTION_FORMAT21c_FIELD_ODEX.add(INSTRUCTION_FORMAT21c_FIELD_ODEX64);
   3156 
   3157 					// AST REWRITE
   3158 					// elements:
   3159 					// token labels:
   3160 					// rule labels: retval
   3161 					// token list labels:
   3162 					// rule list labels:
   3163 					// wildcard labels:
   3164 					retval.tree = root_0;
   3165 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   3166 
   3167 					root_0 = (CommonTree)adaptor.nil();
   3168 					// 558:38: -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_FIELD_ODEX]
   3169 					{
   3170 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT21c_FIELD_ODEX64));
   3171 					}
   3172 
   3173 
   3174 					retval.tree = root_0;
   3175 
   3176 					}
   3177 					break;
   3178 				case 22 :
   3179 					// smaliParser.g:559:5: INSTRUCTION_FORMAT21c_STRING
   3180 					{
   3181 					INSTRUCTION_FORMAT21c_STRING65=(Token)match(input,INSTRUCTION_FORMAT21c_STRING,FOLLOW_INSTRUCTION_FORMAT21c_STRING_in_simple_name2002);
   3182 					stream_INSTRUCTION_FORMAT21c_STRING.add(INSTRUCTION_FORMAT21c_STRING65);
   3183 
   3184 					// AST REWRITE
   3185 					// elements:
   3186 					// token labels:
   3187 					// rule labels: retval
   3188 					// token list labels:
   3189 					// rule list labels:
   3190 					// wildcard labels:
   3191 					retval.tree = root_0;
   3192 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   3193 
   3194 					root_0 = (CommonTree)adaptor.nil();
   3195 					// 559:34: -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_STRING]
   3196 					{
   3197 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT21c_STRING65));
   3198 					}
   3199 
   3200 
   3201 					retval.tree = root_0;
   3202 
   3203 					}
   3204 					break;
   3205 				case 23 :
   3206 					// smaliParser.g:560:5: INSTRUCTION_FORMAT21c_TYPE
   3207 					{
   3208 					INSTRUCTION_FORMAT21c_TYPE66=(Token)match(input,INSTRUCTION_FORMAT21c_TYPE,FOLLOW_INSTRUCTION_FORMAT21c_TYPE_in_simple_name2013);
   3209 					stream_INSTRUCTION_FORMAT21c_TYPE.add(INSTRUCTION_FORMAT21c_TYPE66);
   3210 
   3211 					// AST REWRITE
   3212 					// elements:
   3213 					// token labels:
   3214 					// rule labels: retval
   3215 					// token list labels:
   3216 					// rule list labels:
   3217 					// wildcard labels:
   3218 					retval.tree = root_0;
   3219 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   3220 
   3221 					root_0 = (CommonTree)adaptor.nil();
   3222 					// 560:32: -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_TYPE]
   3223 					{
   3224 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT21c_TYPE66));
   3225 					}
   3226 
   3227 
   3228 					retval.tree = root_0;
   3229 
   3230 					}
   3231 					break;
   3232 				case 24 :
   3233 					// smaliParser.g:561:5: INSTRUCTION_FORMAT21t
   3234 					{
   3235 					INSTRUCTION_FORMAT21t67=(Token)match(input,INSTRUCTION_FORMAT21t,FOLLOW_INSTRUCTION_FORMAT21t_in_simple_name2024);
   3236 					stream_INSTRUCTION_FORMAT21t.add(INSTRUCTION_FORMAT21t67);
   3237 
   3238 					// AST REWRITE
   3239 					// elements:
   3240 					// token labels:
   3241 					// rule labels: retval
   3242 					// token list labels:
   3243 					// rule list labels:
   3244 					// wildcard labels:
   3245 					retval.tree = root_0;
   3246 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   3247 
   3248 					root_0 = (CommonTree)adaptor.nil();
   3249 					// 561:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT21t]
   3250 					{
   3251 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT21t67));
   3252 					}
   3253 
   3254 
   3255 					retval.tree = root_0;
   3256 
   3257 					}
   3258 					break;
   3259 				case 25 :
   3260 					// smaliParser.g:562:5: INSTRUCTION_FORMAT22c_FIELD
   3261 					{
   3262 					INSTRUCTION_FORMAT22c_FIELD68=(Token)match(input,INSTRUCTION_FORMAT22c_FIELD,FOLLOW_INSTRUCTION_FORMAT22c_FIELD_in_simple_name2035);
   3263 					stream_INSTRUCTION_FORMAT22c_FIELD.add(INSTRUCTION_FORMAT22c_FIELD68);
   3264 
   3265 					// AST REWRITE
   3266 					// elements:
   3267 					// token labels:
   3268 					// rule labels: retval
   3269 					// token list labels:
   3270 					// rule list labels:
   3271 					// wildcard labels:
   3272 					retval.tree = root_0;
   3273 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   3274 
   3275 					root_0 = (CommonTree)adaptor.nil();
   3276 					// 562:33: -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_FIELD]
   3277 					{
   3278 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT22c_FIELD68));
   3279 					}
   3280 
   3281 
   3282 					retval.tree = root_0;
   3283 
   3284 					}
   3285 					break;
   3286 				case 26 :
   3287 					// smaliParser.g:563:5: INSTRUCTION_FORMAT22c_FIELD_ODEX
   3288 					{
   3289 					INSTRUCTION_FORMAT22c_FIELD_ODEX69=(Token)match(input,INSTRUCTION_FORMAT22c_FIELD_ODEX,FOLLOW_INSTRUCTION_FORMAT22c_FIELD_ODEX_in_simple_name2046);
   3290 					stream_INSTRUCTION_FORMAT22c_FIELD_ODEX.add(INSTRUCTION_FORMAT22c_FIELD_ODEX69);
   3291 
   3292 					// AST REWRITE
   3293 					// elements:
   3294 					// token labels:
   3295 					// rule labels: retval
   3296 					// token list labels:
   3297 					// rule list labels:
   3298 					// wildcard labels:
   3299 					retval.tree = root_0;
   3300 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   3301 
   3302 					root_0 = (CommonTree)adaptor.nil();
   3303 					// 563:38: -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_FIELD_ODEX]
   3304 					{
   3305 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT22c_FIELD_ODEX69));
   3306 					}
   3307 
   3308 
   3309 					retval.tree = root_0;
   3310 
   3311 					}
   3312 					break;
   3313 				case 27 :
   3314 					// smaliParser.g:564:5: INSTRUCTION_FORMAT22c_TYPE
   3315 					{
   3316 					INSTRUCTION_FORMAT22c_TYPE70=(Token)match(input,INSTRUCTION_FORMAT22c_TYPE,FOLLOW_INSTRUCTION_FORMAT22c_TYPE_in_simple_name2057);
   3317 					stream_INSTRUCTION_FORMAT22c_TYPE.add(INSTRUCTION_FORMAT22c_TYPE70);
   3318 
   3319 					// AST REWRITE
   3320 					// elements:
   3321 					// token labels:
   3322 					// rule labels: retval
   3323 					// token list labels:
   3324 					// rule list labels:
   3325 					// wildcard labels:
   3326 					retval.tree = root_0;
   3327 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   3328 
   3329 					root_0 = (CommonTree)adaptor.nil();
   3330 					// 564:32: -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_TYPE]
   3331 					{
   3332 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT22c_TYPE70));
   3333 					}
   3334 
   3335 
   3336 					retval.tree = root_0;
   3337 
   3338 					}
   3339 					break;
   3340 				case 28 :
   3341 					// smaliParser.g:565:5: INSTRUCTION_FORMAT22cs_FIELD
   3342 					{
   3343 					INSTRUCTION_FORMAT22cs_FIELD71=(Token)match(input,INSTRUCTION_FORMAT22cs_FIELD,FOLLOW_INSTRUCTION_FORMAT22cs_FIELD_in_simple_name2068);
   3344 					stream_INSTRUCTION_FORMAT22cs_FIELD.add(INSTRUCTION_FORMAT22cs_FIELD71);
   3345 
   3346 					// AST REWRITE
   3347 					// elements:
   3348 					// token labels:
   3349 					// rule labels: retval
   3350 					// token list labels:
   3351 					// rule list labels:
   3352 					// wildcard labels:
   3353 					retval.tree = root_0;
   3354 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   3355 
   3356 					root_0 = (CommonTree)adaptor.nil();
   3357 					// 565:34: -> SIMPLE_NAME[$INSTRUCTION_FORMAT22cs_FIELD]
   3358 					{
   3359 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT22cs_FIELD71));
   3360 					}
   3361 
   3362 
   3363 					retval.tree = root_0;
   3364 
   3365 					}
   3366 					break;
   3367 				case 29 :
   3368 					// smaliParser.g:566:5: INSTRUCTION_FORMAT22s_OR_ID
   3369 					{
   3370 					INSTRUCTION_FORMAT22s_OR_ID72=(Token)match(input,INSTRUCTION_FORMAT22s_OR_ID,FOLLOW_INSTRUCTION_FORMAT22s_OR_ID_in_simple_name2079);
   3371 					stream_INSTRUCTION_FORMAT22s_OR_ID.add(INSTRUCTION_FORMAT22s_OR_ID72);
   3372 
   3373 					// AST REWRITE
   3374 					// elements:
   3375 					// token labels:
   3376 					// rule labels: retval
   3377 					// token list labels:
   3378 					// rule list labels:
   3379 					// wildcard labels:
   3380 					retval.tree = root_0;
   3381 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   3382 
   3383 					root_0 = (CommonTree)adaptor.nil();
   3384 					// 566:33: -> SIMPLE_NAME[$INSTRUCTION_FORMAT22s_OR_ID]
   3385 					{
   3386 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT22s_OR_ID72));
   3387 					}
   3388 
   3389 
   3390 					retval.tree = root_0;
   3391 
   3392 					}
   3393 					break;
   3394 				case 30 :
   3395 					// smaliParser.g:567:5: INSTRUCTION_FORMAT22t
   3396 					{
   3397 					INSTRUCTION_FORMAT22t73=(Token)match(input,INSTRUCTION_FORMAT22t,FOLLOW_INSTRUCTION_FORMAT22t_in_simple_name2090);
   3398 					stream_INSTRUCTION_FORMAT22t.add(INSTRUCTION_FORMAT22t73);
   3399 
   3400 					// AST REWRITE
   3401 					// elements:
   3402 					// token labels:
   3403 					// rule labels: retval
   3404 					// token list labels:
   3405 					// rule list labels:
   3406 					// wildcard labels:
   3407 					retval.tree = root_0;
   3408 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   3409 
   3410 					root_0 = (CommonTree)adaptor.nil();
   3411 					// 567:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT22t]
   3412 					{
   3413 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT22t73));
   3414 					}
   3415 
   3416 
   3417 					retval.tree = root_0;
   3418 
   3419 					}
   3420 					break;
   3421 				case 31 :
   3422 					// smaliParser.g:568:5: INSTRUCTION_FORMAT23x
   3423 					{
   3424 					INSTRUCTION_FORMAT23x74=(Token)match(input,INSTRUCTION_FORMAT23x,FOLLOW_INSTRUCTION_FORMAT23x_in_simple_name2101);
   3425 					stream_INSTRUCTION_FORMAT23x.add(INSTRUCTION_FORMAT23x74);
   3426 
   3427 					// AST REWRITE
   3428 					// elements:
   3429 					// token labels:
   3430 					// rule labels: retval
   3431 					// token list labels:
   3432 					// rule list labels:
   3433 					// wildcard labels:
   3434 					retval.tree = root_0;
   3435 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   3436 
   3437 					root_0 = (CommonTree)adaptor.nil();
   3438 					// 568:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT23x]
   3439 					{
   3440 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT23x74));
   3441 					}
   3442 
   3443 
   3444 					retval.tree = root_0;
   3445 
   3446 					}
   3447 					break;
   3448 				case 32 :
   3449 					// smaliParser.g:569:5: INSTRUCTION_FORMAT31i_OR_ID
   3450 					{
   3451 					INSTRUCTION_FORMAT31i_OR_ID75=(Token)match(input,INSTRUCTION_FORMAT31i_OR_ID,FOLLOW_INSTRUCTION_FORMAT31i_OR_ID_in_simple_name2112);
   3452 					stream_INSTRUCTION_FORMAT31i_OR_ID.add(INSTRUCTION_FORMAT31i_OR_ID75);
   3453 
   3454 					// AST REWRITE
   3455 					// elements:
   3456 					// token labels:
   3457 					// rule labels: retval
   3458 					// token list labels:
   3459 					// rule list labels:
   3460 					// wildcard labels:
   3461 					retval.tree = root_0;
   3462 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   3463 
   3464 					root_0 = (CommonTree)adaptor.nil();
   3465 					// 569:33: -> SIMPLE_NAME[$INSTRUCTION_FORMAT31i_OR_ID]
   3466 					{
   3467 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT31i_OR_ID75));
   3468 					}
   3469 
   3470 
   3471 					retval.tree = root_0;
   3472 
   3473 					}
   3474 					break;
   3475 				case 33 :
   3476 					// smaliParser.g:570:5: INSTRUCTION_FORMAT31t
   3477 					{
   3478 					INSTRUCTION_FORMAT31t76=(Token)match(input,INSTRUCTION_FORMAT31t,FOLLOW_INSTRUCTION_FORMAT31t_in_simple_name2123);
   3479 					stream_INSTRUCTION_FORMAT31t.add(INSTRUCTION_FORMAT31t76);
   3480 
   3481 					// AST REWRITE
   3482 					// elements:
   3483 					// token labels:
   3484 					// rule labels: retval
   3485 					// token list labels:
   3486 					// rule list labels:
   3487 					// wildcard labels:
   3488 					retval.tree = root_0;
   3489 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   3490 
   3491 					root_0 = (CommonTree)adaptor.nil();
   3492 					// 570:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT31t]
   3493 					{
   3494 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT31t76));
   3495 					}
   3496 
   3497 
   3498 					retval.tree = root_0;
   3499 
   3500 					}
   3501 					break;
   3502 				case 34 :
   3503 					// smaliParser.g:571:5: INSTRUCTION_FORMAT35c_METHOD
   3504 					{
   3505 					INSTRUCTION_FORMAT35c_METHOD77=(Token)match(input,INSTRUCTION_FORMAT35c_METHOD,FOLLOW_INSTRUCTION_FORMAT35c_METHOD_in_simple_name2134);
   3506 					stream_INSTRUCTION_FORMAT35c_METHOD.add(INSTRUCTION_FORMAT35c_METHOD77);
   3507 
   3508 					// AST REWRITE
   3509 					// elements:
   3510 					// token labels:
   3511 					// rule labels: retval
   3512 					// token list labels:
   3513 					// rule list labels:
   3514 					// wildcard labels:
   3515 					retval.tree = root_0;
   3516 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   3517 
   3518 					root_0 = (CommonTree)adaptor.nil();
   3519 					// 571:34: -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_METHOD]
   3520 					{
   3521 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT35c_METHOD77));
   3522 					}
   3523 
   3524 
   3525 					retval.tree = root_0;
   3526 
   3527 					}
   3528 					break;
   3529 				case 35 :
   3530 					// smaliParser.g:572:5: INSTRUCTION_FORMAT35c_METHOD_ODEX
   3531 					{
   3532 					INSTRUCTION_FORMAT35c_METHOD_ODEX78=(Token)match(input,INSTRUCTION_FORMAT35c_METHOD_ODEX,FOLLOW_INSTRUCTION_FORMAT35c_METHOD_ODEX_in_simple_name2145);
   3533 					stream_INSTRUCTION_FORMAT35c_METHOD_ODEX.add(INSTRUCTION_FORMAT35c_METHOD_ODEX78);
   3534 
   3535 					// AST REWRITE
   3536 					// elements:
   3537 					// token labels:
   3538 					// rule labels: retval
   3539 					// token list labels:
   3540 					// rule list labels:
   3541 					// wildcard labels:
   3542 					retval.tree = root_0;
   3543 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   3544 
   3545 					root_0 = (CommonTree)adaptor.nil();
   3546 					// 572:39: -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_METHOD_ODEX]
   3547 					{
   3548 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT35c_METHOD_ODEX78));
   3549 					}
   3550 
   3551 
   3552 					retval.tree = root_0;
   3553 
   3554 					}
   3555 					break;
   3556 				case 36 :
   3557 					// smaliParser.g:573:5: INSTRUCTION_FORMAT35c_TYPE
   3558 					{
   3559 					INSTRUCTION_FORMAT35c_TYPE79=(Token)match(input,INSTRUCTION_FORMAT35c_TYPE,FOLLOW_INSTRUCTION_FORMAT35c_TYPE_in_simple_name2156);
   3560 					stream_INSTRUCTION_FORMAT35c_TYPE.add(INSTRUCTION_FORMAT35c_TYPE79);
   3561 
   3562 					// AST REWRITE
   3563 					// elements:
   3564 					// token labels:
   3565 					// rule labels: retval
   3566 					// token list labels:
   3567 					// rule list labels:
   3568 					// wildcard labels:
   3569 					retval.tree = root_0;
   3570 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   3571 
   3572 					root_0 = (CommonTree)adaptor.nil();
   3573 					// 573:32: -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_TYPE]
   3574 					{
   3575 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT35c_TYPE79));
   3576 					}
   3577 
   3578 
   3579 					retval.tree = root_0;
   3580 
   3581 					}
   3582 					break;
   3583 				case 37 :
   3584 					// smaliParser.g:574:5: INSTRUCTION_FORMAT35mi_METHOD
   3585 					{
   3586 					INSTRUCTION_FORMAT35mi_METHOD80=(Token)match(input,INSTRUCTION_FORMAT35mi_METHOD,FOLLOW_INSTRUCTION_FORMAT35mi_METHOD_in_simple_name2167);
   3587 					stream_INSTRUCTION_FORMAT35mi_METHOD.add(INSTRUCTION_FORMAT35mi_METHOD80);
   3588 
   3589 					// AST REWRITE
   3590 					// elements:
   3591 					// token labels:
   3592 					// rule labels: retval
   3593 					// token list labels:
   3594 					// rule list labels:
   3595 					// wildcard labels:
   3596 					retval.tree = root_0;
   3597 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   3598 
   3599 					root_0 = (CommonTree)adaptor.nil();
   3600 					// 574:35: -> SIMPLE_NAME[$INSTRUCTION_FORMAT35mi_METHOD]
   3601 					{
   3602 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT35mi_METHOD80));
   3603 					}
   3604 
   3605 
   3606 					retval.tree = root_0;
   3607 
   3608 					}
   3609 					break;
   3610 				case 38 :
   3611 					// smaliParser.g:575:5: INSTRUCTION_FORMAT35ms_METHOD
   3612 					{
   3613 					INSTRUCTION_FORMAT35ms_METHOD81=(Token)match(input,INSTRUCTION_FORMAT35ms_METHOD,FOLLOW_INSTRUCTION_FORMAT35ms_METHOD_in_simple_name2178);
   3614 					stream_INSTRUCTION_FORMAT35ms_METHOD.add(INSTRUCTION_FORMAT35ms_METHOD81);
   3615 
   3616 					// AST REWRITE
   3617 					// elements:
   3618 					// token labels:
   3619 					// rule labels: retval
   3620 					// token list labels:
   3621 					// rule list labels:
   3622 					// wildcard labels:
   3623 					retval.tree = root_0;
   3624 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   3625 
   3626 					root_0 = (CommonTree)adaptor.nil();
   3627 					// 575:35: -> SIMPLE_NAME[$INSTRUCTION_FORMAT35ms_METHOD]
   3628 					{
   3629 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT35ms_METHOD81));
   3630 					}
   3631 
   3632 
   3633 					retval.tree = root_0;
   3634 
   3635 					}
   3636 					break;
   3637 				case 39 :
   3638 					// smaliParser.g:576:5: INSTRUCTION_FORMAT45cc_METHOD
   3639 					{
   3640 					INSTRUCTION_FORMAT45cc_METHOD82=(Token)match(input,INSTRUCTION_FORMAT45cc_METHOD,FOLLOW_INSTRUCTION_FORMAT45cc_METHOD_in_simple_name2189);
   3641 					stream_INSTRUCTION_FORMAT45cc_METHOD.add(INSTRUCTION_FORMAT45cc_METHOD82);
   3642 
   3643 					// AST REWRITE
   3644 					// elements:
   3645 					// token labels:
   3646 					// rule labels: retval
   3647 					// token list labels:
   3648 					// rule list labels:
   3649 					// wildcard labels:
   3650 					retval.tree = root_0;
   3651 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   3652 
   3653 					root_0 = (CommonTree)adaptor.nil();
   3654 					// 576:35: -> SIMPLE_NAME[$INSTRUCTION_FORMAT45cc_METHOD]
   3655 					{
   3656 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT45cc_METHOD82));
   3657 					}
   3658 
   3659 
   3660 					retval.tree = root_0;
   3661 
   3662 					}
   3663 					break;
   3664 				case 40 :
   3665 					// smaliParser.g:577:5: INSTRUCTION_FORMAT4rcc_METHOD
   3666 					{
   3667 					INSTRUCTION_FORMAT4rcc_METHOD83=(Token)match(input,INSTRUCTION_FORMAT4rcc_METHOD,FOLLOW_INSTRUCTION_FORMAT4rcc_METHOD_in_simple_name2200);
   3668 					stream_INSTRUCTION_FORMAT4rcc_METHOD.add(INSTRUCTION_FORMAT4rcc_METHOD83);
   3669 
   3670 					// AST REWRITE
   3671 					// elements:
   3672 					// token labels:
   3673 					// rule labels: retval
   3674 					// token list labels:
   3675 					// rule list labels:
   3676 					// wildcard labels:
   3677 					retval.tree = root_0;
   3678 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   3679 
   3680 					root_0 = (CommonTree)adaptor.nil();
   3681 					// 577:35: -> SIMPLE_NAME[$INSTRUCTION_FORMAT4rcc_METHOD]
   3682 					{
   3683 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT4rcc_METHOD83));
   3684 					}
   3685 
   3686 
   3687 					retval.tree = root_0;
   3688 
   3689 					}
   3690 					break;
   3691 				case 41 :
   3692 					// smaliParser.g:578:5: INSTRUCTION_FORMAT51l
   3693 					{
   3694 					INSTRUCTION_FORMAT51l84=(Token)match(input,INSTRUCTION_FORMAT51l,FOLLOW_INSTRUCTION_FORMAT51l_in_simple_name2211);
   3695 					stream_INSTRUCTION_FORMAT51l.add(INSTRUCTION_FORMAT51l84);
   3696 
   3697 					// AST REWRITE
   3698 					// elements:
   3699 					// token labels:
   3700 					// rule labels: retval
   3701 					// token list labels:
   3702 					// rule list labels:
   3703 					// wildcard labels:
   3704 					retval.tree = root_0;
   3705 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   3706 
   3707 					root_0 = (CommonTree)adaptor.nil();
   3708 					// 578:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT51l]
   3709 					{
   3710 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT51l84));
   3711 					}
   3712 
   3713 
   3714 					retval.tree = root_0;
   3715 
   3716 					}
   3717 					break;
   3718 
   3719 			}
   3720 			retval.stop = input.LT(-1);
   3721 
   3722 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   3723 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   3724 
   3725 		}
   3726 		catch (RecognitionException re) {
   3727 			reportError(re);
   3728 			recover(input,re);
   3729 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   3730 		}
   3731 		finally {
   3732 			// do for sure before leaving
   3733 		}
   3734 		return retval;
   3735 	}
   3736 	// $ANTLR end "simple_name"
   3737 
   3738 
   3739 	public static class member_name_return extends ParserRuleReturnScope {
   3740 		CommonTree tree;
   3741 		@Override
   3742 		public CommonTree getTree() { return tree; }
   3743 	};
   3744 
   3745 
   3746 	// $ANTLR start "member_name"
   3747 	// smaliParser.g:580:1: member_name : ( simple_name | MEMBER_NAME -> SIMPLE_NAME[$MEMBER_NAME] );
   3748 	public final smaliParser.member_name_return member_name() throws RecognitionException {
   3749 		smaliParser.member_name_return retval = new smaliParser.member_name_return();
   3750 		retval.start = input.LT(1);
   3751 
   3752 		CommonTree root_0 = null;
   3753 
   3754 		Token MEMBER_NAME86=null;
   3755 		ParserRuleReturnScope simple_name85 =null;
   3756 
   3757 		CommonTree MEMBER_NAME86_tree=null;
   3758 		RewriteRuleTokenStream stream_MEMBER_NAME=new RewriteRuleTokenStream(adaptor,"token MEMBER_NAME");
   3759 
   3760 		try {
   3761 			// smaliParser.g:581:3: ( simple_name | MEMBER_NAME -> SIMPLE_NAME[$MEMBER_NAME] )
   3762 			int alt11=2;
   3763 			int LA11_0 = input.LA(1);
   3764 			if ( (LA11_0==ACCESS_SPEC||LA11_0==ANNOTATION_VISIBILITY||LA11_0==BOOL_LITERAL||LA11_0==DOUBLE_LITERAL_OR_ID||LA11_0==FLOAT_LITERAL_OR_ID||(LA11_0 >= INSTRUCTION_FORMAT10t && LA11_0 <= INSTRUCTION_FORMAT10x_ODEX)||LA11_0==INSTRUCTION_FORMAT11x||LA11_0==INSTRUCTION_FORMAT12x_OR_ID||(LA11_0 >= INSTRUCTION_FORMAT21c_FIELD && LA11_0 <= INSTRUCTION_FORMAT21c_TYPE)||LA11_0==INSTRUCTION_FORMAT21t||(LA11_0 >= INSTRUCTION_FORMAT22c_FIELD && LA11_0 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA11_0 >= INSTRUCTION_FORMAT22s_OR_ID && LA11_0 <= INSTRUCTION_FORMAT22t)||LA11_0==INSTRUCTION_FORMAT23x||(LA11_0 >= INSTRUCTION_FORMAT31i_OR_ID && LA11_0 <= INSTRUCTION_FORMAT31t)||(LA11_0 >= INSTRUCTION_FORMAT35c_METHOD && LA11_0 <= INSTRUCTION_FORMAT35ms_METHOD)||(LA11_0 >= INSTRUCTION_FORMAT45cc_METHOD && LA11_0 <= INSTRUCTION_FORMAT51l)||(LA11_0 >= NEGATIVE_INTEGER_LITERAL && LA11_0 <= NULL_LITERAL)||(LA11_0 >= PARAM_LIST_OR_ID_PRIMITIVE_TYPE && LA11_0 <= PRIMITIVE_TYPE)||LA11_0==REGISTER||LA11_0==SIMPLE_NAME||(LA11_0 >= VERIFICATION_ERROR_TYPE && LA11_0 <= VOID_TYPE)) ) {
   3765 				alt11=1;
   3766 			}
   3767 			else if ( (LA11_0==MEMBER_NAME) ) {
   3768 				alt11=2;
   3769 			}
   3770 
   3771 			else {
   3772 				NoViableAltException nvae =
   3773 					new NoViableAltException("", 11, 0, input);
   3774 				throw nvae;
   3775 			}
   3776 
   3777 			switch (alt11) {
   3778 				case 1 :
   3779 					// smaliParser.g:581:5: simple_name
   3780 					{
   3781 					root_0 = (CommonTree)adaptor.nil();
   3782 
   3783 
   3784 					pushFollow(FOLLOW_simple_name_in_member_name2226);
   3785 					simple_name85=simple_name();
   3786 					state._fsp--;
   3787 
   3788 					adaptor.addChild(root_0, simple_name85.getTree());
   3789 
   3790 					}
   3791 					break;
   3792 				case 2 :
   3793 					// smaliParser.g:582:5: MEMBER_NAME
   3794 					{
   3795 					MEMBER_NAME86=(Token)match(input,MEMBER_NAME,FOLLOW_MEMBER_NAME_in_member_name2232);
   3796 					stream_MEMBER_NAME.add(MEMBER_NAME86);
   3797 
   3798 					// AST REWRITE
   3799 					// elements:
   3800 					// token labels:
   3801 					// rule labels: retval
   3802 					// token list labels:
   3803 					// rule list labels:
   3804 					// wildcard labels:
   3805 					retval.tree = root_0;
   3806 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   3807 
   3808 					root_0 = (CommonTree)adaptor.nil();
   3809 					// 582:17: -> SIMPLE_NAME[$MEMBER_NAME]
   3810 					{
   3811 						adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, MEMBER_NAME86));
   3812 					}
   3813 
   3814 
   3815 					retval.tree = root_0;
   3816 
   3817 					}
   3818 					break;
   3819 
   3820 			}
   3821 			retval.stop = input.LT(-1);
   3822 
   3823 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   3824 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   3825 
   3826 		}
   3827 		catch (RecognitionException re) {
   3828 			reportError(re);
   3829 			recover(input,re);
   3830 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   3831 		}
   3832 		finally {
   3833 			// do for sure before leaving
   3834 		}
   3835 		return retval;
   3836 	}
   3837 	// $ANTLR end "member_name"
   3838 
   3839 
   3840 	public static class method_prototype_return extends ParserRuleReturnScope {
   3841 		CommonTree tree;
   3842 		@Override
   3843 		public CommonTree getTree() { return tree; }
   3844 	};
   3845 
   3846 
   3847 	// $ANTLR start "method_prototype"
   3848 	// smaliParser.g:584:1: method_prototype : OPEN_PAREN param_list CLOSE_PAREN type_descriptor -> ^( I_METHOD_PROTOTYPE[$start, \"I_METHOD_PROTOTYPE\"] ^( I_METHOD_RETURN_TYPE type_descriptor ) ( param_list )? ) ;
   3849 	public final smaliParser.method_prototype_return method_prototype() throws RecognitionException {
   3850 		smaliParser.method_prototype_return retval = new smaliParser.method_prototype_return();
   3851 		retval.start = input.LT(1);
   3852 
   3853 		CommonTree root_0 = null;
   3854 
   3855 		Token OPEN_PAREN87=null;
   3856 		Token CLOSE_PAREN89=null;
   3857 		ParserRuleReturnScope param_list88 =null;
   3858 		ParserRuleReturnScope type_descriptor90 =null;
   3859 
   3860 		CommonTree OPEN_PAREN87_tree=null;
   3861 		CommonTree CLOSE_PAREN89_tree=null;
   3862 		RewriteRuleTokenStream stream_OPEN_PAREN=new RewriteRuleTokenStream(adaptor,"token OPEN_PAREN");
   3863 		RewriteRuleTokenStream stream_CLOSE_PAREN=new RewriteRuleTokenStream(adaptor,"token CLOSE_PAREN");
   3864 		RewriteRuleSubtreeStream stream_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule type_descriptor");
   3865 		RewriteRuleSubtreeStream stream_param_list=new RewriteRuleSubtreeStream(adaptor,"rule param_list");
   3866 
   3867 		try {
   3868 			// smaliParser.g:585:3: ( OPEN_PAREN param_list CLOSE_PAREN type_descriptor -> ^( I_METHOD_PROTOTYPE[$start, \"I_METHOD_PROTOTYPE\"] ^( I_METHOD_RETURN_TYPE type_descriptor ) ( param_list )? ) )
   3869 			// smaliParser.g:585:5: OPEN_PAREN param_list CLOSE_PAREN type_descriptor
   3870 			{
   3871 			OPEN_PAREN87=(Token)match(input,OPEN_PAREN,FOLLOW_OPEN_PAREN_in_method_prototype2247);
   3872 			stream_OPEN_PAREN.add(OPEN_PAREN87);
   3873 
   3874 			pushFollow(FOLLOW_param_list_in_method_prototype2249);
   3875 			param_list88=param_list();
   3876 			state._fsp--;
   3877 
   3878 			stream_param_list.add(param_list88.getTree());
   3879 			CLOSE_PAREN89=(Token)match(input,CLOSE_PAREN,FOLLOW_CLOSE_PAREN_in_method_prototype2251);
   3880 			stream_CLOSE_PAREN.add(CLOSE_PAREN89);
   3881 
   3882 			pushFollow(FOLLOW_type_descriptor_in_method_prototype2253);
   3883 			type_descriptor90=type_descriptor();
   3884 			state._fsp--;
   3885 
   3886 			stream_type_descriptor.add(type_descriptor90.getTree());
   3887 			// AST REWRITE
   3888 			// elements: type_descriptor, param_list
   3889 			// token labels:
   3890 			// rule labels: retval
   3891 			// token list labels:
   3892 			// rule list labels:
   3893 			// wildcard labels:
   3894 			retval.tree = root_0;
   3895 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   3896 
   3897 			root_0 = (CommonTree)adaptor.nil();
   3898 			// 586:5: -> ^( I_METHOD_PROTOTYPE[$start, \"I_METHOD_PROTOTYPE\"] ^( I_METHOD_RETURN_TYPE type_descriptor ) ( param_list )? )
   3899 			{
   3900 				// smaliParser.g:586:8: ^( I_METHOD_PROTOTYPE[$start, \"I_METHOD_PROTOTYPE\"] ^( I_METHOD_RETURN_TYPE type_descriptor ) ( param_list )? )
   3901 				{
   3902 				CommonTree root_1 = (CommonTree)adaptor.nil();
   3903 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_METHOD_PROTOTYPE, (retval.start), "I_METHOD_PROTOTYPE"), root_1);
   3904 				// smaliParser.g:586:59: ^( I_METHOD_RETURN_TYPE type_descriptor )
   3905 				{
   3906 				CommonTree root_2 = (CommonTree)adaptor.nil();
   3907 				root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_METHOD_RETURN_TYPE, "I_METHOD_RETURN_TYPE"), root_2);
   3908 				adaptor.addChild(root_2, stream_type_descriptor.nextTree());
   3909 				adaptor.addChild(root_1, root_2);
   3910 				}
   3911 
   3912 				// smaliParser.g:586:99: ( param_list )?
   3913 				if ( stream_param_list.hasNext() ) {
   3914 					adaptor.addChild(root_1, stream_param_list.nextTree());
   3915 				}
   3916 				stream_param_list.reset();
   3917 
   3918 				adaptor.addChild(root_0, root_1);
   3919 				}
   3920 
   3921 			}
   3922 
   3923 
   3924 			retval.tree = root_0;
   3925 
   3926 			}
   3927 
   3928 			retval.stop = input.LT(-1);
   3929 
   3930 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   3931 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   3932 
   3933 		}
   3934 		catch (RecognitionException re) {
   3935 			reportError(re);
   3936 			recover(input,re);
   3937 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   3938 		}
   3939 		finally {
   3940 			// do for sure before leaving
   3941 		}
   3942 		return retval;
   3943 	}
   3944 	// $ANTLR end "method_prototype"
   3945 
   3946 
   3947 	public static class param_list_or_id_primitive_type_return extends ParserRuleReturnScope {
   3948 		CommonTree tree;
   3949 		@Override
   3950 		public CommonTree getTree() { return tree; }
   3951 	};
   3952 
   3953 
   3954 	// $ANTLR start "param_list_or_id_primitive_type"
   3955 	// smaliParser.g:588:1: param_list_or_id_primitive_type : PARAM_LIST_OR_ID_PRIMITIVE_TYPE -> PRIMITIVE_TYPE[$PARAM_LIST_OR_ID_PRIMITIVE_TYPE] ;
   3956 	public final smaliParser.param_list_or_id_primitive_type_return param_list_or_id_primitive_type() throws RecognitionException {
   3957 		smaliParser.param_list_or_id_primitive_type_return retval = new smaliParser.param_list_or_id_primitive_type_return();
   3958 		retval.start = input.LT(1);
   3959 
   3960 		CommonTree root_0 = null;
   3961 
   3962 		Token PARAM_LIST_OR_ID_PRIMITIVE_TYPE91=null;
   3963 
   3964 		CommonTree PARAM_LIST_OR_ID_PRIMITIVE_TYPE91_tree=null;
   3965 		RewriteRuleTokenStream stream_PARAM_LIST_OR_ID_PRIMITIVE_TYPE=new RewriteRuleTokenStream(adaptor,"token PARAM_LIST_OR_ID_PRIMITIVE_TYPE");
   3966 
   3967 		try {
   3968 			// smaliParser.g:589:3: ( PARAM_LIST_OR_ID_PRIMITIVE_TYPE -> PRIMITIVE_TYPE[$PARAM_LIST_OR_ID_PRIMITIVE_TYPE] )
   3969 			// smaliParser.g:589:5: PARAM_LIST_OR_ID_PRIMITIVE_TYPE
   3970 			{
   3971 			PARAM_LIST_OR_ID_PRIMITIVE_TYPE91=(Token)match(input,PARAM_LIST_OR_ID_PRIMITIVE_TYPE,FOLLOW_PARAM_LIST_OR_ID_PRIMITIVE_TYPE_in_param_list_or_id_primitive_type2283);
   3972 			stream_PARAM_LIST_OR_ID_PRIMITIVE_TYPE.add(PARAM_LIST_OR_ID_PRIMITIVE_TYPE91);
   3973 
   3974 			// AST REWRITE
   3975 			// elements:
   3976 			// token labels:
   3977 			// rule labels: retval
   3978 			// token list labels:
   3979 			// rule list labels:
   3980 			// wildcard labels:
   3981 			retval.tree = root_0;
   3982 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   3983 
   3984 			root_0 = (CommonTree)adaptor.nil();
   3985 			// 589:37: -> PRIMITIVE_TYPE[$PARAM_LIST_OR_ID_PRIMITIVE_TYPE]
   3986 			{
   3987 				adaptor.addChild(root_0, (CommonTree)adaptor.create(PRIMITIVE_TYPE, PARAM_LIST_OR_ID_PRIMITIVE_TYPE91));
   3988 			}
   3989 
   3990 
   3991 			retval.tree = root_0;
   3992 
   3993 			}
   3994 
   3995 			retval.stop = input.LT(-1);
   3996 
   3997 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   3998 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   3999 
   4000 		}
   4001 		catch (RecognitionException re) {
   4002 			reportError(re);
   4003 			recover(input,re);
   4004 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   4005 		}
   4006 		finally {
   4007 			// do for sure before leaving
   4008 		}
   4009 		return retval;
   4010 	}
   4011 	// $ANTLR end "param_list_or_id_primitive_type"
   4012 
   4013 
   4014 	public static class param_list_return extends ParserRuleReturnScope {
   4015 		CommonTree tree;
   4016 		@Override
   4017 		public CommonTree getTree() { return tree; }
   4018 	};
   4019 
   4020 
   4021 	// $ANTLR start "param_list"
   4022 	// smaliParser.g:591:1: param_list : ( ( param_list_or_id_primitive_type )+ | ( nonvoid_type_descriptor )* );
   4023 	public final smaliParser.param_list_return param_list() throws RecognitionException {
   4024 		smaliParser.param_list_return retval = new smaliParser.param_list_return();
   4025 		retval.start = input.LT(1);
   4026 
   4027 		CommonTree root_0 = null;
   4028 
   4029 		ParserRuleReturnScope param_list_or_id_primitive_type92 =null;
   4030 		ParserRuleReturnScope nonvoid_type_descriptor93 =null;
   4031 
   4032 
   4033 		try {
   4034 			// smaliParser.g:592:3: ( ( param_list_or_id_primitive_type )+ | ( nonvoid_type_descriptor )* )
   4035 			int alt14=2;
   4036 			int LA14_0 = input.LA(1);
   4037 			if ( (LA14_0==PARAM_LIST_OR_ID_PRIMITIVE_TYPE) ) {
   4038 				alt14=1;
   4039 			}
   4040 			else if ( (LA14_0==ARRAY_TYPE_PREFIX||LA14_0==CLASS_DESCRIPTOR||LA14_0==CLOSE_PAREN||LA14_0==PRIMITIVE_TYPE) ) {
   4041 				alt14=2;
   4042 			}
   4043 
   4044 			else {
   4045 				NoViableAltException nvae =
   4046 					new NoViableAltException("", 14, 0, input);
   4047 				throw nvae;
   4048 			}
   4049 
   4050 			switch (alt14) {
   4051 				case 1 :
   4052 					// smaliParser.g:592:5: ( param_list_or_id_primitive_type )+
   4053 					{
   4054 					root_0 = (CommonTree)adaptor.nil();
   4055 
   4056 
   4057 					// smaliParser.g:592:5: ( param_list_or_id_primitive_type )+
   4058 					int cnt12=0;
   4059 					loop12:
   4060 					while (true) {
   4061 						int alt12=2;
   4062 						int LA12_0 = input.LA(1);
   4063 						if ( (LA12_0==PARAM_LIST_OR_ID_PRIMITIVE_TYPE) ) {
   4064 							alt12=1;
   4065 						}
   4066 
   4067 						switch (alt12) {
   4068 						case 1 :
   4069 							// smaliParser.g:592:5: param_list_or_id_primitive_type
   4070 							{
   4071 							pushFollow(FOLLOW_param_list_or_id_primitive_type_in_param_list2298);
   4072 							param_list_or_id_primitive_type92=param_list_or_id_primitive_type();
   4073 							state._fsp--;
   4074 
   4075 							adaptor.addChild(root_0, param_list_or_id_primitive_type92.getTree());
   4076 
   4077 							}
   4078 							break;
   4079 
   4080 						default :
   4081 							if ( cnt12 >= 1 ) break loop12;
   4082 							EarlyExitException eee = new EarlyExitException(12, input);
   4083 							throw eee;
   4084 						}
   4085 						cnt12++;
   4086 					}
   4087 
   4088 					}
   4089 					break;
   4090 				case 2 :
   4091 					// smaliParser.g:593:5: ( nonvoid_type_descriptor )*
   4092 					{
   4093 					root_0 = (CommonTree)adaptor.nil();
   4094 
   4095 
   4096 					// smaliParser.g:593:5: ( nonvoid_type_descriptor )*
   4097 					loop13:
   4098 					while (true) {
   4099 						int alt13=2;
   4100 						int LA13_0 = input.LA(1);
   4101 						if ( (LA13_0==ARRAY_TYPE_PREFIX||LA13_0==CLASS_DESCRIPTOR||LA13_0==PRIMITIVE_TYPE) ) {
   4102 							alt13=1;
   4103 						}
   4104 
   4105 						switch (alt13) {
   4106 						case 1 :
   4107 							// smaliParser.g:593:5: nonvoid_type_descriptor
   4108 							{
   4109 							pushFollow(FOLLOW_nonvoid_type_descriptor_in_param_list2305);
   4110 							nonvoid_type_descriptor93=nonvoid_type_descriptor();
   4111 							state._fsp--;
   4112 
   4113 							adaptor.addChild(root_0, nonvoid_type_descriptor93.getTree());
   4114 
   4115 							}
   4116 							break;
   4117 
   4118 						default :
   4119 							break loop13;
   4120 						}
   4121 					}
   4122 
   4123 					}
   4124 					break;
   4125 
   4126 			}
   4127 			retval.stop = input.LT(-1);
   4128 
   4129 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   4130 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   4131 
   4132 		}
   4133 		catch (RecognitionException re) {
   4134 			reportError(re);
   4135 			recover(input,re);
   4136 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   4137 		}
   4138 		finally {
   4139 			// do for sure before leaving
   4140 		}
   4141 		return retval;
   4142 	}
   4143 	// $ANTLR end "param_list"
   4144 
   4145 
   4146 	public static class array_descriptor_return extends ParserRuleReturnScope {
   4147 		CommonTree tree;
   4148 		@Override
   4149 		public CommonTree getTree() { return tree; }
   4150 	};
   4151 
   4152 
   4153 	// $ANTLR start "array_descriptor"
   4154 	// smaliParser.g:595:1: array_descriptor : ARRAY_TYPE_PREFIX ( PRIMITIVE_TYPE | CLASS_DESCRIPTOR ) ;
   4155 	public final smaliParser.array_descriptor_return array_descriptor() throws RecognitionException {
   4156 		smaliParser.array_descriptor_return retval = new smaliParser.array_descriptor_return();
   4157 		retval.start = input.LT(1);
   4158 
   4159 		CommonTree root_0 = null;
   4160 
   4161 		Token ARRAY_TYPE_PREFIX94=null;
   4162 		Token set95=null;
   4163 
   4164 		CommonTree ARRAY_TYPE_PREFIX94_tree=null;
   4165 		CommonTree set95_tree=null;
   4166 
   4167 		try {
   4168 			// smaliParser.g:596:3: ( ARRAY_TYPE_PREFIX ( PRIMITIVE_TYPE | CLASS_DESCRIPTOR ) )
   4169 			// smaliParser.g:596:5: ARRAY_TYPE_PREFIX ( PRIMITIVE_TYPE | CLASS_DESCRIPTOR )
   4170 			{
   4171 			root_0 = (CommonTree)adaptor.nil();
   4172 
   4173 
   4174 			ARRAY_TYPE_PREFIX94=(Token)match(input,ARRAY_TYPE_PREFIX,FOLLOW_ARRAY_TYPE_PREFIX_in_array_descriptor2316);
   4175 			ARRAY_TYPE_PREFIX94_tree = (CommonTree)adaptor.create(ARRAY_TYPE_PREFIX94);
   4176 			adaptor.addChild(root_0, ARRAY_TYPE_PREFIX94_tree);
   4177 
   4178 			set95=input.LT(1);
   4179 			if ( input.LA(1)==CLASS_DESCRIPTOR||input.LA(1)==PRIMITIVE_TYPE ) {
   4180 				input.consume();
   4181 				adaptor.addChild(root_0, (CommonTree)adaptor.create(set95));
   4182 				state.errorRecovery=false;
   4183 			}
   4184 			else {
   4185 				MismatchedSetException mse = new MismatchedSetException(null,input);
   4186 				throw mse;
   4187 			}
   4188 			}
   4189 
   4190 			retval.stop = input.LT(-1);
   4191 
   4192 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   4193 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   4194 
   4195 		}
   4196 		catch (RecognitionException re) {
   4197 			reportError(re);
   4198 			recover(input,re);
   4199 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   4200 		}
   4201 		finally {
   4202 			// do for sure before leaving
   4203 		}
   4204 		return retval;
   4205 	}
   4206 	// $ANTLR end "array_descriptor"
   4207 
   4208 
   4209 	public static class type_descriptor_return extends ParserRuleReturnScope {
   4210 		CommonTree tree;
   4211 		@Override
   4212 		public CommonTree getTree() { return tree; }
   4213 	};
   4214 
   4215 
   4216 	// $ANTLR start "type_descriptor"
   4217 	// smaliParser.g:598:1: type_descriptor : ( VOID_TYPE | PRIMITIVE_TYPE | CLASS_DESCRIPTOR | array_descriptor );
   4218 	public final smaliParser.type_descriptor_return type_descriptor() throws RecognitionException {
   4219 		smaliParser.type_descriptor_return retval = new smaliParser.type_descriptor_return();
   4220 		retval.start = input.LT(1);
   4221 
   4222 		CommonTree root_0 = null;
   4223 
   4224 		Token VOID_TYPE96=null;
   4225 		Token PRIMITIVE_TYPE97=null;
   4226 		Token CLASS_DESCRIPTOR98=null;
   4227 		ParserRuleReturnScope array_descriptor99 =null;
   4228 
   4229 		CommonTree VOID_TYPE96_tree=null;
   4230 		CommonTree PRIMITIVE_TYPE97_tree=null;
   4231 		CommonTree CLASS_DESCRIPTOR98_tree=null;
   4232 
   4233 		try {
   4234 			// smaliParser.g:599:3: ( VOID_TYPE | PRIMITIVE_TYPE | CLASS_DESCRIPTOR | array_descriptor )
   4235 			int alt15=4;
   4236 			switch ( input.LA(1) ) {
   4237 			case VOID_TYPE:
   4238 				{
   4239 				alt15=1;
   4240 				}
   4241 				break;
   4242 			case PRIMITIVE_TYPE:
   4243 				{
   4244 				alt15=2;
   4245 				}
   4246 				break;
   4247 			case CLASS_DESCRIPTOR:
   4248 				{
   4249 				alt15=3;
   4250 				}
   4251 				break;
   4252 			case ARRAY_TYPE_PREFIX:
   4253 				{
   4254 				alt15=4;
   4255 				}
   4256 				break;
   4257 			default:
   4258 				NoViableAltException nvae =
   4259 					new NoViableAltException("", 15, 0, input);
   4260 				throw nvae;
   4261 			}
   4262 			switch (alt15) {
   4263 				case 1 :
   4264 					// smaliParser.g:599:5: VOID_TYPE
   4265 					{
   4266 					root_0 = (CommonTree)adaptor.nil();
   4267 
   4268 
   4269 					VOID_TYPE96=(Token)match(input,VOID_TYPE,FOLLOW_VOID_TYPE_in_type_descriptor2334);
   4270 					VOID_TYPE96_tree = (CommonTree)adaptor.create(VOID_TYPE96);
   4271 					adaptor.addChild(root_0, VOID_TYPE96_tree);
   4272 
   4273 					}
   4274 					break;
   4275 				case 2 :
   4276 					// smaliParser.g:600:5: PRIMITIVE_TYPE
   4277 					{
   4278 					root_0 = (CommonTree)adaptor.nil();
   4279 
   4280 
   4281 					PRIMITIVE_TYPE97=(Token)match(input,PRIMITIVE_TYPE,FOLLOW_PRIMITIVE_TYPE_in_type_descriptor2340);
   4282 					PRIMITIVE_TYPE97_tree = (CommonTree)adaptor.create(PRIMITIVE_TYPE97);
   4283 					adaptor.addChild(root_0, PRIMITIVE_TYPE97_tree);
   4284 
   4285 					}
   4286 					break;
   4287 				case 3 :
   4288 					// smaliParser.g:601:5: CLASS_DESCRIPTOR
   4289 					{
   4290 					root_0 = (CommonTree)adaptor.nil();
   4291 
   4292 
   4293 					CLASS_DESCRIPTOR98=(Token)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_type_descriptor2346);
   4294 					CLASS_DESCRIPTOR98_tree = (CommonTree)adaptor.create(CLASS_DESCRIPTOR98);
   4295 					adaptor.addChild(root_0, CLASS_DESCRIPTOR98_tree);
   4296 
   4297 					}
   4298 					break;
   4299 				case 4 :
   4300 					// smaliParser.g:602:5: array_descriptor
   4301 					{
   4302 					root_0 = (CommonTree)adaptor.nil();
   4303 
   4304 
   4305 					pushFollow(FOLLOW_array_descriptor_in_type_descriptor2352);
   4306 					array_descriptor99=array_descriptor();
   4307 					state._fsp--;
   4308 
   4309 					adaptor.addChild(root_0, array_descriptor99.getTree());
   4310 
   4311 					}
   4312 					break;
   4313 
   4314 			}
   4315 			retval.stop = input.LT(-1);
   4316 
   4317 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   4318 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   4319 
   4320 		}
   4321 		catch (RecognitionException re) {
   4322 			reportError(re);
   4323 			recover(input,re);
   4324 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   4325 		}
   4326 		finally {
   4327 			// do for sure before leaving
   4328 		}
   4329 		return retval;
   4330 	}
   4331 	// $ANTLR end "type_descriptor"
   4332 
   4333 
   4334 	public static class nonvoid_type_descriptor_return extends ParserRuleReturnScope {
   4335 		CommonTree tree;
   4336 		@Override
   4337 		public CommonTree getTree() { return tree; }
   4338 	};
   4339 
   4340 
   4341 	// $ANTLR start "nonvoid_type_descriptor"
   4342 	// smaliParser.g:604:1: nonvoid_type_descriptor : ( PRIMITIVE_TYPE | CLASS_DESCRIPTOR | array_descriptor );
   4343 	public final smaliParser.nonvoid_type_descriptor_return nonvoid_type_descriptor() throws RecognitionException {
   4344 		smaliParser.nonvoid_type_descriptor_return retval = new smaliParser.nonvoid_type_descriptor_return();
   4345 		retval.start = input.LT(1);
   4346 
   4347 		CommonTree root_0 = null;
   4348 
   4349 		Token PRIMITIVE_TYPE100=null;
   4350 		Token CLASS_DESCRIPTOR101=null;
   4351 		ParserRuleReturnScope array_descriptor102 =null;
   4352 
   4353 		CommonTree PRIMITIVE_TYPE100_tree=null;
   4354 		CommonTree CLASS_DESCRIPTOR101_tree=null;
   4355 
   4356 		try {
   4357 			// smaliParser.g:605:3: ( PRIMITIVE_TYPE | CLASS_DESCRIPTOR | array_descriptor )
   4358 			int alt16=3;
   4359 			switch ( input.LA(1) ) {
   4360 			case PRIMITIVE_TYPE:
   4361 				{
   4362 				alt16=1;
   4363 				}
   4364 				break;
   4365 			case CLASS_DESCRIPTOR:
   4366 				{
   4367 				alt16=2;
   4368 				}
   4369 				break;
   4370 			case ARRAY_TYPE_PREFIX:
   4371 				{
   4372 				alt16=3;
   4373 				}
   4374 				break;
   4375 			default:
   4376 				NoViableAltException nvae =
   4377 					new NoViableAltException("", 16, 0, input);
   4378 				throw nvae;
   4379 			}
   4380 			switch (alt16) {
   4381 				case 1 :
   4382 					// smaliParser.g:605:5: PRIMITIVE_TYPE
   4383 					{
   4384 					root_0 = (CommonTree)adaptor.nil();
   4385 
   4386 
   4387 					PRIMITIVE_TYPE100=(Token)match(input,PRIMITIVE_TYPE,FOLLOW_PRIMITIVE_TYPE_in_nonvoid_type_descriptor2362);
   4388 					PRIMITIVE_TYPE100_tree = (CommonTree)adaptor.create(PRIMITIVE_TYPE100);
   4389 					adaptor.addChild(root_0, PRIMITIVE_TYPE100_tree);
   4390 
   4391 					}
   4392 					break;
   4393 				case 2 :
   4394 					// smaliParser.g:606:5: CLASS_DESCRIPTOR
   4395 					{
   4396 					root_0 = (CommonTree)adaptor.nil();
   4397 
   4398 
   4399 					CLASS_DESCRIPTOR101=(Token)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_nonvoid_type_descriptor2368);
   4400 					CLASS_DESCRIPTOR101_tree = (CommonTree)adaptor.create(CLASS_DESCRIPTOR101);
   4401 					adaptor.addChild(root_0, CLASS_DESCRIPTOR101_tree);
   4402 
   4403 					}
   4404 					break;
   4405 				case 3 :
   4406 					// smaliParser.g:607:5: array_descriptor
   4407 					{
   4408 					root_0 = (CommonTree)adaptor.nil();
   4409 
   4410 
   4411 					pushFollow(FOLLOW_array_descriptor_in_nonvoid_type_descriptor2374);
   4412 					array_descriptor102=array_descriptor();
   4413 					state._fsp--;
   4414 
   4415 					adaptor.addChild(root_0, array_descriptor102.getTree());
   4416 
   4417 					}
   4418 					break;
   4419 
   4420 			}
   4421 			retval.stop = input.LT(-1);
   4422 
   4423 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   4424 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   4425 
   4426 		}
   4427 		catch (RecognitionException re) {
   4428 			reportError(re);
   4429 			recover(input,re);
   4430 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   4431 		}
   4432 		finally {
   4433 			// do for sure before leaving
   4434 		}
   4435 		return retval;
   4436 	}
   4437 	// $ANTLR end "nonvoid_type_descriptor"
   4438 
   4439 
   4440 	public static class reference_type_descriptor_return extends ParserRuleReturnScope {
   4441 		CommonTree tree;
   4442 		@Override
   4443 		public CommonTree getTree() { return tree; }
   4444 	};
   4445 
   4446 
   4447 	// $ANTLR start "reference_type_descriptor"
   4448 	// smaliParser.g:609:1: reference_type_descriptor : ( CLASS_DESCRIPTOR | array_descriptor );
   4449 	public final smaliParser.reference_type_descriptor_return reference_type_descriptor() throws RecognitionException {
   4450 		smaliParser.reference_type_descriptor_return retval = new smaliParser.reference_type_descriptor_return();
   4451 		retval.start = input.LT(1);
   4452 
   4453 		CommonTree root_0 = null;
   4454 
   4455 		Token CLASS_DESCRIPTOR103=null;
   4456 		ParserRuleReturnScope array_descriptor104 =null;
   4457 
   4458 		CommonTree CLASS_DESCRIPTOR103_tree=null;
   4459 
   4460 		try {
   4461 			// smaliParser.g:610:3: ( CLASS_DESCRIPTOR | array_descriptor )
   4462 			int alt17=2;
   4463 			int LA17_0 = input.LA(1);
   4464 			if ( (LA17_0==CLASS_DESCRIPTOR) ) {
   4465 				alt17=1;
   4466 			}
   4467 			else if ( (LA17_0==ARRAY_TYPE_PREFIX) ) {
   4468 				alt17=2;
   4469 			}
   4470 
   4471 			else {
   4472 				NoViableAltException nvae =
   4473 					new NoViableAltException("", 17, 0, input);
   4474 				throw nvae;
   4475 			}
   4476 
   4477 			switch (alt17) {
   4478 				case 1 :
   4479 					// smaliParser.g:610:5: CLASS_DESCRIPTOR
   4480 					{
   4481 					root_0 = (CommonTree)adaptor.nil();
   4482 
   4483 
   4484 					CLASS_DESCRIPTOR103=(Token)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_reference_type_descriptor2384);
   4485 					CLASS_DESCRIPTOR103_tree = (CommonTree)adaptor.create(CLASS_DESCRIPTOR103);
   4486 					adaptor.addChild(root_0, CLASS_DESCRIPTOR103_tree);
   4487 
   4488 					}
   4489 					break;
   4490 				case 2 :
   4491 					// smaliParser.g:611:5: array_descriptor
   4492 					{
   4493 					root_0 = (CommonTree)adaptor.nil();
   4494 
   4495 
   4496 					pushFollow(FOLLOW_array_descriptor_in_reference_type_descriptor2390);
   4497 					array_descriptor104=array_descriptor();
   4498 					state._fsp--;
   4499 
   4500 					adaptor.addChild(root_0, array_descriptor104.getTree());
   4501 
   4502 					}
   4503 					break;
   4504 
   4505 			}
   4506 			retval.stop = input.LT(-1);
   4507 
   4508 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   4509 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   4510 
   4511 		}
   4512 		catch (RecognitionException re) {
   4513 			reportError(re);
   4514 			recover(input,re);
   4515 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   4516 		}
   4517 		finally {
   4518 			// do for sure before leaving
   4519 		}
   4520 		return retval;
   4521 	}
   4522 	// $ANTLR end "reference_type_descriptor"
   4523 
   4524 
   4525 	public static class integer_literal_return extends ParserRuleReturnScope {
   4526 		CommonTree tree;
   4527 		@Override
   4528 		public CommonTree getTree() { return tree; }
   4529 	};
   4530 
   4531 
   4532 	// $ANTLR start "integer_literal"
   4533 	// smaliParser.g:613:1: integer_literal : ( POSITIVE_INTEGER_LITERAL -> INTEGER_LITERAL[$POSITIVE_INTEGER_LITERAL] | NEGATIVE_INTEGER_LITERAL -> INTEGER_LITERAL[$NEGATIVE_INTEGER_LITERAL] );
   4534 	public final smaliParser.integer_literal_return integer_literal() throws RecognitionException {
   4535 		smaliParser.integer_literal_return retval = new smaliParser.integer_literal_return();
   4536 		retval.start = input.LT(1);
   4537 
   4538 		CommonTree root_0 = null;
   4539 
   4540 		Token POSITIVE_INTEGER_LITERAL105=null;
   4541 		Token NEGATIVE_INTEGER_LITERAL106=null;
   4542 
   4543 		CommonTree POSITIVE_INTEGER_LITERAL105_tree=null;
   4544 		CommonTree NEGATIVE_INTEGER_LITERAL106_tree=null;
   4545 		RewriteRuleTokenStream stream_NEGATIVE_INTEGER_LITERAL=new RewriteRuleTokenStream(adaptor,"token NEGATIVE_INTEGER_LITERAL");
   4546 		RewriteRuleTokenStream stream_POSITIVE_INTEGER_LITERAL=new RewriteRuleTokenStream(adaptor,"token POSITIVE_INTEGER_LITERAL");
   4547 
   4548 		try {
   4549 			// smaliParser.g:614:3: ( POSITIVE_INTEGER_LITERAL -> INTEGER_LITERAL[$POSITIVE_INTEGER_LITERAL] | NEGATIVE_INTEGER_LITERAL -> INTEGER_LITERAL[$NEGATIVE_INTEGER_LITERAL] )
   4550 			int alt18=2;
   4551 			int LA18_0 = input.LA(1);
   4552 			if ( (LA18_0==POSITIVE_INTEGER_LITERAL) ) {
   4553 				alt18=1;
   4554 			}
   4555 			else if ( (LA18_0==NEGATIVE_INTEGER_LITERAL) ) {
   4556 				alt18=2;
   4557 			}
   4558 
   4559 			else {
   4560 				NoViableAltException nvae =
   4561 					new NoViableAltException("", 18, 0, input);
   4562 				throw nvae;
   4563 			}
   4564 
   4565 			switch (alt18) {
   4566 				case 1 :
   4567 					// smaliParser.g:614:5: POSITIVE_INTEGER_LITERAL
   4568 					{
   4569 					POSITIVE_INTEGER_LITERAL105=(Token)match(input,POSITIVE_INTEGER_LITERAL,FOLLOW_POSITIVE_INTEGER_LITERAL_in_integer_literal2400);
   4570 					stream_POSITIVE_INTEGER_LITERAL.add(POSITIVE_INTEGER_LITERAL105);
   4571 
   4572 					// AST REWRITE
   4573 					// elements:
   4574 					// token labels:
   4575 					// rule labels: retval
   4576 					// token list labels:
   4577 					// rule list labels:
   4578 					// wildcard labels:
   4579 					retval.tree = root_0;
   4580 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   4581 
   4582 					root_0 = (CommonTree)adaptor.nil();
   4583 					// 614:30: -> INTEGER_LITERAL[$POSITIVE_INTEGER_LITERAL]
   4584 					{
   4585 						adaptor.addChild(root_0, (CommonTree)adaptor.create(INTEGER_LITERAL, POSITIVE_INTEGER_LITERAL105));
   4586 					}
   4587 
   4588 
   4589 					retval.tree = root_0;
   4590 
   4591 					}
   4592 					break;
   4593 				case 2 :
   4594 					// smaliParser.g:615:5: NEGATIVE_INTEGER_LITERAL
   4595 					{
   4596 					NEGATIVE_INTEGER_LITERAL106=(Token)match(input,NEGATIVE_INTEGER_LITERAL,FOLLOW_NEGATIVE_INTEGER_LITERAL_in_integer_literal2411);
   4597 					stream_NEGATIVE_INTEGER_LITERAL.add(NEGATIVE_INTEGER_LITERAL106);
   4598 
   4599 					// AST REWRITE
   4600 					// elements:
   4601 					// token labels:
   4602 					// rule labels: retval
   4603 					// token list labels:
   4604 					// rule list labels:
   4605 					// wildcard labels:
   4606 					retval.tree = root_0;
   4607 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   4608 
   4609 					root_0 = (CommonTree)adaptor.nil();
   4610 					// 615:30: -> INTEGER_LITERAL[$NEGATIVE_INTEGER_LITERAL]
   4611 					{
   4612 						adaptor.addChild(root_0, (CommonTree)adaptor.create(INTEGER_LITERAL, NEGATIVE_INTEGER_LITERAL106));
   4613 					}
   4614 
   4615 
   4616 					retval.tree = root_0;
   4617 
   4618 					}
   4619 					break;
   4620 
   4621 			}
   4622 			retval.stop = input.LT(-1);
   4623 
   4624 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   4625 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   4626 
   4627 		}
   4628 		catch (RecognitionException re) {
   4629 			reportError(re);
   4630 			recover(input,re);
   4631 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   4632 		}
   4633 		finally {
   4634 			// do for sure before leaving
   4635 		}
   4636 		return retval;
   4637 	}
   4638 	// $ANTLR end "integer_literal"
   4639 
   4640 
   4641 	public static class float_literal_return extends ParserRuleReturnScope {
   4642 		CommonTree tree;
   4643 		@Override
   4644 		public CommonTree getTree() { return tree; }
   4645 	};
   4646 
   4647 
   4648 	// $ANTLR start "float_literal"
   4649 	// smaliParser.g:617:1: float_literal : ( FLOAT_LITERAL_OR_ID -> FLOAT_LITERAL[$FLOAT_LITERAL_OR_ID] | FLOAT_LITERAL );
   4650 	public final smaliParser.float_literal_return float_literal() throws RecognitionException {
   4651 		smaliParser.float_literal_return retval = new smaliParser.float_literal_return();
   4652 		retval.start = input.LT(1);
   4653 
   4654 		CommonTree root_0 = null;
   4655 
   4656 		Token FLOAT_LITERAL_OR_ID107=null;
   4657 		Token FLOAT_LITERAL108=null;
   4658 
   4659 		CommonTree FLOAT_LITERAL_OR_ID107_tree=null;
   4660 		CommonTree FLOAT_LITERAL108_tree=null;
   4661 		RewriteRuleTokenStream stream_FLOAT_LITERAL_OR_ID=new RewriteRuleTokenStream(adaptor,"token FLOAT_LITERAL_OR_ID");
   4662 
   4663 		try {
   4664 			// smaliParser.g:618:3: ( FLOAT_LITERAL_OR_ID -> FLOAT_LITERAL[$FLOAT_LITERAL_OR_ID] | FLOAT_LITERAL )
   4665 			int alt19=2;
   4666 			int LA19_0 = input.LA(1);
   4667 			if ( (LA19_0==FLOAT_LITERAL_OR_ID) ) {
   4668 				alt19=1;
   4669 			}
   4670 			else if ( (LA19_0==FLOAT_LITERAL) ) {
   4671 				alt19=2;
   4672 			}
   4673 
   4674 			else {
   4675 				NoViableAltException nvae =
   4676 					new NoViableAltException("", 19, 0, input);
   4677 				throw nvae;
   4678 			}
   4679 
   4680 			switch (alt19) {
   4681 				case 1 :
   4682 					// smaliParser.g:618:5: FLOAT_LITERAL_OR_ID
   4683 					{
   4684 					FLOAT_LITERAL_OR_ID107=(Token)match(input,FLOAT_LITERAL_OR_ID,FOLLOW_FLOAT_LITERAL_OR_ID_in_float_literal2426);
   4685 					stream_FLOAT_LITERAL_OR_ID.add(FLOAT_LITERAL_OR_ID107);
   4686 
   4687 					// AST REWRITE
   4688 					// elements:
   4689 					// token labels:
   4690 					// rule labels: retval
   4691 					// token list labels:
   4692 					// rule list labels:
   4693 					// wildcard labels:
   4694 					retval.tree = root_0;
   4695 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   4696 
   4697 					root_0 = (CommonTree)adaptor.nil();
   4698 					// 618:25: -> FLOAT_LITERAL[$FLOAT_LITERAL_OR_ID]
   4699 					{
   4700 						adaptor.addChild(root_0, (CommonTree)adaptor.create(FLOAT_LITERAL, FLOAT_LITERAL_OR_ID107));
   4701 					}
   4702 
   4703 
   4704 					retval.tree = root_0;
   4705 
   4706 					}
   4707 					break;
   4708 				case 2 :
   4709 					// smaliParser.g:619:5: FLOAT_LITERAL
   4710 					{
   4711 					root_0 = (CommonTree)adaptor.nil();
   4712 
   4713 
   4714 					FLOAT_LITERAL108=(Token)match(input,FLOAT_LITERAL,FOLLOW_FLOAT_LITERAL_in_float_literal2437);
   4715 					FLOAT_LITERAL108_tree = (CommonTree)adaptor.create(FLOAT_LITERAL108);
   4716 					adaptor.addChild(root_0, FLOAT_LITERAL108_tree);
   4717 
   4718 					}
   4719 					break;
   4720 
   4721 			}
   4722 			retval.stop = input.LT(-1);
   4723 
   4724 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   4725 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   4726 
   4727 		}
   4728 		catch (RecognitionException re) {
   4729 			reportError(re);
   4730 			recover(input,re);
   4731 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   4732 		}
   4733 		finally {
   4734 			// do for sure before leaving
   4735 		}
   4736 		return retval;
   4737 	}
   4738 	// $ANTLR end "float_literal"
   4739 
   4740 
   4741 	public static class double_literal_return extends ParserRuleReturnScope {
   4742 		CommonTree tree;
   4743 		@Override
   4744 		public CommonTree getTree() { return tree; }
   4745 	};
   4746 
   4747 
   4748 	// $ANTLR start "double_literal"
   4749 	// smaliParser.g:621:1: double_literal : ( DOUBLE_LITERAL_OR_ID -> DOUBLE_LITERAL[$DOUBLE_LITERAL_OR_ID] | DOUBLE_LITERAL );
   4750 	public final smaliParser.double_literal_return double_literal() throws RecognitionException {
   4751 		smaliParser.double_literal_return retval = new smaliParser.double_literal_return();
   4752 		retval.start = input.LT(1);
   4753 
   4754 		CommonTree root_0 = null;
   4755 
   4756 		Token DOUBLE_LITERAL_OR_ID109=null;
   4757 		Token DOUBLE_LITERAL110=null;
   4758 
   4759 		CommonTree DOUBLE_LITERAL_OR_ID109_tree=null;
   4760 		CommonTree DOUBLE_LITERAL110_tree=null;
   4761 		RewriteRuleTokenStream stream_DOUBLE_LITERAL_OR_ID=new RewriteRuleTokenStream(adaptor,"token DOUBLE_LITERAL_OR_ID");
   4762 
   4763 		try {
   4764 			// smaliParser.g:622:3: ( DOUBLE_LITERAL_OR_ID -> DOUBLE_LITERAL[$DOUBLE_LITERAL_OR_ID] | DOUBLE_LITERAL )
   4765 			int alt20=2;
   4766 			int LA20_0 = input.LA(1);
   4767 			if ( (LA20_0==DOUBLE_LITERAL_OR_ID) ) {
   4768 				alt20=1;
   4769 			}
   4770 			else if ( (LA20_0==DOUBLE_LITERAL) ) {
   4771 				alt20=2;
   4772 			}
   4773 
   4774 			else {
   4775 				NoViableAltException nvae =
   4776 					new NoViableAltException("", 20, 0, input);
   4777 				throw nvae;
   4778 			}
   4779 
   4780 			switch (alt20) {
   4781 				case 1 :
   4782 					// smaliParser.g:622:5: DOUBLE_LITERAL_OR_ID
   4783 					{
   4784 					DOUBLE_LITERAL_OR_ID109=(Token)match(input,DOUBLE_LITERAL_OR_ID,FOLLOW_DOUBLE_LITERAL_OR_ID_in_double_literal2447);
   4785 					stream_DOUBLE_LITERAL_OR_ID.add(DOUBLE_LITERAL_OR_ID109);
   4786 
   4787 					// AST REWRITE
   4788 					// elements:
   4789 					// token labels:
   4790 					// rule labels: retval
   4791 					// token list labels:
   4792 					// rule list labels:
   4793 					// wildcard labels:
   4794 					retval.tree = root_0;
   4795 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   4796 
   4797 					root_0 = (CommonTree)adaptor.nil();
   4798 					// 622:26: -> DOUBLE_LITERAL[$DOUBLE_LITERAL_OR_ID]
   4799 					{
   4800 						adaptor.addChild(root_0, (CommonTree)adaptor.create(DOUBLE_LITERAL, DOUBLE_LITERAL_OR_ID109));
   4801 					}
   4802 
   4803 
   4804 					retval.tree = root_0;
   4805 
   4806 					}
   4807 					break;
   4808 				case 2 :
   4809 					// smaliParser.g:623:5: DOUBLE_LITERAL
   4810 					{
   4811 					root_0 = (CommonTree)adaptor.nil();
   4812 
   4813 
   4814 					DOUBLE_LITERAL110=(Token)match(input,DOUBLE_LITERAL,FOLLOW_DOUBLE_LITERAL_in_double_literal2458);
   4815 					DOUBLE_LITERAL110_tree = (CommonTree)adaptor.create(DOUBLE_LITERAL110);
   4816 					adaptor.addChild(root_0, DOUBLE_LITERAL110_tree);
   4817 
   4818 					}
   4819 					break;
   4820 
   4821 			}
   4822 			retval.stop = input.LT(-1);
   4823 
   4824 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   4825 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   4826 
   4827 		}
   4828 		catch (RecognitionException re) {
   4829 			reportError(re);
   4830 			recover(input,re);
   4831 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   4832 		}
   4833 		finally {
   4834 			// do for sure before leaving
   4835 		}
   4836 		return retval;
   4837 	}
   4838 	// $ANTLR end "double_literal"
   4839 
   4840 
   4841 	public static class literal_return extends ParserRuleReturnScope {
   4842 		CommonTree tree;
   4843 		@Override
   4844 		public CommonTree getTree() { return tree; }
   4845 	};
   4846 
   4847 
   4848 	// $ANTLR start "literal"
   4849 	// smaliParser.g:625:1: literal : ( LONG_LITERAL | integer_literal | SHORT_LITERAL | BYTE_LITERAL | float_literal | double_literal | CHAR_LITERAL | STRING_LITERAL | BOOL_LITERAL | NULL_LITERAL | array_literal | subannotation | type_field_method_literal | enum_literal );
   4850 	public final smaliParser.literal_return literal() throws RecognitionException {
   4851 		smaliParser.literal_return retval = new smaliParser.literal_return();
   4852 		retval.start = input.LT(1);
   4853 
   4854 		CommonTree root_0 = null;
   4855 
   4856 		Token LONG_LITERAL111=null;
   4857 		Token SHORT_LITERAL113=null;
   4858 		Token BYTE_LITERAL114=null;
   4859 		Token CHAR_LITERAL117=null;
   4860 		Token STRING_LITERAL118=null;
   4861 		Token BOOL_LITERAL119=null;
   4862 		Token NULL_LITERAL120=null;
   4863 		ParserRuleReturnScope integer_literal112 =null;
   4864 		ParserRuleReturnScope float_literal115 =null;
   4865 		ParserRuleReturnScope double_literal116 =null;
   4866 		ParserRuleReturnScope array_literal121 =null;
   4867 		ParserRuleReturnScope subannotation122 =null;
   4868 		ParserRuleReturnScope type_field_method_literal123 =null;
   4869 		ParserRuleReturnScope enum_literal124 =null;
   4870 
   4871 		CommonTree LONG_LITERAL111_tree=null;
   4872 		CommonTree SHORT_LITERAL113_tree=null;
   4873 		CommonTree BYTE_LITERAL114_tree=null;
   4874 		CommonTree CHAR_LITERAL117_tree=null;
   4875 		CommonTree STRING_LITERAL118_tree=null;
   4876 		CommonTree BOOL_LITERAL119_tree=null;
   4877 		CommonTree NULL_LITERAL120_tree=null;
   4878 
   4879 		try {
   4880 			// smaliParser.g:626:3: ( LONG_LITERAL | integer_literal | SHORT_LITERAL | BYTE_LITERAL | float_literal | double_literal | CHAR_LITERAL | STRING_LITERAL | BOOL_LITERAL | NULL_LITERAL | array_literal | subannotation | type_field_method_literal | enum_literal )
   4881 			int alt21=14;
   4882 			switch ( input.LA(1) ) {
   4883 			case LONG_LITERAL:
   4884 				{
   4885 				alt21=1;
   4886 				}
   4887 				break;
   4888 			case POSITIVE_INTEGER_LITERAL:
   4889 				{
   4890 				int LA21_2 = input.LA(2);
   4891 				if ( (LA21_2==EOF||(LA21_2 >= ACCESS_SPEC && LA21_2 <= ANNOTATION_VISIBILITY)||LA21_2==BOOL_LITERAL||(LA21_2 >= CLASS_DIRECTIVE && LA21_2 <= CLOSE_BRACE)||LA21_2==COMMA||(LA21_2 >= DOUBLE_LITERAL_OR_ID && LA21_2 <= END_ANNOTATION_DIRECTIVE)||LA21_2==END_FIELD_DIRECTIVE||LA21_2==END_SUBANNOTATION_DIRECTIVE||LA21_2==FIELD_DIRECTIVE||(LA21_2 >= FLOAT_LITERAL_OR_ID && LA21_2 <= IMPLEMENTS_DIRECTIVE)||(LA21_2 >= INSTRUCTION_FORMAT10t && LA21_2 <= INSTRUCTION_FORMAT10x_ODEX)||LA21_2==INSTRUCTION_FORMAT11x||LA21_2==INSTRUCTION_FORMAT12x_OR_ID||(LA21_2 >= INSTRUCTION_FORMAT21c_FIELD && LA21_2 <= INSTRUCTION_FORMAT21c_TYPE)||LA21_2==INSTRUCTION_FORMAT21t||(LA21_2 >= INSTRUCTION_FORMAT22c_FIELD && LA21_2 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA21_2 >= INSTRUCTION_FORMAT22s_OR_ID && LA21_2 <= INSTRUCTION_FORMAT22t)||LA21_2==INSTRUCTION_FORMAT23x||(LA21_2 >= INSTRUCTION_FORMAT31i_OR_ID && LA21_2 <= INSTRUCTION_FORMAT31t)||(LA21_2 >= INSTRUCTION_FORMAT35c_METHOD && LA21_2 <= INSTRUCTION_FORMAT35ms_METHOD)||(LA21_2 >= INSTRUCTION_FORMAT45cc_METHOD && LA21_2 <= INSTRUCTION_FORMAT51l)||(LA21_2 >= METHOD_DIRECTIVE && LA21_2 <= NULL_LITERAL)||(LA21_2 >= PARAM_LIST_OR_ID_PRIMITIVE_TYPE && LA21_2 <= PRIMITIVE_TYPE)||LA21_2==REGISTER||(LA21_2 >= SIMPLE_NAME && LA21_2 <= SOURCE_DIRECTIVE)||(LA21_2 >= SUPER_DIRECTIVE && LA21_2 <= VOID_TYPE)) ) {
   4892 					alt21=2;
   4893 				}
   4894 				else if ( (LA21_2==COLON||LA21_2==OPEN_PAREN) ) {
   4895 					alt21=13;
   4896 				}
   4897 
   4898 				else {
   4899 					int nvaeMark = input.mark();
   4900 					try {
   4901 						input.consume();
   4902 						NoViableAltException nvae =
   4903 							new NoViableAltException("", 21, 2, input);
   4904 						throw nvae;
   4905 					} finally {
   4906 						input.rewind(nvaeMark);
   4907 					}
   4908 				}
   4909 
   4910 				}
   4911 				break;
   4912 			case NEGATIVE_INTEGER_LITERAL:
   4913 				{
   4914 				int LA21_3 = input.LA(2);
   4915 				if ( (LA21_3==EOF||(LA21_3 >= ACCESS_SPEC && LA21_3 <= ANNOTATION_VISIBILITY)||LA21_3==BOOL_LITERAL||(LA21_3 >= CLASS_DIRECTIVE && LA21_3 <= CLOSE_BRACE)||LA21_3==COMMA||(LA21_3 >= DOUBLE_LITERAL_OR_ID && LA21_3 <= END_ANNOTATION_DIRECTIVE)||LA21_3==END_FIELD_DIRECTIVE||LA21_3==END_SUBANNOTATION_DIRECTIVE||LA21_3==FIELD_DIRECTIVE||(LA21_3 >= FLOAT_LITERAL_OR_ID && LA21_3 <= IMPLEMENTS_DIRECTIVE)||(LA21_3 >= INSTRUCTION_FORMAT10t && LA21_3 <= INSTRUCTION_FORMAT10x_ODEX)||LA21_3==INSTRUCTION_FORMAT11x||LA21_3==INSTRUCTION_FORMAT12x_OR_ID||(LA21_3 >= INSTRUCTION_FORMAT21c_FIELD && LA21_3 <= INSTRUCTION_FORMAT21c_TYPE)||LA21_3==INSTRUCTION_FORMAT21t||(LA21_3 >= INSTRUCTION_FORMAT22c_FIELD && LA21_3 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA21_3 >= INSTRUCTION_FORMAT22s_OR_ID && LA21_3 <= INSTRUCTION_FORMAT22t)||LA21_3==INSTRUCTION_FORMAT23x||(LA21_3 >= INSTRUCTION_FORMAT31i_OR_ID && LA21_3 <= INSTRUCTION_FORMAT31t)||(LA21_3 >= INSTRUCTION_FORMAT35c_METHOD && LA21_3 <= INSTRUCTION_FORMAT35ms_METHOD)||(LA21_3 >= INSTRUCTION_FORMAT45cc_METHOD && LA21_3 <= INSTRUCTION_FORMAT51l)||(LA21_3 >= METHOD_DIRECTIVE && LA21_3 <= NULL_LITERAL)||(LA21_3 >= PARAM_LIST_OR_ID_PRIMITIVE_TYPE && LA21_3 <= PRIMITIVE_TYPE)||LA21_3==REGISTER||(LA21_3 >= SIMPLE_NAME && LA21_3 <= SOURCE_DIRECTIVE)||(LA21_3 >= SUPER_DIRECTIVE && LA21_3 <= VOID_TYPE)) ) {
   4916 					alt21=2;
   4917 				}
   4918 				else if ( (LA21_3==COLON||LA21_3==OPEN_PAREN) ) {
   4919 					alt21=13;
   4920 				}
   4921 
   4922 				else {
   4923 					int nvaeMark = input.mark();
   4924 					try {
   4925 						input.consume();
   4926 						NoViableAltException nvae =
   4927 							new NoViableAltException("", 21, 3, input);
   4928 						throw nvae;
   4929 					} finally {
   4930 						input.rewind(nvaeMark);
   4931 					}
   4932 				}
   4933 
   4934 				}
   4935 				break;
   4936 			case SHORT_LITERAL:
   4937 				{
   4938 				alt21=3;
   4939 				}
   4940 				break;
   4941 			case BYTE_LITERAL:
   4942 				{
   4943 				alt21=4;
   4944 				}
   4945 				break;
   4946 			case FLOAT_LITERAL_OR_ID:
   4947 				{
   4948 				int LA21_6 = input.LA(2);
   4949 				if ( (LA21_6==EOF||(LA21_6 >= ACCESS_SPEC && LA21_6 <= ANNOTATION_VISIBILITY)||LA21_6==BOOL_LITERAL||(LA21_6 >= CLASS_DIRECTIVE && LA21_6 <= CLOSE_BRACE)||LA21_6==COMMA||(LA21_6 >= DOUBLE_LITERAL_OR_ID && LA21_6 <= END_ANNOTATION_DIRECTIVE)||LA21_6==END_FIELD_DIRECTIVE||LA21_6==END_SUBANNOTATION_DIRECTIVE||LA21_6==FIELD_DIRECTIVE||(LA21_6 >= FLOAT_LITERAL_OR_ID && LA21_6 <= IMPLEMENTS_DIRECTIVE)||(LA21_6 >= INSTRUCTION_FORMAT10t && LA21_6 <= INSTRUCTION_FORMAT10x_ODEX)||LA21_6==INSTRUCTION_FORMAT11x||LA21_6==INSTRUCTION_FORMAT12x_OR_ID||(LA21_6 >= INSTRUCTION_FORMAT21c_FIELD && LA21_6 <= INSTRUCTION_FORMAT21c_TYPE)||LA21_6==INSTRUCTION_FORMAT21t||(LA21_6 >= INSTRUCTION_FORMAT22c_FIELD && LA21_6 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA21_6 >= INSTRUCTION_FORMAT22s_OR_ID && LA21_6 <= INSTRUCTION_FORMAT22t)||LA21_6==INSTRUCTION_FORMAT23x||(LA21_6 >= INSTRUCTION_FORMAT31i_OR_ID && LA21_6 <= INSTRUCTION_FORMAT31t)||(LA21_6 >= INSTRUCTION_FORMAT35c_METHOD && LA21_6 <= INSTRUCTION_FORMAT35ms_METHOD)||(LA21_6 >= INSTRUCTION_FORMAT45cc_METHOD && LA21_6 <= INSTRUCTION_FORMAT51l)||(LA21_6 >= METHOD_DIRECTIVE && LA21_6 <= NULL_LITERAL)||(LA21_6 >= PARAM_LIST_OR_ID_PRIMITIVE_TYPE && LA21_6 <= PRIMITIVE_TYPE)||LA21_6==REGISTER||(LA21_6 >= SIMPLE_NAME && LA21_6 <= SOURCE_DIRECTIVE)||(LA21_6 >= SUPER_DIRECTIVE && LA21_6 <= VOID_TYPE)) ) {
   4950 					alt21=5;
   4951 				}
   4952 				else if ( (LA21_6==COLON||LA21_6==OPEN_PAREN) ) {
   4953 					alt21=13;
   4954 				}
   4955 
   4956 				else {
   4957 					int nvaeMark = input.mark();
   4958 					try {
   4959 						input.consume();
   4960 						NoViableAltException nvae =
   4961 							new NoViableAltException("", 21, 6, input);
   4962 						throw nvae;
   4963 					} finally {
   4964 						input.rewind(nvaeMark);
   4965 					}
   4966 				}
   4967 
   4968 				}
   4969 				break;
   4970 			case FLOAT_LITERAL:
   4971 				{
   4972 				alt21=5;
   4973 				}
   4974 				break;
   4975 			case DOUBLE_LITERAL_OR_ID:
   4976 				{
   4977 				int LA21_8 = input.LA(2);
   4978 				if ( (LA21_8==EOF||(LA21_8 >= ACCESS_SPEC && LA21_8 <= ANNOTATION_VISIBILITY)||LA21_8==BOOL_LITERAL||(LA21_8 >= CLASS_DIRECTIVE && LA21_8 <= CLOSE_BRACE)||LA21_8==COMMA||(LA21_8 >= DOUBLE_LITERAL_OR_ID && LA21_8 <= END_ANNOTATION_DIRECTIVE)||LA21_8==END_FIELD_DIRECTIVE||LA21_8==END_SUBANNOTATION_DIRECTIVE||LA21_8==FIELD_DIRECTIVE||(LA21_8 >= FLOAT_LITERAL_OR_ID && LA21_8 <= IMPLEMENTS_DIRECTIVE)||(LA21_8 >= INSTRUCTION_FORMAT10t && LA21_8 <= INSTRUCTION_FORMAT10x_ODEX)||LA21_8==INSTRUCTION_FORMAT11x||LA21_8==INSTRUCTION_FORMAT12x_OR_ID||(LA21_8 >= INSTRUCTION_FORMAT21c_FIELD && LA21_8 <= INSTRUCTION_FORMAT21c_TYPE)||LA21_8==INSTRUCTION_FORMAT21t||(LA21_8 >= INSTRUCTION_FORMAT22c_FIELD && LA21_8 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA21_8 >= INSTRUCTION_FORMAT22s_OR_ID && LA21_8 <= INSTRUCTION_FORMAT22t)||LA21_8==INSTRUCTION_FORMAT23x||(LA21_8 >= INSTRUCTION_FORMAT31i_OR_ID && LA21_8 <= INSTRUCTION_FORMAT31t)||(LA21_8 >= INSTRUCTION_FORMAT35c_METHOD && LA21_8 <= INSTRUCTION_FORMAT35ms_METHOD)||(LA21_8 >= INSTRUCTION_FORMAT45cc_METHOD && LA21_8 <= INSTRUCTION_FORMAT51l)||(LA21_8 >= METHOD_DIRECTIVE && LA21_8 <= NULL_LITERAL)||(LA21_8 >= PARAM_LIST_OR_ID_PRIMITIVE_TYPE && LA21_8 <= PRIMITIVE_TYPE)||LA21_8==REGISTER||(LA21_8 >= SIMPLE_NAME && LA21_8 <= SOURCE_DIRECTIVE)||(LA21_8 >= SUPER_DIRECTIVE && LA21_8 <= VOID_TYPE)) ) {
   4979 					alt21=6;
   4980 				}
   4981 				else if ( (LA21_8==COLON||LA21_8==OPEN_PAREN) ) {
   4982 					alt21=13;
   4983 				}
   4984 
   4985 				else {
   4986 					int nvaeMark = input.mark();
   4987 					try {
   4988 						input.consume();
   4989 						NoViableAltException nvae =
   4990 							new NoViableAltException("", 21, 8, input);
   4991 						throw nvae;
   4992 					} finally {
   4993 						input.rewind(nvaeMark);
   4994 					}
   4995 				}
   4996 
   4997 				}
   4998 				break;
   4999 			case DOUBLE_LITERAL:
   5000 				{
   5001 				alt21=6;
   5002 				}
   5003 				break;
   5004 			case CHAR_LITERAL:
   5005 				{
   5006 				alt21=7;
   5007 				}
   5008 				break;
   5009 			case STRING_LITERAL:
   5010 				{
   5011 				alt21=8;
   5012 				}
   5013 				break;
   5014 			case BOOL_LITERAL:
   5015 				{
   5016 				int LA21_12 = input.LA(2);
   5017 				if ( (LA21_12==EOF||(LA21_12 >= ACCESS_SPEC && LA21_12 <= ANNOTATION_VISIBILITY)||LA21_12==BOOL_LITERAL||(LA21_12 >= CLASS_DIRECTIVE && LA21_12 <= CLOSE_BRACE)||LA21_12==COMMA||(LA21_12 >= DOUBLE_LITERAL_OR_ID && LA21_12 <= END_ANNOTATION_DIRECTIVE)||LA21_12==END_FIELD_DIRECTIVE||LA21_12==END_SUBANNOTATION_DIRECTIVE||LA21_12==FIELD_DIRECTIVE||(LA21_12 >= FLOAT_LITERAL_OR_ID && LA21_12 <= IMPLEMENTS_DIRECTIVE)||(LA21_12 >= INSTRUCTION_FORMAT10t && LA21_12 <= INSTRUCTION_FORMAT10x_ODEX)||LA21_12==INSTRUCTION_FORMAT11x||LA21_12==INSTRUCTION_FORMAT12x_OR_ID||(LA21_12 >= INSTRUCTION_FORMAT21c_FIELD && LA21_12 <= INSTRUCTION_FORMAT21c_TYPE)||LA21_12==INSTRUCTION_FORMAT21t||(LA21_12 >= INSTRUCTION_FORMAT22c_FIELD && LA21_12 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA21_12 >= INSTRUCTION_FORMAT22s_OR_ID && LA21_12 <= INSTRUCTION_FORMAT22t)||LA21_12==INSTRUCTION_FORMAT23x||(LA21_12 >= INSTRUCTION_FORMAT31i_OR_ID && LA21_12 <= INSTRUCTION_FORMAT31t)||(LA21_12 >= INSTRUCTION_FORMAT35c_METHOD && LA21_12 <= INSTRUCTION_FORMAT35ms_METHOD)||(LA21_12 >= INSTRUCTION_FORMAT45cc_METHOD && LA21_12 <= INSTRUCTION_FORMAT51l)||(LA21_12 >= METHOD_DIRECTIVE && LA21_12 <= NULL_LITERAL)||(LA21_12 >= PARAM_LIST_OR_ID_PRIMITIVE_TYPE && LA21_12 <= PRIMITIVE_TYPE)||LA21_12==REGISTER||(LA21_12 >= SIMPLE_NAME && LA21_12 <= SOURCE_DIRECTIVE)||(LA21_12 >= SUPER_DIRECTIVE && LA21_12 <= VOID_TYPE)) ) {
   5018 					alt21=9;
   5019 				}
   5020 				else if ( (LA21_12==COLON||LA21_12==OPEN_PAREN) ) {
   5021 					alt21=13;
   5022 				}
   5023 
   5024 				else {
   5025 					int nvaeMark = input.mark();
   5026 					try {
   5027 						input.consume();
   5028 						NoViableAltException nvae =
   5029 							new NoViableAltException("", 21, 12, input);
   5030 						throw nvae;
   5031 					} finally {
   5032 						input.rewind(nvaeMark);
   5033 					}
   5034 				}
   5035 
   5036 				}
   5037 				break;
   5038 			case NULL_LITERAL:
   5039 				{
   5040 				int LA21_13 = input.LA(2);
   5041 				if ( (LA21_13==EOF||(LA21_13 >= ACCESS_SPEC && LA21_13 <= ANNOTATION_VISIBILITY)||LA21_13==BOOL_LITERAL||(LA21_13 >= CLASS_DIRECTIVE && LA21_13 <= CLOSE_BRACE)||LA21_13==COMMA||(LA21_13 >= DOUBLE_LITERAL_OR_ID && LA21_13 <= END_ANNOTATION_DIRECTIVE)||LA21_13==END_FIELD_DIRECTIVE||LA21_13==END_SUBANNOTATION_DIRECTIVE||LA21_13==FIELD_DIRECTIVE||(LA21_13 >= FLOAT_LITERAL_OR_ID && LA21_13 <= IMPLEMENTS_DIRECTIVE)||(LA21_13 >= INSTRUCTION_FORMAT10t && LA21_13 <= INSTRUCTION_FORMAT10x_ODEX)||LA21_13==INSTRUCTION_FORMAT11x||LA21_13==INSTRUCTION_FORMAT12x_OR_ID||(LA21_13 >= INSTRUCTION_FORMAT21c_FIELD && LA21_13 <= INSTRUCTION_FORMAT21c_TYPE)||LA21_13==INSTRUCTION_FORMAT21t||(LA21_13 >= INSTRUCTION_FORMAT22c_FIELD && LA21_13 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA21_13 >= INSTRUCTION_FORMAT22s_OR_ID && LA21_13 <= INSTRUCTION_FORMAT22t)||LA21_13==INSTRUCTION_FORMAT23x||(LA21_13 >= INSTRUCTION_FORMAT31i_OR_ID && LA21_13 <= INSTRUCTION_FORMAT31t)||(LA21_13 >= INSTRUCTION_FORMAT35c_METHOD && LA21_13 <= INSTRUCTION_FORMAT35ms_METHOD)||(LA21_13 >= INSTRUCTION_FORMAT45cc_METHOD && LA21_13 <= INSTRUCTION_FORMAT51l)||(LA21_13 >= METHOD_DIRECTIVE && LA21_13 <= NULL_LITERAL)||(LA21_13 >= PARAM_LIST_OR_ID_PRIMITIVE_TYPE && LA21_13 <= PRIMITIVE_TYPE)||LA21_13==REGISTER||(LA21_13 >= SIMPLE_NAME && LA21_13 <= SOURCE_DIRECTIVE)||(LA21_13 >= SUPER_DIRECTIVE && LA21_13 <= VOID_TYPE)) ) {
   5042 					alt21=10;
   5043 				}
   5044 				else if ( (LA21_13==COLON||LA21_13==OPEN_PAREN) ) {
   5045 					alt21=13;
   5046 				}
   5047 
   5048 				else {
   5049 					int nvaeMark = input.mark();
   5050 					try {
   5051 						input.consume();
   5052 						NoViableAltException nvae =
   5053 							new NoViableAltException("", 21, 13, input);
   5054 						throw nvae;
   5055 					} finally {
   5056 						input.rewind(nvaeMark);
   5057 					}
   5058 				}
   5059 
   5060 				}
   5061 				break;
   5062 			case OPEN_BRACE:
   5063 				{
   5064 				alt21=11;
   5065 				}
   5066 				break;
   5067 			case SUBANNOTATION_DIRECTIVE:
   5068 				{
   5069 				alt21=12;
   5070 				}
   5071 				break;
   5072 			case ACCESS_SPEC:
   5073 			case ANNOTATION_VISIBILITY:
   5074 			case ARRAY_TYPE_PREFIX:
   5075 			case CLASS_DESCRIPTOR:
   5076 			case INSTRUCTION_FORMAT10t:
   5077 			case INSTRUCTION_FORMAT10x:
   5078 			case INSTRUCTION_FORMAT10x_ODEX:
   5079 			case INSTRUCTION_FORMAT11x:
   5080 			case INSTRUCTION_FORMAT12x_OR_ID:
   5081 			case INSTRUCTION_FORMAT21c_FIELD:
   5082 			case INSTRUCTION_FORMAT21c_FIELD_ODEX:
   5083 			case INSTRUCTION_FORMAT21c_STRING:
   5084 			case INSTRUCTION_FORMAT21c_TYPE:
   5085 			case INSTRUCTION_FORMAT21t:
   5086 			case INSTRUCTION_FORMAT22c_FIELD:
   5087 			case INSTRUCTION_FORMAT22c_FIELD_ODEX:
   5088 			case INSTRUCTION_FORMAT22c_TYPE:
   5089 			case INSTRUCTION_FORMAT22cs_FIELD:
   5090 			case INSTRUCTION_FORMAT22s_OR_ID:
   5091 			case INSTRUCTION_FORMAT22t:
   5092 			case INSTRUCTION_FORMAT23x:
   5093 			case INSTRUCTION_FORMAT31i_OR_ID:
   5094 			case INSTRUCTION_FORMAT31t:
   5095 			case INSTRUCTION_FORMAT35c_METHOD:
   5096 			case INSTRUCTION_FORMAT35c_METHOD_ODEX:
   5097 			case INSTRUCTION_FORMAT35c_TYPE:
   5098 			case INSTRUCTION_FORMAT35mi_METHOD:
   5099 			case INSTRUCTION_FORMAT35ms_METHOD:
   5100 			case INSTRUCTION_FORMAT45cc_METHOD:
   5101 			case INSTRUCTION_FORMAT4rcc_METHOD:
   5102 			case INSTRUCTION_FORMAT51l:
   5103 			case MEMBER_NAME:
   5104 			case PARAM_LIST_OR_ID_PRIMITIVE_TYPE:
   5105 			case PRIMITIVE_TYPE:
   5106 			case REGISTER:
   5107 			case SIMPLE_NAME:
   5108 			case VERIFICATION_ERROR_TYPE:
   5109 			case VOID_TYPE:
   5110 				{
   5111 				alt21=13;
   5112 				}
   5113 				break;
   5114 			case ENUM_DIRECTIVE:
   5115 				{
   5116 				alt21=14;
   5117 				}
   5118 				break;
   5119 			default:
   5120 				NoViableAltException nvae =
   5121 					new NoViableAltException("", 21, 0, input);
   5122 				throw nvae;
   5123 			}
   5124 			switch (alt21) {
   5125 				case 1 :
   5126 					// smaliParser.g:626:5: LONG_LITERAL
   5127 					{
   5128 					root_0 = (CommonTree)adaptor.nil();
   5129 
   5130 
   5131 					LONG_LITERAL111=(Token)match(input,LONG_LITERAL,FOLLOW_LONG_LITERAL_in_literal2468);
   5132 					LONG_LITERAL111_tree = (CommonTree)adaptor.create(LONG_LITERAL111);
   5133 					adaptor.addChild(root_0, LONG_LITERAL111_tree);
   5134 
   5135 					}
   5136 					break;
   5137 				case 2 :
   5138 					// smaliParser.g:627:5: integer_literal
   5139 					{
   5140 					root_0 = (CommonTree)adaptor.nil();
   5141 
   5142 
   5143 					pushFollow(FOLLOW_integer_literal_in_literal2474);
   5144 					integer_literal112=integer_literal();
   5145 					state._fsp--;
   5146 
   5147 					adaptor.addChild(root_0, integer_literal112.getTree());
   5148 
   5149 					}
   5150 					break;
   5151 				case 3 :
   5152 					// smaliParser.g:628:5: SHORT_LITERAL
   5153 					{
   5154 					root_0 = (CommonTree)adaptor.nil();
   5155 
   5156 
   5157 					SHORT_LITERAL113=(Token)match(input,SHORT_LITERAL,FOLLOW_SHORT_LITERAL_in_literal2480);
   5158 					SHORT_LITERAL113_tree = (CommonTree)adaptor.create(SHORT_LITERAL113);
   5159 					adaptor.addChild(root_0, SHORT_LITERAL113_tree);
   5160 
   5161 					}
   5162 					break;
   5163 				case 4 :
   5164 					// smaliParser.g:629:5: BYTE_LITERAL
   5165 					{
   5166 					root_0 = (CommonTree)adaptor.nil();
   5167 
   5168 
   5169 					BYTE_LITERAL114=(Token)match(input,BYTE_LITERAL,FOLLOW_BYTE_LITERAL_in_literal2486);
   5170 					BYTE_LITERAL114_tree = (CommonTree)adaptor.create(BYTE_LITERAL114);
   5171 					adaptor.addChild(root_0, BYTE_LITERAL114_tree);
   5172 
   5173 					}
   5174 					break;
   5175 				case 5 :
   5176 					// smaliParser.g:630:5: float_literal
   5177 					{
   5178 					root_0 = (CommonTree)adaptor.nil();
   5179 
   5180 
   5181 					pushFollow(FOLLOW_float_literal_in_literal2492);
   5182 					float_literal115=float_literal();
   5183 					state._fsp--;
   5184 
   5185 					adaptor.addChild(root_0, float_literal115.getTree());
   5186 
   5187 					}
   5188 					break;
   5189 				case 6 :
   5190 					// smaliParser.g:631:5: double_literal
   5191 					{
   5192 					root_0 = (CommonTree)adaptor.nil();
   5193 
   5194 
   5195 					pushFollow(FOLLOW_double_literal_in_literal2498);
   5196 					double_literal116=double_literal();
   5197 					state._fsp--;
   5198 
   5199 					adaptor.addChild(root_0, double_literal116.getTree());
   5200 
   5201 					}
   5202 					break;
   5203 				case 7 :
   5204 					// smaliParser.g:632:5: CHAR_LITERAL
   5205 					{
   5206 					root_0 = (CommonTree)adaptor.nil();
   5207 
   5208 
   5209 					CHAR_LITERAL117=(Token)match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_literal2504);
   5210 					CHAR_LITERAL117_tree = (CommonTree)adaptor.create(CHAR_LITERAL117);
   5211 					adaptor.addChild(root_0, CHAR_LITERAL117_tree);
   5212 
   5213 					}
   5214 					break;
   5215 				case 8 :
   5216 					// smaliParser.g:633:5: STRING_LITERAL
   5217 					{
   5218 					root_0 = (CommonTree)adaptor.nil();
   5219 
   5220 
   5221 					STRING_LITERAL118=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_literal2510);
   5222 					STRING_LITERAL118_tree = (CommonTree)adaptor.create(STRING_LITERAL118);
   5223 					adaptor.addChild(root_0, STRING_LITERAL118_tree);
   5224 
   5225 					}
   5226 					break;
   5227 				case 9 :
   5228 					// smaliParser.g:634:5: BOOL_LITERAL
   5229 					{
   5230 					root_0 = (CommonTree)adaptor.nil();
   5231 
   5232 
   5233 					BOOL_LITERAL119=(Token)match(input,BOOL_LITERAL,FOLLOW_BOOL_LITERAL_in_literal2516);
   5234 					BOOL_LITERAL119_tree = (CommonTree)adaptor.create(BOOL_LITERAL119);
   5235 					adaptor.addChild(root_0, BOOL_LITERAL119_tree);
   5236 
   5237 					}
   5238 					break;
   5239 				case 10 :
   5240 					// smaliParser.g:635:5: NULL_LITERAL
   5241 					{
   5242 					root_0 = (CommonTree)adaptor.nil();
   5243 
   5244 
   5245 					NULL_LITERAL120=(Token)match(input,NULL_LITERAL,FOLLOW_NULL_LITERAL_in_literal2522);
   5246 					NULL_LITERAL120_tree = (CommonTree)adaptor.create(NULL_LITERAL120);
   5247 					adaptor.addChild(root_0, NULL_LITERAL120_tree);
   5248 
   5249 					}
   5250 					break;
   5251 				case 11 :
   5252 					// smaliParser.g:636:5: array_literal
   5253 					{
   5254 					root_0 = (CommonTree)adaptor.nil();
   5255 
   5256 
   5257 					pushFollow(FOLLOW_array_literal_in_literal2528);
   5258 					array_literal121=array_literal();
   5259 					state._fsp--;
   5260 
   5261 					adaptor.addChild(root_0, array_literal121.getTree());
   5262 
   5263 					}
   5264 					break;
   5265 				case 12 :
   5266 					// smaliParser.g:637:5: subannotation
   5267 					{
   5268 					root_0 = (CommonTree)adaptor.nil();
   5269 
   5270 
   5271 					pushFollow(FOLLOW_subannotation_in_literal2534);
   5272 					subannotation122=subannotation();
   5273 					state._fsp--;
   5274 
   5275 					adaptor.addChild(root_0, subannotation122.getTree());
   5276 
   5277 					}
   5278 					break;
   5279 				case 13 :
   5280 					// smaliParser.g:638:5: type_field_method_literal
   5281 					{
   5282 					root_0 = (CommonTree)adaptor.nil();
   5283 
   5284 
   5285 					pushFollow(FOLLOW_type_field_method_literal_in_literal2540);
   5286 					type_field_method_literal123=type_field_method_literal();
   5287 					state._fsp--;
   5288 
   5289 					adaptor.addChild(root_0, type_field_method_literal123.getTree());
   5290 
   5291 					}
   5292 					break;
   5293 				case 14 :
   5294 					// smaliParser.g:639:5: enum_literal
   5295 					{
   5296 					root_0 = (CommonTree)adaptor.nil();
   5297 
   5298 
   5299 					pushFollow(FOLLOW_enum_literal_in_literal2546);
   5300 					enum_literal124=enum_literal();
   5301 					state._fsp--;
   5302 
   5303 					adaptor.addChild(root_0, enum_literal124.getTree());
   5304 
   5305 					}
   5306 					break;
   5307 
   5308 			}
   5309 			retval.stop = input.LT(-1);
   5310 
   5311 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   5312 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   5313 
   5314 		}
   5315 		catch (RecognitionException re) {
   5316 			reportError(re);
   5317 			recover(input,re);
   5318 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   5319 		}
   5320 		finally {
   5321 			// do for sure before leaving
   5322 		}
   5323 		return retval;
   5324 	}
   5325 	// $ANTLR end "literal"
   5326 
   5327 
   5328 	public static class parsed_integer_literal_return extends ParserRuleReturnScope {
   5329 		public int value;
   5330 		CommonTree tree;
   5331 		@Override
   5332 		public CommonTree getTree() { return tree; }
   5333 	};
   5334 
   5335 
   5336 	// $ANTLR start "parsed_integer_literal"
   5337 	// smaliParser.g:641:1: parsed_integer_literal returns [int value] : integer_literal ;
   5338 	public final smaliParser.parsed_integer_literal_return parsed_integer_literal() throws RecognitionException {
   5339 		smaliParser.parsed_integer_literal_return retval = new smaliParser.parsed_integer_literal_return();
   5340 		retval.start = input.LT(1);
   5341 
   5342 		CommonTree root_0 = null;
   5343 
   5344 		ParserRuleReturnScope integer_literal125 =null;
   5345 
   5346 
   5347 		try {
   5348 			// smaliParser.g:642:3: ( integer_literal )
   5349 			// smaliParser.g:642:5: integer_literal
   5350 			{
   5351 			root_0 = (CommonTree)adaptor.nil();
   5352 
   5353 
   5354 			pushFollow(FOLLOW_integer_literal_in_parsed_integer_literal2559);
   5355 			integer_literal125=integer_literal();
   5356 			state._fsp--;
   5357 
   5358 			adaptor.addChild(root_0, integer_literal125.getTree());
   5359 
   5360 			 retval.value = LiteralTools.parseInt((integer_literal125!=null?input.toString(integer_literal125.start,integer_literal125.stop):null));
   5361 			}
   5362 
   5363 			retval.stop = input.LT(-1);
   5364 
   5365 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   5366 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   5367 
   5368 		}
   5369 		catch (RecognitionException re) {
   5370 			reportError(re);
   5371 			recover(input,re);
   5372 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   5373 		}
   5374 		finally {
   5375 			// do for sure before leaving
   5376 		}
   5377 		return retval;
   5378 	}
   5379 	// $ANTLR end "parsed_integer_literal"
   5380 
   5381 
   5382 	public static class integral_literal_return extends ParserRuleReturnScope {
   5383 		CommonTree tree;
   5384 		@Override
   5385 		public CommonTree getTree() { return tree; }
   5386 	};
   5387 
   5388 
   5389 	// $ANTLR start "integral_literal"
   5390 	// smaliParser.g:644:1: integral_literal : ( LONG_LITERAL | integer_literal | SHORT_LITERAL | CHAR_LITERAL | BYTE_LITERAL );
   5391 	public final smaliParser.integral_literal_return integral_literal() throws RecognitionException {
   5392 		smaliParser.integral_literal_return retval = new smaliParser.integral_literal_return();
   5393 		retval.start = input.LT(1);
   5394 
   5395 		CommonTree root_0 = null;
   5396 
   5397 		Token LONG_LITERAL126=null;
   5398 		Token SHORT_LITERAL128=null;
   5399 		Token CHAR_LITERAL129=null;
   5400 		Token BYTE_LITERAL130=null;
   5401 		ParserRuleReturnScope integer_literal127 =null;
   5402 
   5403 		CommonTree LONG_LITERAL126_tree=null;
   5404 		CommonTree SHORT_LITERAL128_tree=null;
   5405 		CommonTree CHAR_LITERAL129_tree=null;
   5406 		CommonTree BYTE_LITERAL130_tree=null;
   5407 
   5408 		try {
   5409 			// smaliParser.g:645:3: ( LONG_LITERAL | integer_literal | SHORT_LITERAL | CHAR_LITERAL | BYTE_LITERAL )
   5410 			int alt22=5;
   5411 			switch ( input.LA(1) ) {
   5412 			case LONG_LITERAL:
   5413 				{
   5414 				alt22=1;
   5415 				}
   5416 				break;
   5417 			case NEGATIVE_INTEGER_LITERAL:
   5418 			case POSITIVE_INTEGER_LITERAL:
   5419 				{
   5420 				alt22=2;
   5421 				}
   5422 				break;
   5423 			case SHORT_LITERAL:
   5424 				{
   5425 				alt22=3;
   5426 				}
   5427 				break;
   5428 			case CHAR_LITERAL:
   5429 				{
   5430 				alt22=4;
   5431 				}
   5432 				break;
   5433 			case BYTE_LITERAL:
   5434 				{
   5435 				alt22=5;
   5436 				}
   5437 				break;
   5438 			default:
   5439 				NoViableAltException nvae =
   5440 					new NoViableAltException("", 22, 0, input);
   5441 				throw nvae;
   5442 			}
   5443 			switch (alt22) {
   5444 				case 1 :
   5445 					// smaliParser.g:645:5: LONG_LITERAL
   5446 					{
   5447 					root_0 = (CommonTree)adaptor.nil();
   5448 
   5449 
   5450 					LONG_LITERAL126=(Token)match(input,LONG_LITERAL,FOLLOW_LONG_LITERAL_in_integral_literal2571);
   5451 					LONG_LITERAL126_tree = (CommonTree)adaptor.create(LONG_LITERAL126);
   5452 					adaptor.addChild(root_0, LONG_LITERAL126_tree);
   5453 
   5454 					}
   5455 					break;
   5456 				case 2 :
   5457 					// smaliParser.g:646:5: integer_literal
   5458 					{
   5459 					root_0 = (CommonTree)adaptor.nil();
   5460 
   5461 
   5462 					pushFollow(FOLLOW_integer_literal_in_integral_literal2577);
   5463 					integer_literal127=integer_literal();
   5464 					state._fsp--;
   5465 
   5466 					adaptor.addChild(root_0, integer_literal127.getTree());
   5467 
   5468 					}
   5469 					break;
   5470 				case 3 :
   5471 					// smaliParser.g:647:5: SHORT_LITERAL
   5472 					{
   5473 					root_0 = (CommonTree)adaptor.nil();
   5474 
   5475 
   5476 					SHORT_LITERAL128=(Token)match(input,SHORT_LITERAL,FOLLOW_SHORT_LITERAL_in_integral_literal2583);
   5477 					SHORT_LITERAL128_tree = (CommonTree)adaptor.create(SHORT_LITERAL128);
   5478 					adaptor.addChild(root_0, SHORT_LITERAL128_tree);
   5479 
   5480 					}
   5481 					break;
   5482 				case 4 :
   5483 					// smaliParser.g:648:5: CHAR_LITERAL
   5484 					{
   5485 					root_0 = (CommonTree)adaptor.nil();
   5486 
   5487 
   5488 					CHAR_LITERAL129=(Token)match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_integral_literal2589);
   5489 					CHAR_LITERAL129_tree = (CommonTree)adaptor.create(CHAR_LITERAL129);
   5490 					adaptor.addChild(root_0, CHAR_LITERAL129_tree);
   5491 
   5492 					}
   5493 					break;
   5494 				case 5 :
   5495 					// smaliParser.g:649:5: BYTE_LITERAL
   5496 					{
   5497 					root_0 = (CommonTree)adaptor.nil();
   5498 
   5499 
   5500 					BYTE_LITERAL130=(Token)match(input,BYTE_LITERAL,FOLLOW_BYTE_LITERAL_in_integral_literal2595);
   5501 					BYTE_LITERAL130_tree = (CommonTree)adaptor.create(BYTE_LITERAL130);
   5502 					adaptor.addChild(root_0, BYTE_LITERAL130_tree);
   5503 
   5504 					}
   5505 					break;
   5506 
   5507 			}
   5508 			retval.stop = input.LT(-1);
   5509 
   5510 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   5511 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   5512 
   5513 		}
   5514 		catch (RecognitionException re) {
   5515 			reportError(re);
   5516 			recover(input,re);
   5517 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   5518 		}
   5519 		finally {
   5520 			// do for sure before leaving
   5521 		}
   5522 		return retval;
   5523 	}
   5524 	// $ANTLR end "integral_literal"
   5525 
   5526 
   5527 	public static class fixed_32bit_literal_return extends ParserRuleReturnScope {
   5528 		CommonTree tree;
   5529 		@Override
   5530 		public CommonTree getTree() { return tree; }
   5531 	};
   5532 
   5533 
   5534 	// $ANTLR start "fixed_32bit_literal"
   5535 	// smaliParser.g:651:1: fixed_32bit_literal : ( LONG_LITERAL | integer_literal | SHORT_LITERAL | BYTE_LITERAL | float_literal | CHAR_LITERAL | BOOL_LITERAL );
   5536 	public final smaliParser.fixed_32bit_literal_return fixed_32bit_literal() throws RecognitionException {
   5537 		smaliParser.fixed_32bit_literal_return retval = new smaliParser.fixed_32bit_literal_return();
   5538 		retval.start = input.LT(1);
   5539 
   5540 		CommonTree root_0 = null;
   5541 
   5542 		Token LONG_LITERAL131=null;
   5543 		Token SHORT_LITERAL133=null;
   5544 		Token BYTE_LITERAL134=null;
   5545 		Token CHAR_LITERAL136=null;
   5546 		Token BOOL_LITERAL137=null;
   5547 		ParserRuleReturnScope integer_literal132 =null;
   5548 		ParserRuleReturnScope float_literal135 =null;
   5549 
   5550 		CommonTree LONG_LITERAL131_tree=null;
   5551 		CommonTree SHORT_LITERAL133_tree=null;
   5552 		CommonTree BYTE_LITERAL134_tree=null;
   5553 		CommonTree CHAR_LITERAL136_tree=null;
   5554 		CommonTree BOOL_LITERAL137_tree=null;
   5555 
   5556 		try {
   5557 			// smaliParser.g:652:3: ( LONG_LITERAL | integer_literal | SHORT_LITERAL | BYTE_LITERAL | float_literal | CHAR_LITERAL | BOOL_LITERAL )
   5558 			int alt23=7;
   5559 			switch ( input.LA(1) ) {
   5560 			case LONG_LITERAL:
   5561 				{
   5562 				alt23=1;
   5563 				}
   5564 				break;
   5565 			case NEGATIVE_INTEGER_LITERAL:
   5566 			case POSITIVE_INTEGER_LITERAL:
   5567 				{
   5568 				alt23=2;
   5569 				}
   5570 				break;
   5571 			case SHORT_LITERAL:
   5572 				{
   5573 				alt23=3;
   5574 				}
   5575 				break;
   5576 			case BYTE_LITERAL:
   5577 				{
   5578 				alt23=4;
   5579 				}
   5580 				break;
   5581 			case FLOAT_LITERAL:
   5582 			case FLOAT_LITERAL_OR_ID:
   5583 				{
   5584 				alt23=5;
   5585 				}
   5586 				break;
   5587 			case CHAR_LITERAL:
   5588 				{
   5589 				alt23=6;
   5590 				}
   5591 				break;
   5592 			case BOOL_LITERAL:
   5593 				{
   5594 				alt23=7;
   5595 				}
   5596 				break;
   5597 			default:
   5598 				NoViableAltException nvae =
   5599 					new NoViableAltException("", 23, 0, input);
   5600 				throw nvae;
   5601 			}
   5602 			switch (alt23) {
   5603 				case 1 :
   5604 					// smaliParser.g:652:5: LONG_LITERAL
   5605 					{
   5606 					root_0 = (CommonTree)adaptor.nil();
   5607 
   5608 
   5609 					LONG_LITERAL131=(Token)match(input,LONG_LITERAL,FOLLOW_LONG_LITERAL_in_fixed_32bit_literal2605);
   5610 					LONG_LITERAL131_tree = (CommonTree)adaptor.create(LONG_LITERAL131);
   5611 					adaptor.addChild(root_0, LONG_LITERAL131_tree);
   5612 
   5613 					}
   5614 					break;
   5615 				case 2 :
   5616 					// smaliParser.g:653:5: integer_literal
   5617 					{
   5618 					root_0 = (CommonTree)adaptor.nil();
   5619 
   5620 
   5621 					pushFollow(FOLLOW_integer_literal_in_fixed_32bit_literal2611);
   5622 					integer_literal132=integer_literal();
   5623 					state._fsp--;
   5624 
   5625 					adaptor.addChild(root_0, integer_literal132.getTree());
   5626 
   5627 					}
   5628 					break;
   5629 				case 3 :
   5630 					// smaliParser.g:654:5: SHORT_LITERAL
   5631 					{
   5632 					root_0 = (CommonTree)adaptor.nil();
   5633 
   5634 
   5635 					SHORT_LITERAL133=(Token)match(input,SHORT_LITERAL,FOLLOW_SHORT_LITERAL_in_fixed_32bit_literal2617);
   5636 					SHORT_LITERAL133_tree = (CommonTree)adaptor.create(SHORT_LITERAL133);
   5637 					adaptor.addChild(root_0, SHORT_LITERAL133_tree);
   5638 
   5639 					}
   5640 					break;
   5641 				case 4 :
   5642 					// smaliParser.g:655:5: BYTE_LITERAL
   5643 					{
   5644 					root_0 = (CommonTree)adaptor.nil();
   5645 
   5646 
   5647 					BYTE_LITERAL134=(Token)match(input,BYTE_LITERAL,FOLLOW_BYTE_LITERAL_in_fixed_32bit_literal2623);
   5648 					BYTE_LITERAL134_tree = (CommonTree)adaptor.create(BYTE_LITERAL134);
   5649 					adaptor.addChild(root_0, BYTE_LITERAL134_tree);
   5650 
   5651 					}
   5652 					break;
   5653 				case 5 :
   5654 					// smaliParser.g:656:5: float_literal
   5655 					{
   5656 					root_0 = (CommonTree)adaptor.nil();
   5657 
   5658 
   5659 					pushFollow(FOLLOW_float_literal_in_fixed_32bit_literal2629);
   5660 					float_literal135=float_literal();
   5661 					state._fsp--;
   5662 
   5663 					adaptor.addChild(root_0, float_literal135.getTree());
   5664 
   5665 					}
   5666 					break;
   5667 				case 6 :
   5668 					// smaliParser.g:657:5: CHAR_LITERAL
   5669 					{
   5670 					root_0 = (CommonTree)adaptor.nil();
   5671 
   5672 
   5673 					CHAR_LITERAL136=(Token)match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_fixed_32bit_literal2635);
   5674 					CHAR_LITERAL136_tree = (CommonTree)adaptor.create(CHAR_LITERAL136);
   5675 					adaptor.addChild(root_0, CHAR_LITERAL136_tree);
   5676 
   5677 					}
   5678 					break;
   5679 				case 7 :
   5680 					// smaliParser.g:658:5: BOOL_LITERAL
   5681 					{
   5682 					root_0 = (CommonTree)adaptor.nil();
   5683 
   5684 
   5685 					BOOL_LITERAL137=(Token)match(input,BOOL_LITERAL,FOLLOW_BOOL_LITERAL_in_fixed_32bit_literal2641);
   5686 					BOOL_LITERAL137_tree = (CommonTree)adaptor.create(BOOL_LITERAL137);
   5687 					adaptor.addChild(root_0, BOOL_LITERAL137_tree);
   5688 
   5689 					}
   5690 					break;
   5691 
   5692 			}
   5693 			retval.stop = input.LT(-1);
   5694 
   5695 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   5696 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   5697 
   5698 		}
   5699 		catch (RecognitionException re) {
   5700 			reportError(re);
   5701 			recover(input,re);
   5702 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   5703 		}
   5704 		finally {
   5705 			// do for sure before leaving
   5706 		}
   5707 		return retval;
   5708 	}
   5709 	// $ANTLR end "fixed_32bit_literal"
   5710 
   5711 
   5712 	public static class fixed_literal_return extends ParserRuleReturnScope {
   5713 		CommonTree tree;
   5714 		@Override
   5715 		public CommonTree getTree() { return tree; }
   5716 	};
   5717 
   5718 
   5719 	// $ANTLR start "fixed_literal"
   5720 	// smaliParser.g:660:1: fixed_literal : ( integer_literal | LONG_LITERAL | SHORT_LITERAL | BYTE_LITERAL | float_literal | double_literal | CHAR_LITERAL | BOOL_LITERAL );
   5721 	public final smaliParser.fixed_literal_return fixed_literal() throws RecognitionException {
   5722 		smaliParser.fixed_literal_return retval = new smaliParser.fixed_literal_return();
   5723 		retval.start = input.LT(1);
   5724 
   5725 		CommonTree root_0 = null;
   5726 
   5727 		Token LONG_LITERAL139=null;
   5728 		Token SHORT_LITERAL140=null;
   5729 		Token BYTE_LITERAL141=null;
   5730 		Token CHAR_LITERAL144=null;
   5731 		Token BOOL_LITERAL145=null;
   5732 		ParserRuleReturnScope integer_literal138 =null;
   5733 		ParserRuleReturnScope float_literal142 =null;
   5734 		ParserRuleReturnScope double_literal143 =null;
   5735 
   5736 		CommonTree LONG_LITERAL139_tree=null;
   5737 		CommonTree SHORT_LITERAL140_tree=null;
   5738 		CommonTree BYTE_LITERAL141_tree=null;
   5739 		CommonTree CHAR_LITERAL144_tree=null;
   5740 		CommonTree BOOL_LITERAL145_tree=null;
   5741 
   5742 		try {
   5743 			// smaliParser.g:661:3: ( integer_literal | LONG_LITERAL | SHORT_LITERAL | BYTE_LITERAL | float_literal | double_literal | CHAR_LITERAL | BOOL_LITERAL )
   5744 			int alt24=8;
   5745 			switch ( input.LA(1) ) {
   5746 			case NEGATIVE_INTEGER_LITERAL:
   5747 			case POSITIVE_INTEGER_LITERAL:
   5748 				{
   5749 				alt24=1;
   5750 				}
   5751 				break;
   5752 			case LONG_LITERAL:
   5753 				{
   5754 				alt24=2;
   5755 				}
   5756 				break;
   5757 			case SHORT_LITERAL:
   5758 				{
   5759 				alt24=3;
   5760 				}
   5761 				break;
   5762 			case BYTE_LITERAL:
   5763 				{
   5764 				alt24=4;
   5765 				}
   5766 				break;
   5767 			case FLOAT_LITERAL:
   5768 			case FLOAT_LITERAL_OR_ID:
   5769 				{
   5770 				alt24=5;
   5771 				}
   5772 				break;
   5773 			case DOUBLE_LITERAL:
   5774 			case DOUBLE_LITERAL_OR_ID:
   5775 				{
   5776 				alt24=6;
   5777 				}
   5778 				break;
   5779 			case CHAR_LITERAL:
   5780 				{
   5781 				alt24=7;
   5782 				}
   5783 				break;
   5784 			case BOOL_LITERAL:
   5785 				{
   5786 				alt24=8;
   5787 				}
   5788 				break;
   5789 			default:
   5790 				NoViableAltException nvae =
   5791 					new NoViableAltException("", 24, 0, input);
   5792 				throw nvae;
   5793 			}
   5794 			switch (alt24) {
   5795 				case 1 :
   5796 					// smaliParser.g:661:5: integer_literal
   5797 					{
   5798 					root_0 = (CommonTree)adaptor.nil();
   5799 
   5800 
   5801 					pushFollow(FOLLOW_integer_literal_in_fixed_literal2651);
   5802 					integer_literal138=integer_literal();
   5803 					state._fsp--;
   5804 
   5805 					adaptor.addChild(root_0, integer_literal138.getTree());
   5806 
   5807 					}
   5808 					break;
   5809 				case 2 :
   5810 					// smaliParser.g:662:5: LONG_LITERAL
   5811 					{
   5812 					root_0 = (CommonTree)adaptor.nil();
   5813 
   5814 
   5815 					LONG_LITERAL139=(Token)match(input,LONG_LITERAL,FOLLOW_LONG_LITERAL_in_fixed_literal2657);
   5816 					LONG_LITERAL139_tree = (CommonTree)adaptor.create(LONG_LITERAL139);
   5817 					adaptor.addChild(root_0, LONG_LITERAL139_tree);
   5818 
   5819 					}
   5820 					break;
   5821 				case 3 :
   5822 					// smaliParser.g:663:5: SHORT_LITERAL
   5823 					{
   5824 					root_0 = (CommonTree)adaptor.nil();
   5825 
   5826 
   5827 					SHORT_LITERAL140=(Token)match(input,SHORT_LITERAL,FOLLOW_SHORT_LITERAL_in_fixed_literal2663);
   5828 					SHORT_LITERAL140_tree = (CommonTree)adaptor.create(SHORT_LITERAL140);
   5829 					adaptor.addChild(root_0, SHORT_LITERAL140_tree);
   5830 
   5831 					}
   5832 					break;
   5833 				case 4 :
   5834 					// smaliParser.g:664:5: BYTE_LITERAL
   5835 					{
   5836 					root_0 = (CommonTree)adaptor.nil();
   5837 
   5838 
   5839 					BYTE_LITERAL141=(Token)match(input,BYTE_LITERAL,FOLLOW_BYTE_LITERAL_in_fixed_literal2669);
   5840 					BYTE_LITERAL141_tree = (CommonTree)adaptor.create(BYTE_LITERAL141);
   5841 					adaptor.addChild(root_0, BYTE_LITERAL141_tree);
   5842 
   5843 					}
   5844 					break;
   5845 				case 5 :
   5846 					// smaliParser.g:665:5: float_literal
   5847 					{
   5848 					root_0 = (CommonTree)adaptor.nil();
   5849 
   5850 
   5851 					pushFollow(FOLLOW_float_literal_in_fixed_literal2675);
   5852 					float_literal142=float_literal();
   5853 					state._fsp--;
   5854 
   5855 					adaptor.addChild(root_0, float_literal142.getTree());
   5856 
   5857 					}
   5858 					break;
   5859 				case 6 :
   5860 					// smaliParser.g:666:5: double_literal
   5861 					{
   5862 					root_0 = (CommonTree)adaptor.nil();
   5863 
   5864 
   5865 					pushFollow(FOLLOW_double_literal_in_fixed_literal2681);
   5866 					double_literal143=double_literal();
   5867 					state._fsp--;
   5868 
   5869 					adaptor.addChild(root_0, double_literal143.getTree());
   5870 
   5871 					}
   5872 					break;
   5873 				case 7 :
   5874 					// smaliParser.g:667:5: CHAR_LITERAL
   5875 					{
   5876 					root_0 = (CommonTree)adaptor.nil();
   5877 
   5878 
   5879 					CHAR_LITERAL144=(Token)match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_fixed_literal2687);
   5880 					CHAR_LITERAL144_tree = (CommonTree)adaptor.create(CHAR_LITERAL144);
   5881 					adaptor.addChild(root_0, CHAR_LITERAL144_tree);
   5882 
   5883 					}
   5884 					break;
   5885 				case 8 :
   5886 					// smaliParser.g:668:5: BOOL_LITERAL
   5887 					{
   5888 					root_0 = (CommonTree)adaptor.nil();
   5889 
   5890 
   5891 					BOOL_LITERAL145=(Token)match(input,BOOL_LITERAL,FOLLOW_BOOL_LITERAL_in_fixed_literal2693);
   5892 					BOOL_LITERAL145_tree = (CommonTree)adaptor.create(BOOL_LITERAL145);
   5893 					adaptor.addChild(root_0, BOOL_LITERAL145_tree);
   5894 
   5895 					}
   5896 					break;
   5897 
   5898 			}
   5899 			retval.stop = input.LT(-1);
   5900 
   5901 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   5902 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   5903 
   5904 		}
   5905 		catch (RecognitionException re) {
   5906 			reportError(re);
   5907 			recover(input,re);
   5908 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   5909 		}
   5910 		finally {
   5911 			// do for sure before leaving
   5912 		}
   5913 		return retval;
   5914 	}
   5915 	// $ANTLR end "fixed_literal"
   5916 
   5917 
   5918 	public static class array_literal_return extends ParserRuleReturnScope {
   5919 		CommonTree tree;
   5920 		@Override
   5921 		public CommonTree getTree() { return tree; }
   5922 	};
   5923 
   5924 
   5925 	// $ANTLR start "array_literal"
   5926 	// smaliParser.g:670:1: array_literal : OPEN_BRACE ( literal ( COMMA literal )* |) CLOSE_BRACE -> ^( I_ENCODED_ARRAY[$start, \"I_ENCODED_ARRAY\"] ( literal )* ) ;
   5927 	public final smaliParser.array_literal_return array_literal() throws RecognitionException {
   5928 		smaliParser.array_literal_return retval = new smaliParser.array_literal_return();
   5929 		retval.start = input.LT(1);
   5930 
   5931 		CommonTree root_0 = null;
   5932 
   5933 		Token OPEN_BRACE146=null;
   5934 		Token COMMA148=null;
   5935 		Token CLOSE_BRACE150=null;
   5936 		ParserRuleReturnScope literal147 =null;
   5937 		ParserRuleReturnScope literal149 =null;
   5938 
   5939 		CommonTree OPEN_BRACE146_tree=null;
   5940 		CommonTree COMMA148_tree=null;
   5941 		CommonTree CLOSE_BRACE150_tree=null;
   5942 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   5943 		RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
   5944 		RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
   5945 		RewriteRuleSubtreeStream stream_literal=new RewriteRuleSubtreeStream(adaptor,"rule literal");
   5946 
   5947 		try {
   5948 			// smaliParser.g:671:3: ( OPEN_BRACE ( literal ( COMMA literal )* |) CLOSE_BRACE -> ^( I_ENCODED_ARRAY[$start, \"I_ENCODED_ARRAY\"] ( literal )* ) )
   5949 			// smaliParser.g:671:5: OPEN_BRACE ( literal ( COMMA literal )* |) CLOSE_BRACE
   5950 			{
   5951 			OPEN_BRACE146=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_array_literal2703);
   5952 			stream_OPEN_BRACE.add(OPEN_BRACE146);
   5953 
   5954 			// smaliParser.g:671:16: ( literal ( COMMA literal )* |)
   5955 			int alt26=2;
   5956 			int LA26_0 = input.LA(1);
   5957 			if ( (LA26_0==ACCESS_SPEC||LA26_0==ANNOTATION_VISIBILITY||LA26_0==ARRAY_TYPE_PREFIX||(LA26_0 >= BOOL_LITERAL && LA26_0 <= BYTE_LITERAL)||(LA26_0 >= CHAR_LITERAL && LA26_0 <= CLASS_DESCRIPTOR)||(LA26_0 >= DOUBLE_LITERAL && LA26_0 <= DOUBLE_LITERAL_OR_ID)||LA26_0==ENUM_DIRECTIVE||(LA26_0 >= FLOAT_LITERAL && LA26_0 <= FLOAT_LITERAL_OR_ID)||(LA26_0 >= INSTRUCTION_FORMAT10t && LA26_0 <= INSTRUCTION_FORMAT10x_ODEX)||LA26_0==INSTRUCTION_FORMAT11x||LA26_0==INSTRUCTION_FORMAT12x_OR_ID||(LA26_0 >= INSTRUCTION_FORMAT21c_FIELD && LA26_0 <= INSTRUCTION_FORMAT21c_TYPE)||LA26_0==INSTRUCTION_FORMAT21t||(LA26_0 >= INSTRUCTION_FORMAT22c_FIELD && LA26_0 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA26_0 >= INSTRUCTION_FORMAT22s_OR_ID && LA26_0 <= INSTRUCTION_FORMAT22t)||LA26_0==INSTRUCTION_FORMAT23x||(LA26_0 >= INSTRUCTION_FORMAT31i_OR_ID && LA26_0 <= INSTRUCTION_FORMAT31t)||(LA26_0 >= INSTRUCTION_FORMAT35c_METHOD && LA26_0 <= INSTRUCTION_FORMAT35ms_METHOD)||(LA26_0 >= INSTRUCTION_FORMAT45cc_METHOD && LA26_0 <= INSTRUCTION_FORMAT51l)||(LA26_0 >= LONG_LITERAL && LA26_0 <= MEMBER_NAME)||(LA26_0 >= NEGATIVE_INTEGER_LITERAL && LA26_0 <= OPEN_BRACE)||(LA26_0 >= PARAM_LIST_OR_ID_PRIMITIVE_TYPE && LA26_0 <= PRIMITIVE_TYPE)||LA26_0==REGISTER||(LA26_0 >= SHORT_LITERAL && LA26_0 <= SIMPLE_NAME)||(LA26_0 >= STRING_LITERAL && LA26_0 <= SUBANNOTATION_DIRECTIVE)||(LA26_0 >= VERIFICATION_ERROR_TYPE && LA26_0 <= VOID_TYPE)) ) {
   5958 				alt26=1;
   5959 			}
   5960 			else if ( (LA26_0==CLOSE_BRACE) ) {
   5961 				alt26=2;
   5962 			}
   5963 
   5964 			else {
   5965 				NoViableAltException nvae =
   5966 					new NoViableAltException("", 26, 0, input);
   5967 				throw nvae;
   5968 			}
   5969 
   5970 			switch (alt26) {
   5971 				case 1 :
   5972 					// smaliParser.g:671:17: literal ( COMMA literal )*
   5973 					{
   5974 					pushFollow(FOLLOW_literal_in_array_literal2706);
   5975 					literal147=literal();
   5976 					state._fsp--;
   5977 
   5978 					stream_literal.add(literal147.getTree());
   5979 					// smaliParser.g:671:25: ( COMMA literal )*
   5980 					loop25:
   5981 					while (true) {
   5982 						int alt25=2;
   5983 						int LA25_0 = input.LA(1);
   5984 						if ( (LA25_0==COMMA) ) {
   5985 							alt25=1;
   5986 						}
   5987 
   5988 						switch (alt25) {
   5989 						case 1 :
   5990 							// smaliParser.g:671:26: COMMA literal
   5991 							{
   5992 							COMMA148=(Token)match(input,COMMA,FOLLOW_COMMA_in_array_literal2709);
   5993 							stream_COMMA.add(COMMA148);
   5994 
   5995 							pushFollow(FOLLOW_literal_in_array_literal2711);
   5996 							literal149=literal();
   5997 							state._fsp--;
   5998 
   5999 							stream_literal.add(literal149.getTree());
   6000 							}
   6001 							break;
   6002 
   6003 						default :
   6004 							break loop25;
   6005 						}
   6006 					}
   6007 
   6008 					}
   6009 					break;
   6010 				case 2 :
   6011 					// smaliParser.g:671:44:
   6012 					{
   6013 					}
   6014 					break;
   6015 
   6016 			}
   6017 
   6018 			CLOSE_BRACE150=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_array_literal2719);
   6019 			stream_CLOSE_BRACE.add(CLOSE_BRACE150);
   6020 
   6021 			// AST REWRITE
   6022 			// elements: literal
   6023 			// token labels:
   6024 			// rule labels: retval
   6025 			// token list labels:
   6026 			// rule list labels:
   6027 			// wildcard labels:
   6028 			retval.tree = root_0;
   6029 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   6030 
   6031 			root_0 = (CommonTree)adaptor.nil();
   6032 			// 672:5: -> ^( I_ENCODED_ARRAY[$start, \"I_ENCODED_ARRAY\"] ( literal )* )
   6033 			{
   6034 				// smaliParser.g:672:8: ^( I_ENCODED_ARRAY[$start, \"I_ENCODED_ARRAY\"] ( literal )* )
   6035 				{
   6036 				CommonTree root_1 = (CommonTree)adaptor.nil();
   6037 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ENCODED_ARRAY, (retval.start), "I_ENCODED_ARRAY"), root_1);
   6038 				// smaliParser.g:672:53: ( literal )*
   6039 				while ( stream_literal.hasNext() ) {
   6040 					adaptor.addChild(root_1, stream_literal.nextTree());
   6041 				}
   6042 				stream_literal.reset();
   6043 
   6044 				adaptor.addChild(root_0, root_1);
   6045 				}
   6046 
   6047 			}
   6048 
   6049 
   6050 			retval.tree = root_0;
   6051 
   6052 			}
   6053 
   6054 			retval.stop = input.LT(-1);
   6055 
   6056 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   6057 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   6058 
   6059 		}
   6060 		catch (RecognitionException re) {
   6061 			reportError(re);
   6062 			recover(input,re);
   6063 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   6064 		}
   6065 		finally {
   6066 			// do for sure before leaving
   6067 		}
   6068 		return retval;
   6069 	}
   6070 	// $ANTLR end "array_literal"
   6071 
   6072 
   6073 	public static class annotation_element_return extends ParserRuleReturnScope {
   6074 		CommonTree tree;
   6075 		@Override
   6076 		public CommonTree getTree() { return tree; }
   6077 	};
   6078 
   6079 
   6080 	// $ANTLR start "annotation_element"
   6081 	// smaliParser.g:674:1: annotation_element : simple_name EQUAL literal -> ^( I_ANNOTATION_ELEMENT[$start, \"I_ANNOTATION_ELEMENT\"] simple_name literal ) ;
   6082 	public final smaliParser.annotation_element_return annotation_element() throws RecognitionException {
   6083 		smaliParser.annotation_element_return retval = new smaliParser.annotation_element_return();
   6084 		retval.start = input.LT(1);
   6085 
   6086 		CommonTree root_0 = null;
   6087 
   6088 		Token EQUAL152=null;
   6089 		ParserRuleReturnScope simple_name151 =null;
   6090 		ParserRuleReturnScope literal153 =null;
   6091 
   6092 		CommonTree EQUAL152_tree=null;
   6093 		RewriteRuleTokenStream stream_EQUAL=new RewriteRuleTokenStream(adaptor,"token EQUAL");
   6094 		RewriteRuleSubtreeStream stream_simple_name=new RewriteRuleSubtreeStream(adaptor,"rule simple_name");
   6095 		RewriteRuleSubtreeStream stream_literal=new RewriteRuleSubtreeStream(adaptor,"rule literal");
   6096 
   6097 		try {
   6098 			// smaliParser.g:675:3: ( simple_name EQUAL literal -> ^( I_ANNOTATION_ELEMENT[$start, \"I_ANNOTATION_ELEMENT\"] simple_name literal ) )
   6099 			// smaliParser.g:675:5: simple_name EQUAL literal
   6100 			{
   6101 			pushFollow(FOLLOW_simple_name_in_annotation_element2743);
   6102 			simple_name151=simple_name();
   6103 			state._fsp--;
   6104 
   6105 			stream_simple_name.add(simple_name151.getTree());
   6106 			EQUAL152=(Token)match(input,EQUAL,FOLLOW_EQUAL_in_annotation_element2745);
   6107 			stream_EQUAL.add(EQUAL152);
   6108 
   6109 			pushFollow(FOLLOW_literal_in_annotation_element2747);
   6110 			literal153=literal();
   6111 			state._fsp--;
   6112 
   6113 			stream_literal.add(literal153.getTree());
   6114 			// AST REWRITE
   6115 			// elements: simple_name, literal
   6116 			// token labels:
   6117 			// rule labels: retval
   6118 			// token list labels:
   6119 			// rule list labels:
   6120 			// wildcard labels:
   6121 			retval.tree = root_0;
   6122 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   6123 
   6124 			root_0 = (CommonTree)adaptor.nil();
   6125 			// 676:5: -> ^( I_ANNOTATION_ELEMENT[$start, \"I_ANNOTATION_ELEMENT\"] simple_name literal )
   6126 			{
   6127 				// smaliParser.g:676:8: ^( I_ANNOTATION_ELEMENT[$start, \"I_ANNOTATION_ELEMENT\"] simple_name literal )
   6128 				{
   6129 				CommonTree root_1 = (CommonTree)adaptor.nil();
   6130 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ANNOTATION_ELEMENT, (retval.start), "I_ANNOTATION_ELEMENT"), root_1);
   6131 				adaptor.addChild(root_1, stream_simple_name.nextTree());
   6132 				adaptor.addChild(root_1, stream_literal.nextTree());
   6133 				adaptor.addChild(root_0, root_1);
   6134 				}
   6135 
   6136 			}
   6137 
   6138 
   6139 			retval.tree = root_0;
   6140 
   6141 			}
   6142 
   6143 			retval.stop = input.LT(-1);
   6144 
   6145 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   6146 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   6147 
   6148 		}
   6149 		catch (RecognitionException re) {
   6150 			reportError(re);
   6151 			recover(input,re);
   6152 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   6153 		}
   6154 		finally {
   6155 			// do for sure before leaving
   6156 		}
   6157 		return retval;
   6158 	}
   6159 	// $ANTLR end "annotation_element"
   6160 
   6161 
   6162 	public static class annotation_return extends ParserRuleReturnScope {
   6163 		CommonTree tree;
   6164 		@Override
   6165 		public CommonTree getTree() { return tree; }
   6166 	};
   6167 
   6168 
   6169 	// $ANTLR start "annotation"
   6170 	// smaliParser.g:678:1: annotation : ANNOTATION_DIRECTIVE ANNOTATION_VISIBILITY CLASS_DESCRIPTOR ( annotation_element )* END_ANNOTATION_DIRECTIVE -> ^( I_ANNOTATION[$start, \"I_ANNOTATION\"] ANNOTATION_VISIBILITY ^( I_SUBANNOTATION[$start, \"I_SUBANNOTATION\"] CLASS_DESCRIPTOR ( annotation_element )* ) ) ;
   6171 	public final smaliParser.annotation_return annotation() throws RecognitionException {
   6172 		smaliParser.annotation_return retval = new smaliParser.annotation_return();
   6173 		retval.start = input.LT(1);
   6174 
   6175 		CommonTree root_0 = null;
   6176 
   6177 		Token ANNOTATION_DIRECTIVE154=null;
   6178 		Token ANNOTATION_VISIBILITY155=null;
   6179 		Token CLASS_DESCRIPTOR156=null;
   6180 		Token END_ANNOTATION_DIRECTIVE158=null;
   6181 		ParserRuleReturnScope annotation_element157 =null;
   6182 
   6183 		CommonTree ANNOTATION_DIRECTIVE154_tree=null;
   6184 		CommonTree ANNOTATION_VISIBILITY155_tree=null;
   6185 		CommonTree CLASS_DESCRIPTOR156_tree=null;
   6186 		CommonTree END_ANNOTATION_DIRECTIVE158_tree=null;
   6187 		RewriteRuleTokenStream stream_ANNOTATION_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token ANNOTATION_DIRECTIVE");
   6188 		RewriteRuleTokenStream stream_ANNOTATION_VISIBILITY=new RewriteRuleTokenStream(adaptor,"token ANNOTATION_VISIBILITY");
   6189 		RewriteRuleTokenStream stream_CLASS_DESCRIPTOR=new RewriteRuleTokenStream(adaptor,"token CLASS_DESCRIPTOR");
   6190 		RewriteRuleTokenStream stream_END_ANNOTATION_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_ANNOTATION_DIRECTIVE");
   6191 		RewriteRuleSubtreeStream stream_annotation_element=new RewriteRuleSubtreeStream(adaptor,"rule annotation_element");
   6192 
   6193 		try {
   6194 			// smaliParser.g:679:3: ( ANNOTATION_DIRECTIVE ANNOTATION_VISIBILITY CLASS_DESCRIPTOR ( annotation_element )* END_ANNOTATION_DIRECTIVE -> ^( I_ANNOTATION[$start, \"I_ANNOTATION\"] ANNOTATION_VISIBILITY ^( I_SUBANNOTATION[$start, \"I_SUBANNOTATION\"] CLASS_DESCRIPTOR ( annotation_element )* ) ) )
   6195 			// smaliParser.g:679:5: ANNOTATION_DIRECTIVE ANNOTATION_VISIBILITY CLASS_DESCRIPTOR ( annotation_element )* END_ANNOTATION_DIRECTIVE
   6196 			{
   6197 			ANNOTATION_DIRECTIVE154=(Token)match(input,ANNOTATION_DIRECTIVE,FOLLOW_ANNOTATION_DIRECTIVE_in_annotation2772);
   6198 			stream_ANNOTATION_DIRECTIVE.add(ANNOTATION_DIRECTIVE154);
   6199 
   6200 			ANNOTATION_VISIBILITY155=(Token)match(input,ANNOTATION_VISIBILITY,FOLLOW_ANNOTATION_VISIBILITY_in_annotation2774);
   6201 			stream_ANNOTATION_VISIBILITY.add(ANNOTATION_VISIBILITY155);
   6202 
   6203 			CLASS_DESCRIPTOR156=(Token)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_annotation2776);
   6204 			stream_CLASS_DESCRIPTOR.add(CLASS_DESCRIPTOR156);
   6205 
   6206 			// smaliParser.g:680:5: ( annotation_element )*
   6207 			loop27:
   6208 			while (true) {
   6209 				int alt27=2;
   6210 				int LA27_0 = input.LA(1);
   6211 				if ( (LA27_0==ACCESS_SPEC||LA27_0==ANNOTATION_VISIBILITY||LA27_0==BOOL_LITERAL||LA27_0==DOUBLE_LITERAL_OR_ID||LA27_0==FLOAT_LITERAL_OR_ID||(LA27_0 >= INSTRUCTION_FORMAT10t && LA27_0 <= INSTRUCTION_FORMAT10x_ODEX)||LA27_0==INSTRUCTION_FORMAT11x||LA27_0==INSTRUCTION_FORMAT12x_OR_ID||(LA27_0 >= INSTRUCTION_FORMAT21c_FIELD && LA27_0 <= INSTRUCTION_FORMAT21c_TYPE)||LA27_0==INSTRUCTION_FORMAT21t||(LA27_0 >= INSTRUCTION_FORMAT22c_FIELD && LA27_0 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA27_0 >= INSTRUCTION_FORMAT22s_OR_ID && LA27_0 <= INSTRUCTION_FORMAT22t)||LA27_0==INSTRUCTION_FORMAT23x||(LA27_0 >= INSTRUCTION_FORMAT31i_OR_ID && LA27_0 <= INSTRUCTION_FORMAT31t)||(LA27_0 >= INSTRUCTION_FORMAT35c_METHOD && LA27_0 <= INSTRUCTION_FORMAT35ms_METHOD)||(LA27_0 >= INSTRUCTION_FORMAT45cc_METHOD && LA27_0 <= INSTRUCTION_FORMAT51l)||(LA27_0 >= NEGATIVE_INTEGER_LITERAL && LA27_0 <= NULL_LITERAL)||(LA27_0 >= PARAM_LIST_OR_ID_PRIMITIVE_TYPE && LA27_0 <= PRIMITIVE_TYPE)||LA27_0==REGISTER||LA27_0==SIMPLE_NAME||(LA27_0 >= VERIFICATION_ERROR_TYPE && LA27_0 <= VOID_TYPE)) ) {
   6212 					alt27=1;
   6213 				}
   6214 
   6215 				switch (alt27) {
   6216 				case 1 :
   6217 					// smaliParser.g:680:5: annotation_element
   6218 					{
   6219 					pushFollow(FOLLOW_annotation_element_in_annotation2782);
   6220 					annotation_element157=annotation_element();
   6221 					state._fsp--;
   6222 
   6223 					stream_annotation_element.add(annotation_element157.getTree());
   6224 					}
   6225 					break;
   6226 
   6227 				default :
   6228 					break loop27;
   6229 				}
   6230 			}
   6231 
   6232 			END_ANNOTATION_DIRECTIVE158=(Token)match(input,END_ANNOTATION_DIRECTIVE,FOLLOW_END_ANNOTATION_DIRECTIVE_in_annotation2785);
   6233 			stream_END_ANNOTATION_DIRECTIVE.add(END_ANNOTATION_DIRECTIVE158);
   6234 
   6235 			// AST REWRITE
   6236 			// elements: CLASS_DESCRIPTOR, annotation_element, ANNOTATION_VISIBILITY
   6237 			// token labels:
   6238 			// rule labels: retval
   6239 			// token list labels:
   6240 			// rule list labels:
   6241 			// wildcard labels:
   6242 			retval.tree = root_0;
   6243 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   6244 
   6245 			root_0 = (CommonTree)adaptor.nil();
   6246 			// 681:5: -> ^( I_ANNOTATION[$start, \"I_ANNOTATION\"] ANNOTATION_VISIBILITY ^( I_SUBANNOTATION[$start, \"I_SUBANNOTATION\"] CLASS_DESCRIPTOR ( annotation_element )* ) )
   6247 			{
   6248 				// smaliParser.g:681:8: ^( I_ANNOTATION[$start, \"I_ANNOTATION\"] ANNOTATION_VISIBILITY ^( I_SUBANNOTATION[$start, \"I_SUBANNOTATION\"] CLASS_DESCRIPTOR ( annotation_element )* ) )
   6249 				{
   6250 				CommonTree root_1 = (CommonTree)adaptor.nil();
   6251 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ANNOTATION, (retval.start), "I_ANNOTATION"), root_1);
   6252 				adaptor.addChild(root_1, stream_ANNOTATION_VISIBILITY.nextNode());
   6253 				// smaliParser.g:681:69: ^( I_SUBANNOTATION[$start, \"I_SUBANNOTATION\"] CLASS_DESCRIPTOR ( annotation_element )* )
   6254 				{
   6255 				CommonTree root_2 = (CommonTree)adaptor.nil();
   6256 				root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_SUBANNOTATION, (retval.start), "I_SUBANNOTATION"), root_2);
   6257 				adaptor.addChild(root_2, stream_CLASS_DESCRIPTOR.nextNode());
   6258 				// smaliParser.g:681:131: ( annotation_element )*
   6259 				while ( stream_annotation_element.hasNext() ) {
   6260 					adaptor.addChild(root_2, stream_annotation_element.nextTree());
   6261 				}
   6262 				stream_annotation_element.reset();
   6263 
   6264 				adaptor.addChild(root_1, root_2);
   6265 				}
   6266 
   6267 				adaptor.addChild(root_0, root_1);
   6268 				}
   6269 
   6270 			}
   6271 
   6272 
   6273 			retval.tree = root_0;
   6274 
   6275 			}
   6276 
   6277 			retval.stop = input.LT(-1);
   6278 
   6279 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   6280 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   6281 
   6282 		}
   6283 		catch (RecognitionException re) {
   6284 			reportError(re);
   6285 			recover(input,re);
   6286 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   6287 		}
   6288 		finally {
   6289 			// do for sure before leaving
   6290 		}
   6291 		return retval;
   6292 	}
   6293 	// $ANTLR end "annotation"
   6294 
   6295 
   6296 	public static class subannotation_return extends ParserRuleReturnScope {
   6297 		CommonTree tree;
   6298 		@Override
   6299 		public CommonTree getTree() { return tree; }
   6300 	};
   6301 
   6302 
   6303 	// $ANTLR start "subannotation"
   6304 	// smaliParser.g:683:1: subannotation : SUBANNOTATION_DIRECTIVE CLASS_DESCRIPTOR ( annotation_element )* END_SUBANNOTATION_DIRECTIVE -> ^( I_SUBANNOTATION[$start, \"I_SUBANNOTATION\"] CLASS_DESCRIPTOR ( annotation_element )* ) ;
   6305 	public final smaliParser.subannotation_return subannotation() throws RecognitionException {
   6306 		smaliParser.subannotation_return retval = new smaliParser.subannotation_return();
   6307 		retval.start = input.LT(1);
   6308 
   6309 		CommonTree root_0 = null;
   6310 
   6311 		Token SUBANNOTATION_DIRECTIVE159=null;
   6312 		Token CLASS_DESCRIPTOR160=null;
   6313 		Token END_SUBANNOTATION_DIRECTIVE162=null;
   6314 		ParserRuleReturnScope annotation_element161 =null;
   6315 
   6316 		CommonTree SUBANNOTATION_DIRECTIVE159_tree=null;
   6317 		CommonTree CLASS_DESCRIPTOR160_tree=null;
   6318 		CommonTree END_SUBANNOTATION_DIRECTIVE162_tree=null;
   6319 		RewriteRuleTokenStream stream_SUBANNOTATION_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token SUBANNOTATION_DIRECTIVE");
   6320 		RewriteRuleTokenStream stream_CLASS_DESCRIPTOR=new RewriteRuleTokenStream(adaptor,"token CLASS_DESCRIPTOR");
   6321 		RewriteRuleTokenStream stream_END_SUBANNOTATION_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_SUBANNOTATION_DIRECTIVE");
   6322 		RewriteRuleSubtreeStream stream_annotation_element=new RewriteRuleSubtreeStream(adaptor,"rule annotation_element");
   6323 
   6324 		try {
   6325 			// smaliParser.g:684:3: ( SUBANNOTATION_DIRECTIVE CLASS_DESCRIPTOR ( annotation_element )* END_SUBANNOTATION_DIRECTIVE -> ^( I_SUBANNOTATION[$start, \"I_SUBANNOTATION\"] CLASS_DESCRIPTOR ( annotation_element )* ) )
   6326 			// smaliParser.g:684:5: SUBANNOTATION_DIRECTIVE CLASS_DESCRIPTOR ( annotation_element )* END_SUBANNOTATION_DIRECTIVE
   6327 			{
   6328 			SUBANNOTATION_DIRECTIVE159=(Token)match(input,SUBANNOTATION_DIRECTIVE,FOLLOW_SUBANNOTATION_DIRECTIVE_in_subannotation2818);
   6329 			stream_SUBANNOTATION_DIRECTIVE.add(SUBANNOTATION_DIRECTIVE159);
   6330 
   6331 			CLASS_DESCRIPTOR160=(Token)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_subannotation2820);
   6332 			stream_CLASS_DESCRIPTOR.add(CLASS_DESCRIPTOR160);
   6333 
   6334 			// smaliParser.g:684:46: ( annotation_element )*
   6335 			loop28:
   6336 			while (true) {
   6337 				int alt28=2;
   6338 				int LA28_0 = input.LA(1);
   6339 				if ( (LA28_0==ACCESS_SPEC||LA28_0==ANNOTATION_VISIBILITY||LA28_0==BOOL_LITERAL||LA28_0==DOUBLE_LITERAL_OR_ID||LA28_0==FLOAT_LITERAL_OR_ID||(LA28_0 >= INSTRUCTION_FORMAT10t && LA28_0 <= INSTRUCTION_FORMAT10x_ODEX)||LA28_0==INSTRUCTION_FORMAT11x||LA28_0==INSTRUCTION_FORMAT12x_OR_ID||(LA28_0 >= INSTRUCTION_FORMAT21c_FIELD && LA28_0 <= INSTRUCTION_FORMAT21c_TYPE)||LA28_0==INSTRUCTION_FORMAT21t||(LA28_0 >= INSTRUCTION_FORMAT22c_FIELD && LA28_0 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA28_0 >= INSTRUCTION_FORMAT22s_OR_ID && LA28_0 <= INSTRUCTION_FORMAT22t)||LA28_0==INSTRUCTION_FORMAT23x||(LA28_0 >= INSTRUCTION_FORMAT31i_OR_ID && LA28_0 <= INSTRUCTION_FORMAT31t)||(LA28_0 >= INSTRUCTION_FORMAT35c_METHOD && LA28_0 <= INSTRUCTION_FORMAT35ms_METHOD)||(LA28_0 >= INSTRUCTION_FORMAT45cc_METHOD && LA28_0 <= INSTRUCTION_FORMAT51l)||(LA28_0 >= NEGATIVE_INTEGER_LITERAL && LA28_0 <= NULL_LITERAL)||(LA28_0 >= PARAM_LIST_OR_ID_PRIMITIVE_TYPE && LA28_0 <= PRIMITIVE_TYPE)||LA28_0==REGISTER||LA28_0==SIMPLE_NAME||(LA28_0 >= VERIFICATION_ERROR_TYPE && LA28_0 <= VOID_TYPE)) ) {
   6340 					alt28=1;
   6341 				}
   6342 
   6343 				switch (alt28) {
   6344 				case 1 :
   6345 					// smaliParser.g:684:46: annotation_element
   6346 					{
   6347 					pushFollow(FOLLOW_annotation_element_in_subannotation2822);
   6348 					annotation_element161=annotation_element();
   6349 					state._fsp--;
   6350 
   6351 					stream_annotation_element.add(annotation_element161.getTree());
   6352 					}
   6353 					break;
   6354 
   6355 				default :
   6356 					break loop28;
   6357 				}
   6358 			}
   6359 
   6360 			END_SUBANNOTATION_DIRECTIVE162=(Token)match(input,END_SUBANNOTATION_DIRECTIVE,FOLLOW_END_SUBANNOTATION_DIRECTIVE_in_subannotation2825);
   6361 			stream_END_SUBANNOTATION_DIRECTIVE.add(END_SUBANNOTATION_DIRECTIVE162);
   6362 
   6363 			// AST REWRITE
   6364 			// elements: CLASS_DESCRIPTOR, annotation_element
   6365 			// token labels:
   6366 			// rule labels: retval
   6367 			// token list labels:
   6368 			// rule list labels:
   6369 			// wildcard labels:
   6370 			retval.tree = root_0;
   6371 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   6372 
   6373 			root_0 = (CommonTree)adaptor.nil();
   6374 			// 685:5: -> ^( I_SUBANNOTATION[$start, \"I_SUBANNOTATION\"] CLASS_DESCRIPTOR ( annotation_element )* )
   6375 			{
   6376 				// smaliParser.g:685:8: ^( I_SUBANNOTATION[$start, \"I_SUBANNOTATION\"] CLASS_DESCRIPTOR ( annotation_element )* )
   6377 				{
   6378 				CommonTree root_1 = (CommonTree)adaptor.nil();
   6379 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_SUBANNOTATION, (retval.start), "I_SUBANNOTATION"), root_1);
   6380 				adaptor.addChild(root_1, stream_CLASS_DESCRIPTOR.nextNode());
   6381 				// smaliParser.g:685:70: ( annotation_element )*
   6382 				while ( stream_annotation_element.hasNext() ) {
   6383 					adaptor.addChild(root_1, stream_annotation_element.nextTree());
   6384 				}
   6385 				stream_annotation_element.reset();
   6386 
   6387 				adaptor.addChild(root_0, root_1);
   6388 				}
   6389 
   6390 			}
   6391 
   6392 
   6393 			retval.tree = root_0;
   6394 
   6395 			}
   6396 
   6397 			retval.stop = input.LT(-1);
   6398 
   6399 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   6400 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   6401 
   6402 		}
   6403 		catch (RecognitionException re) {
   6404 			reportError(re);
   6405 			recover(input,re);
   6406 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   6407 		}
   6408 		finally {
   6409 			// do for sure before leaving
   6410 		}
   6411 		return retval;
   6412 	}
   6413 	// $ANTLR end "subannotation"
   6414 
   6415 
   6416 	public static class enum_literal_return extends ParserRuleReturnScope {
   6417 		CommonTree tree;
   6418 		@Override
   6419 		public CommonTree getTree() { return tree; }
   6420 	};
   6421 
   6422 
   6423 	// $ANTLR start "enum_literal"
   6424 	// smaliParser.g:688:1: enum_literal : ENUM_DIRECTIVE field_reference -> ^( I_ENCODED_ENUM field_reference ) ;
   6425 	public final smaliParser.enum_literal_return enum_literal() throws RecognitionException {
   6426 		smaliParser.enum_literal_return retval = new smaliParser.enum_literal_return();
   6427 		retval.start = input.LT(1);
   6428 
   6429 		CommonTree root_0 = null;
   6430 
   6431 		Token ENUM_DIRECTIVE163=null;
   6432 		ParserRuleReturnScope field_reference164 =null;
   6433 
   6434 		CommonTree ENUM_DIRECTIVE163_tree=null;
   6435 		RewriteRuleTokenStream stream_ENUM_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token ENUM_DIRECTIVE");
   6436 		RewriteRuleSubtreeStream stream_field_reference=new RewriteRuleSubtreeStream(adaptor,"rule field_reference");
   6437 
   6438 		try {
   6439 			// smaliParser.g:689:3: ( ENUM_DIRECTIVE field_reference -> ^( I_ENCODED_ENUM field_reference ) )
   6440 			// smaliParser.g:689:5: ENUM_DIRECTIVE field_reference
   6441 			{
   6442 			ENUM_DIRECTIVE163=(Token)match(input,ENUM_DIRECTIVE,FOLLOW_ENUM_DIRECTIVE_in_enum_literal2852);
   6443 			stream_ENUM_DIRECTIVE.add(ENUM_DIRECTIVE163);
   6444 
   6445 			pushFollow(FOLLOW_field_reference_in_enum_literal2854);
   6446 			field_reference164=field_reference();
   6447 			state._fsp--;
   6448 
   6449 			stream_field_reference.add(field_reference164.getTree());
   6450 			// AST REWRITE
   6451 			// elements: field_reference
   6452 			// token labels:
   6453 			// rule labels: retval
   6454 			// token list labels:
   6455 			// rule list labels:
   6456 			// wildcard labels:
   6457 			retval.tree = root_0;
   6458 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   6459 
   6460 			root_0 = (CommonTree)adaptor.nil();
   6461 			// 690:3: -> ^( I_ENCODED_ENUM field_reference )
   6462 			{
   6463 				// smaliParser.g:690:6: ^( I_ENCODED_ENUM field_reference )
   6464 				{
   6465 				CommonTree root_1 = (CommonTree)adaptor.nil();
   6466 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ENCODED_ENUM, "I_ENCODED_ENUM"), root_1);
   6467 				adaptor.addChild(root_1, stream_field_reference.nextTree());
   6468 				adaptor.addChild(root_0, root_1);
   6469 				}
   6470 
   6471 			}
   6472 
   6473 
   6474 			retval.tree = root_0;
   6475 
   6476 			}
   6477 
   6478 			retval.stop = input.LT(-1);
   6479 
   6480 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   6481 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   6482 
   6483 		}
   6484 		catch (RecognitionException re) {
   6485 			reportError(re);
   6486 			recover(input,re);
   6487 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   6488 		}
   6489 		finally {
   6490 			// do for sure before leaving
   6491 		}
   6492 		return retval;
   6493 	}
   6494 	// $ANTLR end "enum_literal"
   6495 
   6496 
   6497 	public static class type_field_method_literal_return extends ParserRuleReturnScope {
   6498 		CommonTree tree;
   6499 		@Override
   6500 		public CommonTree getTree() { return tree; }
   6501 	};
   6502 
   6503 
   6504 	// $ANTLR start "type_field_method_literal"
   6505 	// smaliParser.g:692:1: type_field_method_literal : ( reference_type_descriptor | ( ( reference_type_descriptor ARROW )? ( member_name COLON nonvoid_type_descriptor -> ^( I_ENCODED_FIELD ( reference_type_descriptor )? member_name nonvoid_type_descriptor ) | member_name method_prototype -> ^( I_ENCODED_METHOD ( reference_type_descriptor )? member_name method_prototype ) ) ) | PRIMITIVE_TYPE | VOID_TYPE );
   6506 	public final smaliParser.type_field_method_literal_return type_field_method_literal() throws RecognitionException {
   6507 		smaliParser.type_field_method_literal_return retval = new smaliParser.type_field_method_literal_return();
   6508 		retval.start = input.LT(1);
   6509 
   6510 		CommonTree root_0 = null;
   6511 
   6512 		Token ARROW167=null;
   6513 		Token COLON169=null;
   6514 		Token PRIMITIVE_TYPE173=null;
   6515 		Token VOID_TYPE174=null;
   6516 		ParserRuleReturnScope reference_type_descriptor165 =null;
   6517 		ParserRuleReturnScope reference_type_descriptor166 =null;
   6518 		ParserRuleReturnScope member_name168 =null;
   6519 		ParserRuleReturnScope nonvoid_type_descriptor170 =null;
   6520 		ParserRuleReturnScope member_name171 =null;
   6521 		ParserRuleReturnScope method_prototype172 =null;
   6522 
   6523 		CommonTree ARROW167_tree=null;
   6524 		CommonTree COLON169_tree=null;
   6525 		CommonTree PRIMITIVE_TYPE173_tree=null;
   6526 		CommonTree VOID_TYPE174_tree=null;
   6527 		RewriteRuleTokenStream stream_ARROW=new RewriteRuleTokenStream(adaptor,"token ARROW");
   6528 		RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON");
   6529 		RewriteRuleSubtreeStream stream_method_prototype=new RewriteRuleSubtreeStream(adaptor,"rule method_prototype");
   6530 		RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor");
   6531 		RewriteRuleSubtreeStream stream_member_name=new RewriteRuleSubtreeStream(adaptor,"rule member_name");
   6532 		RewriteRuleSubtreeStream stream_reference_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule reference_type_descriptor");
   6533 
   6534 		try {
   6535 			// smaliParser.g:693:3: ( reference_type_descriptor | ( ( reference_type_descriptor ARROW )? ( member_name COLON nonvoid_type_descriptor -> ^( I_ENCODED_FIELD ( reference_type_descriptor )? member_name nonvoid_type_descriptor ) | member_name method_prototype -> ^( I_ENCODED_METHOD ( reference_type_descriptor )? member_name method_prototype ) ) ) | PRIMITIVE_TYPE | VOID_TYPE )
   6536 			int alt31=4;
   6537 			switch ( input.LA(1) ) {
   6538 			case CLASS_DESCRIPTOR:
   6539 				{
   6540 				int LA31_1 = input.LA(2);
   6541 				if ( (LA31_1==EOF||(LA31_1 >= ACCESS_SPEC && LA31_1 <= ANNOTATION_VISIBILITY)||LA31_1==BOOL_LITERAL||(LA31_1 >= CLASS_DIRECTIVE && LA31_1 <= CLOSE_BRACE)||LA31_1==COMMA||(LA31_1 >= DOUBLE_LITERAL_OR_ID && LA31_1 <= END_ANNOTATION_DIRECTIVE)||LA31_1==END_FIELD_DIRECTIVE||LA31_1==END_SUBANNOTATION_DIRECTIVE||LA31_1==FIELD_DIRECTIVE||(LA31_1 >= FLOAT_LITERAL_OR_ID && LA31_1 <= IMPLEMENTS_DIRECTIVE)||(LA31_1 >= INSTRUCTION_FORMAT10t && LA31_1 <= INSTRUCTION_FORMAT10x_ODEX)||LA31_1==INSTRUCTION_FORMAT11x||LA31_1==INSTRUCTION_FORMAT12x_OR_ID||(LA31_1 >= INSTRUCTION_FORMAT21c_FIELD && LA31_1 <= INSTRUCTION_FORMAT21c_TYPE)||LA31_1==INSTRUCTION_FORMAT21t||(LA31_1 >= INSTRUCTION_FORMAT22c_FIELD && LA31_1 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA31_1 >= INSTRUCTION_FORMAT22s_OR_ID && LA31_1 <= INSTRUCTION_FORMAT22t)||LA31_1==INSTRUCTION_FORMAT23x||(LA31_1 >= INSTRUCTION_FORMAT31i_OR_ID && LA31_1 <= INSTRUCTION_FORMAT31t)||(LA31_1 >= INSTRUCTION_FORMAT35c_METHOD && LA31_1 <= INSTRUCTION_FORMAT35ms_METHOD)||(LA31_1 >= INSTRUCTION_FORMAT45cc_METHOD && LA31_1 <= INSTRUCTION_FORMAT51l)||(LA31_1 >= METHOD_DIRECTIVE && LA31_1 <= NULL_LITERAL)||(LA31_1 >= PARAM_LIST_OR_ID_PRIMITIVE_TYPE && LA31_1 <= PRIMITIVE_TYPE)||LA31_1==REGISTER||(LA31_1 >= SIMPLE_NAME && LA31_1 <= SOURCE_DIRECTIVE)||(LA31_1 >= SUPER_DIRECTIVE && LA31_1 <= VOID_TYPE)) ) {
   6542 					alt31=1;
   6543 				}
   6544 				else if ( (LA31_1==ARROW) ) {
   6545 					alt31=2;
   6546 				}
   6547 
   6548 				else {
   6549 					int nvaeMark = input.mark();
   6550 					try {
   6551 						input.consume();
   6552 						NoViableAltException nvae =
   6553 							new NoViableAltException("", 31, 1, input);
   6554 						throw nvae;
   6555 					} finally {
   6556 						input.rewind(nvaeMark);
   6557 					}
   6558 				}
   6559 
   6560 				}
   6561 				break;
   6562 			case ARRAY_TYPE_PREFIX:
   6563 				{
   6564 				int LA31_2 = input.LA(2);
   6565 				if ( (LA31_2==CLASS_DESCRIPTOR||LA31_2==PRIMITIVE_TYPE) ) {
   6566 					int LA31_7 = input.LA(3);
   6567 					if ( (LA31_7==EOF||(LA31_7 >= ACCESS_SPEC && LA31_7 <= ANNOTATION_VISIBILITY)||LA31_7==BOOL_LITERAL||(LA31_7 >= CLASS_DIRECTIVE && LA31_7 <= CLOSE_BRACE)||LA31_7==COMMA||(LA31_7 >= DOUBLE_LITERAL_OR_ID && LA31_7 <= END_ANNOTATION_DIRECTIVE)||LA31_7==END_FIELD_DIRECTIVE||LA31_7==END_SUBANNOTATION_DIRECTIVE||LA31_7==FIELD_DIRECTIVE||(LA31_7 >= FLOAT_LITERAL_OR_ID && LA31_7 <= IMPLEMENTS_DIRECTIVE)||(LA31_7 >= INSTRUCTION_FORMAT10t && LA31_7 <= INSTRUCTION_FORMAT10x_ODEX)||LA31_7==INSTRUCTION_FORMAT11x||LA31_7==INSTRUCTION_FORMAT12x_OR_ID||(LA31_7 >= INSTRUCTION_FORMAT21c_FIELD && LA31_7 <= INSTRUCTION_FORMAT21c_TYPE)||LA31_7==INSTRUCTION_FORMAT21t||(LA31_7 >= INSTRUCTION_FORMAT22c_FIELD && LA31_7 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA31_7 >= INSTRUCTION_FORMAT22s_OR_ID && LA31_7 <= INSTRUCTION_FORMAT22t)||LA31_7==INSTRUCTION_FORMAT23x||(LA31_7 >= INSTRUCTION_FORMAT31i_OR_ID && LA31_7 <= INSTRUCTION_FORMAT31t)||(LA31_7 >= INSTRUCTION_FORMAT35c_METHOD && LA31_7 <= INSTRUCTION_FORMAT35ms_METHOD)||(LA31_7 >= INSTRUCTION_FORMAT45cc_METHOD && LA31_7 <= INSTRUCTION_FORMAT51l)||(LA31_7 >= METHOD_DIRECTIVE && LA31_7 <= NULL_LITERAL)||(LA31_7 >= PARAM_LIST_OR_ID_PRIMITIVE_TYPE && LA31_7 <= PRIMITIVE_TYPE)||LA31_7==REGISTER||(LA31_7 >= SIMPLE_NAME && LA31_7 <= SOURCE_DIRECTIVE)||(LA31_7 >= SUPER_DIRECTIVE && LA31_7 <= VOID_TYPE)) ) {
   6568 						alt31=1;
   6569 					}
   6570 					else if ( (LA31_7==ARROW) ) {
   6571 						alt31=2;
   6572 					}
   6573 
   6574 					else {
   6575 						int nvaeMark = input.mark();
   6576 						try {
   6577 							for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) {
   6578 								input.consume();
   6579 							}
   6580 							NoViableAltException nvae =
   6581 								new NoViableAltException("", 31, 7, input);
   6582 							throw nvae;
   6583 						} finally {
   6584 							input.rewind(nvaeMark);
   6585 						}
   6586 					}
   6587 
   6588 				}
   6589 
   6590 				else {
   6591 					int nvaeMark = input.mark();
   6592 					try {
   6593 						input.consume();
   6594 						NoViableAltException nvae =
   6595 							new NoViableAltException("", 31, 2, input);
   6596 						throw nvae;
   6597 					} finally {
   6598 						input.rewind(nvaeMark);
   6599 					}
   6600 				}
   6601 
   6602 				}
   6603 				break;
   6604 			case ACCESS_SPEC:
   6605 			case ANNOTATION_VISIBILITY:
   6606 			case BOOL_LITERAL:
   6607 			case DOUBLE_LITERAL_OR_ID:
   6608 			case FLOAT_LITERAL_OR_ID:
   6609 			case INSTRUCTION_FORMAT10t:
   6610 			case INSTRUCTION_FORMAT10x:
   6611 			case INSTRUCTION_FORMAT10x_ODEX:
   6612 			case INSTRUCTION_FORMAT11x:
   6613 			case INSTRUCTION_FORMAT12x_OR_ID:
   6614 			case INSTRUCTION_FORMAT21c_FIELD:
   6615 			case INSTRUCTION_FORMAT21c_FIELD_ODEX:
   6616 			case INSTRUCTION_FORMAT21c_STRING:
   6617 			case INSTRUCTION_FORMAT21c_TYPE:
   6618 			case INSTRUCTION_FORMAT21t:
   6619 			case INSTRUCTION_FORMAT22c_FIELD:
   6620 			case INSTRUCTION_FORMAT22c_FIELD_ODEX:
   6621 			case INSTRUCTION_FORMAT22c_TYPE:
   6622 			case INSTRUCTION_FORMAT22cs_FIELD:
   6623 			case INSTRUCTION_FORMAT22s_OR_ID:
   6624 			case INSTRUCTION_FORMAT22t:
   6625 			case INSTRUCTION_FORMAT23x:
   6626 			case INSTRUCTION_FORMAT31i_OR_ID:
   6627 			case INSTRUCTION_FORMAT31t:
   6628 			case INSTRUCTION_FORMAT35c_METHOD:
   6629 			case INSTRUCTION_FORMAT35c_METHOD_ODEX:
   6630 			case INSTRUCTION_FORMAT35c_TYPE:
   6631 			case INSTRUCTION_FORMAT35mi_METHOD:
   6632 			case INSTRUCTION_FORMAT35ms_METHOD:
   6633 			case INSTRUCTION_FORMAT45cc_METHOD:
   6634 			case INSTRUCTION_FORMAT4rcc_METHOD:
   6635 			case INSTRUCTION_FORMAT51l:
   6636 			case MEMBER_NAME:
   6637 			case NEGATIVE_INTEGER_LITERAL:
   6638 			case NULL_LITERAL:
   6639 			case PARAM_LIST_OR_ID_PRIMITIVE_TYPE:
   6640 			case POSITIVE_INTEGER_LITERAL:
   6641 			case REGISTER:
   6642 			case SIMPLE_NAME:
   6643 			case VERIFICATION_ERROR_TYPE:
   6644 				{
   6645 				alt31=2;
   6646 				}
   6647 				break;
   6648 			case PRIMITIVE_TYPE:
   6649 				{
   6650 				int LA31_4 = input.LA(2);
   6651 				if ( (LA31_4==COLON||LA31_4==OPEN_PAREN) ) {
   6652 					alt31=2;
   6653 				}
   6654 				else if ( (LA31_4==EOF||(LA31_4 >= ACCESS_SPEC && LA31_4 <= ANNOTATION_VISIBILITY)||LA31_4==BOOL_LITERAL||(LA31_4 >= CLASS_DIRECTIVE && LA31_4 <= CLOSE_BRACE)||LA31_4==COMMA||(LA31_4 >= DOUBLE_LITERAL_OR_ID && LA31_4 <= END_ANNOTATION_DIRECTIVE)||LA31_4==END_FIELD_DIRECTIVE||LA31_4==END_SUBANNOTATION_DIRECTIVE||LA31_4==FIELD_DIRECTIVE||(LA31_4 >= FLOAT_LITERAL_OR_ID && LA31_4 <= IMPLEMENTS_DIRECTIVE)||(LA31_4 >= INSTRUCTION_FORMAT10t && LA31_4 <= INSTRUCTION_FORMAT10x_ODEX)||LA31_4==INSTRUCTION_FORMAT11x||LA31_4==INSTRUCTION_FORMAT12x_OR_ID||(LA31_4 >= INSTRUCTION_FORMAT21c_FIELD && LA31_4 <= INSTRUCTION_FORMAT21c_TYPE)||LA31_4==INSTRUCTION_FORMAT21t||(LA31_4 >= INSTRUCTION_FORMAT22c_FIELD && LA31_4 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA31_4 >= INSTRUCTION_FORMAT22s_OR_ID && LA31_4 <= INSTRUCTION_FORMAT22t)||LA31_4==INSTRUCTION_FORMAT23x||(LA31_4 >= INSTRUCTION_FORMAT31i_OR_ID && LA31_4 <= INSTRUCTION_FORMAT31t)||(LA31_4 >= INSTRUCTION_FORMAT35c_METHOD && LA31_4 <= INSTRUCTION_FORMAT35ms_METHOD)||(LA31_4 >= INSTRUCTION_FORMAT45cc_METHOD && LA31_4 <= INSTRUCTION_FORMAT51l)||(LA31_4 >= METHOD_DIRECTIVE && LA31_4 <= NULL_LITERAL)||(LA31_4 >= PARAM_LIST_OR_ID_PRIMITIVE_TYPE && LA31_4 <= PRIMITIVE_TYPE)||LA31_4==REGISTER||(LA31_4 >= SIMPLE_NAME && LA31_4 <= SOURCE_DIRECTIVE)||(LA31_4 >= SUPER_DIRECTIVE && LA31_4 <= VOID_TYPE)) ) {
   6655 					alt31=3;
   6656 				}
   6657 
   6658 				else {
   6659 					int nvaeMark = input.mark();
   6660 					try {
   6661 						input.consume();
   6662 						NoViableAltException nvae =
   6663 							new NoViableAltException("", 31, 4, input);
   6664 						throw nvae;
   6665 					} finally {
   6666 						input.rewind(nvaeMark);
   6667 					}
   6668 				}
   6669 
   6670 				}
   6671 				break;
   6672 			case VOID_TYPE:
   6673 				{
   6674 				int LA31_5 = input.LA(2);
   6675 				if ( (LA31_5==COLON||LA31_5==OPEN_PAREN) ) {
   6676 					alt31=2;
   6677 				}
   6678 				else if ( (LA31_5==EOF||(LA31_5 >= ACCESS_SPEC && LA31_5 <= ANNOTATION_VISIBILITY)||LA31_5==BOOL_LITERAL||(LA31_5 >= CLASS_DIRECTIVE && LA31_5 <= CLOSE_BRACE)||LA31_5==COMMA||(LA31_5 >= DOUBLE_LITERAL_OR_ID && LA31_5 <= END_ANNOTATION_DIRECTIVE)||LA31_5==END_FIELD_DIRECTIVE||LA31_5==END_SUBANNOTATION_DIRECTIVE||LA31_5==FIELD_DIRECTIVE||(LA31_5 >= FLOAT_LITERAL_OR_ID && LA31_5 <= IMPLEMENTS_DIRECTIVE)||(LA31_5 >= INSTRUCTION_FORMAT10t && LA31_5 <= INSTRUCTION_FORMAT10x_ODEX)||LA31_5==INSTRUCTION_FORMAT11x||LA31_5==INSTRUCTION_FORMAT12x_OR_ID||(LA31_5 >= INSTRUCTION_FORMAT21c_FIELD && LA31_5 <= INSTRUCTION_FORMAT21c_TYPE)||LA31_5==INSTRUCTION_FORMAT21t||(LA31_5 >= INSTRUCTION_FORMAT22c_FIELD && LA31_5 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA31_5 >= INSTRUCTION_FORMAT22s_OR_ID && LA31_5 <= INSTRUCTION_FORMAT22t)||LA31_5==INSTRUCTION_FORMAT23x||(LA31_5 >= INSTRUCTION_FORMAT31i_OR_ID && LA31_5 <= INSTRUCTION_FORMAT31t)||(LA31_5 >= INSTRUCTION_FORMAT35c_METHOD && LA31_5 <= INSTRUCTION_FORMAT35ms_METHOD)||(LA31_5 >= INSTRUCTION_FORMAT45cc_METHOD && LA31_5 <= INSTRUCTION_FORMAT51l)||(LA31_5 >= METHOD_DIRECTIVE && LA31_5 <= NULL_LITERAL)||(LA31_5 >= PARAM_LIST_OR_ID_PRIMITIVE_TYPE && LA31_5 <= PRIMITIVE_TYPE)||LA31_5==REGISTER||(LA31_5 >= SIMPLE_NAME && LA31_5 <= SOURCE_DIRECTIVE)||(LA31_5 >= SUPER_DIRECTIVE && LA31_5 <= VOID_TYPE)) ) {
   6679 					alt31=4;
   6680 				}
   6681 
   6682 				else {
   6683 					int nvaeMark = input.mark();
   6684 					try {
   6685 						input.consume();
   6686 						NoViableAltException nvae =
   6687 							new NoViableAltException("", 31, 5, input);
   6688 						throw nvae;
   6689 					} finally {
   6690 						input.rewind(nvaeMark);
   6691 					}
   6692 				}
   6693 
   6694 				}
   6695 				break;
   6696 			default:
   6697 				NoViableAltException nvae =
   6698 					new NoViableAltException("", 31, 0, input);
   6699 				throw nvae;
   6700 			}
   6701 			switch (alt31) {
   6702 				case 1 :
   6703 					// smaliParser.g:693:5: reference_type_descriptor
   6704 					{
   6705 					root_0 = (CommonTree)adaptor.nil();
   6706 
   6707 
   6708 					pushFollow(FOLLOW_reference_type_descriptor_in_type_field_method_literal2874);
   6709 					reference_type_descriptor165=reference_type_descriptor();
   6710 					state._fsp--;
   6711 
   6712 					adaptor.addChild(root_0, reference_type_descriptor165.getTree());
   6713 
   6714 					}
   6715 					break;
   6716 				case 2 :
   6717 					// smaliParser.g:694:5: ( ( reference_type_descriptor ARROW )? ( member_name COLON nonvoid_type_descriptor -> ^( I_ENCODED_FIELD ( reference_type_descriptor )? member_name nonvoid_type_descriptor ) | member_name method_prototype -> ^( I_ENCODED_METHOD ( reference_type_descriptor )? member_name method_prototype ) ) )
   6718 					{
   6719 					// smaliParser.g:694:5: ( ( reference_type_descriptor ARROW )? ( member_name COLON nonvoid_type_descriptor -> ^( I_ENCODED_FIELD ( reference_type_descriptor )? member_name nonvoid_type_descriptor ) | member_name method_prototype -> ^( I_ENCODED_METHOD ( reference_type_descriptor )? member_name method_prototype ) ) )
   6720 					// smaliParser.g:694:7: ( reference_type_descriptor ARROW )? ( member_name COLON nonvoid_type_descriptor -> ^( I_ENCODED_FIELD ( reference_type_descriptor )? member_name nonvoid_type_descriptor ) | member_name method_prototype -> ^( I_ENCODED_METHOD ( reference_type_descriptor )? member_name method_prototype ) )
   6721 					{
   6722 					// smaliParser.g:694:7: ( reference_type_descriptor ARROW )?
   6723 					int alt29=2;
   6724 					int LA29_0 = input.LA(1);
   6725 					if ( (LA29_0==ARRAY_TYPE_PREFIX||LA29_0==CLASS_DESCRIPTOR) ) {
   6726 						alt29=1;
   6727 					}
   6728 					switch (alt29) {
   6729 						case 1 :
   6730 							// smaliParser.g:694:8: reference_type_descriptor ARROW
   6731 							{
   6732 							pushFollow(FOLLOW_reference_type_descriptor_in_type_field_method_literal2883);
   6733 							reference_type_descriptor166=reference_type_descriptor();
   6734 							state._fsp--;
   6735 
   6736 							stream_reference_type_descriptor.add(reference_type_descriptor166.getTree());
   6737 							ARROW167=(Token)match(input,ARROW,FOLLOW_ARROW_in_type_field_method_literal2885);
   6738 							stream_ARROW.add(ARROW167);
   6739 
   6740 							}
   6741 							break;
   6742 
   6743 					}
   6744 
   6745 					// smaliParser.g:695:7: ( member_name COLON nonvoid_type_descriptor -> ^( I_ENCODED_FIELD ( reference_type_descriptor )? member_name nonvoid_type_descriptor ) | member_name method_prototype -> ^( I_ENCODED_METHOD ( reference_type_descriptor )? member_name method_prototype ) )
   6746 					int alt30=2;
   6747 					alt30 = dfa30.predict(input);
   6748 					switch (alt30) {
   6749 						case 1 :
   6750 							// smaliParser.g:695:9: member_name COLON nonvoid_type_descriptor
   6751 							{
   6752 							pushFollow(FOLLOW_member_name_in_type_field_method_literal2897);
   6753 							member_name168=member_name();
   6754 							state._fsp--;
   6755 
   6756 							stream_member_name.add(member_name168.getTree());
   6757 							COLON169=(Token)match(input,COLON,FOLLOW_COLON_in_type_field_method_literal2899);
   6758 							stream_COLON.add(COLON169);
   6759 
   6760 							pushFollow(FOLLOW_nonvoid_type_descriptor_in_type_field_method_literal2901);
   6761 							nonvoid_type_descriptor170=nonvoid_type_descriptor();
   6762 							state._fsp--;
   6763 
   6764 							stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor170.getTree());
   6765 							// AST REWRITE
   6766 							// elements: reference_type_descriptor, member_name, nonvoid_type_descriptor
   6767 							// token labels:
   6768 							// rule labels: retval
   6769 							// token list labels:
   6770 							// rule list labels:
   6771 							// wildcard labels:
   6772 							retval.tree = root_0;
   6773 							RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   6774 
   6775 							root_0 = (CommonTree)adaptor.nil();
   6776 							// 695:51: -> ^( I_ENCODED_FIELD ( reference_type_descriptor )? member_name nonvoid_type_descriptor )
   6777 							{
   6778 								// smaliParser.g:695:54: ^( I_ENCODED_FIELD ( reference_type_descriptor )? member_name nonvoid_type_descriptor )
   6779 								{
   6780 								CommonTree root_1 = (CommonTree)adaptor.nil();
   6781 								root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ENCODED_FIELD, "I_ENCODED_FIELD"), root_1);
   6782 								// smaliParser.g:695:72: ( reference_type_descriptor )?
   6783 								if ( stream_reference_type_descriptor.hasNext() ) {
   6784 									adaptor.addChild(root_1, stream_reference_type_descriptor.nextTree());
   6785 								}
   6786 								stream_reference_type_descriptor.reset();
   6787 
   6788 								adaptor.addChild(root_1, stream_member_name.nextTree());
   6789 								adaptor.addChild(root_1, stream_nonvoid_type_descriptor.nextTree());
   6790 								adaptor.addChild(root_0, root_1);
   6791 								}
   6792 
   6793 							}
   6794 
   6795 
   6796 							retval.tree = root_0;
   6797 
   6798 							}
   6799 							break;
   6800 						case 2 :
   6801 							// smaliParser.g:696:9: member_name method_prototype
   6802 							{
   6803 							pushFollow(FOLLOW_member_name_in_type_field_method_literal2924);
   6804 							member_name171=member_name();
   6805 							state._fsp--;
   6806 
   6807 							stream_member_name.add(member_name171.getTree());
   6808 							pushFollow(FOLLOW_method_prototype_in_type_field_method_literal2926);
   6809 							method_prototype172=method_prototype();
   6810 							state._fsp--;
   6811 
   6812 							stream_method_prototype.add(method_prototype172.getTree());
   6813 							// AST REWRITE
   6814 							// elements: member_name, method_prototype, reference_type_descriptor
   6815 							// token labels:
   6816 							// rule labels: retval
   6817 							// token list labels:
   6818 							// rule list labels:
   6819 							// wildcard labels:
   6820 							retval.tree = root_0;
   6821 							RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   6822 
   6823 							root_0 = (CommonTree)adaptor.nil();
   6824 							// 696:38: -> ^( I_ENCODED_METHOD ( reference_type_descriptor )? member_name method_prototype )
   6825 							{
   6826 								// smaliParser.g:696:41: ^( I_ENCODED_METHOD ( reference_type_descriptor )? member_name method_prototype )
   6827 								{
   6828 								CommonTree root_1 = (CommonTree)adaptor.nil();
   6829 								root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ENCODED_METHOD, "I_ENCODED_METHOD"), root_1);
   6830 								// smaliParser.g:696:60: ( reference_type_descriptor )?
   6831 								if ( stream_reference_type_descriptor.hasNext() ) {
   6832 									adaptor.addChild(root_1, stream_reference_type_descriptor.nextTree());
   6833 								}
   6834 								stream_reference_type_descriptor.reset();
   6835 
   6836 								adaptor.addChild(root_1, stream_member_name.nextTree());
   6837 								adaptor.addChild(root_1, stream_method_prototype.nextTree());
   6838 								adaptor.addChild(root_0, root_1);
   6839 								}
   6840 
   6841 							}
   6842 
   6843 
   6844 							retval.tree = root_0;
   6845 
   6846 							}
   6847 							break;
   6848 
   6849 					}
   6850 
   6851 					}
   6852 
   6853 					}
   6854 					break;
   6855 				case 3 :
   6856 					// smaliParser.g:699:5: PRIMITIVE_TYPE
   6857 					{
   6858 					root_0 = (CommonTree)adaptor.nil();
   6859 
   6860 
   6861 					PRIMITIVE_TYPE173=(Token)match(input,PRIMITIVE_TYPE,FOLLOW_PRIMITIVE_TYPE_in_type_field_method_literal2959);
   6862 					PRIMITIVE_TYPE173_tree = (CommonTree)adaptor.create(PRIMITIVE_TYPE173);
   6863 					adaptor.addChild(root_0, PRIMITIVE_TYPE173_tree);
   6864 
   6865 					}
   6866 					break;
   6867 				case 4 :
   6868 					// smaliParser.g:700:5: VOID_TYPE
   6869 					{
   6870 					root_0 = (CommonTree)adaptor.nil();
   6871 
   6872 
   6873 					VOID_TYPE174=(Token)match(input,VOID_TYPE,FOLLOW_VOID_TYPE_in_type_field_method_literal2965);
   6874 					VOID_TYPE174_tree = (CommonTree)adaptor.create(VOID_TYPE174);
   6875 					adaptor.addChild(root_0, VOID_TYPE174_tree);
   6876 
   6877 					}
   6878 					break;
   6879 
   6880 			}
   6881 			retval.stop = input.LT(-1);
   6882 
   6883 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   6884 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   6885 
   6886 		}
   6887 		catch (RecognitionException re) {
   6888 			reportError(re);
   6889 			recover(input,re);
   6890 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   6891 		}
   6892 		finally {
   6893 			// do for sure before leaving
   6894 		}
   6895 		return retval;
   6896 	}
   6897 	// $ANTLR end "type_field_method_literal"
   6898 
   6899 
   6900 	public static class method_reference_return extends ParserRuleReturnScope {
   6901 		CommonTree tree;
   6902 		@Override
   6903 		public CommonTree getTree() { return tree; }
   6904 	};
   6905 
   6906 
   6907 	// $ANTLR start "method_reference"
   6908 	// smaliParser.g:702:1: method_reference : ( reference_type_descriptor ARROW )? member_name method_prototype -> ( reference_type_descriptor )? member_name method_prototype ;
   6909 	public final smaliParser.method_reference_return method_reference() throws RecognitionException {
   6910 		smaliParser.method_reference_return retval = new smaliParser.method_reference_return();
   6911 		retval.start = input.LT(1);
   6912 
   6913 		CommonTree root_0 = null;
   6914 
   6915 		Token ARROW176=null;
   6916 		ParserRuleReturnScope reference_type_descriptor175 =null;
   6917 		ParserRuleReturnScope member_name177 =null;
   6918 		ParserRuleReturnScope method_prototype178 =null;
   6919 
   6920 		CommonTree ARROW176_tree=null;
   6921 		RewriteRuleTokenStream stream_ARROW=new RewriteRuleTokenStream(adaptor,"token ARROW");
   6922 		RewriteRuleSubtreeStream stream_method_prototype=new RewriteRuleSubtreeStream(adaptor,"rule method_prototype");
   6923 		RewriteRuleSubtreeStream stream_member_name=new RewriteRuleSubtreeStream(adaptor,"rule member_name");
   6924 		RewriteRuleSubtreeStream stream_reference_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule reference_type_descriptor");
   6925 
   6926 		try {
   6927 			// smaliParser.g:703:3: ( ( reference_type_descriptor ARROW )? member_name method_prototype -> ( reference_type_descriptor )? member_name method_prototype )
   6928 			// smaliParser.g:703:5: ( reference_type_descriptor ARROW )? member_name method_prototype
   6929 			{
   6930 			// smaliParser.g:703:5: ( reference_type_descriptor ARROW )?
   6931 			int alt32=2;
   6932 			int LA32_0 = input.LA(1);
   6933 			if ( (LA32_0==ARRAY_TYPE_PREFIX||LA32_0==CLASS_DESCRIPTOR) ) {
   6934 				alt32=1;
   6935 			}
   6936 			switch (alt32) {
   6937 				case 1 :
   6938 					// smaliParser.g:703:6: reference_type_descriptor ARROW
   6939 					{
   6940 					pushFollow(FOLLOW_reference_type_descriptor_in_method_reference2976);
   6941 					reference_type_descriptor175=reference_type_descriptor();
   6942 					state._fsp--;
   6943 
   6944 					stream_reference_type_descriptor.add(reference_type_descriptor175.getTree());
   6945 					ARROW176=(Token)match(input,ARROW,FOLLOW_ARROW_in_method_reference2978);
   6946 					stream_ARROW.add(ARROW176);
   6947 
   6948 					}
   6949 					break;
   6950 
   6951 			}
   6952 
   6953 			pushFollow(FOLLOW_member_name_in_method_reference2982);
   6954 			member_name177=member_name();
   6955 			state._fsp--;
   6956 
   6957 			stream_member_name.add(member_name177.getTree());
   6958 			pushFollow(FOLLOW_method_prototype_in_method_reference2984);
   6959 			method_prototype178=method_prototype();
   6960 			state._fsp--;
   6961 
   6962 			stream_method_prototype.add(method_prototype178.getTree());
   6963 			// AST REWRITE
   6964 			// elements: method_prototype, reference_type_descriptor, member_name
   6965 			// token labels:
   6966 			// rule labels: retval
   6967 			// token list labels:
   6968 			// rule list labels:
   6969 			// wildcard labels:
   6970 			retval.tree = root_0;
   6971 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   6972 
   6973 			root_0 = (CommonTree)adaptor.nil();
   6974 			// 704:3: -> ( reference_type_descriptor )? member_name method_prototype
   6975 			{
   6976 				// smaliParser.g:704:6: ( reference_type_descriptor )?
   6977 				if ( stream_reference_type_descriptor.hasNext() ) {
   6978 					adaptor.addChild(root_0, stream_reference_type_descriptor.nextTree());
   6979 				}
   6980 				stream_reference_type_descriptor.reset();
   6981 
   6982 				adaptor.addChild(root_0, stream_member_name.nextTree());
   6983 				adaptor.addChild(root_0, stream_method_prototype.nextTree());
   6984 			}
   6985 
   6986 
   6987 			retval.tree = root_0;
   6988 
   6989 			}
   6990 
   6991 			retval.stop = input.LT(-1);
   6992 
   6993 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   6994 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   6995 
   6996 		}
   6997 		catch (RecognitionException re) {
   6998 			reportError(re);
   6999 			recover(input,re);
   7000 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   7001 		}
   7002 		finally {
   7003 			// do for sure before leaving
   7004 		}
   7005 		return retval;
   7006 	}
   7007 	// $ANTLR end "method_reference"
   7008 
   7009 
   7010 	public static class field_reference_return extends ParserRuleReturnScope {
   7011 		CommonTree tree;
   7012 		@Override
   7013 		public CommonTree getTree() { return tree; }
   7014 	};
   7015 
   7016 
   7017 	// $ANTLR start "field_reference"
   7018 	// smaliParser.g:706:1: field_reference : ( reference_type_descriptor ARROW )? member_name COLON nonvoid_type_descriptor -> ( reference_type_descriptor )? member_name nonvoid_type_descriptor ;
   7019 	public final smaliParser.field_reference_return field_reference() throws RecognitionException {
   7020 		smaliParser.field_reference_return retval = new smaliParser.field_reference_return();
   7021 		retval.start = input.LT(1);
   7022 
   7023 		CommonTree root_0 = null;
   7024 
   7025 		Token ARROW180=null;
   7026 		Token COLON182=null;
   7027 		ParserRuleReturnScope reference_type_descriptor179 =null;
   7028 		ParserRuleReturnScope member_name181 =null;
   7029 		ParserRuleReturnScope nonvoid_type_descriptor183 =null;
   7030 
   7031 		CommonTree ARROW180_tree=null;
   7032 		CommonTree COLON182_tree=null;
   7033 		RewriteRuleTokenStream stream_ARROW=new RewriteRuleTokenStream(adaptor,"token ARROW");
   7034 		RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON");
   7035 		RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor");
   7036 		RewriteRuleSubtreeStream stream_member_name=new RewriteRuleSubtreeStream(adaptor,"rule member_name");
   7037 		RewriteRuleSubtreeStream stream_reference_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule reference_type_descriptor");
   7038 
   7039 		try {
   7040 			// smaliParser.g:707:3: ( ( reference_type_descriptor ARROW )? member_name COLON nonvoid_type_descriptor -> ( reference_type_descriptor )? member_name nonvoid_type_descriptor )
   7041 			// smaliParser.g:707:5: ( reference_type_descriptor ARROW )? member_name COLON nonvoid_type_descriptor
   7042 			{
   7043 			// smaliParser.g:707:5: ( reference_type_descriptor ARROW )?
   7044 			int alt33=2;
   7045 			int LA33_0 = input.LA(1);
   7046 			if ( (LA33_0==ARRAY_TYPE_PREFIX||LA33_0==CLASS_DESCRIPTOR) ) {
   7047 				alt33=1;
   7048 			}
   7049 			switch (alt33) {
   7050 				case 1 :
   7051 					// smaliParser.g:707:6: reference_type_descriptor ARROW
   7052 					{
   7053 					pushFollow(FOLLOW_reference_type_descriptor_in_field_reference3006);
   7054 					reference_type_descriptor179=reference_type_descriptor();
   7055 					state._fsp--;
   7056 
   7057 					stream_reference_type_descriptor.add(reference_type_descriptor179.getTree());
   7058 					ARROW180=(Token)match(input,ARROW,FOLLOW_ARROW_in_field_reference3008);
   7059 					stream_ARROW.add(ARROW180);
   7060 
   7061 					}
   7062 					break;
   7063 
   7064 			}
   7065 
   7066 			pushFollow(FOLLOW_member_name_in_field_reference3012);
   7067 			member_name181=member_name();
   7068 			state._fsp--;
   7069 
   7070 			stream_member_name.add(member_name181.getTree());
   7071 			COLON182=(Token)match(input,COLON,FOLLOW_COLON_in_field_reference3014);
   7072 			stream_COLON.add(COLON182);
   7073 
   7074 			pushFollow(FOLLOW_nonvoid_type_descriptor_in_field_reference3016);
   7075 			nonvoid_type_descriptor183=nonvoid_type_descriptor();
   7076 			state._fsp--;
   7077 
   7078 			stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor183.getTree());
   7079 			// AST REWRITE
   7080 			// elements: reference_type_descriptor, nonvoid_type_descriptor, member_name
   7081 			// token labels:
   7082 			// rule labels: retval
   7083 			// token list labels:
   7084 			// rule list labels:
   7085 			// wildcard labels:
   7086 			retval.tree = root_0;
   7087 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   7088 
   7089 			root_0 = (CommonTree)adaptor.nil();
   7090 			// 708:3: -> ( reference_type_descriptor )? member_name nonvoid_type_descriptor
   7091 			{
   7092 				// smaliParser.g:708:6: ( reference_type_descriptor )?
   7093 				if ( stream_reference_type_descriptor.hasNext() ) {
   7094 					adaptor.addChild(root_0, stream_reference_type_descriptor.nextTree());
   7095 				}
   7096 				stream_reference_type_descriptor.reset();
   7097 
   7098 				adaptor.addChild(root_0, stream_member_name.nextTree());
   7099 				adaptor.addChild(root_0, stream_nonvoid_type_descriptor.nextTree());
   7100 			}
   7101 
   7102 
   7103 			retval.tree = root_0;
   7104 
   7105 			}
   7106 
   7107 			retval.stop = input.LT(-1);
   7108 
   7109 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   7110 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   7111 
   7112 		}
   7113 		catch (RecognitionException re) {
   7114 			reportError(re);
   7115 			recover(input,re);
   7116 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   7117 		}
   7118 		finally {
   7119 			// do for sure before leaving
   7120 		}
   7121 		return retval;
   7122 	}
   7123 	// $ANTLR end "field_reference"
   7124 
   7125 
   7126 	public static class label_return extends ParserRuleReturnScope {
   7127 		CommonTree tree;
   7128 		@Override
   7129 		public CommonTree getTree() { return tree; }
   7130 	};
   7131 
   7132 
   7133 	// $ANTLR start "label"
   7134 	// smaliParser.g:710:1: label : COLON simple_name -> ^( I_LABEL[$COLON, \"I_LABEL\"] simple_name ) ;
   7135 	public final smaliParser.label_return label() throws RecognitionException {
   7136 		smaliParser.label_return retval = new smaliParser.label_return();
   7137 		retval.start = input.LT(1);
   7138 
   7139 		CommonTree root_0 = null;
   7140 
   7141 		Token COLON184=null;
   7142 		ParserRuleReturnScope simple_name185 =null;
   7143 
   7144 		CommonTree COLON184_tree=null;
   7145 		RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON");
   7146 		RewriteRuleSubtreeStream stream_simple_name=new RewriteRuleSubtreeStream(adaptor,"rule simple_name");
   7147 
   7148 		try {
   7149 			// smaliParser.g:711:3: ( COLON simple_name -> ^( I_LABEL[$COLON, \"I_LABEL\"] simple_name ) )
   7150 			// smaliParser.g:711:5: COLON simple_name
   7151 			{
   7152 			COLON184=(Token)match(input,COLON,FOLLOW_COLON_in_label3037);
   7153 			stream_COLON.add(COLON184);
   7154 
   7155 			pushFollow(FOLLOW_simple_name_in_label3039);
   7156 			simple_name185=simple_name();
   7157 			state._fsp--;
   7158 
   7159 			stream_simple_name.add(simple_name185.getTree());
   7160 			// AST REWRITE
   7161 			// elements: simple_name
   7162 			// token labels:
   7163 			// rule labels: retval
   7164 			// token list labels:
   7165 			// rule list labels:
   7166 			// wildcard labels:
   7167 			retval.tree = root_0;
   7168 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   7169 
   7170 			root_0 = (CommonTree)adaptor.nil();
   7171 			// 711:23: -> ^( I_LABEL[$COLON, \"I_LABEL\"] simple_name )
   7172 			{
   7173 				// smaliParser.g:711:26: ^( I_LABEL[$COLON, \"I_LABEL\"] simple_name )
   7174 				{
   7175 				CommonTree root_1 = (CommonTree)adaptor.nil();
   7176 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_LABEL, COLON184, "I_LABEL"), root_1);
   7177 				adaptor.addChild(root_1, stream_simple_name.nextTree());
   7178 				adaptor.addChild(root_0, root_1);
   7179 				}
   7180 
   7181 			}
   7182 
   7183 
   7184 			retval.tree = root_0;
   7185 
   7186 			}
   7187 
   7188 			retval.stop = input.LT(-1);
   7189 
   7190 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   7191 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   7192 
   7193 		}
   7194 		catch (RecognitionException re) {
   7195 			reportError(re);
   7196 			recover(input,re);
   7197 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   7198 		}
   7199 		finally {
   7200 			// do for sure before leaving
   7201 		}
   7202 		return retval;
   7203 	}
   7204 	// $ANTLR end "label"
   7205 
   7206 
   7207 	public static class label_ref_return extends ParserRuleReturnScope {
   7208 		CommonTree tree;
   7209 		@Override
   7210 		public CommonTree getTree() { return tree; }
   7211 	};
   7212 
   7213 
   7214 	// $ANTLR start "label_ref"
   7215 	// smaliParser.g:713:1: label_ref : COLON simple_name -> simple_name ;
   7216 	public final smaliParser.label_ref_return label_ref() throws RecognitionException {
   7217 		smaliParser.label_ref_return retval = new smaliParser.label_ref_return();
   7218 		retval.start = input.LT(1);
   7219 
   7220 		CommonTree root_0 = null;
   7221 
   7222 		Token COLON186=null;
   7223 		ParserRuleReturnScope simple_name187 =null;
   7224 
   7225 		CommonTree COLON186_tree=null;
   7226 		RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON");
   7227 		RewriteRuleSubtreeStream stream_simple_name=new RewriteRuleSubtreeStream(adaptor,"rule simple_name");
   7228 
   7229 		try {
   7230 			// smaliParser.g:714:3: ( COLON simple_name -> simple_name )
   7231 			// smaliParser.g:714:5: COLON simple_name
   7232 			{
   7233 			COLON186=(Token)match(input,COLON,FOLLOW_COLON_in_label_ref3058);
   7234 			stream_COLON.add(COLON186);
   7235 
   7236 			pushFollow(FOLLOW_simple_name_in_label_ref3060);
   7237 			simple_name187=simple_name();
   7238 			state._fsp--;
   7239 
   7240 			stream_simple_name.add(simple_name187.getTree());
   7241 			// AST REWRITE
   7242 			// elements: simple_name
   7243 			// token labels:
   7244 			// rule labels: retval
   7245 			// token list labels:
   7246 			// rule list labels:
   7247 			// wildcard labels:
   7248 			retval.tree = root_0;
   7249 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   7250 
   7251 			root_0 = (CommonTree)adaptor.nil();
   7252 			// 714:23: -> simple_name
   7253 			{
   7254 				adaptor.addChild(root_0, stream_simple_name.nextTree());
   7255 			}
   7256 
   7257 
   7258 			retval.tree = root_0;
   7259 
   7260 			}
   7261 
   7262 			retval.stop = input.LT(-1);
   7263 
   7264 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   7265 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   7266 
   7267 		}
   7268 		catch (RecognitionException re) {
   7269 			reportError(re);
   7270 			recover(input,re);
   7271 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   7272 		}
   7273 		finally {
   7274 			// do for sure before leaving
   7275 		}
   7276 		return retval;
   7277 	}
   7278 	// $ANTLR end "label_ref"
   7279 
   7280 
   7281 	public static class register_list_return extends ParserRuleReturnScope {
   7282 		CommonTree tree;
   7283 		@Override
   7284 		public CommonTree getTree() { return tree; }
   7285 	};
   7286 
   7287 
   7288 	// $ANTLR start "register_list"
   7289 	// smaliParser.g:716:1: register_list : ( REGISTER ( COMMA REGISTER )* -> ^( I_REGISTER_LIST[$start, \"I_REGISTER_LIST\"] ( REGISTER )* ) | -> ^( I_REGISTER_LIST[$start, \"I_REGISTER_LIST\"] ) );
   7290 	public final smaliParser.register_list_return register_list() throws RecognitionException {
   7291 		smaliParser.register_list_return retval = new smaliParser.register_list_return();
   7292 		retval.start = input.LT(1);
   7293 
   7294 		CommonTree root_0 = null;
   7295 
   7296 		Token REGISTER188=null;
   7297 		Token COMMA189=null;
   7298 		Token REGISTER190=null;
   7299 
   7300 		CommonTree REGISTER188_tree=null;
   7301 		CommonTree COMMA189_tree=null;
   7302 		CommonTree REGISTER190_tree=null;
   7303 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   7304 		RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER");
   7305 
   7306 		try {
   7307 			// smaliParser.g:717:3: ( REGISTER ( COMMA REGISTER )* -> ^( I_REGISTER_LIST[$start, \"I_REGISTER_LIST\"] ( REGISTER )* ) | -> ^( I_REGISTER_LIST[$start, \"I_REGISTER_LIST\"] ) )
   7308 			int alt35=2;
   7309 			int LA35_0 = input.LA(1);
   7310 			if ( (LA35_0==REGISTER) ) {
   7311 				alt35=1;
   7312 			}
   7313 			else if ( (LA35_0==CLOSE_BRACE) ) {
   7314 				alt35=2;
   7315 			}
   7316 
   7317 			else {
   7318 				NoViableAltException nvae =
   7319 					new NoViableAltException("", 35, 0, input);
   7320 				throw nvae;
   7321 			}
   7322 
   7323 			switch (alt35) {
   7324 				case 1 :
   7325 					// smaliParser.g:717:5: REGISTER ( COMMA REGISTER )*
   7326 					{
   7327 					REGISTER188=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_register_list3074);
   7328 					stream_REGISTER.add(REGISTER188);
   7329 
   7330 					// smaliParser.g:717:14: ( COMMA REGISTER )*
   7331 					loop34:
   7332 					while (true) {
   7333 						int alt34=2;
   7334 						int LA34_0 = input.LA(1);
   7335 						if ( (LA34_0==COMMA) ) {
   7336 							alt34=1;
   7337 						}
   7338 
   7339 						switch (alt34) {
   7340 						case 1 :
   7341 							// smaliParser.g:717:15: COMMA REGISTER
   7342 							{
   7343 							COMMA189=(Token)match(input,COMMA,FOLLOW_COMMA_in_register_list3077);
   7344 							stream_COMMA.add(COMMA189);
   7345 
   7346 							REGISTER190=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_register_list3079);
   7347 							stream_REGISTER.add(REGISTER190);
   7348 
   7349 							}
   7350 							break;
   7351 
   7352 						default :
   7353 							break loop34;
   7354 						}
   7355 					}
   7356 
   7357 					// AST REWRITE
   7358 					// elements: REGISTER
   7359 					// token labels:
   7360 					// rule labels: retval
   7361 					// token list labels:
   7362 					// rule list labels:
   7363 					// wildcard labels:
   7364 					retval.tree = root_0;
   7365 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   7366 
   7367 					root_0 = (CommonTree)adaptor.nil();
   7368 					// 717:32: -> ^( I_REGISTER_LIST[$start, \"I_REGISTER_LIST\"] ( REGISTER )* )
   7369 					{
   7370 						// smaliParser.g:717:35: ^( I_REGISTER_LIST[$start, \"I_REGISTER_LIST\"] ( REGISTER )* )
   7371 						{
   7372 						CommonTree root_1 = (CommonTree)adaptor.nil();
   7373 						root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_REGISTER_LIST, (retval.start), "I_REGISTER_LIST"), root_1);
   7374 						// smaliParser.g:717:80: ( REGISTER )*
   7375 						while ( stream_REGISTER.hasNext() ) {
   7376 							adaptor.addChild(root_1, stream_REGISTER.nextNode());
   7377 						}
   7378 						stream_REGISTER.reset();
   7379 
   7380 						adaptor.addChild(root_0, root_1);
   7381 						}
   7382 
   7383 					}
   7384 
   7385 
   7386 					retval.tree = root_0;
   7387 
   7388 					}
   7389 					break;
   7390 				case 2 :
   7391 					// smaliParser.g:718:5:
   7392 					{
   7393 					// AST REWRITE
   7394 					// elements:
   7395 					// token labels:
   7396 					// rule labels: retval
   7397 					// token list labels:
   7398 					// rule list labels:
   7399 					// wildcard labels:
   7400 					retval.tree = root_0;
   7401 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   7402 
   7403 					root_0 = (CommonTree)adaptor.nil();
   7404 					// 718:5: -> ^( I_REGISTER_LIST[$start, \"I_REGISTER_LIST\"] )
   7405 					{
   7406 						// smaliParser.g:718:7: ^( I_REGISTER_LIST[$start, \"I_REGISTER_LIST\"] )
   7407 						{
   7408 						CommonTree root_1 = (CommonTree)adaptor.nil();
   7409 						root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_REGISTER_LIST, (retval.start), "I_REGISTER_LIST"), root_1);
   7410 						adaptor.addChild(root_0, root_1);
   7411 						}
   7412 
   7413 					}
   7414 
   7415 
   7416 					retval.tree = root_0;
   7417 
   7418 					}
   7419 					break;
   7420 
   7421 			}
   7422 			retval.stop = input.LT(-1);
   7423 
   7424 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   7425 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   7426 
   7427 		}
   7428 		catch (RecognitionException re) {
   7429 			reportError(re);
   7430 			recover(input,re);
   7431 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   7432 		}
   7433 		finally {
   7434 			// do for sure before leaving
   7435 		}
   7436 		return retval;
   7437 	}
   7438 	// $ANTLR end "register_list"
   7439 
   7440 
   7441 	public static class register_range_return extends ParserRuleReturnScope {
   7442 		CommonTree tree;
   7443 		@Override
   7444 		public CommonTree getTree() { return tree; }
   7445 	};
   7446 
   7447 
   7448 	// $ANTLR start "register_range"
   7449 	// smaliParser.g:720:1: register_range : (startreg= REGISTER ( DOTDOT endreg= REGISTER )? )? -> ^( I_REGISTER_RANGE[$start, \"I_REGISTER_RANGE\"] ( $startreg)? ( $endreg)? ) ;
   7450 	public final smaliParser.register_range_return register_range() throws RecognitionException {
   7451 		smaliParser.register_range_return retval = new smaliParser.register_range_return();
   7452 		retval.start = input.LT(1);
   7453 
   7454 		CommonTree root_0 = null;
   7455 
   7456 		Token startreg=null;
   7457 		Token endreg=null;
   7458 		Token DOTDOT191=null;
   7459 
   7460 		CommonTree startreg_tree=null;
   7461 		CommonTree endreg_tree=null;
   7462 		CommonTree DOTDOT191_tree=null;
   7463 		RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER");
   7464 		RewriteRuleTokenStream stream_DOTDOT=new RewriteRuleTokenStream(adaptor,"token DOTDOT");
   7465 
   7466 		try {
   7467 			// smaliParser.g:721:3: ( (startreg= REGISTER ( DOTDOT endreg= REGISTER )? )? -> ^( I_REGISTER_RANGE[$start, \"I_REGISTER_RANGE\"] ( $startreg)? ( $endreg)? ) )
   7468 			// smaliParser.g:721:5: (startreg= REGISTER ( DOTDOT endreg= REGISTER )? )?
   7469 			{
   7470 			// smaliParser.g:721:5: (startreg= REGISTER ( DOTDOT endreg= REGISTER )? )?
   7471 			int alt37=2;
   7472 			int LA37_0 = input.LA(1);
   7473 			if ( (LA37_0==REGISTER) ) {
   7474 				alt37=1;
   7475 			}
   7476 			switch (alt37) {
   7477 				case 1 :
   7478 					// smaliParser.g:721:6: startreg= REGISTER ( DOTDOT endreg= REGISTER )?
   7479 					{
   7480 					startreg=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_register_range3114);
   7481 					stream_REGISTER.add(startreg);
   7482 
   7483 					// smaliParser.g:721:24: ( DOTDOT endreg= REGISTER )?
   7484 					int alt36=2;
   7485 					int LA36_0 = input.LA(1);
   7486 					if ( (LA36_0==DOTDOT) ) {
   7487 						alt36=1;
   7488 					}
   7489 					switch (alt36) {
   7490 						case 1 :
   7491 							// smaliParser.g:721:25: DOTDOT endreg= REGISTER
   7492 							{
   7493 							DOTDOT191=(Token)match(input,DOTDOT,FOLLOW_DOTDOT_in_register_range3117);
   7494 							stream_DOTDOT.add(DOTDOT191);
   7495 
   7496 							endreg=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_register_range3121);
   7497 							stream_REGISTER.add(endreg);
   7498 
   7499 							}
   7500 							break;
   7501 
   7502 					}
   7503 
   7504 					}
   7505 					break;
   7506 
   7507 			}
   7508 
   7509 			// AST REWRITE
   7510 			// elements: startreg, endreg
   7511 			// token labels: startreg, endreg
   7512 			// rule labels: retval
   7513 			// token list labels:
   7514 			// rule list labels:
   7515 			// wildcard labels:
   7516 			retval.tree = root_0;
   7517 			RewriteRuleTokenStream stream_startreg=new RewriteRuleTokenStream(adaptor,"token startreg",startreg);
   7518 			RewriteRuleTokenStream stream_endreg=new RewriteRuleTokenStream(adaptor,"token endreg",endreg);
   7519 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   7520 
   7521 			root_0 = (CommonTree)adaptor.nil();
   7522 			// 721:52: -> ^( I_REGISTER_RANGE[$start, \"I_REGISTER_RANGE\"] ( $startreg)? ( $endreg)? )
   7523 			{
   7524 				// smaliParser.g:721:55: ^( I_REGISTER_RANGE[$start, \"I_REGISTER_RANGE\"] ( $startreg)? ( $endreg)? )
   7525 				{
   7526 				CommonTree root_1 = (CommonTree)adaptor.nil();
   7527 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_REGISTER_RANGE, (retval.start), "I_REGISTER_RANGE"), root_1);
   7528 				// smaliParser.g:721:103: ( $startreg)?
   7529 				if ( stream_startreg.hasNext() ) {
   7530 					adaptor.addChild(root_1, stream_startreg.nextNode());
   7531 				}
   7532 				stream_startreg.reset();
   7533 
   7534 				// smaliParser.g:721:114: ( $endreg)?
   7535 				if ( stream_endreg.hasNext() ) {
   7536 					adaptor.addChild(root_1, stream_endreg.nextNode());
   7537 				}
   7538 				stream_endreg.reset();
   7539 
   7540 				adaptor.addChild(root_0, root_1);
   7541 				}
   7542 
   7543 			}
   7544 
   7545 
   7546 			retval.tree = root_0;
   7547 
   7548 			}
   7549 
   7550 			retval.stop = input.LT(-1);
   7551 
   7552 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   7553 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   7554 
   7555 		}
   7556 		catch (RecognitionException re) {
   7557 			reportError(re);
   7558 			recover(input,re);
   7559 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   7560 		}
   7561 		finally {
   7562 			// do for sure before leaving
   7563 		}
   7564 		return retval;
   7565 	}
   7566 	// $ANTLR end "register_range"
   7567 
   7568 
   7569 	public static class verification_error_reference_return extends ParserRuleReturnScope {
   7570 		CommonTree tree;
   7571 		@Override
   7572 		public CommonTree getTree() { return tree; }
   7573 	};
   7574 
   7575 
   7576 	// $ANTLR start "verification_error_reference"
   7577 	// smaliParser.g:723:1: verification_error_reference : ( CLASS_DESCRIPTOR | field_reference | method_reference );
   7578 	public final smaliParser.verification_error_reference_return verification_error_reference() throws RecognitionException {
   7579 		smaliParser.verification_error_reference_return retval = new smaliParser.verification_error_reference_return();
   7580 		retval.start = input.LT(1);
   7581 
   7582 		CommonTree root_0 = null;
   7583 
   7584 		Token CLASS_DESCRIPTOR192=null;
   7585 		ParserRuleReturnScope field_reference193 =null;
   7586 		ParserRuleReturnScope method_reference194 =null;
   7587 
   7588 		CommonTree CLASS_DESCRIPTOR192_tree=null;
   7589 
   7590 		try {
   7591 			// smaliParser.g:724:3: ( CLASS_DESCRIPTOR | field_reference | method_reference )
   7592 			int alt38=3;
   7593 			alt38 = dfa38.predict(input);
   7594 			switch (alt38) {
   7595 				case 1 :
   7596 					// smaliParser.g:724:5: CLASS_DESCRIPTOR
   7597 					{
   7598 					root_0 = (CommonTree)adaptor.nil();
   7599 
   7600 
   7601 					CLASS_DESCRIPTOR192=(Token)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_verification_error_reference3150);
   7602 					CLASS_DESCRIPTOR192_tree = (CommonTree)adaptor.create(CLASS_DESCRIPTOR192);
   7603 					adaptor.addChild(root_0, CLASS_DESCRIPTOR192_tree);
   7604 
   7605 					}
   7606 					break;
   7607 				case 2 :
   7608 					// smaliParser.g:724:24: field_reference
   7609 					{
   7610 					root_0 = (CommonTree)adaptor.nil();
   7611 
   7612 
   7613 					pushFollow(FOLLOW_field_reference_in_verification_error_reference3154);
   7614 					field_reference193=field_reference();
   7615 					state._fsp--;
   7616 
   7617 					adaptor.addChild(root_0, field_reference193.getTree());
   7618 
   7619 					}
   7620 					break;
   7621 				case 3 :
   7622 					// smaliParser.g:724:42: method_reference
   7623 					{
   7624 					root_0 = (CommonTree)adaptor.nil();
   7625 
   7626 
   7627 					pushFollow(FOLLOW_method_reference_in_verification_error_reference3158);
   7628 					method_reference194=method_reference();
   7629 					state._fsp--;
   7630 
   7631 					adaptor.addChild(root_0, method_reference194.getTree());
   7632 
   7633 					}
   7634 					break;
   7635 
   7636 			}
   7637 			retval.stop = input.LT(-1);
   7638 
   7639 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   7640 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   7641 
   7642 		}
   7643 		catch (RecognitionException re) {
   7644 			reportError(re);
   7645 			recover(input,re);
   7646 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   7647 		}
   7648 		finally {
   7649 			// do for sure before leaving
   7650 		}
   7651 		return retval;
   7652 	}
   7653 	// $ANTLR end "verification_error_reference"
   7654 
   7655 
   7656 	public static class catch_directive_return extends ParserRuleReturnScope {
   7657 		CommonTree tree;
   7658 		@Override
   7659 		public CommonTree getTree() { return tree; }
   7660 	};
   7661 
   7662 
   7663 	// $ANTLR start "catch_directive"
   7664 	// smaliParser.g:726:1: catch_directive : CATCH_DIRECTIVE nonvoid_type_descriptor OPEN_BRACE from= label_ref DOTDOT to= label_ref CLOSE_BRACE using= label_ref -> ^( I_CATCH[$start, \"I_CATCH\"] nonvoid_type_descriptor $from $to $using) ;
   7665 	public final smaliParser.catch_directive_return catch_directive() throws RecognitionException {
   7666 		smaliParser.catch_directive_return retval = new smaliParser.catch_directive_return();
   7667 		retval.start = input.LT(1);
   7668 
   7669 		CommonTree root_0 = null;
   7670 
   7671 		Token CATCH_DIRECTIVE195=null;
   7672 		Token OPEN_BRACE197=null;
   7673 		Token DOTDOT198=null;
   7674 		Token CLOSE_BRACE199=null;
   7675 		ParserRuleReturnScope from =null;
   7676 		ParserRuleReturnScope to =null;
   7677 		ParserRuleReturnScope using =null;
   7678 		ParserRuleReturnScope nonvoid_type_descriptor196 =null;
   7679 
   7680 		CommonTree CATCH_DIRECTIVE195_tree=null;
   7681 		CommonTree OPEN_BRACE197_tree=null;
   7682 		CommonTree DOTDOT198_tree=null;
   7683 		CommonTree CLOSE_BRACE199_tree=null;
   7684 		RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
   7685 		RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
   7686 		RewriteRuleTokenStream stream_DOTDOT=new RewriteRuleTokenStream(adaptor,"token DOTDOT");
   7687 		RewriteRuleTokenStream stream_CATCH_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token CATCH_DIRECTIVE");
   7688 		RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref");
   7689 		RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor");
   7690 
   7691 		try {
   7692 			// smaliParser.g:727:3: ( CATCH_DIRECTIVE nonvoid_type_descriptor OPEN_BRACE from= label_ref DOTDOT to= label_ref CLOSE_BRACE using= label_ref -> ^( I_CATCH[$start, \"I_CATCH\"] nonvoid_type_descriptor $from $to $using) )
   7693 			// smaliParser.g:727:5: CATCH_DIRECTIVE nonvoid_type_descriptor OPEN_BRACE from= label_ref DOTDOT to= label_ref CLOSE_BRACE using= label_ref
   7694 			{
   7695 			CATCH_DIRECTIVE195=(Token)match(input,CATCH_DIRECTIVE,FOLLOW_CATCH_DIRECTIVE_in_catch_directive3168);
   7696 			stream_CATCH_DIRECTIVE.add(CATCH_DIRECTIVE195);
   7697 
   7698 			pushFollow(FOLLOW_nonvoid_type_descriptor_in_catch_directive3170);
   7699 			nonvoid_type_descriptor196=nonvoid_type_descriptor();
   7700 			state._fsp--;
   7701 
   7702 			stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor196.getTree());
   7703 			OPEN_BRACE197=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_catch_directive3172);
   7704 			stream_OPEN_BRACE.add(OPEN_BRACE197);
   7705 
   7706 			pushFollow(FOLLOW_label_ref_in_catch_directive3176);
   7707 			from=label_ref();
   7708 			state._fsp--;
   7709 
   7710 			stream_label_ref.add(from.getTree());
   7711 			DOTDOT198=(Token)match(input,DOTDOT,FOLLOW_DOTDOT_in_catch_directive3178);
   7712 			stream_DOTDOT.add(DOTDOT198);
   7713 
   7714 			pushFollow(FOLLOW_label_ref_in_catch_directive3182);
   7715 			to=label_ref();
   7716 			state._fsp--;
   7717 
   7718 			stream_label_ref.add(to.getTree());
   7719 			CLOSE_BRACE199=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_catch_directive3184);
   7720 			stream_CLOSE_BRACE.add(CLOSE_BRACE199);
   7721 
   7722 			pushFollow(FOLLOW_label_ref_in_catch_directive3188);
   7723 			using=label_ref();
   7724 			state._fsp--;
   7725 
   7726 			stream_label_ref.add(using.getTree());
   7727 			// AST REWRITE
   7728 			// elements: from, nonvoid_type_descriptor, using, to
   7729 			// token labels:
   7730 			// rule labels: using, from, to, retval
   7731 			// token list labels:
   7732 			// rule list labels:
   7733 			// wildcard labels:
   7734 			retval.tree = root_0;
   7735 			RewriteRuleSubtreeStream stream_using=new RewriteRuleSubtreeStream(adaptor,"rule using",using!=null?using.getTree():null);
   7736 			RewriteRuleSubtreeStream stream_from=new RewriteRuleSubtreeStream(adaptor,"rule from",from!=null?from.getTree():null);
   7737 			RewriteRuleSubtreeStream stream_to=new RewriteRuleSubtreeStream(adaptor,"rule to",to!=null?to.getTree():null);
   7738 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   7739 
   7740 			root_0 = (CommonTree)adaptor.nil();
   7741 			// 728:5: -> ^( I_CATCH[$start, \"I_CATCH\"] nonvoid_type_descriptor $from $to $using)
   7742 			{
   7743 				// smaliParser.g:728:8: ^( I_CATCH[$start, \"I_CATCH\"] nonvoid_type_descriptor $from $to $using)
   7744 				{
   7745 				CommonTree root_1 = (CommonTree)adaptor.nil();
   7746 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_CATCH, (retval.start), "I_CATCH"), root_1);
   7747 				adaptor.addChild(root_1, stream_nonvoid_type_descriptor.nextTree());
   7748 				adaptor.addChild(root_1, stream_from.nextTree());
   7749 				adaptor.addChild(root_1, stream_to.nextTree());
   7750 				adaptor.addChild(root_1, stream_using.nextTree());
   7751 				adaptor.addChild(root_0, root_1);
   7752 				}
   7753 
   7754 			}
   7755 
   7756 
   7757 			retval.tree = root_0;
   7758 
   7759 			}
   7760 
   7761 			retval.stop = input.LT(-1);
   7762 
   7763 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   7764 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   7765 
   7766 		}
   7767 		catch (RecognitionException re) {
   7768 			reportError(re);
   7769 			recover(input,re);
   7770 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   7771 		}
   7772 		finally {
   7773 			// do for sure before leaving
   7774 		}
   7775 		return retval;
   7776 	}
   7777 	// $ANTLR end "catch_directive"
   7778 
   7779 
   7780 	public static class catchall_directive_return extends ParserRuleReturnScope {
   7781 		CommonTree tree;
   7782 		@Override
   7783 		public CommonTree getTree() { return tree; }
   7784 	};
   7785 
   7786 
   7787 	// $ANTLR start "catchall_directive"
   7788 	// smaliParser.g:730:1: catchall_directive : CATCHALL_DIRECTIVE OPEN_BRACE from= label_ref DOTDOT to= label_ref CLOSE_BRACE using= label_ref -> ^( I_CATCHALL[$start, \"I_CATCHALL\"] $from $to $using) ;
   7789 	public final smaliParser.catchall_directive_return catchall_directive() throws RecognitionException {
   7790 		smaliParser.catchall_directive_return retval = new smaliParser.catchall_directive_return();
   7791 		retval.start = input.LT(1);
   7792 
   7793 		CommonTree root_0 = null;
   7794 
   7795 		Token CATCHALL_DIRECTIVE200=null;
   7796 		Token OPEN_BRACE201=null;
   7797 		Token DOTDOT202=null;
   7798 		Token CLOSE_BRACE203=null;
   7799 		ParserRuleReturnScope from =null;
   7800 		ParserRuleReturnScope to =null;
   7801 		ParserRuleReturnScope using =null;
   7802 
   7803 		CommonTree CATCHALL_DIRECTIVE200_tree=null;
   7804 		CommonTree OPEN_BRACE201_tree=null;
   7805 		CommonTree DOTDOT202_tree=null;
   7806 		CommonTree CLOSE_BRACE203_tree=null;
   7807 		RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
   7808 		RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
   7809 		RewriteRuleTokenStream stream_DOTDOT=new RewriteRuleTokenStream(adaptor,"token DOTDOT");
   7810 		RewriteRuleTokenStream stream_CATCHALL_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token CATCHALL_DIRECTIVE");
   7811 		RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref");
   7812 
   7813 		try {
   7814 			// smaliParser.g:731:3: ( CATCHALL_DIRECTIVE OPEN_BRACE from= label_ref DOTDOT to= label_ref CLOSE_BRACE using= label_ref -> ^( I_CATCHALL[$start, \"I_CATCHALL\"] $from $to $using) )
   7815 			// smaliParser.g:731:5: CATCHALL_DIRECTIVE OPEN_BRACE from= label_ref DOTDOT to= label_ref CLOSE_BRACE using= label_ref
   7816 			{
   7817 			CATCHALL_DIRECTIVE200=(Token)match(input,CATCHALL_DIRECTIVE,FOLLOW_CATCHALL_DIRECTIVE_in_catchall_directive3220);
   7818 			stream_CATCHALL_DIRECTIVE.add(CATCHALL_DIRECTIVE200);
   7819 
   7820 			OPEN_BRACE201=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_catchall_directive3222);
   7821 			stream_OPEN_BRACE.add(OPEN_BRACE201);
   7822 
   7823 			pushFollow(FOLLOW_label_ref_in_catchall_directive3226);
   7824 			from=label_ref();
   7825 			state._fsp--;
   7826 
   7827 			stream_label_ref.add(from.getTree());
   7828 			DOTDOT202=(Token)match(input,DOTDOT,FOLLOW_DOTDOT_in_catchall_directive3228);
   7829 			stream_DOTDOT.add(DOTDOT202);
   7830 
   7831 			pushFollow(FOLLOW_label_ref_in_catchall_directive3232);
   7832 			to=label_ref();
   7833 			state._fsp--;
   7834 
   7835 			stream_label_ref.add(to.getTree());
   7836 			CLOSE_BRACE203=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_catchall_directive3234);
   7837 			stream_CLOSE_BRACE.add(CLOSE_BRACE203);
   7838 
   7839 			pushFollow(FOLLOW_label_ref_in_catchall_directive3238);
   7840 			using=label_ref();
   7841 			state._fsp--;
   7842 
   7843 			stream_label_ref.add(using.getTree());
   7844 			// AST REWRITE
   7845 			// elements: using, to, from
   7846 			// token labels:
   7847 			// rule labels: using, from, to, retval
   7848 			// token list labels:
   7849 			// rule list labels:
   7850 			// wildcard labels:
   7851 			retval.tree = root_0;
   7852 			RewriteRuleSubtreeStream stream_using=new RewriteRuleSubtreeStream(adaptor,"rule using",using!=null?using.getTree():null);
   7853 			RewriteRuleSubtreeStream stream_from=new RewriteRuleSubtreeStream(adaptor,"rule from",from!=null?from.getTree():null);
   7854 			RewriteRuleSubtreeStream stream_to=new RewriteRuleSubtreeStream(adaptor,"rule to",to!=null?to.getTree():null);
   7855 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   7856 
   7857 			root_0 = (CommonTree)adaptor.nil();
   7858 			// 732:5: -> ^( I_CATCHALL[$start, \"I_CATCHALL\"] $from $to $using)
   7859 			{
   7860 				// smaliParser.g:732:8: ^( I_CATCHALL[$start, \"I_CATCHALL\"] $from $to $using)
   7861 				{
   7862 				CommonTree root_1 = (CommonTree)adaptor.nil();
   7863 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_CATCHALL, (retval.start), "I_CATCHALL"), root_1);
   7864 				adaptor.addChild(root_1, stream_from.nextTree());
   7865 				adaptor.addChild(root_1, stream_to.nextTree());
   7866 				adaptor.addChild(root_1, stream_using.nextTree());
   7867 				adaptor.addChild(root_0, root_1);
   7868 				}
   7869 
   7870 			}
   7871 
   7872 
   7873 			retval.tree = root_0;
   7874 
   7875 			}
   7876 
   7877 			retval.stop = input.LT(-1);
   7878 
   7879 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   7880 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   7881 
   7882 		}
   7883 		catch (RecognitionException re) {
   7884 			reportError(re);
   7885 			recover(input,re);
   7886 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   7887 		}
   7888 		finally {
   7889 			// do for sure before leaving
   7890 		}
   7891 		return retval;
   7892 	}
   7893 	// $ANTLR end "catchall_directive"
   7894 
   7895 
   7896 	public static class parameter_directive_return extends ParserRuleReturnScope {
   7897 		CommonTree tree;
   7898 		@Override
   7899 		public CommonTree getTree() { return tree; }
   7900 	};
   7901 
   7902 
   7903 	// $ANTLR start "parameter_directive"
   7904 	// smaliParser.g:738:1: parameter_directive : PARAMETER_DIRECTIVE REGISTER ( COMMA STRING_LITERAL )? ({...}? annotation )* ( END_PARAMETER_DIRECTIVE -> ^( I_PARAMETER[$start, \"I_PARAMETER\"] REGISTER ( STRING_LITERAL )? ^( I_ANNOTATIONS ( annotation )* ) ) | -> ^( I_PARAMETER[$start, \"I_PARAMETER\"] REGISTER ( STRING_LITERAL )? ^( I_ANNOTATIONS ) ) ) ;
   7905 	public final smaliParser.parameter_directive_return parameter_directive() throws RecognitionException {
   7906 		smaliParser.parameter_directive_return retval = new smaliParser.parameter_directive_return();
   7907 		retval.start = input.LT(1);
   7908 
   7909 		CommonTree root_0 = null;
   7910 
   7911 		Token PARAMETER_DIRECTIVE204=null;
   7912 		Token REGISTER205=null;
   7913 		Token COMMA206=null;
   7914 		Token STRING_LITERAL207=null;
   7915 		Token END_PARAMETER_DIRECTIVE209=null;
   7916 		ParserRuleReturnScope annotation208 =null;
   7917 
   7918 		CommonTree PARAMETER_DIRECTIVE204_tree=null;
   7919 		CommonTree REGISTER205_tree=null;
   7920 		CommonTree COMMA206_tree=null;
   7921 		CommonTree STRING_LITERAL207_tree=null;
   7922 		CommonTree END_PARAMETER_DIRECTIVE209_tree=null;
   7923 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   7924 		RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER");
   7925 		RewriteRuleTokenStream stream_PARAMETER_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token PARAMETER_DIRECTIVE");
   7926 		RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL");
   7927 		RewriteRuleTokenStream stream_END_PARAMETER_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_PARAMETER_DIRECTIVE");
   7928 		RewriteRuleSubtreeStream stream_annotation=new RewriteRuleSubtreeStream(adaptor,"rule annotation");
   7929 
   7930 		List<CommonTree> annotations = new ArrayList<CommonTree>();
   7931 		try {
   7932 			// smaliParser.g:740:3: ( PARAMETER_DIRECTIVE REGISTER ( COMMA STRING_LITERAL )? ({...}? annotation )* ( END_PARAMETER_DIRECTIVE -> ^( I_PARAMETER[$start, \"I_PARAMETER\"] REGISTER ( STRING_LITERAL )? ^( I_ANNOTATIONS ( annotation )* ) ) | -> ^( I_PARAMETER[$start, \"I_PARAMETER\"] REGISTER ( STRING_LITERAL )? ^( I_ANNOTATIONS ) ) ) )
   7933 			// smaliParser.g:740:5: PARAMETER_DIRECTIVE REGISTER ( COMMA STRING_LITERAL )? ({...}? annotation )* ( END_PARAMETER_DIRECTIVE -> ^( I_PARAMETER[$start, \"I_PARAMETER\"] REGISTER ( STRING_LITERAL )? ^( I_ANNOTATIONS ( annotation )* ) ) | -> ^( I_PARAMETER[$start, \"I_PARAMETER\"] REGISTER ( STRING_LITERAL )? ^( I_ANNOTATIONS ) ) )
   7934 			{
   7935 			PARAMETER_DIRECTIVE204=(Token)match(input,PARAMETER_DIRECTIVE,FOLLOW_PARAMETER_DIRECTIVE_in_parameter_directive3277);
   7936 			stream_PARAMETER_DIRECTIVE.add(PARAMETER_DIRECTIVE204);
   7937 
   7938 			REGISTER205=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_parameter_directive3279);
   7939 			stream_REGISTER.add(REGISTER205);
   7940 
   7941 			// smaliParser.g:740:34: ( COMMA STRING_LITERAL )?
   7942 			int alt39=2;
   7943 			int LA39_0 = input.LA(1);
   7944 			if ( (LA39_0==COMMA) ) {
   7945 				alt39=1;
   7946 			}
   7947 			switch (alt39) {
   7948 				case 1 :
   7949 					// smaliParser.g:740:35: COMMA STRING_LITERAL
   7950 					{
   7951 					COMMA206=(Token)match(input,COMMA,FOLLOW_COMMA_in_parameter_directive3282);
   7952 					stream_COMMA.add(COMMA206);
   7953 
   7954 					STRING_LITERAL207=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_parameter_directive3284);
   7955 					stream_STRING_LITERAL.add(STRING_LITERAL207);
   7956 
   7957 					}
   7958 					break;
   7959 
   7960 			}
   7961 
   7962 			// smaliParser.g:741:5: ({...}? annotation )*
   7963 			loop40:
   7964 			while (true) {
   7965 				int alt40=2;
   7966 				alt40 = dfa40.predict(input);
   7967 				switch (alt40) {
   7968 				case 1 :
   7969 					// smaliParser.g:741:6: {...}? annotation
   7970 					{
   7971 					if ( !((input.LA(1) == ANNOTATION_DIRECTIVE)) ) {
   7972 						throw new FailedPredicateException(input, "parameter_directive", "input.LA(1) == ANNOTATION_DIRECTIVE");
   7973 					}
   7974 					pushFollow(FOLLOW_annotation_in_parameter_directive3295);
   7975 					annotation208=annotation();
   7976 					state._fsp--;
   7977 
   7978 					stream_annotation.add(annotation208.getTree());
   7979 					annotations.add((annotation208!=null?((CommonTree)annotation208.getTree()):null));
   7980 					}
   7981 					break;
   7982 
   7983 				default :
   7984 					break loop40;
   7985 				}
   7986 			}
   7987 
   7988 			// smaliParser.g:743:5: ( END_PARAMETER_DIRECTIVE -> ^( I_PARAMETER[$start, \"I_PARAMETER\"] REGISTER ( STRING_LITERAL )? ^( I_ANNOTATIONS ( annotation )* ) ) | -> ^( I_PARAMETER[$start, \"I_PARAMETER\"] REGISTER ( STRING_LITERAL )? ^( I_ANNOTATIONS ) ) )
   7989 			int alt41=2;
   7990 			int LA41_0 = input.LA(1);
   7991 			if ( (LA41_0==END_PARAMETER_DIRECTIVE) ) {
   7992 				alt41=1;
   7993 			}
   7994 			else if ( (LA41_0==ANNOTATION_DIRECTIVE||LA41_0==ARRAY_DATA_DIRECTIVE||(LA41_0 >= CATCHALL_DIRECTIVE && LA41_0 <= CATCH_DIRECTIVE)||LA41_0==COLON||(LA41_0 >= END_LOCAL_DIRECTIVE && LA41_0 <= END_METHOD_DIRECTIVE)||LA41_0==EPILOGUE_DIRECTIVE||(LA41_0 >= INSTRUCTION_FORMAT10t && LA41_0 <= INSTRUCTION_FORMAT51l)||(LA41_0 >= LINE_DIRECTIVE && LA41_0 <= LOCAL_DIRECTIVE)||(LA41_0 >= PACKED_SWITCH_DIRECTIVE && LA41_0 <= PARAMETER_DIRECTIVE)||LA41_0==PROLOGUE_DIRECTIVE||(LA41_0 >= REGISTERS_DIRECTIVE && LA41_0 <= RESTART_LOCAL_DIRECTIVE)||(LA41_0 >= SOURCE_DIRECTIVE && LA41_0 <= SPARSE_SWITCH_DIRECTIVE)) ) {
   7995 				alt41=2;
   7996 			}
   7997 
   7998 			else {
   7999 				NoViableAltException nvae =
   8000 					new NoViableAltException("", 41, 0, input);
   8001 				throw nvae;
   8002 			}
   8003 
   8004 			switch (alt41) {
   8005 				case 1 :
   8006 					// smaliParser.g:743:7: END_PARAMETER_DIRECTIVE
   8007 					{
   8008 					END_PARAMETER_DIRECTIVE209=(Token)match(input,END_PARAMETER_DIRECTIVE,FOLLOW_END_PARAMETER_DIRECTIVE_in_parameter_directive3308);
   8009 					stream_END_PARAMETER_DIRECTIVE.add(END_PARAMETER_DIRECTIVE209);
   8010 
   8011 					// AST REWRITE
   8012 					// elements: STRING_LITERAL, annotation, REGISTER
   8013 					// token labels:
   8014 					// rule labels: retval
   8015 					// token list labels:
   8016 					// rule list labels:
   8017 					// wildcard labels:
   8018 					retval.tree = root_0;
   8019 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   8020 
   8021 					root_0 = (CommonTree)adaptor.nil();
   8022 					// 744:7: -> ^( I_PARAMETER[$start, \"I_PARAMETER\"] REGISTER ( STRING_LITERAL )? ^( I_ANNOTATIONS ( annotation )* ) )
   8023 					{
   8024 						// smaliParser.g:744:10: ^( I_PARAMETER[$start, \"I_PARAMETER\"] REGISTER ( STRING_LITERAL )? ^( I_ANNOTATIONS ( annotation )* ) )
   8025 						{
   8026 						CommonTree root_1 = (CommonTree)adaptor.nil();
   8027 						root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_PARAMETER, (retval.start), "I_PARAMETER"), root_1);
   8028 						adaptor.addChild(root_1, stream_REGISTER.nextNode());
   8029 						// smaliParser.g:744:56: ( STRING_LITERAL )?
   8030 						if ( stream_STRING_LITERAL.hasNext() ) {
   8031 							adaptor.addChild(root_1, stream_STRING_LITERAL.nextNode());
   8032 						}
   8033 						stream_STRING_LITERAL.reset();
   8034 
   8035 						// smaliParser.g:744:72: ^( I_ANNOTATIONS ( annotation )* )
   8036 						{
   8037 						CommonTree root_2 = (CommonTree)adaptor.nil();
   8038 						root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ANNOTATIONS, "I_ANNOTATIONS"), root_2);
   8039 						// smaliParser.g:744:88: ( annotation )*
   8040 						while ( stream_annotation.hasNext() ) {
   8041 							adaptor.addChild(root_2, stream_annotation.nextTree());
   8042 						}
   8043 						stream_annotation.reset();
   8044 
   8045 						adaptor.addChild(root_1, root_2);
   8046 						}
   8047 
   8048 						adaptor.addChild(root_0, root_1);
   8049 						}
   8050 
   8051 					}
   8052 
   8053 
   8054 					retval.tree = root_0;
   8055 
   8056 					}
   8057 					break;
   8058 				case 2 :
   8059 					// smaliParser.g:745:19:
   8060 					{
   8061 					statements_and_directives_stack.peek().methodAnnotations.addAll(annotations);
   8062 					// AST REWRITE
   8063 					// elements: STRING_LITERAL, REGISTER
   8064 					// token labels:
   8065 					// rule labels: retval
   8066 					// token list labels:
   8067 					// rule list labels:
   8068 					// wildcard labels:
   8069 					retval.tree = root_0;
   8070 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   8071 
   8072 					root_0 = (CommonTree)adaptor.nil();
   8073 					// 746:7: -> ^( I_PARAMETER[$start, \"I_PARAMETER\"] REGISTER ( STRING_LITERAL )? ^( I_ANNOTATIONS ) )
   8074 					{
   8075 						// smaliParser.g:746:10: ^( I_PARAMETER[$start, \"I_PARAMETER\"] REGISTER ( STRING_LITERAL )? ^( I_ANNOTATIONS ) )
   8076 						{
   8077 						CommonTree root_1 = (CommonTree)adaptor.nil();
   8078 						root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_PARAMETER, (retval.start), "I_PARAMETER"), root_1);
   8079 						adaptor.addChild(root_1, stream_REGISTER.nextNode());
   8080 						// smaliParser.g:746:56: ( STRING_LITERAL )?
   8081 						if ( stream_STRING_LITERAL.hasNext() ) {
   8082 							adaptor.addChild(root_1, stream_STRING_LITERAL.nextNode());
   8083 						}
   8084 						stream_STRING_LITERAL.reset();
   8085 
   8086 						// smaliParser.g:746:72: ^( I_ANNOTATIONS )
   8087 						{
   8088 						CommonTree root_2 = (CommonTree)adaptor.nil();
   8089 						root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ANNOTATIONS, "I_ANNOTATIONS"), root_2);
   8090 						adaptor.addChild(root_1, root_2);
   8091 						}
   8092 
   8093 						adaptor.addChild(root_0, root_1);
   8094 						}
   8095 
   8096 					}
   8097 
   8098 
   8099 					retval.tree = root_0;
   8100 
   8101 					}
   8102 					break;
   8103 
   8104 			}
   8105 
   8106 			}
   8107 
   8108 			retval.stop = input.LT(-1);
   8109 
   8110 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   8111 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   8112 
   8113 		}
   8114 		catch (RecognitionException re) {
   8115 			reportError(re);
   8116 			recover(input,re);
   8117 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   8118 		}
   8119 		finally {
   8120 			// do for sure before leaving
   8121 		}
   8122 		return retval;
   8123 	}
   8124 	// $ANTLR end "parameter_directive"
   8125 
   8126 
   8127 	public static class debug_directive_return extends ParserRuleReturnScope {
   8128 		CommonTree tree;
   8129 		@Override
   8130 		public CommonTree getTree() { return tree; }
   8131 	};
   8132 
   8133 
   8134 	// $ANTLR start "debug_directive"
   8135 	// smaliParser.g:749:1: debug_directive : ( line_directive | local_directive | end_local_directive | restart_local_directive | prologue_directive | epilogue_directive | source_directive );
   8136 	public final smaliParser.debug_directive_return debug_directive() throws RecognitionException {
   8137 		smaliParser.debug_directive_return retval = new smaliParser.debug_directive_return();
   8138 		retval.start = input.LT(1);
   8139 
   8140 		CommonTree root_0 = null;
   8141 
   8142 		ParserRuleReturnScope line_directive210 =null;
   8143 		ParserRuleReturnScope local_directive211 =null;
   8144 		ParserRuleReturnScope end_local_directive212 =null;
   8145 		ParserRuleReturnScope restart_local_directive213 =null;
   8146 		ParserRuleReturnScope prologue_directive214 =null;
   8147 		ParserRuleReturnScope epilogue_directive215 =null;
   8148 		ParserRuleReturnScope source_directive216 =null;
   8149 
   8150 
   8151 		try {
   8152 			// smaliParser.g:750:3: ( line_directive | local_directive | end_local_directive | restart_local_directive | prologue_directive | epilogue_directive | source_directive )
   8153 			int alt42=7;
   8154 			switch ( input.LA(1) ) {
   8155 			case LINE_DIRECTIVE:
   8156 				{
   8157 				alt42=1;
   8158 				}
   8159 				break;
   8160 			case LOCAL_DIRECTIVE:
   8161 				{
   8162 				alt42=2;
   8163 				}
   8164 				break;
   8165 			case END_LOCAL_DIRECTIVE:
   8166 				{
   8167 				alt42=3;
   8168 				}
   8169 				break;
   8170 			case RESTART_LOCAL_DIRECTIVE:
   8171 				{
   8172 				alt42=4;
   8173 				}
   8174 				break;
   8175 			case PROLOGUE_DIRECTIVE:
   8176 				{
   8177 				alt42=5;
   8178 				}
   8179 				break;
   8180 			case EPILOGUE_DIRECTIVE:
   8181 				{
   8182 				alt42=6;
   8183 				}
   8184 				break;
   8185 			case SOURCE_DIRECTIVE:
   8186 				{
   8187 				alt42=7;
   8188 				}
   8189 				break;
   8190 			default:
   8191 				NoViableAltException nvae =
   8192 					new NoViableAltException("", 42, 0, input);
   8193 				throw nvae;
   8194 			}
   8195 			switch (alt42) {
   8196 				case 1 :
   8197 					// smaliParser.g:750:5: line_directive
   8198 					{
   8199 					root_0 = (CommonTree)adaptor.nil();
   8200 
   8201 
   8202 					pushFollow(FOLLOW_line_directive_in_debug_directive3381);
   8203 					line_directive210=line_directive();
   8204 					state._fsp--;
   8205 
   8206 					adaptor.addChild(root_0, line_directive210.getTree());
   8207 
   8208 					}
   8209 					break;
   8210 				case 2 :
   8211 					// smaliParser.g:751:5: local_directive
   8212 					{
   8213 					root_0 = (CommonTree)adaptor.nil();
   8214 
   8215 
   8216 					pushFollow(FOLLOW_local_directive_in_debug_directive3387);
   8217 					local_directive211=local_directive();
   8218 					state._fsp--;
   8219 
   8220 					adaptor.addChild(root_0, local_directive211.getTree());
   8221 
   8222 					}
   8223 					break;
   8224 				case 3 :
   8225 					// smaliParser.g:752:5: end_local_directive
   8226 					{
   8227 					root_0 = (CommonTree)adaptor.nil();
   8228 
   8229 
   8230 					pushFollow(FOLLOW_end_local_directive_in_debug_directive3393);
   8231 					end_local_directive212=end_local_directive();
   8232 					state._fsp--;
   8233 
   8234 					adaptor.addChild(root_0, end_local_directive212.getTree());
   8235 
   8236 					}
   8237 					break;
   8238 				case 4 :
   8239 					// smaliParser.g:753:5: restart_local_directive
   8240 					{
   8241 					root_0 = (CommonTree)adaptor.nil();
   8242 
   8243 
   8244 					pushFollow(FOLLOW_restart_local_directive_in_debug_directive3399);
   8245 					restart_local_directive213=restart_local_directive();
   8246 					state._fsp--;
   8247 
   8248 					adaptor.addChild(root_0, restart_local_directive213.getTree());
   8249 
   8250 					}
   8251 					break;
   8252 				case 5 :
   8253 					// smaliParser.g:754:5: prologue_directive
   8254 					{
   8255 					root_0 = (CommonTree)adaptor.nil();
   8256 
   8257 
   8258 					pushFollow(FOLLOW_prologue_directive_in_debug_directive3405);
   8259 					prologue_directive214=prologue_directive();
   8260 					state._fsp--;
   8261 
   8262 					adaptor.addChild(root_0, prologue_directive214.getTree());
   8263 
   8264 					}
   8265 					break;
   8266 				case 6 :
   8267 					// smaliParser.g:755:5: epilogue_directive
   8268 					{
   8269 					root_0 = (CommonTree)adaptor.nil();
   8270 
   8271 
   8272 					pushFollow(FOLLOW_epilogue_directive_in_debug_directive3411);
   8273 					epilogue_directive215=epilogue_directive();
   8274 					state._fsp--;
   8275 
   8276 					adaptor.addChild(root_0, epilogue_directive215.getTree());
   8277 
   8278 					}
   8279 					break;
   8280 				case 7 :
   8281 					// smaliParser.g:756:5: source_directive
   8282 					{
   8283 					root_0 = (CommonTree)adaptor.nil();
   8284 
   8285 
   8286 					pushFollow(FOLLOW_source_directive_in_debug_directive3417);
   8287 					source_directive216=source_directive();
   8288 					state._fsp--;
   8289 
   8290 					adaptor.addChild(root_0, source_directive216.getTree());
   8291 
   8292 					}
   8293 					break;
   8294 
   8295 			}
   8296 			retval.stop = input.LT(-1);
   8297 
   8298 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   8299 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   8300 
   8301 		}
   8302 		catch (RecognitionException re) {
   8303 			reportError(re);
   8304 			recover(input,re);
   8305 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   8306 		}
   8307 		finally {
   8308 			// do for sure before leaving
   8309 		}
   8310 		return retval;
   8311 	}
   8312 	// $ANTLR end "debug_directive"
   8313 
   8314 
   8315 	public static class line_directive_return extends ParserRuleReturnScope {
   8316 		CommonTree tree;
   8317 		@Override
   8318 		public CommonTree getTree() { return tree; }
   8319 	};
   8320 
   8321 
   8322 	// $ANTLR start "line_directive"
   8323 	// smaliParser.g:758:1: line_directive : LINE_DIRECTIVE integral_literal -> ^( I_LINE[$start, \"I_LINE\"] integral_literal ) ;
   8324 	public final smaliParser.line_directive_return line_directive() throws RecognitionException {
   8325 		smaliParser.line_directive_return retval = new smaliParser.line_directive_return();
   8326 		retval.start = input.LT(1);
   8327 
   8328 		CommonTree root_0 = null;
   8329 
   8330 		Token LINE_DIRECTIVE217=null;
   8331 		ParserRuleReturnScope integral_literal218 =null;
   8332 
   8333 		CommonTree LINE_DIRECTIVE217_tree=null;
   8334 		RewriteRuleTokenStream stream_LINE_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token LINE_DIRECTIVE");
   8335 		RewriteRuleSubtreeStream stream_integral_literal=new RewriteRuleSubtreeStream(adaptor,"rule integral_literal");
   8336 
   8337 		try {
   8338 			// smaliParser.g:759:3: ( LINE_DIRECTIVE integral_literal -> ^( I_LINE[$start, \"I_LINE\"] integral_literal ) )
   8339 			// smaliParser.g:759:5: LINE_DIRECTIVE integral_literal
   8340 			{
   8341 			LINE_DIRECTIVE217=(Token)match(input,LINE_DIRECTIVE,FOLLOW_LINE_DIRECTIVE_in_line_directive3427);
   8342 			stream_LINE_DIRECTIVE.add(LINE_DIRECTIVE217);
   8343 
   8344 			pushFollow(FOLLOW_integral_literal_in_line_directive3429);
   8345 			integral_literal218=integral_literal();
   8346 			state._fsp--;
   8347 
   8348 			stream_integral_literal.add(integral_literal218.getTree());
   8349 			// AST REWRITE
   8350 			// elements: integral_literal
   8351 			// token labels:
   8352 			// rule labels: retval
   8353 			// token list labels:
   8354 			// rule list labels:
   8355 			// wildcard labels:
   8356 			retval.tree = root_0;
   8357 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   8358 
   8359 			root_0 = (CommonTree)adaptor.nil();
   8360 			// 760:5: -> ^( I_LINE[$start, \"I_LINE\"] integral_literal )
   8361 			{
   8362 				// smaliParser.g:760:8: ^( I_LINE[$start, \"I_LINE\"] integral_literal )
   8363 				{
   8364 				CommonTree root_1 = (CommonTree)adaptor.nil();
   8365 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_LINE, (retval.start), "I_LINE"), root_1);
   8366 				adaptor.addChild(root_1, stream_integral_literal.nextTree());
   8367 				adaptor.addChild(root_0, root_1);
   8368 				}
   8369 
   8370 			}
   8371 
   8372 
   8373 			retval.tree = root_0;
   8374 
   8375 			}
   8376 
   8377 			retval.stop = input.LT(-1);
   8378 
   8379 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   8380 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   8381 
   8382 		}
   8383 		catch (RecognitionException re) {
   8384 			reportError(re);
   8385 			recover(input,re);
   8386 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   8387 		}
   8388 		finally {
   8389 			// do for sure before leaving
   8390 		}
   8391 		return retval;
   8392 	}
   8393 	// $ANTLR end "line_directive"
   8394 
   8395 
   8396 	public static class local_directive_return extends ParserRuleReturnScope {
   8397 		CommonTree tree;
   8398 		@Override
   8399 		public CommonTree getTree() { return tree; }
   8400 	};
   8401 
   8402 
   8403 	// $ANTLR start "local_directive"
   8404 	// smaliParser.g:762:1: local_directive : LOCAL_DIRECTIVE REGISTER ( COMMA ( NULL_LITERAL |name= STRING_LITERAL ) COLON ( VOID_TYPE | nonvoid_type_descriptor ) ( COMMA signature= STRING_LITERAL )? )? -> ^( I_LOCAL[$start, \"I_LOCAL\"] REGISTER ( NULL_LITERAL )? ( $name)? ( nonvoid_type_descriptor )? ( $signature)? ) ;
   8405 	public final smaliParser.local_directive_return local_directive() throws RecognitionException {
   8406 		smaliParser.local_directive_return retval = new smaliParser.local_directive_return();
   8407 		retval.start = input.LT(1);
   8408 
   8409 		CommonTree root_0 = null;
   8410 
   8411 		Token name=null;
   8412 		Token signature=null;
   8413 		Token LOCAL_DIRECTIVE219=null;
   8414 		Token REGISTER220=null;
   8415 		Token COMMA221=null;
   8416 		Token NULL_LITERAL222=null;
   8417 		Token COLON223=null;
   8418 		Token VOID_TYPE224=null;
   8419 		Token COMMA226=null;
   8420 		ParserRuleReturnScope nonvoid_type_descriptor225 =null;
   8421 
   8422 		CommonTree name_tree=null;
   8423 		CommonTree signature_tree=null;
   8424 		CommonTree LOCAL_DIRECTIVE219_tree=null;
   8425 		CommonTree REGISTER220_tree=null;
   8426 		CommonTree COMMA221_tree=null;
   8427 		CommonTree NULL_LITERAL222_tree=null;
   8428 		CommonTree COLON223_tree=null;
   8429 		CommonTree VOID_TYPE224_tree=null;
   8430 		CommonTree COMMA226_tree=null;
   8431 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   8432 		RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER");
   8433 		RewriteRuleTokenStream stream_LOCAL_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token LOCAL_DIRECTIVE");
   8434 		RewriteRuleTokenStream stream_VOID_TYPE=new RewriteRuleTokenStream(adaptor,"token VOID_TYPE");
   8435 		RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL");
   8436 		RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON");
   8437 		RewriteRuleTokenStream stream_NULL_LITERAL=new RewriteRuleTokenStream(adaptor,"token NULL_LITERAL");
   8438 		RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor");
   8439 
   8440 		try {
   8441 			// smaliParser.g:763:3: ( LOCAL_DIRECTIVE REGISTER ( COMMA ( NULL_LITERAL |name= STRING_LITERAL ) COLON ( VOID_TYPE | nonvoid_type_descriptor ) ( COMMA signature= STRING_LITERAL )? )? -> ^( I_LOCAL[$start, \"I_LOCAL\"] REGISTER ( NULL_LITERAL )? ( $name)? ( nonvoid_type_descriptor )? ( $signature)? ) )
   8442 			// smaliParser.g:763:5: LOCAL_DIRECTIVE REGISTER ( COMMA ( NULL_LITERAL |name= STRING_LITERAL ) COLON ( VOID_TYPE | nonvoid_type_descriptor ) ( COMMA signature= STRING_LITERAL )? )?
   8443 			{
   8444 			LOCAL_DIRECTIVE219=(Token)match(input,LOCAL_DIRECTIVE,FOLLOW_LOCAL_DIRECTIVE_in_local_directive3452);
   8445 			stream_LOCAL_DIRECTIVE.add(LOCAL_DIRECTIVE219);
   8446 
   8447 			REGISTER220=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_local_directive3454);
   8448 			stream_REGISTER.add(REGISTER220);
   8449 
   8450 			// smaliParser.g:763:30: ( COMMA ( NULL_LITERAL |name= STRING_LITERAL ) COLON ( VOID_TYPE | nonvoid_type_descriptor ) ( COMMA signature= STRING_LITERAL )? )?
   8451 			int alt46=2;
   8452 			int LA46_0 = input.LA(1);
   8453 			if ( (LA46_0==COMMA) ) {
   8454 				alt46=1;
   8455 			}
   8456 			switch (alt46) {
   8457 				case 1 :
   8458 					// smaliParser.g:763:31: COMMA ( NULL_LITERAL |name= STRING_LITERAL ) COLON ( VOID_TYPE | nonvoid_type_descriptor ) ( COMMA signature= STRING_LITERAL )?
   8459 					{
   8460 					COMMA221=(Token)match(input,COMMA,FOLLOW_COMMA_in_local_directive3457);
   8461 					stream_COMMA.add(COMMA221);
   8462 
   8463 					// smaliParser.g:763:37: ( NULL_LITERAL |name= STRING_LITERAL )
   8464 					int alt43=2;
   8465 					int LA43_0 = input.LA(1);
   8466 					if ( (LA43_0==NULL_LITERAL) ) {
   8467 						alt43=1;
   8468 					}
   8469 					else if ( (LA43_0==STRING_LITERAL) ) {
   8470 						alt43=2;
   8471 					}
   8472 
   8473 					else {
   8474 						NoViableAltException nvae =
   8475 							new NoViableAltException("", 43, 0, input);
   8476 						throw nvae;
   8477 					}
   8478 
   8479 					switch (alt43) {
   8480 						case 1 :
   8481 							// smaliParser.g:763:38: NULL_LITERAL
   8482 							{
   8483 							NULL_LITERAL222=(Token)match(input,NULL_LITERAL,FOLLOW_NULL_LITERAL_in_local_directive3460);
   8484 							stream_NULL_LITERAL.add(NULL_LITERAL222);
   8485 
   8486 							}
   8487 							break;
   8488 						case 2 :
   8489 							// smaliParser.g:763:53: name= STRING_LITERAL
   8490 							{
   8491 							name=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_local_directive3466);
   8492 							stream_STRING_LITERAL.add(name);
   8493 
   8494 							}
   8495 							break;
   8496 
   8497 					}
   8498 
   8499 					COLON223=(Token)match(input,COLON,FOLLOW_COLON_in_local_directive3469);
   8500 					stream_COLON.add(COLON223);
   8501 
   8502 					// smaliParser.g:763:80: ( VOID_TYPE | nonvoid_type_descriptor )
   8503 					int alt44=2;
   8504 					int LA44_0 = input.LA(1);
   8505 					if ( (LA44_0==VOID_TYPE) ) {
   8506 						alt44=1;
   8507 					}
   8508 					else if ( (LA44_0==ARRAY_TYPE_PREFIX||LA44_0==CLASS_DESCRIPTOR||LA44_0==PRIMITIVE_TYPE) ) {
   8509 						alt44=2;
   8510 					}
   8511 
   8512 					else {
   8513 						NoViableAltException nvae =
   8514 							new NoViableAltException("", 44, 0, input);
   8515 						throw nvae;
   8516 					}
   8517 
   8518 					switch (alt44) {
   8519 						case 1 :
   8520 							// smaliParser.g:763:81: VOID_TYPE
   8521 							{
   8522 							VOID_TYPE224=(Token)match(input,VOID_TYPE,FOLLOW_VOID_TYPE_in_local_directive3472);
   8523 							stream_VOID_TYPE.add(VOID_TYPE224);
   8524 
   8525 							}
   8526 							break;
   8527 						case 2 :
   8528 							// smaliParser.g:763:93: nonvoid_type_descriptor
   8529 							{
   8530 							pushFollow(FOLLOW_nonvoid_type_descriptor_in_local_directive3476);
   8531 							nonvoid_type_descriptor225=nonvoid_type_descriptor();
   8532 							state._fsp--;
   8533 
   8534 							stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor225.getTree());
   8535 							}
   8536 							break;
   8537 
   8538 					}
   8539 
   8540 					// smaliParser.g:764:31: ( COMMA signature= STRING_LITERAL )?
   8541 					int alt45=2;
   8542 					int LA45_0 = input.LA(1);
   8543 					if ( (LA45_0==COMMA) ) {
   8544 						alt45=1;
   8545 					}
   8546 					switch (alt45) {
   8547 						case 1 :
   8548 							// smaliParser.g:764:32: COMMA signature= STRING_LITERAL
   8549 							{
   8550 							COMMA226=(Token)match(input,COMMA,FOLLOW_COMMA_in_local_directive3510);
   8551 							stream_COMMA.add(COMMA226);
   8552 
   8553 							signature=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_local_directive3514);
   8554 							stream_STRING_LITERAL.add(signature);
   8555 
   8556 							}
   8557 							break;
   8558 
   8559 					}
   8560 
   8561 					}
   8562 					break;
   8563 
   8564 			}
   8565 
   8566 			// AST REWRITE
   8567 			// elements: name, NULL_LITERAL, nonvoid_type_descriptor, REGISTER, signature
   8568 			// token labels: signature, name
   8569 			// rule labels: retval
   8570 			// token list labels:
   8571 			// rule list labels:
   8572 			// wildcard labels:
   8573 			retval.tree = root_0;
   8574 			RewriteRuleTokenStream stream_signature=new RewriteRuleTokenStream(adaptor,"token signature",signature);
   8575 			RewriteRuleTokenStream stream_name=new RewriteRuleTokenStream(adaptor,"token name",name);
   8576 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   8577 
   8578 			root_0 = (CommonTree)adaptor.nil();
   8579 			// 765:5: -> ^( I_LOCAL[$start, \"I_LOCAL\"] REGISTER ( NULL_LITERAL )? ( $name)? ( nonvoid_type_descriptor )? ( $signature)? )
   8580 			{
   8581 				// smaliParser.g:765:8: ^( I_LOCAL[$start, \"I_LOCAL\"] REGISTER ( NULL_LITERAL )? ( $name)? ( nonvoid_type_descriptor )? ( $signature)? )
   8582 				{
   8583 				CommonTree root_1 = (CommonTree)adaptor.nil();
   8584 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_LOCAL, (retval.start), "I_LOCAL"), root_1);
   8585 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   8586 				// smaliParser.g:765:46: ( NULL_LITERAL )?
   8587 				if ( stream_NULL_LITERAL.hasNext() ) {
   8588 					adaptor.addChild(root_1, stream_NULL_LITERAL.nextNode());
   8589 				}
   8590 				stream_NULL_LITERAL.reset();
   8591 
   8592 				// smaliParser.g:765:61: ( $name)?
   8593 				if ( stream_name.hasNext() ) {
   8594 					adaptor.addChild(root_1, stream_name.nextNode());
   8595 				}
   8596 				stream_name.reset();
   8597 
   8598 				// smaliParser.g:765:67: ( nonvoid_type_descriptor )?
   8599 				if ( stream_nonvoid_type_descriptor.hasNext() ) {
   8600 					adaptor.addChild(root_1, stream_nonvoid_type_descriptor.nextTree());
   8601 				}
   8602 				stream_nonvoid_type_descriptor.reset();
   8603 
   8604 				// smaliParser.g:765:93: ( $signature)?
   8605 				if ( stream_signature.hasNext() ) {
   8606 					adaptor.addChild(root_1, stream_signature.nextNode());
   8607 				}
   8608 				stream_signature.reset();
   8609 
   8610 				adaptor.addChild(root_0, root_1);
   8611 				}
   8612 
   8613 			}
   8614 
   8615 
   8616 			retval.tree = root_0;
   8617 
   8618 			}
   8619 
   8620 			retval.stop = input.LT(-1);
   8621 
   8622 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   8623 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   8624 
   8625 		}
   8626 		catch (RecognitionException re) {
   8627 			reportError(re);
   8628 			recover(input,re);
   8629 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   8630 		}
   8631 		finally {
   8632 			// do for sure before leaving
   8633 		}
   8634 		return retval;
   8635 	}
   8636 	// $ANTLR end "local_directive"
   8637 
   8638 
   8639 	public static class end_local_directive_return extends ParserRuleReturnScope {
   8640 		CommonTree tree;
   8641 		@Override
   8642 		public CommonTree getTree() { return tree; }
   8643 	};
   8644 
   8645 
   8646 	// $ANTLR start "end_local_directive"
   8647 	// smaliParser.g:767:1: end_local_directive : END_LOCAL_DIRECTIVE REGISTER -> ^( I_END_LOCAL[$start, \"I_END_LOCAL\"] REGISTER ) ;
   8648 	public final smaliParser.end_local_directive_return end_local_directive() throws RecognitionException {
   8649 		smaliParser.end_local_directive_return retval = new smaliParser.end_local_directive_return();
   8650 		retval.start = input.LT(1);
   8651 
   8652 		CommonTree root_0 = null;
   8653 
   8654 		Token END_LOCAL_DIRECTIVE227=null;
   8655 		Token REGISTER228=null;
   8656 
   8657 		CommonTree END_LOCAL_DIRECTIVE227_tree=null;
   8658 		CommonTree REGISTER228_tree=null;
   8659 		RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER");
   8660 		RewriteRuleTokenStream stream_END_LOCAL_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_LOCAL_DIRECTIVE");
   8661 
   8662 		try {
   8663 			// smaliParser.g:768:3: ( END_LOCAL_DIRECTIVE REGISTER -> ^( I_END_LOCAL[$start, \"I_END_LOCAL\"] REGISTER ) )
   8664 			// smaliParser.g:768:5: END_LOCAL_DIRECTIVE REGISTER
   8665 			{
   8666 			END_LOCAL_DIRECTIVE227=(Token)match(input,END_LOCAL_DIRECTIVE,FOLLOW_END_LOCAL_DIRECTIVE_in_end_local_directive3556);
   8667 			stream_END_LOCAL_DIRECTIVE.add(END_LOCAL_DIRECTIVE227);
   8668 
   8669 			REGISTER228=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_end_local_directive3558);
   8670 			stream_REGISTER.add(REGISTER228);
   8671 
   8672 			// AST REWRITE
   8673 			// elements: REGISTER
   8674 			// token labels:
   8675 			// rule labels: retval
   8676 			// token list labels:
   8677 			// rule list labels:
   8678 			// wildcard labels:
   8679 			retval.tree = root_0;
   8680 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   8681 
   8682 			root_0 = (CommonTree)adaptor.nil();
   8683 			// 769:5: -> ^( I_END_LOCAL[$start, \"I_END_LOCAL\"] REGISTER )
   8684 			{
   8685 				// smaliParser.g:769:8: ^( I_END_LOCAL[$start, \"I_END_LOCAL\"] REGISTER )
   8686 				{
   8687 				CommonTree root_1 = (CommonTree)adaptor.nil();
   8688 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_END_LOCAL, (retval.start), "I_END_LOCAL"), root_1);
   8689 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   8690 				adaptor.addChild(root_0, root_1);
   8691 				}
   8692 
   8693 			}
   8694 
   8695 
   8696 			retval.tree = root_0;
   8697 
   8698 			}
   8699 
   8700 			retval.stop = input.LT(-1);
   8701 
   8702 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   8703 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   8704 
   8705 		}
   8706 		catch (RecognitionException re) {
   8707 			reportError(re);
   8708 			recover(input,re);
   8709 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   8710 		}
   8711 		finally {
   8712 			// do for sure before leaving
   8713 		}
   8714 		return retval;
   8715 	}
   8716 	// $ANTLR end "end_local_directive"
   8717 
   8718 
   8719 	public static class restart_local_directive_return extends ParserRuleReturnScope {
   8720 		CommonTree tree;
   8721 		@Override
   8722 		public CommonTree getTree() { return tree; }
   8723 	};
   8724 
   8725 
   8726 	// $ANTLR start "restart_local_directive"
   8727 	// smaliParser.g:771:1: restart_local_directive : RESTART_LOCAL_DIRECTIVE REGISTER -> ^( I_RESTART_LOCAL[$start, \"I_RESTART_LOCAL\"] REGISTER ) ;
   8728 	public final smaliParser.restart_local_directive_return restart_local_directive() throws RecognitionException {
   8729 		smaliParser.restart_local_directive_return retval = new smaliParser.restart_local_directive_return();
   8730 		retval.start = input.LT(1);
   8731 
   8732 		CommonTree root_0 = null;
   8733 
   8734 		Token RESTART_LOCAL_DIRECTIVE229=null;
   8735 		Token REGISTER230=null;
   8736 
   8737 		CommonTree RESTART_LOCAL_DIRECTIVE229_tree=null;
   8738 		CommonTree REGISTER230_tree=null;
   8739 		RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER");
   8740 		RewriteRuleTokenStream stream_RESTART_LOCAL_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token RESTART_LOCAL_DIRECTIVE");
   8741 
   8742 		try {
   8743 			// smaliParser.g:772:3: ( RESTART_LOCAL_DIRECTIVE REGISTER -> ^( I_RESTART_LOCAL[$start, \"I_RESTART_LOCAL\"] REGISTER ) )
   8744 			// smaliParser.g:772:5: RESTART_LOCAL_DIRECTIVE REGISTER
   8745 			{
   8746 			RESTART_LOCAL_DIRECTIVE229=(Token)match(input,RESTART_LOCAL_DIRECTIVE,FOLLOW_RESTART_LOCAL_DIRECTIVE_in_restart_local_directive3581);
   8747 			stream_RESTART_LOCAL_DIRECTIVE.add(RESTART_LOCAL_DIRECTIVE229);
   8748 
   8749 			REGISTER230=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_restart_local_directive3583);
   8750 			stream_REGISTER.add(REGISTER230);
   8751 
   8752 			// AST REWRITE
   8753 			// elements: REGISTER
   8754 			// token labels:
   8755 			// rule labels: retval
   8756 			// token list labels:
   8757 			// rule list labels:
   8758 			// wildcard labels:
   8759 			retval.tree = root_0;
   8760 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   8761 
   8762 			root_0 = (CommonTree)adaptor.nil();
   8763 			// 773:5: -> ^( I_RESTART_LOCAL[$start, \"I_RESTART_LOCAL\"] REGISTER )
   8764 			{
   8765 				// smaliParser.g:773:8: ^( I_RESTART_LOCAL[$start, \"I_RESTART_LOCAL\"] REGISTER )
   8766 				{
   8767 				CommonTree root_1 = (CommonTree)adaptor.nil();
   8768 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_RESTART_LOCAL, (retval.start), "I_RESTART_LOCAL"), root_1);
   8769 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   8770 				adaptor.addChild(root_0, root_1);
   8771 				}
   8772 
   8773 			}
   8774 
   8775 
   8776 			retval.tree = root_0;
   8777 
   8778 			}
   8779 
   8780 			retval.stop = input.LT(-1);
   8781 
   8782 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   8783 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   8784 
   8785 		}
   8786 		catch (RecognitionException re) {
   8787 			reportError(re);
   8788 			recover(input,re);
   8789 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   8790 		}
   8791 		finally {
   8792 			// do for sure before leaving
   8793 		}
   8794 		return retval;
   8795 	}
   8796 	// $ANTLR end "restart_local_directive"
   8797 
   8798 
   8799 	public static class prologue_directive_return extends ParserRuleReturnScope {
   8800 		CommonTree tree;
   8801 		@Override
   8802 		public CommonTree getTree() { return tree; }
   8803 	};
   8804 
   8805 
   8806 	// $ANTLR start "prologue_directive"
   8807 	// smaliParser.g:775:1: prologue_directive : PROLOGUE_DIRECTIVE -> ^( I_PROLOGUE[$start, \"I_PROLOGUE\"] ) ;
   8808 	public final smaliParser.prologue_directive_return prologue_directive() throws RecognitionException {
   8809 		smaliParser.prologue_directive_return retval = new smaliParser.prologue_directive_return();
   8810 		retval.start = input.LT(1);
   8811 
   8812 		CommonTree root_0 = null;
   8813 
   8814 		Token PROLOGUE_DIRECTIVE231=null;
   8815 
   8816 		CommonTree PROLOGUE_DIRECTIVE231_tree=null;
   8817 		RewriteRuleTokenStream stream_PROLOGUE_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token PROLOGUE_DIRECTIVE");
   8818 
   8819 		try {
   8820 			// smaliParser.g:776:3: ( PROLOGUE_DIRECTIVE -> ^( I_PROLOGUE[$start, \"I_PROLOGUE\"] ) )
   8821 			// smaliParser.g:776:5: PROLOGUE_DIRECTIVE
   8822 			{
   8823 			PROLOGUE_DIRECTIVE231=(Token)match(input,PROLOGUE_DIRECTIVE,FOLLOW_PROLOGUE_DIRECTIVE_in_prologue_directive3606);
   8824 			stream_PROLOGUE_DIRECTIVE.add(PROLOGUE_DIRECTIVE231);
   8825 
   8826 			// AST REWRITE
   8827 			// elements:
   8828 			// token labels:
   8829 			// rule labels: retval
   8830 			// token list labels:
   8831 			// rule list labels:
   8832 			// wildcard labels:
   8833 			retval.tree = root_0;
   8834 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   8835 
   8836 			root_0 = (CommonTree)adaptor.nil();
   8837 			// 777:5: -> ^( I_PROLOGUE[$start, \"I_PROLOGUE\"] )
   8838 			{
   8839 				// smaliParser.g:777:8: ^( I_PROLOGUE[$start, \"I_PROLOGUE\"] )
   8840 				{
   8841 				CommonTree root_1 = (CommonTree)adaptor.nil();
   8842 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_PROLOGUE, (retval.start), "I_PROLOGUE"), root_1);
   8843 				adaptor.addChild(root_0, root_1);
   8844 				}
   8845 
   8846 			}
   8847 
   8848 
   8849 			retval.tree = root_0;
   8850 
   8851 			}
   8852 
   8853 			retval.stop = input.LT(-1);
   8854 
   8855 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   8856 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   8857 
   8858 		}
   8859 		catch (RecognitionException re) {
   8860 			reportError(re);
   8861 			recover(input,re);
   8862 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   8863 		}
   8864 		finally {
   8865 			// do for sure before leaving
   8866 		}
   8867 		return retval;
   8868 	}
   8869 	// $ANTLR end "prologue_directive"
   8870 
   8871 
   8872 	public static class epilogue_directive_return extends ParserRuleReturnScope {
   8873 		CommonTree tree;
   8874 		@Override
   8875 		public CommonTree getTree() { return tree; }
   8876 	};
   8877 
   8878 
   8879 	// $ANTLR start "epilogue_directive"
   8880 	// smaliParser.g:779:1: epilogue_directive : EPILOGUE_DIRECTIVE -> ^( I_EPILOGUE[$start, \"I_EPILOGUE\"] ) ;
   8881 	public final smaliParser.epilogue_directive_return epilogue_directive() throws RecognitionException {
   8882 		smaliParser.epilogue_directive_return retval = new smaliParser.epilogue_directive_return();
   8883 		retval.start = input.LT(1);
   8884 
   8885 		CommonTree root_0 = null;
   8886 
   8887 		Token EPILOGUE_DIRECTIVE232=null;
   8888 
   8889 		CommonTree EPILOGUE_DIRECTIVE232_tree=null;
   8890 		RewriteRuleTokenStream stream_EPILOGUE_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token EPILOGUE_DIRECTIVE");
   8891 
   8892 		try {
   8893 			// smaliParser.g:780:3: ( EPILOGUE_DIRECTIVE -> ^( I_EPILOGUE[$start, \"I_EPILOGUE\"] ) )
   8894 			// smaliParser.g:780:5: EPILOGUE_DIRECTIVE
   8895 			{
   8896 			EPILOGUE_DIRECTIVE232=(Token)match(input,EPILOGUE_DIRECTIVE,FOLLOW_EPILOGUE_DIRECTIVE_in_epilogue_directive3627);
   8897 			stream_EPILOGUE_DIRECTIVE.add(EPILOGUE_DIRECTIVE232);
   8898 
   8899 			// AST REWRITE
   8900 			// elements:
   8901 			// token labels:
   8902 			// rule labels: retval
   8903 			// token list labels:
   8904 			// rule list labels:
   8905 			// wildcard labels:
   8906 			retval.tree = root_0;
   8907 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   8908 
   8909 			root_0 = (CommonTree)adaptor.nil();
   8910 			// 781:5: -> ^( I_EPILOGUE[$start, \"I_EPILOGUE\"] )
   8911 			{
   8912 				// smaliParser.g:781:8: ^( I_EPILOGUE[$start, \"I_EPILOGUE\"] )
   8913 				{
   8914 				CommonTree root_1 = (CommonTree)adaptor.nil();
   8915 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_EPILOGUE, (retval.start), "I_EPILOGUE"), root_1);
   8916 				adaptor.addChild(root_0, root_1);
   8917 				}
   8918 
   8919 			}
   8920 
   8921 
   8922 			retval.tree = root_0;
   8923 
   8924 			}
   8925 
   8926 			retval.stop = input.LT(-1);
   8927 
   8928 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   8929 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   8930 
   8931 		}
   8932 		catch (RecognitionException re) {
   8933 			reportError(re);
   8934 			recover(input,re);
   8935 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   8936 		}
   8937 		finally {
   8938 			// do for sure before leaving
   8939 		}
   8940 		return retval;
   8941 	}
   8942 	// $ANTLR end "epilogue_directive"
   8943 
   8944 
   8945 	public static class source_directive_return extends ParserRuleReturnScope {
   8946 		CommonTree tree;
   8947 		@Override
   8948 		public CommonTree getTree() { return tree; }
   8949 	};
   8950 
   8951 
   8952 	// $ANTLR start "source_directive"
   8953 	// smaliParser.g:783:1: source_directive : SOURCE_DIRECTIVE ( STRING_LITERAL )? -> ^( I_SOURCE[$start, \"I_SOURCE\"] ( STRING_LITERAL )? ) ;
   8954 	public final smaliParser.source_directive_return source_directive() throws RecognitionException {
   8955 		smaliParser.source_directive_return retval = new smaliParser.source_directive_return();
   8956 		retval.start = input.LT(1);
   8957 
   8958 		CommonTree root_0 = null;
   8959 
   8960 		Token SOURCE_DIRECTIVE233=null;
   8961 		Token STRING_LITERAL234=null;
   8962 
   8963 		CommonTree SOURCE_DIRECTIVE233_tree=null;
   8964 		CommonTree STRING_LITERAL234_tree=null;
   8965 		RewriteRuleTokenStream stream_SOURCE_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token SOURCE_DIRECTIVE");
   8966 		RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL");
   8967 
   8968 		try {
   8969 			// smaliParser.g:784:3: ( SOURCE_DIRECTIVE ( STRING_LITERAL )? -> ^( I_SOURCE[$start, \"I_SOURCE\"] ( STRING_LITERAL )? ) )
   8970 			// smaliParser.g:784:5: SOURCE_DIRECTIVE ( STRING_LITERAL )?
   8971 			{
   8972 			SOURCE_DIRECTIVE233=(Token)match(input,SOURCE_DIRECTIVE,FOLLOW_SOURCE_DIRECTIVE_in_source_directive3648);
   8973 			stream_SOURCE_DIRECTIVE.add(SOURCE_DIRECTIVE233);
   8974 
   8975 			// smaliParser.g:784:22: ( STRING_LITERAL )?
   8976 			int alt47=2;
   8977 			int LA47_0 = input.LA(1);
   8978 			if ( (LA47_0==STRING_LITERAL) ) {
   8979 				alt47=1;
   8980 			}
   8981 			switch (alt47) {
   8982 				case 1 :
   8983 					// smaliParser.g:784:22: STRING_LITERAL
   8984 					{
   8985 					STRING_LITERAL234=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_source_directive3650);
   8986 					stream_STRING_LITERAL.add(STRING_LITERAL234);
   8987 
   8988 					}
   8989 					break;
   8990 
   8991 			}
   8992 
   8993 			// AST REWRITE
   8994 			// elements: STRING_LITERAL
   8995 			// token labels:
   8996 			// rule labels: retval
   8997 			// token list labels:
   8998 			// rule list labels:
   8999 			// wildcard labels:
   9000 			retval.tree = root_0;
   9001 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   9002 
   9003 			root_0 = (CommonTree)adaptor.nil();
   9004 			// 785:5: -> ^( I_SOURCE[$start, \"I_SOURCE\"] ( STRING_LITERAL )? )
   9005 			{
   9006 				// smaliParser.g:785:8: ^( I_SOURCE[$start, \"I_SOURCE\"] ( STRING_LITERAL )? )
   9007 				{
   9008 				CommonTree root_1 = (CommonTree)adaptor.nil();
   9009 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_SOURCE, (retval.start), "I_SOURCE"), root_1);
   9010 				// smaliParser.g:785:39: ( STRING_LITERAL )?
   9011 				if ( stream_STRING_LITERAL.hasNext() ) {
   9012 					adaptor.addChild(root_1, stream_STRING_LITERAL.nextNode());
   9013 				}
   9014 				stream_STRING_LITERAL.reset();
   9015 
   9016 				adaptor.addChild(root_0, root_1);
   9017 				}
   9018 
   9019 			}
   9020 
   9021 
   9022 			retval.tree = root_0;
   9023 
   9024 			}
   9025 
   9026 			retval.stop = input.LT(-1);
   9027 
   9028 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   9029 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   9030 
   9031 		}
   9032 		catch (RecognitionException re) {
   9033 			reportError(re);
   9034 			recover(input,re);
   9035 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   9036 		}
   9037 		finally {
   9038 			// do for sure before leaving
   9039 		}
   9040 		return retval;
   9041 	}
   9042 	// $ANTLR end "source_directive"
   9043 
   9044 
   9045 	public static class instruction_format12x_return extends ParserRuleReturnScope {
   9046 		CommonTree tree;
   9047 		@Override
   9048 		public CommonTree getTree() { return tree; }
   9049 	};
   9050 
   9051 
   9052 	// $ANTLR start "instruction_format12x"
   9053 	// smaliParser.g:787:1: instruction_format12x : ( INSTRUCTION_FORMAT12x | INSTRUCTION_FORMAT12x_OR_ID -> INSTRUCTION_FORMAT12x[$INSTRUCTION_FORMAT12x_OR_ID] );
   9054 	public final smaliParser.instruction_format12x_return instruction_format12x() throws RecognitionException {
   9055 		smaliParser.instruction_format12x_return retval = new smaliParser.instruction_format12x_return();
   9056 		retval.start = input.LT(1);
   9057 
   9058 		CommonTree root_0 = null;
   9059 
   9060 		Token INSTRUCTION_FORMAT12x235=null;
   9061 		Token INSTRUCTION_FORMAT12x_OR_ID236=null;
   9062 
   9063 		CommonTree INSTRUCTION_FORMAT12x235_tree=null;
   9064 		CommonTree INSTRUCTION_FORMAT12x_OR_ID236_tree=null;
   9065 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT12x_OR_ID=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT12x_OR_ID");
   9066 
   9067 		try {
   9068 			// smaliParser.g:788:3: ( INSTRUCTION_FORMAT12x | INSTRUCTION_FORMAT12x_OR_ID -> INSTRUCTION_FORMAT12x[$INSTRUCTION_FORMAT12x_OR_ID] )
   9069 			int alt48=2;
   9070 			int LA48_0 = input.LA(1);
   9071 			if ( (LA48_0==INSTRUCTION_FORMAT12x) ) {
   9072 				alt48=1;
   9073 			}
   9074 			else if ( (LA48_0==INSTRUCTION_FORMAT12x_OR_ID) ) {
   9075 				alt48=2;
   9076 			}
   9077 
   9078 			else {
   9079 				NoViableAltException nvae =
   9080 					new NoViableAltException("", 48, 0, input);
   9081 				throw nvae;
   9082 			}
   9083 
   9084 			switch (alt48) {
   9085 				case 1 :
   9086 					// smaliParser.g:788:5: INSTRUCTION_FORMAT12x
   9087 					{
   9088 					root_0 = (CommonTree)adaptor.nil();
   9089 
   9090 
   9091 					INSTRUCTION_FORMAT12x235=(Token)match(input,INSTRUCTION_FORMAT12x,FOLLOW_INSTRUCTION_FORMAT12x_in_instruction_format12x3675);
   9092 					INSTRUCTION_FORMAT12x235_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT12x235);
   9093 					adaptor.addChild(root_0, INSTRUCTION_FORMAT12x235_tree);
   9094 
   9095 					}
   9096 					break;
   9097 				case 2 :
   9098 					// smaliParser.g:789:5: INSTRUCTION_FORMAT12x_OR_ID
   9099 					{
   9100 					INSTRUCTION_FORMAT12x_OR_ID236=(Token)match(input,INSTRUCTION_FORMAT12x_OR_ID,FOLLOW_INSTRUCTION_FORMAT12x_OR_ID_in_instruction_format12x3681);
   9101 					stream_INSTRUCTION_FORMAT12x_OR_ID.add(INSTRUCTION_FORMAT12x_OR_ID236);
   9102 
   9103 					// AST REWRITE
   9104 					// elements:
   9105 					// token labels:
   9106 					// rule labels: retval
   9107 					// token list labels:
   9108 					// rule list labels:
   9109 					// wildcard labels:
   9110 					retval.tree = root_0;
   9111 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   9112 
   9113 					root_0 = (CommonTree)adaptor.nil();
   9114 					// 789:33: -> INSTRUCTION_FORMAT12x[$INSTRUCTION_FORMAT12x_OR_ID]
   9115 					{
   9116 						adaptor.addChild(root_0, (CommonTree)adaptor.create(INSTRUCTION_FORMAT12x, INSTRUCTION_FORMAT12x_OR_ID236));
   9117 					}
   9118 
   9119 
   9120 					retval.tree = root_0;
   9121 
   9122 					}
   9123 					break;
   9124 
   9125 			}
   9126 			retval.stop = input.LT(-1);
   9127 
   9128 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   9129 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   9130 
   9131 		}
   9132 		catch (RecognitionException re) {
   9133 			reportError(re);
   9134 			recover(input,re);
   9135 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   9136 		}
   9137 		finally {
   9138 			// do for sure before leaving
   9139 		}
   9140 		return retval;
   9141 	}
   9142 	// $ANTLR end "instruction_format12x"
   9143 
   9144 
   9145 	public static class instruction_format22s_return extends ParserRuleReturnScope {
   9146 		CommonTree tree;
   9147 		@Override
   9148 		public CommonTree getTree() { return tree; }
   9149 	};
   9150 
   9151 
   9152 	// $ANTLR start "instruction_format22s"
   9153 	// smaliParser.g:791:1: instruction_format22s : ( INSTRUCTION_FORMAT22s | INSTRUCTION_FORMAT22s_OR_ID -> INSTRUCTION_FORMAT22s[$INSTRUCTION_FORMAT22s_OR_ID] );
   9154 	public final smaliParser.instruction_format22s_return instruction_format22s() throws RecognitionException {
   9155 		smaliParser.instruction_format22s_return retval = new smaliParser.instruction_format22s_return();
   9156 		retval.start = input.LT(1);
   9157 
   9158 		CommonTree root_0 = null;
   9159 
   9160 		Token INSTRUCTION_FORMAT22s237=null;
   9161 		Token INSTRUCTION_FORMAT22s_OR_ID238=null;
   9162 
   9163 		CommonTree INSTRUCTION_FORMAT22s237_tree=null;
   9164 		CommonTree INSTRUCTION_FORMAT22s_OR_ID238_tree=null;
   9165 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22s_OR_ID=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22s_OR_ID");
   9166 
   9167 		try {
   9168 			// smaliParser.g:792:3: ( INSTRUCTION_FORMAT22s | INSTRUCTION_FORMAT22s_OR_ID -> INSTRUCTION_FORMAT22s[$INSTRUCTION_FORMAT22s_OR_ID] )
   9169 			int alt49=2;
   9170 			int LA49_0 = input.LA(1);
   9171 			if ( (LA49_0==INSTRUCTION_FORMAT22s) ) {
   9172 				alt49=1;
   9173 			}
   9174 			else if ( (LA49_0==INSTRUCTION_FORMAT22s_OR_ID) ) {
   9175 				alt49=2;
   9176 			}
   9177 
   9178 			else {
   9179 				NoViableAltException nvae =
   9180 					new NoViableAltException("", 49, 0, input);
   9181 				throw nvae;
   9182 			}
   9183 
   9184 			switch (alt49) {
   9185 				case 1 :
   9186 					// smaliParser.g:792:5: INSTRUCTION_FORMAT22s
   9187 					{
   9188 					root_0 = (CommonTree)adaptor.nil();
   9189 
   9190 
   9191 					INSTRUCTION_FORMAT22s237=(Token)match(input,INSTRUCTION_FORMAT22s,FOLLOW_INSTRUCTION_FORMAT22s_in_instruction_format22s3696);
   9192 					INSTRUCTION_FORMAT22s237_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT22s237);
   9193 					adaptor.addChild(root_0, INSTRUCTION_FORMAT22s237_tree);
   9194 
   9195 					}
   9196 					break;
   9197 				case 2 :
   9198 					// smaliParser.g:793:5: INSTRUCTION_FORMAT22s_OR_ID
   9199 					{
   9200 					INSTRUCTION_FORMAT22s_OR_ID238=(Token)match(input,INSTRUCTION_FORMAT22s_OR_ID,FOLLOW_INSTRUCTION_FORMAT22s_OR_ID_in_instruction_format22s3702);
   9201 					stream_INSTRUCTION_FORMAT22s_OR_ID.add(INSTRUCTION_FORMAT22s_OR_ID238);
   9202 
   9203 					// AST REWRITE
   9204 					// elements:
   9205 					// token labels:
   9206 					// rule labels: retval
   9207 					// token list labels:
   9208 					// rule list labels:
   9209 					// wildcard labels:
   9210 					retval.tree = root_0;
   9211 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   9212 
   9213 					root_0 = (CommonTree)adaptor.nil();
   9214 					// 793:33: -> INSTRUCTION_FORMAT22s[$INSTRUCTION_FORMAT22s_OR_ID]
   9215 					{
   9216 						adaptor.addChild(root_0, (CommonTree)adaptor.create(INSTRUCTION_FORMAT22s, INSTRUCTION_FORMAT22s_OR_ID238));
   9217 					}
   9218 
   9219 
   9220 					retval.tree = root_0;
   9221 
   9222 					}
   9223 					break;
   9224 
   9225 			}
   9226 			retval.stop = input.LT(-1);
   9227 
   9228 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   9229 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   9230 
   9231 		}
   9232 		catch (RecognitionException re) {
   9233 			reportError(re);
   9234 			recover(input,re);
   9235 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   9236 		}
   9237 		finally {
   9238 			// do for sure before leaving
   9239 		}
   9240 		return retval;
   9241 	}
   9242 	// $ANTLR end "instruction_format22s"
   9243 
   9244 
   9245 	public static class instruction_format31i_return extends ParserRuleReturnScope {
   9246 		CommonTree tree;
   9247 		@Override
   9248 		public CommonTree getTree() { return tree; }
   9249 	};
   9250 
   9251 
   9252 	// $ANTLR start "instruction_format31i"
   9253 	// smaliParser.g:795:1: instruction_format31i : ( INSTRUCTION_FORMAT31i | INSTRUCTION_FORMAT31i_OR_ID -> INSTRUCTION_FORMAT31i[$INSTRUCTION_FORMAT31i_OR_ID] );
   9254 	public final smaliParser.instruction_format31i_return instruction_format31i() throws RecognitionException {
   9255 		smaliParser.instruction_format31i_return retval = new smaliParser.instruction_format31i_return();
   9256 		retval.start = input.LT(1);
   9257 
   9258 		CommonTree root_0 = null;
   9259 
   9260 		Token INSTRUCTION_FORMAT31i239=null;
   9261 		Token INSTRUCTION_FORMAT31i_OR_ID240=null;
   9262 
   9263 		CommonTree INSTRUCTION_FORMAT31i239_tree=null;
   9264 		CommonTree INSTRUCTION_FORMAT31i_OR_ID240_tree=null;
   9265 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT31i_OR_ID=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT31i_OR_ID");
   9266 
   9267 		try {
   9268 			// smaliParser.g:796:3: ( INSTRUCTION_FORMAT31i | INSTRUCTION_FORMAT31i_OR_ID -> INSTRUCTION_FORMAT31i[$INSTRUCTION_FORMAT31i_OR_ID] )
   9269 			int alt50=2;
   9270 			int LA50_0 = input.LA(1);
   9271 			if ( (LA50_0==INSTRUCTION_FORMAT31i) ) {
   9272 				alt50=1;
   9273 			}
   9274 			else if ( (LA50_0==INSTRUCTION_FORMAT31i_OR_ID) ) {
   9275 				alt50=2;
   9276 			}
   9277 
   9278 			else {
   9279 				NoViableAltException nvae =
   9280 					new NoViableAltException("", 50, 0, input);
   9281 				throw nvae;
   9282 			}
   9283 
   9284 			switch (alt50) {
   9285 				case 1 :
   9286 					// smaliParser.g:796:5: INSTRUCTION_FORMAT31i
   9287 					{
   9288 					root_0 = (CommonTree)adaptor.nil();
   9289 
   9290 
   9291 					INSTRUCTION_FORMAT31i239=(Token)match(input,INSTRUCTION_FORMAT31i,FOLLOW_INSTRUCTION_FORMAT31i_in_instruction_format31i3717);
   9292 					INSTRUCTION_FORMAT31i239_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT31i239);
   9293 					adaptor.addChild(root_0, INSTRUCTION_FORMAT31i239_tree);
   9294 
   9295 					}
   9296 					break;
   9297 				case 2 :
   9298 					// smaliParser.g:797:5: INSTRUCTION_FORMAT31i_OR_ID
   9299 					{
   9300 					INSTRUCTION_FORMAT31i_OR_ID240=(Token)match(input,INSTRUCTION_FORMAT31i_OR_ID,FOLLOW_INSTRUCTION_FORMAT31i_OR_ID_in_instruction_format31i3723);
   9301 					stream_INSTRUCTION_FORMAT31i_OR_ID.add(INSTRUCTION_FORMAT31i_OR_ID240);
   9302 
   9303 					// AST REWRITE
   9304 					// elements:
   9305 					// token labels:
   9306 					// rule labels: retval
   9307 					// token list labels:
   9308 					// rule list labels:
   9309 					// wildcard labels:
   9310 					retval.tree = root_0;
   9311 					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   9312 
   9313 					root_0 = (CommonTree)adaptor.nil();
   9314 					// 797:33: -> INSTRUCTION_FORMAT31i[$INSTRUCTION_FORMAT31i_OR_ID]
   9315 					{
   9316 						adaptor.addChild(root_0, (CommonTree)adaptor.create(INSTRUCTION_FORMAT31i, INSTRUCTION_FORMAT31i_OR_ID240));
   9317 					}
   9318 
   9319 
   9320 					retval.tree = root_0;
   9321 
   9322 					}
   9323 					break;
   9324 
   9325 			}
   9326 			retval.stop = input.LT(-1);
   9327 
   9328 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   9329 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   9330 
   9331 		}
   9332 		catch (RecognitionException re) {
   9333 			reportError(re);
   9334 			recover(input,re);
   9335 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   9336 		}
   9337 		finally {
   9338 			// do for sure before leaving
   9339 		}
   9340 		return retval;
   9341 	}
   9342 	// $ANTLR end "instruction_format31i"
   9343 
   9344 
   9345 	public static class instruction_return extends ParserRuleReturnScope {
   9346 		CommonTree tree;
   9347 		@Override
   9348 		public CommonTree getTree() { return tree; }
   9349 	};
   9350 
   9351 
   9352 	// $ANTLR start "instruction"
   9353 	// smaliParser.g:801:1: instruction : ( insn_format10t | insn_format10x | insn_format10x_odex | insn_format11n | insn_format11x | insn_format12x | insn_format20bc | insn_format20t | insn_format21c_field | insn_format21c_field_odex | insn_format21c_string | insn_format21c_type | insn_format21ih | insn_format21lh | insn_format21s | insn_format21t | insn_format22b | insn_format22c_field | insn_format22c_field_odex | insn_format22c_type | insn_format22cs_field | insn_format22s | insn_format22t | insn_format22x | insn_format23x | insn_format30t | insn_format31c | insn_format31i | insn_format31t | insn_format32x | insn_format35c_method | insn_format35c_type | insn_format35c_method_odex | insn_format35mi_method | insn_format35ms_method | insn_format3rc_method | insn_format3rc_method_odex | insn_format3rc_type | insn_format3rmi_method | insn_format3rms_method | insn_format45cc_method | insn_format4rcc_method | insn_format51l | insn_array_data_directive | insn_packed_switch_directive | insn_sparse_switch_directive );
   9354 	public final smaliParser.instruction_return instruction() throws RecognitionException {
   9355 		smaliParser.instruction_return retval = new smaliParser.instruction_return();
   9356 		retval.start = input.LT(1);
   9357 
   9358 		CommonTree root_0 = null;
   9359 
   9360 		ParserRuleReturnScope insn_format10t241 =null;
   9361 		ParserRuleReturnScope insn_format10x242 =null;
   9362 		ParserRuleReturnScope insn_format10x_odex243 =null;
   9363 		ParserRuleReturnScope insn_format11n244 =null;
   9364 		ParserRuleReturnScope insn_format11x245 =null;
   9365 		ParserRuleReturnScope insn_format12x246 =null;
   9366 		ParserRuleReturnScope insn_format20bc247 =null;
   9367 		ParserRuleReturnScope insn_format20t248 =null;
   9368 		ParserRuleReturnScope insn_format21c_field249 =null;
   9369 		ParserRuleReturnScope insn_format21c_field_odex250 =null;
   9370 		ParserRuleReturnScope insn_format21c_string251 =null;
   9371 		ParserRuleReturnScope insn_format21c_type252 =null;
   9372 		ParserRuleReturnScope insn_format21ih253 =null;
   9373 		ParserRuleReturnScope insn_format21lh254 =null;
   9374 		ParserRuleReturnScope insn_format21s255 =null;
   9375 		ParserRuleReturnScope insn_format21t256 =null;
   9376 		ParserRuleReturnScope insn_format22b257 =null;
   9377 		ParserRuleReturnScope insn_format22c_field258 =null;
   9378 		ParserRuleReturnScope insn_format22c_field_odex259 =null;
   9379 		ParserRuleReturnScope insn_format22c_type260 =null;
   9380 		ParserRuleReturnScope insn_format22cs_field261 =null;
   9381 		ParserRuleReturnScope insn_format22s262 =null;
   9382 		ParserRuleReturnScope insn_format22t263 =null;
   9383 		ParserRuleReturnScope insn_format22x264 =null;
   9384 		ParserRuleReturnScope insn_format23x265 =null;
   9385 		ParserRuleReturnScope insn_format30t266 =null;
   9386 		ParserRuleReturnScope insn_format31c267 =null;
   9387 		ParserRuleReturnScope insn_format31i268 =null;
   9388 		ParserRuleReturnScope insn_format31t269 =null;
   9389 		ParserRuleReturnScope insn_format32x270 =null;
   9390 		ParserRuleReturnScope insn_format35c_method271 =null;
   9391 		ParserRuleReturnScope insn_format35c_type272 =null;
   9392 		ParserRuleReturnScope insn_format35c_method_odex273 =null;
   9393 		ParserRuleReturnScope insn_format35mi_method274 =null;
   9394 		ParserRuleReturnScope insn_format35ms_method275 =null;
   9395 		ParserRuleReturnScope insn_format3rc_method276 =null;
   9396 		ParserRuleReturnScope insn_format3rc_method_odex277 =null;
   9397 		ParserRuleReturnScope insn_format3rc_type278 =null;
   9398 		ParserRuleReturnScope insn_format3rmi_method279 =null;
   9399 		ParserRuleReturnScope insn_format3rms_method280 =null;
   9400 		ParserRuleReturnScope insn_format45cc_method281 =null;
   9401 		ParserRuleReturnScope insn_format4rcc_method282 =null;
   9402 		ParserRuleReturnScope insn_format51l283 =null;
   9403 		ParserRuleReturnScope insn_array_data_directive284 =null;
   9404 		ParserRuleReturnScope insn_packed_switch_directive285 =null;
   9405 		ParserRuleReturnScope insn_sparse_switch_directive286 =null;
   9406 
   9407 
   9408 		try {
   9409 			// smaliParser.g:802:3: ( insn_format10t | insn_format10x | insn_format10x_odex | insn_format11n | insn_format11x | insn_format12x | insn_format20bc | insn_format20t | insn_format21c_field | insn_format21c_field_odex | insn_format21c_string | insn_format21c_type | insn_format21ih | insn_format21lh | insn_format21s | insn_format21t | insn_format22b | insn_format22c_field | insn_format22c_field_odex | insn_format22c_type | insn_format22cs_field | insn_format22s | insn_format22t | insn_format22x | insn_format23x | insn_format30t | insn_format31c | insn_format31i | insn_format31t | insn_format32x | insn_format35c_method | insn_format35c_type | insn_format35c_method_odex | insn_format35mi_method | insn_format35ms_method | insn_format3rc_method | insn_format3rc_method_odex | insn_format3rc_type | insn_format3rmi_method | insn_format3rms_method | insn_format45cc_method | insn_format4rcc_method | insn_format51l | insn_array_data_directive | insn_packed_switch_directive | insn_sparse_switch_directive )
   9410 			int alt51=46;
   9411 			switch ( input.LA(1) ) {
   9412 			case INSTRUCTION_FORMAT10t:
   9413 				{
   9414 				alt51=1;
   9415 				}
   9416 				break;
   9417 			case INSTRUCTION_FORMAT10x:
   9418 				{
   9419 				alt51=2;
   9420 				}
   9421 				break;
   9422 			case INSTRUCTION_FORMAT10x_ODEX:
   9423 				{
   9424 				alt51=3;
   9425 				}
   9426 				break;
   9427 			case INSTRUCTION_FORMAT11n:
   9428 				{
   9429 				alt51=4;
   9430 				}
   9431 				break;
   9432 			case INSTRUCTION_FORMAT11x:
   9433 				{
   9434 				alt51=5;
   9435 				}
   9436 				break;
   9437 			case INSTRUCTION_FORMAT12x:
   9438 			case INSTRUCTION_FORMAT12x_OR_ID:
   9439 				{
   9440 				alt51=6;
   9441 				}
   9442 				break;
   9443 			case INSTRUCTION_FORMAT20bc:
   9444 				{
   9445 				alt51=7;
   9446 				}
   9447 				break;
   9448 			case INSTRUCTION_FORMAT20t:
   9449 				{
   9450 				alt51=8;
   9451 				}
   9452 				break;
   9453 			case INSTRUCTION_FORMAT21c_FIELD:
   9454 				{
   9455 				alt51=9;
   9456 				}
   9457 				break;
   9458 			case INSTRUCTION_FORMAT21c_FIELD_ODEX:
   9459 				{
   9460 				alt51=10;
   9461 				}
   9462 				break;
   9463 			case INSTRUCTION_FORMAT21c_STRING:
   9464 				{
   9465 				alt51=11;
   9466 				}
   9467 				break;
   9468 			case INSTRUCTION_FORMAT21c_TYPE:
   9469 				{
   9470 				alt51=12;
   9471 				}
   9472 				break;
   9473 			case INSTRUCTION_FORMAT21ih:
   9474 				{
   9475 				alt51=13;
   9476 				}
   9477 				break;
   9478 			case INSTRUCTION_FORMAT21lh:
   9479 				{
   9480 				alt51=14;
   9481 				}
   9482 				break;
   9483 			case INSTRUCTION_FORMAT21s:
   9484 				{
   9485 				alt51=15;
   9486 				}
   9487 				break;
   9488 			case INSTRUCTION_FORMAT21t:
   9489 				{
   9490 				alt51=16;
   9491 				}
   9492 				break;
   9493 			case INSTRUCTION_FORMAT22b:
   9494 				{
   9495 				alt51=17;
   9496 				}
   9497 				break;
   9498 			case INSTRUCTION_FORMAT22c_FIELD:
   9499 				{
   9500 				alt51=18;
   9501 				}
   9502 				break;
   9503 			case INSTRUCTION_FORMAT22c_FIELD_ODEX:
   9504 				{
   9505 				alt51=19;
   9506 				}
   9507 				break;
   9508 			case INSTRUCTION_FORMAT22c_TYPE:
   9509 				{
   9510 				alt51=20;
   9511 				}
   9512 				break;
   9513 			case INSTRUCTION_FORMAT22cs_FIELD:
   9514 				{
   9515 				alt51=21;
   9516 				}
   9517 				break;
   9518 			case INSTRUCTION_FORMAT22s:
   9519 			case INSTRUCTION_FORMAT22s_OR_ID:
   9520 				{
   9521 				alt51=22;
   9522 				}
   9523 				break;
   9524 			case INSTRUCTION_FORMAT22t:
   9525 				{
   9526 				alt51=23;
   9527 				}
   9528 				break;
   9529 			case INSTRUCTION_FORMAT22x:
   9530 				{
   9531 				alt51=24;
   9532 				}
   9533 				break;
   9534 			case INSTRUCTION_FORMAT23x:
   9535 				{
   9536 				alt51=25;
   9537 				}
   9538 				break;
   9539 			case INSTRUCTION_FORMAT30t:
   9540 				{
   9541 				alt51=26;
   9542 				}
   9543 				break;
   9544 			case INSTRUCTION_FORMAT31c:
   9545 				{
   9546 				alt51=27;
   9547 				}
   9548 				break;
   9549 			case INSTRUCTION_FORMAT31i:
   9550 			case INSTRUCTION_FORMAT31i_OR_ID:
   9551 				{
   9552 				alt51=28;
   9553 				}
   9554 				break;
   9555 			case INSTRUCTION_FORMAT31t:
   9556 				{
   9557 				alt51=29;
   9558 				}
   9559 				break;
   9560 			case INSTRUCTION_FORMAT32x:
   9561 				{
   9562 				alt51=30;
   9563 				}
   9564 				break;
   9565 			case INSTRUCTION_FORMAT35c_METHOD:
   9566 				{
   9567 				alt51=31;
   9568 				}
   9569 				break;
   9570 			case INSTRUCTION_FORMAT35c_TYPE:
   9571 				{
   9572 				alt51=32;
   9573 				}
   9574 				break;
   9575 			case INSTRUCTION_FORMAT35c_METHOD_ODEX:
   9576 				{
   9577 				alt51=33;
   9578 				}
   9579 				break;
   9580 			case INSTRUCTION_FORMAT35mi_METHOD:
   9581 				{
   9582 				alt51=34;
   9583 				}
   9584 				break;
   9585 			case INSTRUCTION_FORMAT35ms_METHOD:
   9586 				{
   9587 				alt51=35;
   9588 				}
   9589 				break;
   9590 			case INSTRUCTION_FORMAT3rc_METHOD:
   9591 				{
   9592 				alt51=36;
   9593 				}
   9594 				break;
   9595 			case INSTRUCTION_FORMAT3rc_METHOD_ODEX:
   9596 				{
   9597 				alt51=37;
   9598 				}
   9599 				break;
   9600 			case INSTRUCTION_FORMAT3rc_TYPE:
   9601 				{
   9602 				alt51=38;
   9603 				}
   9604 				break;
   9605 			case INSTRUCTION_FORMAT3rmi_METHOD:
   9606 				{
   9607 				alt51=39;
   9608 				}
   9609 				break;
   9610 			case INSTRUCTION_FORMAT3rms_METHOD:
   9611 				{
   9612 				alt51=40;
   9613 				}
   9614 				break;
   9615 			case INSTRUCTION_FORMAT45cc_METHOD:
   9616 				{
   9617 				alt51=41;
   9618 				}
   9619 				break;
   9620 			case INSTRUCTION_FORMAT4rcc_METHOD:
   9621 				{
   9622 				alt51=42;
   9623 				}
   9624 				break;
   9625 			case INSTRUCTION_FORMAT51l:
   9626 				{
   9627 				alt51=43;
   9628 				}
   9629 				break;
   9630 			case ARRAY_DATA_DIRECTIVE:
   9631 				{
   9632 				alt51=44;
   9633 				}
   9634 				break;
   9635 			case PACKED_SWITCH_DIRECTIVE:
   9636 				{
   9637 				alt51=45;
   9638 				}
   9639 				break;
   9640 			case SPARSE_SWITCH_DIRECTIVE:
   9641 				{
   9642 				alt51=46;
   9643 				}
   9644 				break;
   9645 			default:
   9646 				NoViableAltException nvae =
   9647 					new NoViableAltException("", 51, 0, input);
   9648 				throw nvae;
   9649 			}
   9650 			switch (alt51) {
   9651 				case 1 :
   9652 					// smaliParser.g:802:5: insn_format10t
   9653 					{
   9654 					root_0 = (CommonTree)adaptor.nil();
   9655 
   9656 
   9657 					pushFollow(FOLLOW_insn_format10t_in_instruction3740);
   9658 					insn_format10t241=insn_format10t();
   9659 					state._fsp--;
   9660 
   9661 					adaptor.addChild(root_0, insn_format10t241.getTree());
   9662 
   9663 					}
   9664 					break;
   9665 				case 2 :
   9666 					// smaliParser.g:803:5: insn_format10x
   9667 					{
   9668 					root_0 = (CommonTree)adaptor.nil();
   9669 
   9670 
   9671 					pushFollow(FOLLOW_insn_format10x_in_instruction3746);
   9672 					insn_format10x242=insn_format10x();
   9673 					state._fsp--;
   9674 
   9675 					adaptor.addChild(root_0, insn_format10x242.getTree());
   9676 
   9677 					}
   9678 					break;
   9679 				case 3 :
   9680 					// smaliParser.g:804:5: insn_format10x_odex
   9681 					{
   9682 					root_0 = (CommonTree)adaptor.nil();
   9683 
   9684 
   9685 					pushFollow(FOLLOW_insn_format10x_odex_in_instruction3752);
   9686 					insn_format10x_odex243=insn_format10x_odex();
   9687 					state._fsp--;
   9688 
   9689 					adaptor.addChild(root_0, insn_format10x_odex243.getTree());
   9690 
   9691 					}
   9692 					break;
   9693 				case 4 :
   9694 					// smaliParser.g:805:5: insn_format11n
   9695 					{
   9696 					root_0 = (CommonTree)adaptor.nil();
   9697 
   9698 
   9699 					pushFollow(FOLLOW_insn_format11n_in_instruction3758);
   9700 					insn_format11n244=insn_format11n();
   9701 					state._fsp--;
   9702 
   9703 					adaptor.addChild(root_0, insn_format11n244.getTree());
   9704 
   9705 					}
   9706 					break;
   9707 				case 5 :
   9708 					// smaliParser.g:806:5: insn_format11x
   9709 					{
   9710 					root_0 = (CommonTree)adaptor.nil();
   9711 
   9712 
   9713 					pushFollow(FOLLOW_insn_format11x_in_instruction3764);
   9714 					insn_format11x245=insn_format11x();
   9715 					state._fsp--;
   9716 
   9717 					adaptor.addChild(root_0, insn_format11x245.getTree());
   9718 
   9719 					}
   9720 					break;
   9721 				case 6 :
   9722 					// smaliParser.g:807:5: insn_format12x
   9723 					{
   9724 					root_0 = (CommonTree)adaptor.nil();
   9725 
   9726 
   9727 					pushFollow(FOLLOW_insn_format12x_in_instruction3770);
   9728 					insn_format12x246=insn_format12x();
   9729 					state._fsp--;
   9730 
   9731 					adaptor.addChild(root_0, insn_format12x246.getTree());
   9732 
   9733 					}
   9734 					break;
   9735 				case 7 :
   9736 					// smaliParser.g:808:5: insn_format20bc
   9737 					{
   9738 					root_0 = (CommonTree)adaptor.nil();
   9739 
   9740 
   9741 					pushFollow(FOLLOW_insn_format20bc_in_instruction3776);
   9742 					insn_format20bc247=insn_format20bc();
   9743 					state._fsp--;
   9744 
   9745 					adaptor.addChild(root_0, insn_format20bc247.getTree());
   9746 
   9747 					}
   9748 					break;
   9749 				case 8 :
   9750 					// smaliParser.g:809:5: insn_format20t
   9751 					{
   9752 					root_0 = (CommonTree)adaptor.nil();
   9753 
   9754 
   9755 					pushFollow(FOLLOW_insn_format20t_in_instruction3782);
   9756 					insn_format20t248=insn_format20t();
   9757 					state._fsp--;
   9758 
   9759 					adaptor.addChild(root_0, insn_format20t248.getTree());
   9760 
   9761 					}
   9762 					break;
   9763 				case 9 :
   9764 					// smaliParser.g:810:5: insn_format21c_field
   9765 					{
   9766 					root_0 = (CommonTree)adaptor.nil();
   9767 
   9768 
   9769 					pushFollow(FOLLOW_insn_format21c_field_in_instruction3788);
   9770 					insn_format21c_field249=insn_format21c_field();
   9771 					state._fsp--;
   9772 
   9773 					adaptor.addChild(root_0, insn_format21c_field249.getTree());
   9774 
   9775 					}
   9776 					break;
   9777 				case 10 :
   9778 					// smaliParser.g:811:5: insn_format21c_field_odex
   9779 					{
   9780 					root_0 = (CommonTree)adaptor.nil();
   9781 
   9782 
   9783 					pushFollow(FOLLOW_insn_format21c_field_odex_in_instruction3794);
   9784 					insn_format21c_field_odex250=insn_format21c_field_odex();
   9785 					state._fsp--;
   9786 
   9787 					adaptor.addChild(root_0, insn_format21c_field_odex250.getTree());
   9788 
   9789 					}
   9790 					break;
   9791 				case 11 :
   9792 					// smaliParser.g:812:5: insn_format21c_string
   9793 					{
   9794 					root_0 = (CommonTree)adaptor.nil();
   9795 
   9796 
   9797 					pushFollow(FOLLOW_insn_format21c_string_in_instruction3800);
   9798 					insn_format21c_string251=insn_format21c_string();
   9799 					state._fsp--;
   9800 
   9801 					adaptor.addChild(root_0, insn_format21c_string251.getTree());
   9802 
   9803 					}
   9804 					break;
   9805 				case 12 :
   9806 					// smaliParser.g:813:5: insn_format21c_type
   9807 					{
   9808 					root_0 = (CommonTree)adaptor.nil();
   9809 
   9810 
   9811 					pushFollow(FOLLOW_insn_format21c_type_in_instruction3806);
   9812 					insn_format21c_type252=insn_format21c_type();
   9813 					state._fsp--;
   9814 
   9815 					adaptor.addChild(root_0, insn_format21c_type252.getTree());
   9816 
   9817 					}
   9818 					break;
   9819 				case 13 :
   9820 					// smaliParser.g:814:5: insn_format21ih
   9821 					{
   9822 					root_0 = (CommonTree)adaptor.nil();
   9823 
   9824 
   9825 					pushFollow(FOLLOW_insn_format21ih_in_instruction3812);
   9826 					insn_format21ih253=insn_format21ih();
   9827 					state._fsp--;
   9828 
   9829 					adaptor.addChild(root_0, insn_format21ih253.getTree());
   9830 
   9831 					}
   9832 					break;
   9833 				case 14 :
   9834 					// smaliParser.g:815:5: insn_format21lh
   9835 					{
   9836 					root_0 = (CommonTree)adaptor.nil();
   9837 
   9838 
   9839 					pushFollow(FOLLOW_insn_format21lh_in_instruction3818);
   9840 					insn_format21lh254=insn_format21lh();
   9841 					state._fsp--;
   9842 
   9843 					adaptor.addChild(root_0, insn_format21lh254.getTree());
   9844 
   9845 					}
   9846 					break;
   9847 				case 15 :
   9848 					// smaliParser.g:816:5: insn_format21s
   9849 					{
   9850 					root_0 = (CommonTree)adaptor.nil();
   9851 
   9852 
   9853 					pushFollow(FOLLOW_insn_format21s_in_instruction3824);
   9854 					insn_format21s255=insn_format21s();
   9855 					state._fsp--;
   9856 
   9857 					adaptor.addChild(root_0, insn_format21s255.getTree());
   9858 
   9859 					}
   9860 					break;
   9861 				case 16 :
   9862 					// smaliParser.g:817:5: insn_format21t
   9863 					{
   9864 					root_0 = (CommonTree)adaptor.nil();
   9865 
   9866 
   9867 					pushFollow(FOLLOW_insn_format21t_in_instruction3830);
   9868 					insn_format21t256=insn_format21t();
   9869 					state._fsp--;
   9870 
   9871 					adaptor.addChild(root_0, insn_format21t256.getTree());
   9872 
   9873 					}
   9874 					break;
   9875 				case 17 :
   9876 					// smaliParser.g:818:5: insn_format22b
   9877 					{
   9878 					root_0 = (CommonTree)adaptor.nil();
   9879 
   9880 
   9881 					pushFollow(FOLLOW_insn_format22b_in_instruction3836);
   9882 					insn_format22b257=insn_format22b();
   9883 					state._fsp--;
   9884 
   9885 					adaptor.addChild(root_0, insn_format22b257.getTree());
   9886 
   9887 					}
   9888 					break;
   9889 				case 18 :
   9890 					// smaliParser.g:819:5: insn_format22c_field
   9891 					{
   9892 					root_0 = (CommonTree)adaptor.nil();
   9893 
   9894 
   9895 					pushFollow(FOLLOW_insn_format22c_field_in_instruction3842);
   9896 					insn_format22c_field258=insn_format22c_field();
   9897 					state._fsp--;
   9898 
   9899 					adaptor.addChild(root_0, insn_format22c_field258.getTree());
   9900 
   9901 					}
   9902 					break;
   9903 				case 19 :
   9904 					// smaliParser.g:820:5: insn_format22c_field_odex
   9905 					{
   9906 					root_0 = (CommonTree)adaptor.nil();
   9907 
   9908 
   9909 					pushFollow(FOLLOW_insn_format22c_field_odex_in_instruction3848);
   9910 					insn_format22c_field_odex259=insn_format22c_field_odex();
   9911 					state._fsp--;
   9912 
   9913 					adaptor.addChild(root_0, insn_format22c_field_odex259.getTree());
   9914 
   9915 					}
   9916 					break;
   9917 				case 20 :
   9918 					// smaliParser.g:821:5: insn_format22c_type
   9919 					{
   9920 					root_0 = (CommonTree)adaptor.nil();
   9921 
   9922 
   9923 					pushFollow(FOLLOW_insn_format22c_type_in_instruction3854);
   9924 					insn_format22c_type260=insn_format22c_type();
   9925 					state._fsp--;
   9926 
   9927 					adaptor.addChild(root_0, insn_format22c_type260.getTree());
   9928 
   9929 					}
   9930 					break;
   9931 				case 21 :
   9932 					// smaliParser.g:822:5: insn_format22cs_field
   9933 					{
   9934 					root_0 = (CommonTree)adaptor.nil();
   9935 
   9936 
   9937 					pushFollow(FOLLOW_insn_format22cs_field_in_instruction3860);
   9938 					insn_format22cs_field261=insn_format22cs_field();
   9939 					state._fsp--;
   9940 
   9941 					adaptor.addChild(root_0, insn_format22cs_field261.getTree());
   9942 
   9943 					}
   9944 					break;
   9945 				case 22 :
   9946 					// smaliParser.g:823:5: insn_format22s
   9947 					{
   9948 					root_0 = (CommonTree)adaptor.nil();
   9949 
   9950 
   9951 					pushFollow(FOLLOW_insn_format22s_in_instruction3866);
   9952 					insn_format22s262=insn_format22s();
   9953 					state._fsp--;
   9954 
   9955 					adaptor.addChild(root_0, insn_format22s262.getTree());
   9956 
   9957 					}
   9958 					break;
   9959 				case 23 :
   9960 					// smaliParser.g:824:5: insn_format22t
   9961 					{
   9962 					root_0 = (CommonTree)adaptor.nil();
   9963 
   9964 
   9965 					pushFollow(FOLLOW_insn_format22t_in_instruction3872);
   9966 					insn_format22t263=insn_format22t();
   9967 					state._fsp--;
   9968 
   9969 					adaptor.addChild(root_0, insn_format22t263.getTree());
   9970 
   9971 					}
   9972 					break;
   9973 				case 24 :
   9974 					// smaliParser.g:825:5: insn_format22x
   9975 					{
   9976 					root_0 = (CommonTree)adaptor.nil();
   9977 
   9978 
   9979 					pushFollow(FOLLOW_insn_format22x_in_instruction3878);
   9980 					insn_format22x264=insn_format22x();
   9981 					state._fsp--;
   9982 
   9983 					adaptor.addChild(root_0, insn_format22x264.getTree());
   9984 
   9985 					}
   9986 					break;
   9987 				case 25 :
   9988 					// smaliParser.g:826:5: insn_format23x
   9989 					{
   9990 					root_0 = (CommonTree)adaptor.nil();
   9991 
   9992 
   9993 					pushFollow(FOLLOW_insn_format23x_in_instruction3884);
   9994 					insn_format23x265=insn_format23x();
   9995 					state._fsp--;
   9996 
   9997 					adaptor.addChild(root_0, insn_format23x265.getTree());
   9998 
   9999 					}
   10000 					break;
   10001 				case 26 :
   10002 					// smaliParser.g:827:5: insn_format30t
   10003 					{
   10004 					root_0 = (CommonTree)adaptor.nil();
   10005 
   10006 
   10007 					pushFollow(FOLLOW_insn_format30t_in_instruction3890);
   10008 					insn_format30t266=insn_format30t();
   10009 					state._fsp--;
   10010 
   10011 					adaptor.addChild(root_0, insn_format30t266.getTree());
   10012 
   10013 					}
   10014 					break;
   10015 				case 27 :
   10016 					// smaliParser.g:828:5: insn_format31c
   10017 					{
   10018 					root_0 = (CommonTree)adaptor.nil();
   10019 
   10020 
   10021 					pushFollow(FOLLOW_insn_format31c_in_instruction3896);
   10022 					insn_format31c267=insn_format31c();
   10023 					state._fsp--;
   10024 
   10025 					adaptor.addChild(root_0, insn_format31c267.getTree());
   10026 
   10027 					}
   10028 					break;
   10029 				case 28 :
   10030 					// smaliParser.g:829:5: insn_format31i
   10031 					{
   10032 					root_0 = (CommonTree)adaptor.nil();
   10033 
   10034 
   10035 					pushFollow(FOLLOW_insn_format31i_in_instruction3902);
   10036 					insn_format31i268=insn_format31i();
   10037 					state._fsp--;
   10038 
   10039 					adaptor.addChild(root_0, insn_format31i268.getTree());
   10040 
   10041 					}
   10042 					break;
   10043 				case 29 :
   10044 					// smaliParser.g:830:5: insn_format31t
   10045 					{
   10046 					root_0 = (CommonTree)adaptor.nil();
   10047 
   10048 
   10049 					pushFollow(FOLLOW_insn_format31t_in_instruction3908);
   10050 					insn_format31t269=insn_format31t();
   10051 					state._fsp--;
   10052 
   10053 					adaptor.addChild(root_0, insn_format31t269.getTree());
   10054 
   10055 					}
   10056 					break;
   10057 				case 30 :
   10058 					// smaliParser.g:831:5: insn_format32x
   10059 					{
   10060 					root_0 = (CommonTree)adaptor.nil();
   10061 
   10062 
   10063 					pushFollow(FOLLOW_insn_format32x_in_instruction3914);
   10064 					insn_format32x270=insn_format32x();
   10065 					state._fsp--;
   10066 
   10067 					adaptor.addChild(root_0, insn_format32x270.getTree());
   10068 
   10069 					}
   10070 					break;
   10071 				case 31 :
   10072 					// smaliParser.g:832:5: insn_format35c_method
   10073 					{
   10074 					root_0 = (CommonTree)adaptor.nil();
   10075 
   10076 
   10077 					pushFollow(FOLLOW_insn_format35c_method_in_instruction3920);
   10078 					insn_format35c_method271=insn_format35c_method();
   10079 					state._fsp--;
   10080 
   10081 					adaptor.addChild(root_0, insn_format35c_method271.getTree());
   10082 
   10083 					}
   10084 					break;
   10085 				case 32 :
   10086 					// smaliParser.g:833:5: insn_format35c_type
   10087 					{
   10088 					root_0 = (CommonTree)adaptor.nil();
   10089 
   10090 
   10091 					pushFollow(FOLLOW_insn_format35c_type_in_instruction3926);
   10092 					insn_format35c_type272=insn_format35c_type();
   10093 					state._fsp--;
   10094 
   10095 					adaptor.addChild(root_0, insn_format35c_type272.getTree());
   10096 
   10097 					}
   10098 					break;
   10099 				case 33 :
   10100 					// smaliParser.g:834:5: insn_format35c_method_odex
   10101 					{
   10102 					root_0 = (CommonTree)adaptor.nil();
   10103 
   10104 
   10105 					pushFollow(FOLLOW_insn_format35c_method_odex_in_instruction3932);
   10106 					insn_format35c_method_odex273=insn_format35c_method_odex();
   10107 					state._fsp--;
   10108 
   10109 					adaptor.addChild(root_0, insn_format35c_method_odex273.getTree());
   10110 
   10111 					}
   10112 					break;
   10113 				case 34 :
   10114 					// smaliParser.g:835:5: insn_format35mi_method
   10115 					{
   10116 					root_0 = (CommonTree)adaptor.nil();
   10117 
   10118 
   10119 					pushFollow(FOLLOW_insn_format35mi_method_in_instruction3938);
   10120 					insn_format35mi_method274=insn_format35mi_method();
   10121 					state._fsp--;
   10122 
   10123 					adaptor.addChild(root_0, insn_format35mi_method274.getTree());
   10124 
   10125 					}
   10126 					break;
   10127 				case 35 :
   10128 					// smaliParser.g:836:5: insn_format35ms_method
   10129 					{
   10130 					root_0 = (CommonTree)adaptor.nil();
   10131 
   10132 
   10133 					pushFollow(FOLLOW_insn_format35ms_method_in_instruction3944);
   10134 					insn_format35ms_method275=insn_format35ms_method();
   10135 					state._fsp--;
   10136 
   10137 					adaptor.addChild(root_0, insn_format35ms_method275.getTree());
   10138 
   10139 					}
   10140 					break;
   10141 				case 36 :
   10142 					// smaliParser.g:837:5: insn_format3rc_method
   10143 					{
   10144 					root_0 = (CommonTree)adaptor.nil();
   10145 
   10146 
   10147 					pushFollow(FOLLOW_insn_format3rc_method_in_instruction3950);
   10148 					insn_format3rc_method276=insn_format3rc_method();
   10149 					state._fsp--;
   10150 
   10151 					adaptor.addChild(root_0, insn_format3rc_method276.getTree());
   10152 
   10153 					}
   10154 					break;
   10155 				case 37 :
   10156 					// smaliParser.g:838:5: insn_format3rc_method_odex
   10157 					{
   10158 					root_0 = (CommonTree)adaptor.nil();
   10159 
   10160 
   10161 					pushFollow(FOLLOW_insn_format3rc_method_odex_in_instruction3956);
   10162 					insn_format3rc_method_odex277=insn_format3rc_method_odex();
   10163 					state._fsp--;
   10164 
   10165 					adaptor.addChild(root_0, insn_format3rc_method_odex277.getTree());
   10166 
   10167 					}
   10168 					break;
   10169 				case 38 :
   10170 					// smaliParser.g:839:5: insn_format3rc_type
   10171 					{
   10172 					root_0 = (CommonTree)adaptor.nil();
   10173 
   10174 
   10175 					pushFollow(FOLLOW_insn_format3rc_type_in_instruction3962);
   10176 					insn_format3rc_type278=insn_format3rc_type();
   10177 					state._fsp--;
   10178 
   10179 					adaptor.addChild(root_0, insn_format3rc_type278.getTree());
   10180 
   10181 					}
   10182 					break;
   10183 				case 39 :
   10184 					// smaliParser.g:840:5: insn_format3rmi_method
   10185 					{
   10186 					root_0 = (CommonTree)adaptor.nil();
   10187 
   10188 
   10189 					pushFollow(FOLLOW_insn_format3rmi_method_in_instruction3968);
   10190 					insn_format3rmi_method279=insn_format3rmi_method();
   10191 					state._fsp--;
   10192 
   10193 					adaptor.addChild(root_0, insn_format3rmi_method279.getTree());
   10194 
   10195 					}
   10196 					break;
   10197 				case 40 :
   10198 					// smaliParser.g:841:5: insn_format3rms_method
   10199 					{
   10200 					root_0 = (CommonTree)adaptor.nil();
   10201 
   10202 
   10203 					pushFollow(FOLLOW_insn_format3rms_method_in_instruction3974);
   10204 					insn_format3rms_method280=insn_format3rms_method();
   10205 					state._fsp--;
   10206 
   10207 					adaptor.addChild(root_0, insn_format3rms_method280.getTree());
   10208 
   10209 					}
   10210 					break;
   10211 				case 41 :
   10212 					// smaliParser.g:842:5: insn_format45cc_method
   10213 					{
   10214 					root_0 = (CommonTree)adaptor.nil();
   10215 
   10216 
   10217 					pushFollow(FOLLOW_insn_format45cc_method_in_instruction3980);
   10218 					insn_format45cc_method281=insn_format45cc_method();
   10219 					state._fsp--;
   10220 
   10221 					adaptor.addChild(root_0, insn_format45cc_method281.getTree());
   10222 
   10223 					}
   10224 					break;
   10225 				case 42 :
   10226 					// smaliParser.g:843:5: insn_format4rcc_method
   10227 					{
   10228 					root_0 = (CommonTree)adaptor.nil();
   10229 
   10230 
   10231 					pushFollow(FOLLOW_insn_format4rcc_method_in_instruction3986);
   10232 					insn_format4rcc_method282=insn_format4rcc_method();
   10233 					state._fsp--;
   10234 
   10235 					adaptor.addChild(root_0, insn_format4rcc_method282.getTree());
   10236 
   10237 					}
   10238 					break;
   10239 				case 43 :
   10240 					// smaliParser.g:844:5: insn_format51l
   10241 					{
   10242 					root_0 = (CommonTree)adaptor.nil();
   10243 
   10244 
   10245 					pushFollow(FOLLOW_insn_format51l_in_instruction3992);
   10246 					insn_format51l283=insn_format51l();
   10247 					state._fsp--;
   10248 
   10249 					adaptor.addChild(root_0, insn_format51l283.getTree());
   10250 
   10251 					}
   10252 					break;
   10253 				case 44 :
   10254 					// smaliParser.g:845:5: insn_array_data_directive
   10255 					{
   10256 					root_0 = (CommonTree)adaptor.nil();
   10257 
   10258 
   10259 					pushFollow(FOLLOW_insn_array_data_directive_in_instruction3998);
   10260 					insn_array_data_directive284=insn_array_data_directive();
   10261 					state._fsp--;
   10262 
   10263 					adaptor.addChild(root_0, insn_array_data_directive284.getTree());
   10264 
   10265 					}
   10266 					break;
   10267 				case 45 :
   10268 					// smaliParser.g:846:5: insn_packed_switch_directive
   10269 					{
   10270 					root_0 = (CommonTree)adaptor.nil();
   10271 
   10272 
   10273 					pushFollow(FOLLOW_insn_packed_switch_directive_in_instruction4004);
   10274 					insn_packed_switch_directive285=insn_packed_switch_directive();
   10275 					state._fsp--;
   10276 
   10277 					adaptor.addChild(root_0, insn_packed_switch_directive285.getTree());
   10278 
   10279 					}
   10280 					break;
   10281 				case 46 :
   10282 					// smaliParser.g:847:5: insn_sparse_switch_directive
   10283 					{
   10284 					root_0 = (CommonTree)adaptor.nil();
   10285 
   10286 
   10287 					pushFollow(FOLLOW_insn_sparse_switch_directive_in_instruction4010);
   10288 					insn_sparse_switch_directive286=insn_sparse_switch_directive();
   10289 					state._fsp--;
   10290 
   10291 					adaptor.addChild(root_0, insn_sparse_switch_directive286.getTree());
   10292 
   10293 					}
   10294 					break;
   10295 
   10296 			}
   10297 			retval.stop = input.LT(-1);
   10298 
   10299 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   10300 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   10301 
   10302 		}
   10303 		catch (RecognitionException re) {
   10304 			reportError(re);
   10305 			recover(input,re);
   10306 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   10307 		}
   10308 		finally {
   10309 			// do for sure before leaving
   10310 		}
   10311 		return retval;
   10312 	}
   10313 	// $ANTLR end "instruction"
   10314 
   10315 
   10316 	public static class insn_format10t_return extends ParserRuleReturnScope {
   10317 		CommonTree tree;
   10318 		@Override
   10319 		public CommonTree getTree() { return tree; }
   10320 	};
   10321 
   10322 
   10323 	// $ANTLR start "insn_format10t"
   10324 	// smaliParser.g:849:1: insn_format10t : INSTRUCTION_FORMAT10t label_ref -> ^( I_STATEMENT_FORMAT10t[$start, \"I_STATEMENT_FORMAT10t\"] INSTRUCTION_FORMAT10t label_ref ) ;
   10325 	public final smaliParser.insn_format10t_return insn_format10t() throws RecognitionException {
   10326 		smaliParser.insn_format10t_return retval = new smaliParser.insn_format10t_return();
   10327 		retval.start = input.LT(1);
   10328 
   10329 		CommonTree root_0 = null;
   10330 
   10331 		Token INSTRUCTION_FORMAT10t287=null;
   10332 		ParserRuleReturnScope label_ref288 =null;
   10333 
   10334 		CommonTree INSTRUCTION_FORMAT10t287_tree=null;
   10335 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT10t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT10t");
   10336 		RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref");
   10337 
   10338 		try {
   10339 			// smaliParser.g:850:3: ( INSTRUCTION_FORMAT10t label_ref -> ^( I_STATEMENT_FORMAT10t[$start, \"I_STATEMENT_FORMAT10t\"] INSTRUCTION_FORMAT10t label_ref ) )
   10340 			// smaliParser.g:852:5: INSTRUCTION_FORMAT10t label_ref
   10341 			{
   10342 			INSTRUCTION_FORMAT10t287=(Token)match(input,INSTRUCTION_FORMAT10t,FOLLOW_INSTRUCTION_FORMAT10t_in_insn_format10t4030);
   10343 			stream_INSTRUCTION_FORMAT10t.add(INSTRUCTION_FORMAT10t287);
   10344 
   10345 			pushFollow(FOLLOW_label_ref_in_insn_format10t4032);
   10346 			label_ref288=label_ref();
   10347 			state._fsp--;
   10348 
   10349 			stream_label_ref.add(label_ref288.getTree());
   10350 			// AST REWRITE
   10351 			// elements: INSTRUCTION_FORMAT10t, label_ref
   10352 			// token labels:
   10353 			// rule labels: retval
   10354 			// token list labels:
   10355 			// rule list labels:
   10356 			// wildcard labels:
   10357 			retval.tree = root_0;
   10358 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   10359 
   10360 			root_0 = (CommonTree)adaptor.nil();
   10361 			// 853:5: -> ^( I_STATEMENT_FORMAT10t[$start, \"I_STATEMENT_FORMAT10t\"] INSTRUCTION_FORMAT10t label_ref )
   10362 			{
   10363 				// smaliParser.g:853:8: ^( I_STATEMENT_FORMAT10t[$start, \"I_STATEMENT_FORMAT10t\"] INSTRUCTION_FORMAT10t label_ref )
   10364 				{
   10365 				CommonTree root_1 = (CommonTree)adaptor.nil();
   10366 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT10t, (retval.start), "I_STATEMENT_FORMAT10t"), root_1);
   10367 				adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT10t.nextNode());
   10368 				adaptor.addChild(root_1, stream_label_ref.nextTree());
   10369 				adaptor.addChild(root_0, root_1);
   10370 				}
   10371 
   10372 			}
   10373 
   10374 
   10375 			retval.tree = root_0;
   10376 
   10377 			}
   10378 
   10379 			retval.stop = input.LT(-1);
   10380 
   10381 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   10382 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   10383 
   10384 		}
   10385 		catch (RecognitionException re) {
   10386 			reportError(re);
   10387 			recover(input,re);
   10388 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   10389 		}
   10390 		finally {
   10391 			// do for sure before leaving
   10392 		}
   10393 		return retval;
   10394 	}
   10395 	// $ANTLR end "insn_format10t"
   10396 
   10397 
   10398 	public static class insn_format10x_return extends ParserRuleReturnScope {
   10399 		CommonTree tree;
   10400 		@Override
   10401 		public CommonTree getTree() { return tree; }
   10402 	};
   10403 
   10404 
   10405 	// $ANTLR start "insn_format10x"
   10406 	// smaliParser.g:855:1: insn_format10x : INSTRUCTION_FORMAT10x -> ^( I_STATEMENT_FORMAT10x[$start, \"I_STATEMENT_FORMAT10x\"] INSTRUCTION_FORMAT10x ) ;
   10407 	public final smaliParser.insn_format10x_return insn_format10x() throws RecognitionException {
   10408 		smaliParser.insn_format10x_return retval = new smaliParser.insn_format10x_return();
   10409 		retval.start = input.LT(1);
   10410 
   10411 		CommonTree root_0 = null;
   10412 
   10413 		Token INSTRUCTION_FORMAT10x289=null;
   10414 
   10415 		CommonTree INSTRUCTION_FORMAT10x289_tree=null;
   10416 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT10x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT10x");
   10417 
   10418 		try {
   10419 			// smaliParser.g:856:3: ( INSTRUCTION_FORMAT10x -> ^( I_STATEMENT_FORMAT10x[$start, \"I_STATEMENT_FORMAT10x\"] INSTRUCTION_FORMAT10x ) )
   10420 			// smaliParser.g:857:5: INSTRUCTION_FORMAT10x
   10421 			{
   10422 			INSTRUCTION_FORMAT10x289=(Token)match(input,INSTRUCTION_FORMAT10x,FOLLOW_INSTRUCTION_FORMAT10x_in_insn_format10x4062);
   10423 			stream_INSTRUCTION_FORMAT10x.add(INSTRUCTION_FORMAT10x289);
   10424 
   10425 			// AST REWRITE
   10426 			// elements: INSTRUCTION_FORMAT10x
   10427 			// token labels:
   10428 			// rule labels: retval
   10429 			// token list labels:
   10430 			// rule list labels:
   10431 			// wildcard labels:
   10432 			retval.tree = root_0;
   10433 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   10434 
   10435 			root_0 = (CommonTree)adaptor.nil();
   10436 			// 858:5: -> ^( I_STATEMENT_FORMAT10x[$start, \"I_STATEMENT_FORMAT10x\"] INSTRUCTION_FORMAT10x )
   10437 			{
   10438 				// smaliParser.g:858:8: ^( I_STATEMENT_FORMAT10x[$start, \"I_STATEMENT_FORMAT10x\"] INSTRUCTION_FORMAT10x )
   10439 				{
   10440 				CommonTree root_1 = (CommonTree)adaptor.nil();
   10441 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT10x, (retval.start), "I_STATEMENT_FORMAT10x"), root_1);
   10442 				adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT10x.nextNode());
   10443 				adaptor.addChild(root_0, root_1);
   10444 				}
   10445 
   10446 			}
   10447 
   10448 
   10449 			retval.tree = root_0;
   10450 
   10451 			}
   10452 
   10453 			retval.stop = input.LT(-1);
   10454 
   10455 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   10456 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   10457 
   10458 		}
   10459 		catch (RecognitionException re) {
   10460 			reportError(re);
   10461 			recover(input,re);
   10462 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   10463 		}
   10464 		finally {
   10465 			// do for sure before leaving
   10466 		}
   10467 		return retval;
   10468 	}
   10469 	// $ANTLR end "insn_format10x"
   10470 
   10471 
   10472 	public static class insn_format10x_odex_return extends ParserRuleReturnScope {
   10473 		CommonTree tree;
   10474 		@Override
   10475 		public CommonTree getTree() { return tree; }
   10476 	};
   10477 
   10478 
   10479 	// $ANTLR start "insn_format10x_odex"
   10480 	// smaliParser.g:860:1: insn_format10x_odex : INSTRUCTION_FORMAT10x_ODEX ;
   10481 	public final smaliParser.insn_format10x_odex_return insn_format10x_odex() throws RecognitionException {
   10482 		smaliParser.insn_format10x_odex_return retval = new smaliParser.insn_format10x_odex_return();
   10483 		retval.start = input.LT(1);
   10484 
   10485 		CommonTree root_0 = null;
   10486 
   10487 		Token INSTRUCTION_FORMAT10x_ODEX290=null;
   10488 
   10489 		CommonTree INSTRUCTION_FORMAT10x_ODEX290_tree=null;
   10490 
   10491 		try {
   10492 			// smaliParser.g:861:3: ( INSTRUCTION_FORMAT10x_ODEX )
   10493 			// smaliParser.g:862:5: INSTRUCTION_FORMAT10x_ODEX
   10494 			{
   10495 			root_0 = (CommonTree)adaptor.nil();
   10496 
   10497 
   10498 			INSTRUCTION_FORMAT10x_ODEX290=(Token)match(input,INSTRUCTION_FORMAT10x_ODEX,FOLLOW_INSTRUCTION_FORMAT10x_ODEX_in_insn_format10x_odex4090);
   10499 			INSTRUCTION_FORMAT10x_ODEX290_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT10x_ODEX290);
   10500 			adaptor.addChild(root_0, INSTRUCTION_FORMAT10x_ODEX290_tree);
   10501 
   10502 
   10503 			      throwOdexedInstructionException(input, (INSTRUCTION_FORMAT10x_ODEX290!=null?INSTRUCTION_FORMAT10x_ODEX290.getText():null));
   10504 
   10505 			}
   10506 
   10507 			retval.stop = input.LT(-1);
   10508 
   10509 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   10510 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   10511 
   10512 		}
   10513 		catch (RecognitionException re) {
   10514 			reportError(re);
   10515 			recover(input,re);
   10516 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   10517 		}
   10518 		finally {
   10519 			// do for sure before leaving
   10520 		}
   10521 		return retval;
   10522 	}
   10523 	// $ANTLR end "insn_format10x_odex"
   10524 
   10525 
   10526 	public static class insn_format11n_return extends ParserRuleReturnScope {
   10527 		CommonTree tree;
   10528 		@Override
   10529 		public CommonTree getTree() { return tree; }
   10530 	};
   10531 
   10532 
   10533 	// $ANTLR start "insn_format11n"
   10534 	// smaliParser.g:867:1: insn_format11n : INSTRUCTION_FORMAT11n REGISTER COMMA integral_literal -> ^( I_STATEMENT_FORMAT11n[$start, \"I_STATEMENT_FORMAT11n\"] INSTRUCTION_FORMAT11n REGISTER integral_literal ) ;
   10535 	public final smaliParser.insn_format11n_return insn_format11n() throws RecognitionException {
   10536 		smaliParser.insn_format11n_return retval = new smaliParser.insn_format11n_return();
   10537 		retval.start = input.LT(1);
   10538 
   10539 		CommonTree root_0 = null;
   10540 
   10541 		Token INSTRUCTION_FORMAT11n291=null;
   10542 		Token REGISTER292=null;
   10543 		Token COMMA293=null;
   10544 		ParserRuleReturnScope integral_literal294 =null;
   10545 
   10546 		CommonTree INSTRUCTION_FORMAT11n291_tree=null;
   10547 		CommonTree REGISTER292_tree=null;
   10548 		CommonTree COMMA293_tree=null;
   10549 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   10550 		RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER");
   10551 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT11n=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT11n");
   10552 		RewriteRuleSubtreeStream stream_integral_literal=new RewriteRuleSubtreeStream(adaptor,"rule integral_literal");
   10553 
   10554 		try {
   10555 			// smaliParser.g:868:3: ( INSTRUCTION_FORMAT11n REGISTER COMMA integral_literal -> ^( I_STATEMENT_FORMAT11n[$start, \"I_STATEMENT_FORMAT11n\"] INSTRUCTION_FORMAT11n REGISTER integral_literal ) )
   10556 			// smaliParser.g:869:5: INSTRUCTION_FORMAT11n REGISTER COMMA integral_literal
   10557 			{
   10558 			INSTRUCTION_FORMAT11n291=(Token)match(input,INSTRUCTION_FORMAT11n,FOLLOW_INSTRUCTION_FORMAT11n_in_insn_format11n4111);
   10559 			stream_INSTRUCTION_FORMAT11n.add(INSTRUCTION_FORMAT11n291);
   10560 
   10561 			REGISTER292=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format11n4113);
   10562 			stream_REGISTER.add(REGISTER292);
   10563 
   10564 			COMMA293=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format11n4115);
   10565 			stream_COMMA.add(COMMA293);
   10566 
   10567 			pushFollow(FOLLOW_integral_literal_in_insn_format11n4117);
   10568 			integral_literal294=integral_literal();
   10569 			state._fsp--;
   10570 
   10571 			stream_integral_literal.add(integral_literal294.getTree());
   10572 			// AST REWRITE
   10573 			// elements: integral_literal, INSTRUCTION_FORMAT11n, REGISTER
   10574 			// token labels:
   10575 			// rule labels: retval
   10576 			// token list labels:
   10577 			// rule list labels:
   10578 			// wildcard labels:
   10579 			retval.tree = root_0;
   10580 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   10581 
   10582 			root_0 = (CommonTree)adaptor.nil();
   10583 			// 870:5: -> ^( I_STATEMENT_FORMAT11n[$start, \"I_STATEMENT_FORMAT11n\"] INSTRUCTION_FORMAT11n REGISTER integral_literal )
   10584 			{
   10585 				// smaliParser.g:870:8: ^( I_STATEMENT_FORMAT11n[$start, \"I_STATEMENT_FORMAT11n\"] INSTRUCTION_FORMAT11n REGISTER integral_literal )
   10586 				{
   10587 				CommonTree root_1 = (CommonTree)adaptor.nil();
   10588 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT11n, (retval.start), "I_STATEMENT_FORMAT11n"), root_1);
   10589 				adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT11n.nextNode());
   10590 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   10591 				adaptor.addChild(root_1, stream_integral_literal.nextTree());
   10592 				adaptor.addChild(root_0, root_1);
   10593 				}
   10594 
   10595 			}
   10596 
   10597 
   10598 			retval.tree = root_0;
   10599 
   10600 			}
   10601 
   10602 			retval.stop = input.LT(-1);
   10603 
   10604 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   10605 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   10606 
   10607 		}
   10608 		catch (RecognitionException re) {
   10609 			reportError(re);
   10610 			recover(input,re);
   10611 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   10612 		}
   10613 		finally {
   10614 			// do for sure before leaving
   10615 		}
   10616 		return retval;
   10617 	}
   10618 	// $ANTLR end "insn_format11n"
   10619 
   10620 
   10621 	public static class insn_format11x_return extends ParserRuleReturnScope {
   10622 		CommonTree tree;
   10623 		@Override
   10624 		public CommonTree getTree() { return tree; }
   10625 	};
   10626 
   10627 
   10628 	// $ANTLR start "insn_format11x"
   10629 	// smaliParser.g:872:1: insn_format11x : INSTRUCTION_FORMAT11x REGISTER -> ^( I_STATEMENT_FORMAT11x[$start, \"I_STATEMENT_FORMAT11x\"] INSTRUCTION_FORMAT11x REGISTER ) ;
   10630 	public final smaliParser.insn_format11x_return insn_format11x() throws RecognitionException {
   10631 		smaliParser.insn_format11x_return retval = new smaliParser.insn_format11x_return();
   10632 		retval.start = input.LT(1);
   10633 
   10634 		CommonTree root_0 = null;
   10635 
   10636 		Token INSTRUCTION_FORMAT11x295=null;
   10637 		Token REGISTER296=null;
   10638 
   10639 		CommonTree INSTRUCTION_FORMAT11x295_tree=null;
   10640 		CommonTree REGISTER296_tree=null;
   10641 		RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER");
   10642 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT11x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT11x");
   10643 
   10644 		try {
   10645 			// smaliParser.g:873:3: ( INSTRUCTION_FORMAT11x REGISTER -> ^( I_STATEMENT_FORMAT11x[$start, \"I_STATEMENT_FORMAT11x\"] INSTRUCTION_FORMAT11x REGISTER ) )
   10646 			// smaliParser.g:874:5: INSTRUCTION_FORMAT11x REGISTER
   10647 			{
   10648 			INSTRUCTION_FORMAT11x295=(Token)match(input,INSTRUCTION_FORMAT11x,FOLLOW_INSTRUCTION_FORMAT11x_in_insn_format11x4149);
   10649 			stream_INSTRUCTION_FORMAT11x.add(INSTRUCTION_FORMAT11x295);
   10650 
   10651 			REGISTER296=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format11x4151);
   10652 			stream_REGISTER.add(REGISTER296);
   10653 
   10654 			// AST REWRITE
   10655 			// elements: REGISTER, INSTRUCTION_FORMAT11x
   10656 			// token labels:
   10657 			// rule labels: retval
   10658 			// token list labels:
   10659 			// rule list labels:
   10660 			// wildcard labels:
   10661 			retval.tree = root_0;
   10662 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   10663 
   10664 			root_0 = (CommonTree)adaptor.nil();
   10665 			// 875:5: -> ^( I_STATEMENT_FORMAT11x[$start, \"I_STATEMENT_FORMAT11x\"] INSTRUCTION_FORMAT11x REGISTER )
   10666 			{
   10667 				// smaliParser.g:875:8: ^( I_STATEMENT_FORMAT11x[$start, \"I_STATEMENT_FORMAT11x\"] INSTRUCTION_FORMAT11x REGISTER )
   10668 				{
   10669 				CommonTree root_1 = (CommonTree)adaptor.nil();
   10670 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT11x, (retval.start), "I_STATEMENT_FORMAT11x"), root_1);
   10671 				adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT11x.nextNode());
   10672 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   10673 				adaptor.addChild(root_0, root_1);
   10674 				}
   10675 
   10676 			}
   10677 
   10678 
   10679 			retval.tree = root_0;
   10680 
   10681 			}
   10682 
   10683 			retval.stop = input.LT(-1);
   10684 
   10685 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   10686 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   10687 
   10688 		}
   10689 		catch (RecognitionException re) {
   10690 			reportError(re);
   10691 			recover(input,re);
   10692 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   10693 		}
   10694 		finally {
   10695 			// do for sure before leaving
   10696 		}
   10697 		return retval;
   10698 	}
   10699 	// $ANTLR end "insn_format11x"
   10700 
   10701 
   10702 	public static class insn_format12x_return extends ParserRuleReturnScope {
   10703 		CommonTree tree;
   10704 		@Override
   10705 		public CommonTree getTree() { return tree; }
   10706 	};
   10707 
   10708 
   10709 	// $ANTLR start "insn_format12x"
   10710 	// smaliParser.g:877:1: insn_format12x : instruction_format12x REGISTER COMMA REGISTER -> ^( I_STATEMENT_FORMAT12x[$start, \"I_STATEMENT_FORMAT12x\"] instruction_format12x REGISTER REGISTER ) ;
   10711 	public final smaliParser.insn_format12x_return insn_format12x() throws RecognitionException {
   10712 		smaliParser.insn_format12x_return retval = new smaliParser.insn_format12x_return();
   10713 		retval.start = input.LT(1);
   10714 
   10715 		CommonTree root_0 = null;
   10716 
   10717 		Token REGISTER298=null;
   10718 		Token COMMA299=null;
   10719 		Token REGISTER300=null;
   10720 		ParserRuleReturnScope instruction_format12x297 =null;
   10721 
   10722 		CommonTree REGISTER298_tree=null;
   10723 		CommonTree COMMA299_tree=null;
   10724 		CommonTree REGISTER300_tree=null;
   10725 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   10726 		RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER");
   10727 		RewriteRuleSubtreeStream stream_instruction_format12x=new RewriteRuleSubtreeStream(adaptor,"rule instruction_format12x");
   10728 
   10729 		try {
   10730 			// smaliParser.g:878:3: ( instruction_format12x REGISTER COMMA REGISTER -> ^( I_STATEMENT_FORMAT12x[$start, \"I_STATEMENT_FORMAT12x\"] instruction_format12x REGISTER REGISTER ) )
   10731 			// smaliParser.g:879:5: instruction_format12x REGISTER COMMA REGISTER
   10732 			{
   10733 			pushFollow(FOLLOW_instruction_format12x_in_insn_format12x4181);
   10734 			instruction_format12x297=instruction_format12x();
   10735 			state._fsp--;
   10736 
   10737 			stream_instruction_format12x.add(instruction_format12x297.getTree());
   10738 			REGISTER298=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format12x4183);
   10739 			stream_REGISTER.add(REGISTER298);
   10740 
   10741 			COMMA299=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format12x4185);
   10742 			stream_COMMA.add(COMMA299);
   10743 
   10744 			REGISTER300=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format12x4187);
   10745 			stream_REGISTER.add(REGISTER300);
   10746 
   10747 			// AST REWRITE
   10748 			// elements: REGISTER, instruction_format12x, REGISTER
   10749 			// token labels:
   10750 			// rule labels: retval
   10751 			// token list labels:
   10752 			// rule list labels:
   10753 			// wildcard labels:
   10754 			retval.tree = root_0;
   10755 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   10756 
   10757 			root_0 = (CommonTree)adaptor.nil();
   10758 			// 880:5: -> ^( I_STATEMENT_FORMAT12x[$start, \"I_STATEMENT_FORMAT12x\"] instruction_format12x REGISTER REGISTER )
   10759 			{
   10760 				// smaliParser.g:880:8: ^( I_STATEMENT_FORMAT12x[$start, \"I_STATEMENT_FORMAT12x\"] instruction_format12x REGISTER REGISTER )
   10761 				{
   10762 				CommonTree root_1 = (CommonTree)adaptor.nil();
   10763 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT12x, (retval.start), "I_STATEMENT_FORMAT12x"), root_1);
   10764 				adaptor.addChild(root_1, stream_instruction_format12x.nextTree());
   10765 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   10766 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   10767 				adaptor.addChild(root_0, root_1);
   10768 				}
   10769 
   10770 			}
   10771 
   10772 
   10773 			retval.tree = root_0;
   10774 
   10775 			}
   10776 
   10777 			retval.stop = input.LT(-1);
   10778 
   10779 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   10780 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   10781 
   10782 		}
   10783 		catch (RecognitionException re) {
   10784 			reportError(re);
   10785 			recover(input,re);
   10786 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   10787 		}
   10788 		finally {
   10789 			// do for sure before leaving
   10790 		}
   10791 		return retval;
   10792 	}
   10793 	// $ANTLR end "insn_format12x"
   10794 
   10795 
   10796 	public static class insn_format20bc_return extends ParserRuleReturnScope {
   10797 		CommonTree tree;
   10798 		@Override
   10799 		public CommonTree getTree() { return tree; }
   10800 	};
   10801 
   10802 
   10803 	// $ANTLR start "insn_format20bc"
   10804 	// smaliParser.g:882:1: insn_format20bc : INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE COMMA verification_error_reference -> ^( I_STATEMENT_FORMAT20bc INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE verification_error_reference ) ;
   10805 	public final smaliParser.insn_format20bc_return insn_format20bc() throws RecognitionException {
   10806 		smaliParser.insn_format20bc_return retval = new smaliParser.insn_format20bc_return();
   10807 		retval.start = input.LT(1);
   10808 
   10809 		CommonTree root_0 = null;
   10810 
   10811 		Token INSTRUCTION_FORMAT20bc301=null;
   10812 		Token VERIFICATION_ERROR_TYPE302=null;
   10813 		Token COMMA303=null;
   10814 		ParserRuleReturnScope verification_error_reference304 =null;
   10815 
   10816 		CommonTree INSTRUCTION_FORMAT20bc301_tree=null;
   10817 		CommonTree VERIFICATION_ERROR_TYPE302_tree=null;
   10818 		CommonTree COMMA303_tree=null;
   10819 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   10820 		RewriteRuleTokenStream stream_VERIFICATION_ERROR_TYPE=new RewriteRuleTokenStream(adaptor,"token VERIFICATION_ERROR_TYPE");
   10821 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT20bc=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT20bc");
   10822 		RewriteRuleSubtreeStream stream_verification_error_reference=new RewriteRuleSubtreeStream(adaptor,"rule verification_error_reference");
   10823 
   10824 		try {
   10825 			// smaliParser.g:883:3: ( INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE COMMA verification_error_reference -> ^( I_STATEMENT_FORMAT20bc INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE verification_error_reference ) )
   10826 			// smaliParser.g:884:5: INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE COMMA verification_error_reference
   10827 			{
   10828 			INSTRUCTION_FORMAT20bc301=(Token)match(input,INSTRUCTION_FORMAT20bc,FOLLOW_INSTRUCTION_FORMAT20bc_in_insn_format20bc4219);
   10829 			stream_INSTRUCTION_FORMAT20bc.add(INSTRUCTION_FORMAT20bc301);
   10830 
   10831 			VERIFICATION_ERROR_TYPE302=(Token)match(input,VERIFICATION_ERROR_TYPE,FOLLOW_VERIFICATION_ERROR_TYPE_in_insn_format20bc4221);
   10832 			stream_VERIFICATION_ERROR_TYPE.add(VERIFICATION_ERROR_TYPE302);
   10833 
   10834 			COMMA303=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format20bc4223);
   10835 			stream_COMMA.add(COMMA303);
   10836 
   10837 			pushFollow(FOLLOW_verification_error_reference_in_insn_format20bc4225);
   10838 			verification_error_reference304=verification_error_reference();
   10839 			state._fsp--;
   10840 
   10841 			stream_verification_error_reference.add(verification_error_reference304.getTree());
   10842 
   10843 			      if (!allowOdex || opcodes.getOpcodeByName((INSTRUCTION_FORMAT20bc301!=null?INSTRUCTION_FORMAT20bc301.getText():null)) == null || apiLevel >= 14) {
   10844 			        throwOdexedInstructionException(input, (INSTRUCTION_FORMAT20bc301!=null?INSTRUCTION_FORMAT20bc301.getText():null));
   10845 			      }
   10846 
   10847 			// AST REWRITE
   10848 			// elements: VERIFICATION_ERROR_TYPE, verification_error_reference, INSTRUCTION_FORMAT20bc
   10849 			// token labels:
   10850 			// rule labels: retval
   10851 			// token list labels:
   10852 			// rule list labels:
   10853 			// wildcard labels:
   10854 			retval.tree = root_0;
   10855 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   10856 
   10857 			root_0 = (CommonTree)adaptor.nil();
   10858 			// 890:5: -> ^( I_STATEMENT_FORMAT20bc INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE verification_error_reference )
   10859 			{
   10860 				// smaliParser.g:890:8: ^( I_STATEMENT_FORMAT20bc INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE verification_error_reference )
   10861 				{
   10862 				CommonTree root_1 = (CommonTree)adaptor.nil();
   10863 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT20bc, "I_STATEMENT_FORMAT20bc"), root_1);
   10864 				adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT20bc.nextNode());
   10865 				adaptor.addChild(root_1, stream_VERIFICATION_ERROR_TYPE.nextNode());
   10866 				adaptor.addChild(root_1, stream_verification_error_reference.nextTree());
   10867 				adaptor.addChild(root_0, root_1);
   10868 				}
   10869 
   10870 			}
   10871 
   10872 
   10873 			retval.tree = root_0;
   10874 
   10875 			}
   10876 
   10877 			retval.stop = input.LT(-1);
   10878 
   10879 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   10880 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   10881 
   10882 		}
   10883 		catch (RecognitionException re) {
   10884 			reportError(re);
   10885 			recover(input,re);
   10886 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   10887 		}
   10888 		finally {
   10889 			// do for sure before leaving
   10890 		}
   10891 		return retval;
   10892 	}
   10893 	// $ANTLR end "insn_format20bc"
   10894 
   10895 
   10896 	public static class insn_format20t_return extends ParserRuleReturnScope {
   10897 		CommonTree tree;
   10898 		@Override
   10899 		public CommonTree getTree() { return tree; }
   10900 	};
   10901 
   10902 
   10903 	// $ANTLR start "insn_format20t"
   10904 	// smaliParser.g:892:1: insn_format20t : INSTRUCTION_FORMAT20t label_ref -> ^( I_STATEMENT_FORMAT20t[$start, \"I_STATEMENT_FORMAT20t\"] INSTRUCTION_FORMAT20t label_ref ) ;
   10905 	public final smaliParser.insn_format20t_return insn_format20t() throws RecognitionException {
   10906 		smaliParser.insn_format20t_return retval = new smaliParser.insn_format20t_return();
   10907 		retval.start = input.LT(1);
   10908 
   10909 		CommonTree root_0 = null;
   10910 
   10911 		Token INSTRUCTION_FORMAT20t305=null;
   10912 		ParserRuleReturnScope label_ref306 =null;
   10913 
   10914 		CommonTree INSTRUCTION_FORMAT20t305_tree=null;
   10915 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT20t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT20t");
   10916 		RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref");
   10917 
   10918 		try {
   10919 			// smaliParser.g:893:3: ( INSTRUCTION_FORMAT20t label_ref -> ^( I_STATEMENT_FORMAT20t[$start, \"I_STATEMENT_FORMAT20t\"] INSTRUCTION_FORMAT20t label_ref ) )
   10920 			// smaliParser.g:894:5: INSTRUCTION_FORMAT20t label_ref
   10921 			{
   10922 			INSTRUCTION_FORMAT20t305=(Token)match(input,INSTRUCTION_FORMAT20t,FOLLOW_INSTRUCTION_FORMAT20t_in_insn_format20t4262);
   10923 			stream_INSTRUCTION_FORMAT20t.add(INSTRUCTION_FORMAT20t305);
   10924 
   10925 			pushFollow(FOLLOW_label_ref_in_insn_format20t4264);
   10926 			label_ref306=label_ref();
   10927 			state._fsp--;
   10928 
   10929 			stream_label_ref.add(label_ref306.getTree());
   10930 			// AST REWRITE
   10931 			// elements: INSTRUCTION_FORMAT20t, label_ref
   10932 			// token labels:
   10933 			// rule labels: retval
   10934 			// token list labels:
   10935 			// rule list labels:
   10936 			// wildcard labels:
   10937 			retval.tree = root_0;
   10938 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   10939 
   10940 			root_0 = (CommonTree)adaptor.nil();
   10941 			// 895:5: -> ^( I_STATEMENT_FORMAT20t[$start, \"I_STATEMENT_FORMAT20t\"] INSTRUCTION_FORMAT20t label_ref )
   10942 			{
   10943 				// smaliParser.g:895:8: ^( I_STATEMENT_FORMAT20t[$start, \"I_STATEMENT_FORMAT20t\"] INSTRUCTION_FORMAT20t label_ref )
   10944 				{
   10945 				CommonTree root_1 = (CommonTree)adaptor.nil();
   10946 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT20t, (retval.start), "I_STATEMENT_FORMAT20t"), root_1);
   10947 				adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT20t.nextNode());
   10948 				adaptor.addChild(root_1, stream_label_ref.nextTree());
   10949 				adaptor.addChild(root_0, root_1);
   10950 				}
   10951 
   10952 			}
   10953 
   10954 
   10955 			retval.tree = root_0;
   10956 
   10957 			}
   10958 
   10959 			retval.stop = input.LT(-1);
   10960 
   10961 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   10962 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   10963 
   10964 		}
   10965 		catch (RecognitionException re) {
   10966 			reportError(re);
   10967 			recover(input,re);
   10968 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   10969 		}
   10970 		finally {
   10971 			// do for sure before leaving
   10972 		}
   10973 		return retval;
   10974 	}
   10975 	// $ANTLR end "insn_format20t"
   10976 
   10977 
   10978 	public static class insn_format21c_field_return extends ParserRuleReturnScope {
   10979 		CommonTree tree;
   10980 		@Override
   10981 		public CommonTree getTree() { return tree; }
   10982 	};
   10983 
   10984 
   10985 	// $ANTLR start "insn_format21c_field"
   10986 	// smaliParser.g:897:1: insn_format21c_field : INSTRUCTION_FORMAT21c_FIELD REGISTER COMMA field_reference -> ^( I_STATEMENT_FORMAT21c_FIELD[$start, \"I_STATEMENT_FORMAT21c_FIELD\"] INSTRUCTION_FORMAT21c_FIELD REGISTER field_reference ) ;
   10987 	public final smaliParser.insn_format21c_field_return insn_format21c_field() throws RecognitionException {
   10988 		smaliParser.insn_format21c_field_return retval = new smaliParser.insn_format21c_field_return();
   10989 		retval.start = input.LT(1);
   10990 
   10991 		CommonTree root_0 = null;
   10992 
   10993 		Token INSTRUCTION_FORMAT21c_FIELD307=null;
   10994 		Token REGISTER308=null;
   10995 		Token COMMA309=null;
   10996 		ParserRuleReturnScope field_reference310 =null;
   10997 
   10998 		CommonTree INSTRUCTION_FORMAT21c_FIELD307_tree=null;
   10999 		CommonTree REGISTER308_tree=null;
   11000 		CommonTree COMMA309_tree=null;
   11001 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   11002 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_FIELD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_FIELD");
   11003 		RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER");
   11004 		RewriteRuleSubtreeStream stream_field_reference=new RewriteRuleSubtreeStream(adaptor,"rule field_reference");
   11005 
   11006 		try {
   11007 			// smaliParser.g:898:3: ( INSTRUCTION_FORMAT21c_FIELD REGISTER COMMA field_reference -> ^( I_STATEMENT_FORMAT21c_FIELD[$start, \"I_STATEMENT_FORMAT21c_FIELD\"] INSTRUCTION_FORMAT21c_FIELD REGISTER field_reference ) )
   11008 			// smaliParser.g:899:5: INSTRUCTION_FORMAT21c_FIELD REGISTER COMMA field_reference
   11009 			{
   11010 			INSTRUCTION_FORMAT21c_FIELD307=(Token)match(input,INSTRUCTION_FORMAT21c_FIELD,FOLLOW_INSTRUCTION_FORMAT21c_FIELD_in_insn_format21c_field4294);
   11011 			stream_INSTRUCTION_FORMAT21c_FIELD.add(INSTRUCTION_FORMAT21c_FIELD307);
   11012 
   11013 			REGISTER308=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21c_field4296);
   11014 			stream_REGISTER.add(REGISTER308);
   11015 
   11016 			COMMA309=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21c_field4298);
   11017 			stream_COMMA.add(COMMA309);
   11018 
   11019 			pushFollow(FOLLOW_field_reference_in_insn_format21c_field4300);
   11020 			field_reference310=field_reference();
   11021 			state._fsp--;
   11022 
   11023 			stream_field_reference.add(field_reference310.getTree());
   11024 			// AST REWRITE
   11025 			// elements: REGISTER, INSTRUCTION_FORMAT21c_FIELD, field_reference
   11026 			// token labels:
   11027 			// rule labels: retval
   11028 			// token list labels:
   11029 			// rule list labels:
   11030 			// wildcard labels:
   11031 			retval.tree = root_0;
   11032 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   11033 
   11034 			root_0 = (CommonTree)adaptor.nil();
   11035 			// 900:5: -> ^( I_STATEMENT_FORMAT21c_FIELD[$start, \"I_STATEMENT_FORMAT21c_FIELD\"] INSTRUCTION_FORMAT21c_FIELD REGISTER field_reference )
   11036 			{
   11037 				// smaliParser.g:900:8: ^( I_STATEMENT_FORMAT21c_FIELD[$start, \"I_STATEMENT_FORMAT21c_FIELD\"] INSTRUCTION_FORMAT21c_FIELD REGISTER field_reference )
   11038 				{
   11039 				CommonTree root_1 = (CommonTree)adaptor.nil();
   11040 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21c_FIELD, (retval.start), "I_STATEMENT_FORMAT21c_FIELD"), root_1);
   11041 				adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21c_FIELD.nextNode());
   11042 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   11043 				adaptor.addChild(root_1, stream_field_reference.nextTree());
   11044 				adaptor.addChild(root_0, root_1);
   11045 				}
   11046 
   11047 			}
   11048 
   11049 
   11050 			retval.tree = root_0;
   11051 
   11052 			}
   11053 
   11054 			retval.stop = input.LT(-1);
   11055 
   11056 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   11057 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   11058 
   11059 		}
   11060 		catch (RecognitionException re) {
   11061 			reportError(re);
   11062 			recover(input,re);
   11063 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   11064 		}
   11065 		finally {
   11066 			// do for sure before leaving
   11067 		}
   11068 		return retval;
   11069 	}
   11070 	// $ANTLR end "insn_format21c_field"
   11071 
   11072 
   11073 	public static class insn_format21c_field_odex_return extends ParserRuleReturnScope {
   11074 		CommonTree tree;
   11075 		@Override
   11076 		public CommonTree getTree() { return tree; }
   11077 	};
   11078 
   11079 
   11080 	// $ANTLR start "insn_format21c_field_odex"
   11081 	// smaliParser.g:902:1: insn_format21c_field_odex : INSTRUCTION_FORMAT21c_FIELD_ODEX REGISTER COMMA field_reference -> ^( I_STATEMENT_FORMAT21c_FIELD[$start, \"I_STATEMENT_FORMAT21c_FIELD\"] INSTRUCTION_FORMAT21c_FIELD_ODEX REGISTER field_reference ) ;
   11082 	public final smaliParser.insn_format21c_field_odex_return insn_format21c_field_odex() throws RecognitionException {
   11083 		smaliParser.insn_format21c_field_odex_return retval = new smaliParser.insn_format21c_field_odex_return();
   11084 		retval.start = input.LT(1);
   11085 
   11086 		CommonTree root_0 = null;
   11087 
   11088 		Token INSTRUCTION_FORMAT21c_FIELD_ODEX311=null;
   11089 		Token REGISTER312=null;
   11090 		Token COMMA313=null;
   11091 		ParserRuleReturnScope field_reference314 =null;
   11092 
   11093 		CommonTree INSTRUCTION_FORMAT21c_FIELD_ODEX311_tree=null;
   11094 		CommonTree REGISTER312_tree=null;
   11095 		CommonTree COMMA313_tree=null;
   11096 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   11097 		RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER");
   11098 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_FIELD_ODEX=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_FIELD_ODEX");
   11099 		RewriteRuleSubtreeStream stream_field_reference=new RewriteRuleSubtreeStream(adaptor,"rule field_reference");
   11100 
   11101 		try {
   11102 			// smaliParser.g:903:3: ( INSTRUCTION_FORMAT21c_FIELD_ODEX REGISTER COMMA field_reference -> ^( I_STATEMENT_FORMAT21c_FIELD[$start, \"I_STATEMENT_FORMAT21c_FIELD\"] INSTRUCTION_FORMAT21c_FIELD_ODEX REGISTER field_reference ) )
   11103 			// smaliParser.g:904:5: INSTRUCTION_FORMAT21c_FIELD_ODEX REGISTER COMMA field_reference
   11104 			{
   11105 			INSTRUCTION_FORMAT21c_FIELD_ODEX311=(Token)match(input,INSTRUCTION_FORMAT21c_FIELD_ODEX,FOLLOW_INSTRUCTION_FORMAT21c_FIELD_ODEX_in_insn_format21c_field_odex4332);
   11106 			stream_INSTRUCTION_FORMAT21c_FIELD_ODEX.add(INSTRUCTION_FORMAT21c_FIELD_ODEX311);
   11107 
   11108 			REGISTER312=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21c_field_odex4334);
   11109 			stream_REGISTER.add(REGISTER312);
   11110 
   11111 			COMMA313=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21c_field_odex4336);
   11112 			stream_COMMA.add(COMMA313);
   11113 
   11114 			pushFollow(FOLLOW_field_reference_in_insn_format21c_field_odex4338);
   11115 			field_reference314=field_reference();
   11116 			state._fsp--;
   11117 
   11118 			stream_field_reference.add(field_reference314.getTree());
   11119 
   11120 			      if (!allowOdex || opcodes.getOpcodeByName((INSTRUCTION_FORMAT21c_FIELD_ODEX311!=null?INSTRUCTION_FORMAT21c_FIELD_ODEX311.getText():null)) == null || apiLevel >= 14) {
   11121 			        throwOdexedInstructionException(input, (INSTRUCTION_FORMAT21c_FIELD_ODEX311!=null?INSTRUCTION_FORMAT21c_FIELD_ODEX311.getText():null));
   11122 			      }
   11123 
   11124 			// AST REWRITE
   11125 			// elements: INSTRUCTION_FORMAT21c_FIELD_ODEX, REGISTER, field_reference
   11126 			// token labels:
   11127 			// rule labels: retval
   11128 			// token list labels:
   11129 			// rule list labels:
   11130 			// wildcard labels:
   11131 			retval.tree = root_0;
   11132 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   11133 
   11134 			root_0 = (CommonTree)adaptor.nil();
   11135 			// 910:5: -> ^( I_STATEMENT_FORMAT21c_FIELD[$start, \"I_STATEMENT_FORMAT21c_FIELD\"] INSTRUCTION_FORMAT21c_FIELD_ODEX REGISTER field_reference )
   11136 			{
   11137 				// smaliParser.g:910:8: ^( I_STATEMENT_FORMAT21c_FIELD[$start, \"I_STATEMENT_FORMAT21c_FIELD\"] INSTRUCTION_FORMAT21c_FIELD_ODEX REGISTER field_reference )
   11138 				{
   11139 				CommonTree root_1 = (CommonTree)adaptor.nil();
   11140 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21c_FIELD, (retval.start), "I_STATEMENT_FORMAT21c_FIELD"), root_1);
   11141 				adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21c_FIELD_ODEX.nextNode());
   11142 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   11143 				adaptor.addChild(root_1, stream_field_reference.nextTree());
   11144 				adaptor.addChild(root_0, root_1);
   11145 				}
   11146 
   11147 			}
   11148 
   11149 
   11150 			retval.tree = root_0;
   11151 
   11152 			}
   11153 
   11154 			retval.stop = input.LT(-1);
   11155 
   11156 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   11157 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   11158 
   11159 		}
   11160 		catch (RecognitionException re) {
   11161 			reportError(re);
   11162 			recover(input,re);
   11163 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   11164 		}
   11165 		finally {
   11166 			// do for sure before leaving
   11167 		}
   11168 		return retval;
   11169 	}
   11170 	// $ANTLR end "insn_format21c_field_odex"
   11171 
   11172 
   11173 	public static class insn_format21c_string_return extends ParserRuleReturnScope {
   11174 		CommonTree tree;
   11175 		@Override
   11176 		public CommonTree getTree() { return tree; }
   11177 	};
   11178 
   11179 
   11180 	// $ANTLR start "insn_format21c_string"
   11181 	// smaliParser.g:912:1: insn_format21c_string : INSTRUCTION_FORMAT21c_STRING REGISTER COMMA STRING_LITERAL -> ^( I_STATEMENT_FORMAT21c_STRING[$start, \"I_STATEMENT_FORMAT21c_STRING\"] INSTRUCTION_FORMAT21c_STRING REGISTER STRING_LITERAL ) ;
   11182 	public final smaliParser.insn_format21c_string_return insn_format21c_string() throws RecognitionException {
   11183 		smaliParser.insn_format21c_string_return retval = new smaliParser.insn_format21c_string_return();
   11184 		retval.start = input.LT(1);
   11185 
   11186 		CommonTree root_0 = null;
   11187 
   11188 		Token INSTRUCTION_FORMAT21c_STRING315=null;
   11189 		Token REGISTER316=null;
   11190 		Token COMMA317=null;
   11191 		Token STRING_LITERAL318=null;
   11192 
   11193 		CommonTree INSTRUCTION_FORMAT21c_STRING315_tree=null;
   11194 		CommonTree REGISTER316_tree=null;
   11195 		CommonTree COMMA317_tree=null;
   11196 		CommonTree STRING_LITERAL318_tree=null;
   11197 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   11198 		RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER");
   11199 		RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL");
   11200 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_STRING=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_STRING");
   11201 
   11202 		try {
   11203 			// smaliParser.g:913:3: ( INSTRUCTION_FORMAT21c_STRING REGISTER COMMA STRING_LITERAL -> ^( I_STATEMENT_FORMAT21c_STRING[$start, \"I_STATEMENT_FORMAT21c_STRING\"] INSTRUCTION_FORMAT21c_STRING REGISTER STRING_LITERAL ) )
   11204 			// smaliParser.g:914:5: INSTRUCTION_FORMAT21c_STRING REGISTER COMMA STRING_LITERAL
   11205 			{
   11206 			INSTRUCTION_FORMAT21c_STRING315=(Token)match(input,INSTRUCTION_FORMAT21c_STRING,FOLLOW_INSTRUCTION_FORMAT21c_STRING_in_insn_format21c_string4376);
   11207 			stream_INSTRUCTION_FORMAT21c_STRING.add(INSTRUCTION_FORMAT21c_STRING315);
   11208 
   11209 			REGISTER316=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21c_string4378);
   11210 			stream_REGISTER.add(REGISTER316);
   11211 
   11212 			COMMA317=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21c_string4380);
   11213 			stream_COMMA.add(COMMA317);
   11214 
   11215 			STRING_LITERAL318=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_insn_format21c_string4382);
   11216 			stream_STRING_LITERAL.add(STRING_LITERAL318);
   11217 
   11218 			// AST REWRITE
   11219 			// elements: STRING_LITERAL, REGISTER, INSTRUCTION_FORMAT21c_STRING
   11220 			// token labels:
   11221 			// rule labels: retval
   11222 			// token list labels:
   11223 			// rule list labels:
   11224 			// wildcard labels:
   11225 			retval.tree = root_0;
   11226 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   11227 
   11228 			root_0 = (CommonTree)adaptor.nil();
   11229 			// 915:5: -> ^( I_STATEMENT_FORMAT21c_STRING[$start, \"I_STATEMENT_FORMAT21c_STRING\"] INSTRUCTION_FORMAT21c_STRING REGISTER STRING_LITERAL )
   11230 			{
   11231 				// smaliParser.g:915:8: ^( I_STATEMENT_FORMAT21c_STRING[$start, \"I_STATEMENT_FORMAT21c_STRING\"] INSTRUCTION_FORMAT21c_STRING REGISTER STRING_LITERAL )
   11232 				{
   11233 				CommonTree root_1 = (CommonTree)adaptor.nil();
   11234 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21c_STRING, (retval.start), "I_STATEMENT_FORMAT21c_STRING"), root_1);
   11235 				adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21c_STRING.nextNode());
   11236 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   11237 				adaptor.addChild(root_1, stream_STRING_LITERAL.nextNode());
   11238 				adaptor.addChild(root_0, root_1);
   11239 				}
   11240 
   11241 			}
   11242 
   11243 
   11244 			retval.tree = root_0;
   11245 
   11246 			}
   11247 
   11248 			retval.stop = input.LT(-1);
   11249 
   11250 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   11251 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   11252 
   11253 		}
   11254 		catch (RecognitionException re) {
   11255 			reportError(re);
   11256 			recover(input,re);
   11257 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   11258 		}
   11259 		finally {
   11260 			// do for sure before leaving
   11261 		}
   11262 		return retval;
   11263 	}
   11264 	// $ANTLR end "insn_format21c_string"
   11265 
   11266 
   11267 	public static class insn_format21c_type_return extends ParserRuleReturnScope {
   11268 		CommonTree tree;
   11269 		@Override
   11270 		public CommonTree getTree() { return tree; }
   11271 	};
   11272 
   11273 
   11274 	// $ANTLR start "insn_format21c_type"
   11275 	// smaliParser.g:917:1: insn_format21c_type : INSTRUCTION_FORMAT21c_TYPE REGISTER COMMA nonvoid_type_descriptor -> ^( I_STATEMENT_FORMAT21c_TYPE[$start, \"I_STATEMENT_FORMAT21c\"] INSTRUCTION_FORMAT21c_TYPE REGISTER nonvoid_type_descriptor ) ;
   11276 	public final smaliParser.insn_format21c_type_return insn_format21c_type() throws RecognitionException {
   11277 		smaliParser.insn_format21c_type_return retval = new smaliParser.insn_format21c_type_return();
   11278 		retval.start = input.LT(1);
   11279 
   11280 		CommonTree root_0 = null;
   11281 
   11282 		Token INSTRUCTION_FORMAT21c_TYPE319=null;
   11283 		Token REGISTER320=null;
   11284 		Token COMMA321=null;
   11285 		ParserRuleReturnScope nonvoid_type_descriptor322 =null;
   11286 
   11287 		CommonTree INSTRUCTION_FORMAT21c_TYPE319_tree=null;
   11288 		CommonTree REGISTER320_tree=null;
   11289 		CommonTree COMMA321_tree=null;
   11290 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   11291 		RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER");
   11292 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_TYPE=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_TYPE");
   11293 		RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor");
   11294 
   11295 		try {
   11296 			// smaliParser.g:918:3: ( INSTRUCTION_FORMAT21c_TYPE REGISTER COMMA nonvoid_type_descriptor -> ^( I_STATEMENT_FORMAT21c_TYPE[$start, \"I_STATEMENT_FORMAT21c\"] INSTRUCTION_FORMAT21c_TYPE REGISTER nonvoid_type_descriptor ) )
   11297 			// smaliParser.g:919:5: INSTRUCTION_FORMAT21c_TYPE REGISTER COMMA nonvoid_type_descriptor
   11298 			{
   11299 			INSTRUCTION_FORMAT21c_TYPE319=(Token)match(input,INSTRUCTION_FORMAT21c_TYPE,FOLLOW_INSTRUCTION_FORMAT21c_TYPE_in_insn_format21c_type4414);
   11300 			stream_INSTRUCTION_FORMAT21c_TYPE.add(INSTRUCTION_FORMAT21c_TYPE319);
   11301 
   11302 			REGISTER320=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21c_type4416);
   11303 			stream_REGISTER.add(REGISTER320);
   11304 
   11305 			COMMA321=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21c_type4418);
   11306 			stream_COMMA.add(COMMA321);
   11307 
   11308 			pushFollow(FOLLOW_nonvoid_type_descriptor_in_insn_format21c_type4420);
   11309 			nonvoid_type_descriptor322=nonvoid_type_descriptor();
   11310 			state._fsp--;
   11311 
   11312 			stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor322.getTree());
   11313 			// AST REWRITE
   11314 			// elements: REGISTER, INSTRUCTION_FORMAT21c_TYPE, nonvoid_type_descriptor
   11315 			// token labels:
   11316 			// rule labels: retval
   11317 			// token list labels:
   11318 			// rule list labels:
   11319 			// wildcard labels:
   11320 			retval.tree = root_0;
   11321 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   11322 
   11323 			root_0 = (CommonTree)adaptor.nil();
   11324 			// 920:5: -> ^( I_STATEMENT_FORMAT21c_TYPE[$start, \"I_STATEMENT_FORMAT21c\"] INSTRUCTION_FORMAT21c_TYPE REGISTER nonvoid_type_descriptor )
   11325 			{
   11326 				// smaliParser.g:920:8: ^( I_STATEMENT_FORMAT21c_TYPE[$start, \"I_STATEMENT_FORMAT21c\"] INSTRUCTION_FORMAT21c_TYPE REGISTER nonvoid_type_descriptor )
   11327 				{
   11328 				CommonTree root_1 = (CommonTree)adaptor.nil();
   11329 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21c_TYPE, (retval.start), "I_STATEMENT_FORMAT21c"), root_1);
   11330 				adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21c_TYPE.nextNode());
   11331 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   11332 				adaptor.addChild(root_1, stream_nonvoid_type_descriptor.nextTree());
   11333 				adaptor.addChild(root_0, root_1);
   11334 				}
   11335 
   11336 			}
   11337 
   11338 
   11339 			retval.tree = root_0;
   11340 
   11341 			}
   11342 
   11343 			retval.stop = input.LT(-1);
   11344 
   11345 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   11346 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   11347 
   11348 		}
   11349 		catch (RecognitionException re) {
   11350 			reportError(re);
   11351 			recover(input,re);
   11352 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   11353 		}
   11354 		finally {
   11355 			// do for sure before leaving
   11356 		}
   11357 		return retval;
   11358 	}
   11359 	// $ANTLR end "insn_format21c_type"
   11360 
   11361 
   11362 	public static class insn_format21ih_return extends ParserRuleReturnScope {
   11363 		CommonTree tree;
   11364 		@Override
   11365 		public CommonTree getTree() { return tree; }
   11366 	};
   11367 
   11368 
   11369 	// $ANTLR start "insn_format21ih"
   11370 	// smaliParser.g:922:1: insn_format21ih : INSTRUCTION_FORMAT21ih REGISTER COMMA fixed_32bit_literal -> ^( I_STATEMENT_FORMAT21ih[$start, \"I_STATEMENT_FORMAT21ih\"] INSTRUCTION_FORMAT21ih REGISTER fixed_32bit_literal ) ;
   11371 	public final smaliParser.insn_format21ih_return insn_format21ih() throws RecognitionException {
   11372 		smaliParser.insn_format21ih_return retval = new smaliParser.insn_format21ih_return();
   11373 		retval.start = input.LT(1);
   11374 
   11375 		CommonTree root_0 = null;
   11376 
   11377 		Token INSTRUCTION_FORMAT21ih323=null;
   11378 		Token REGISTER324=null;
   11379 		Token COMMA325=null;
   11380 		ParserRuleReturnScope fixed_32bit_literal326 =null;
   11381 
   11382 		CommonTree INSTRUCTION_FORMAT21ih323_tree=null;
   11383 		CommonTree REGISTER324_tree=null;
   11384 		CommonTree COMMA325_tree=null;
   11385 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   11386 		RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER");
   11387 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21ih=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21ih");
   11388 		RewriteRuleSubtreeStream stream_fixed_32bit_literal=new RewriteRuleSubtreeStream(adaptor,"rule fixed_32bit_literal");
   11389 
   11390 		try {
   11391 			// smaliParser.g:923:3: ( INSTRUCTION_FORMAT21ih REGISTER COMMA fixed_32bit_literal -> ^( I_STATEMENT_FORMAT21ih[$start, \"I_STATEMENT_FORMAT21ih\"] INSTRUCTION_FORMAT21ih REGISTER fixed_32bit_literal ) )
   11392 			// smaliParser.g:924:5: INSTRUCTION_FORMAT21ih REGISTER COMMA fixed_32bit_literal
   11393 			{
   11394 			INSTRUCTION_FORMAT21ih323=(Token)match(input,INSTRUCTION_FORMAT21ih,FOLLOW_INSTRUCTION_FORMAT21ih_in_insn_format21ih4452);
   11395 			stream_INSTRUCTION_FORMAT21ih.add(INSTRUCTION_FORMAT21ih323);
   11396 
   11397 			REGISTER324=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21ih4454);
   11398 			stream_REGISTER.add(REGISTER324);
   11399 
   11400 			COMMA325=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21ih4456);
   11401 			stream_COMMA.add(COMMA325);
   11402 
   11403 			pushFollow(FOLLOW_fixed_32bit_literal_in_insn_format21ih4458);
   11404 			fixed_32bit_literal326=fixed_32bit_literal();
   11405 			state._fsp--;
   11406 
   11407 			stream_fixed_32bit_literal.add(fixed_32bit_literal326.getTree());
   11408 			// AST REWRITE
   11409 			// elements: REGISTER, INSTRUCTION_FORMAT21ih, fixed_32bit_literal
   11410 			// token labels:
   11411 			// rule labels: retval
   11412 			// token list labels:
   11413 			// rule list labels:
   11414 			// wildcard labels:
   11415 			retval.tree = root_0;
   11416 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   11417 
   11418 			root_0 = (CommonTree)adaptor.nil();
   11419 			// 925:5: -> ^( I_STATEMENT_FORMAT21ih[$start, \"I_STATEMENT_FORMAT21ih\"] INSTRUCTION_FORMAT21ih REGISTER fixed_32bit_literal )
   11420 			{
   11421 				// smaliParser.g:925:8: ^( I_STATEMENT_FORMAT21ih[$start, \"I_STATEMENT_FORMAT21ih\"] INSTRUCTION_FORMAT21ih REGISTER fixed_32bit_literal )
   11422 				{
   11423 				CommonTree root_1 = (CommonTree)adaptor.nil();
   11424 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21ih, (retval.start), "I_STATEMENT_FORMAT21ih"), root_1);
   11425 				adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21ih.nextNode());
   11426 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   11427 				adaptor.addChild(root_1, stream_fixed_32bit_literal.nextTree());
   11428 				adaptor.addChild(root_0, root_1);
   11429 				}
   11430 
   11431 			}
   11432 
   11433 
   11434 			retval.tree = root_0;
   11435 
   11436 			}
   11437 
   11438 			retval.stop = input.LT(-1);
   11439 
   11440 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   11441 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   11442 
   11443 		}
   11444 		catch (RecognitionException re) {
   11445 			reportError(re);
   11446 			recover(input,re);
   11447 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   11448 		}
   11449 		finally {
   11450 			// do for sure before leaving
   11451 		}
   11452 		return retval;
   11453 	}
   11454 	// $ANTLR end "insn_format21ih"
   11455 
   11456 
   11457 	public static class insn_format21lh_return extends ParserRuleReturnScope {
   11458 		CommonTree tree;
   11459 		@Override
   11460 		public CommonTree getTree() { return tree; }
   11461 	};
   11462 
   11463 
   11464 	// $ANTLR start "insn_format21lh"
   11465 	// smaliParser.g:927:1: insn_format21lh : INSTRUCTION_FORMAT21lh REGISTER COMMA fixed_32bit_literal -> ^( I_STATEMENT_FORMAT21lh[$start, \"I_STATEMENT_FORMAT21lh\"] INSTRUCTION_FORMAT21lh REGISTER fixed_32bit_literal ) ;
   11466 	public final smaliParser.insn_format21lh_return insn_format21lh() throws RecognitionException {
   11467 		smaliParser.insn_format21lh_return retval = new smaliParser.insn_format21lh_return();
   11468 		retval.start = input.LT(1);
   11469 
   11470 		CommonTree root_0 = null;
   11471 
   11472 		Token INSTRUCTION_FORMAT21lh327=null;
   11473 		Token REGISTER328=null;
   11474 		Token COMMA329=null;
   11475 		ParserRuleReturnScope fixed_32bit_literal330 =null;
   11476 
   11477 		CommonTree INSTRUCTION_FORMAT21lh327_tree=null;
   11478 		CommonTree REGISTER328_tree=null;
   11479 		CommonTree COMMA329_tree=null;
   11480 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   11481 		RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER");
   11482 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21lh=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21lh");
   11483 		RewriteRuleSubtreeStream stream_fixed_32bit_literal=new RewriteRuleSubtreeStream(adaptor,"rule fixed_32bit_literal");
   11484 
   11485 		try {
   11486 			// smaliParser.g:928:3: ( INSTRUCTION_FORMAT21lh REGISTER COMMA fixed_32bit_literal -> ^( I_STATEMENT_FORMAT21lh[$start, \"I_STATEMENT_FORMAT21lh\"] INSTRUCTION_FORMAT21lh REGISTER fixed_32bit_literal ) )
   11487 			// smaliParser.g:929:5: INSTRUCTION_FORMAT21lh REGISTER COMMA fixed_32bit_literal
   11488 			{
   11489 			INSTRUCTION_FORMAT21lh327=(Token)match(input,INSTRUCTION_FORMAT21lh,FOLLOW_INSTRUCTION_FORMAT21lh_in_insn_format21lh4490);
   11490 			stream_INSTRUCTION_FORMAT21lh.add(INSTRUCTION_FORMAT21lh327);
   11491 
   11492 			REGISTER328=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21lh4492);
   11493 			stream_REGISTER.add(REGISTER328);
   11494 
   11495 			COMMA329=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21lh4494);
   11496 			stream_COMMA.add(COMMA329);
   11497 
   11498 			pushFollow(FOLLOW_fixed_32bit_literal_in_insn_format21lh4496);
   11499 			fixed_32bit_literal330=fixed_32bit_literal();
   11500 			state._fsp--;
   11501 
   11502 			stream_fixed_32bit_literal.add(fixed_32bit_literal330.getTree());
   11503 			// AST REWRITE
   11504 			// elements: INSTRUCTION_FORMAT21lh, fixed_32bit_literal, REGISTER
   11505 			// token labels:
   11506 			// rule labels: retval
   11507 			// token list labels:
   11508 			// rule list labels:
   11509 			// wildcard labels:
   11510 			retval.tree = root_0;
   11511 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   11512 
   11513 			root_0 = (CommonTree)adaptor.nil();
   11514 			// 930:5: -> ^( I_STATEMENT_FORMAT21lh[$start, \"I_STATEMENT_FORMAT21lh\"] INSTRUCTION_FORMAT21lh REGISTER fixed_32bit_literal )
   11515 			{
   11516 				// smaliParser.g:930:8: ^( I_STATEMENT_FORMAT21lh[$start, \"I_STATEMENT_FORMAT21lh\"] INSTRUCTION_FORMAT21lh REGISTER fixed_32bit_literal )
   11517 				{
   11518 				CommonTree root_1 = (CommonTree)adaptor.nil();
   11519 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21lh, (retval.start), "I_STATEMENT_FORMAT21lh"), root_1);
   11520 				adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21lh.nextNode());
   11521 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   11522 				adaptor.addChild(root_1, stream_fixed_32bit_literal.nextTree());
   11523 				adaptor.addChild(root_0, root_1);
   11524 				}
   11525 
   11526 			}
   11527 
   11528 
   11529 			retval.tree = root_0;
   11530 
   11531 			}
   11532 
   11533 			retval.stop = input.LT(-1);
   11534 
   11535 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   11536 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   11537 
   11538 		}
   11539 		catch (RecognitionException re) {
   11540 			reportError(re);
   11541 			recover(input,re);
   11542 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   11543 		}
   11544 		finally {
   11545 			// do for sure before leaving
   11546 		}
   11547 		return retval;
   11548 	}
   11549 	// $ANTLR end "insn_format21lh"
   11550 
   11551 
   11552 	public static class insn_format21s_return extends ParserRuleReturnScope {
   11553 		CommonTree tree;
   11554 		@Override
   11555 		public CommonTree getTree() { return tree; }
   11556 	};
   11557 
   11558 
   11559 	// $ANTLR start "insn_format21s"
   11560 	// smaliParser.g:932:1: insn_format21s : INSTRUCTION_FORMAT21s REGISTER COMMA integral_literal -> ^( I_STATEMENT_FORMAT21s[$start, \"I_STATEMENT_FORMAT21s\"] INSTRUCTION_FORMAT21s REGISTER integral_literal ) ;
   11561 	public final smaliParser.insn_format21s_return insn_format21s() throws RecognitionException {
   11562 		smaliParser.insn_format21s_return retval = new smaliParser.insn_format21s_return();
   11563 		retval.start = input.LT(1);
   11564 
   11565 		CommonTree root_0 = null;
   11566 
   11567 		Token INSTRUCTION_FORMAT21s331=null;
   11568 		Token REGISTER332=null;
   11569 		Token COMMA333=null;
   11570 		ParserRuleReturnScope integral_literal334 =null;
   11571 
   11572 		CommonTree INSTRUCTION_FORMAT21s331_tree=null;
   11573 		CommonTree REGISTER332_tree=null;
   11574 		CommonTree COMMA333_tree=null;
   11575 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   11576 		RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER");
   11577 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21s=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21s");
   11578 		RewriteRuleSubtreeStream stream_integral_literal=new RewriteRuleSubtreeStream(adaptor,"rule integral_literal");
   11579 
   11580 		try {
   11581 			// smaliParser.g:933:3: ( INSTRUCTION_FORMAT21s REGISTER COMMA integral_literal -> ^( I_STATEMENT_FORMAT21s[$start, \"I_STATEMENT_FORMAT21s\"] INSTRUCTION_FORMAT21s REGISTER integral_literal ) )
   11582 			// smaliParser.g:934:5: INSTRUCTION_FORMAT21s REGISTER COMMA integral_literal
   11583 			{
   11584 			INSTRUCTION_FORMAT21s331=(Token)match(input,INSTRUCTION_FORMAT21s,FOLLOW_INSTRUCTION_FORMAT21s_in_insn_format21s4528);
   11585 			stream_INSTRUCTION_FORMAT21s.add(INSTRUCTION_FORMAT21s331);
   11586 
   11587 			REGISTER332=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21s4530);
   11588 			stream_REGISTER.add(REGISTER332);
   11589 
   11590 			COMMA333=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21s4532);
   11591 			stream_COMMA.add(COMMA333);
   11592 
   11593 			pushFollow(FOLLOW_integral_literal_in_insn_format21s4534);
   11594 			integral_literal334=integral_literal();
   11595 			state._fsp--;
   11596 
   11597 			stream_integral_literal.add(integral_literal334.getTree());
   11598 			// AST REWRITE
   11599 			// elements: integral_literal, REGISTER, INSTRUCTION_FORMAT21s
   11600 			// token labels:
   11601 			// rule labels: retval
   11602 			// token list labels:
   11603 			// rule list labels:
   11604 			// wildcard labels:
   11605 			retval.tree = root_0;
   11606 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   11607 
   11608 			root_0 = (CommonTree)adaptor.nil();
   11609 			// 935:5: -> ^( I_STATEMENT_FORMAT21s[$start, \"I_STATEMENT_FORMAT21s\"] INSTRUCTION_FORMAT21s REGISTER integral_literal )
   11610 			{
   11611 				// smaliParser.g:935:8: ^( I_STATEMENT_FORMAT21s[$start, \"I_STATEMENT_FORMAT21s\"] INSTRUCTION_FORMAT21s REGISTER integral_literal )
   11612 				{
   11613 				CommonTree root_1 = (CommonTree)adaptor.nil();
   11614 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21s, (retval.start), "I_STATEMENT_FORMAT21s"), root_1);
   11615 				adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21s.nextNode());
   11616 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   11617 				adaptor.addChild(root_1, stream_integral_literal.nextTree());
   11618 				adaptor.addChild(root_0, root_1);
   11619 				}
   11620 
   11621 			}
   11622 
   11623 
   11624 			retval.tree = root_0;
   11625 
   11626 			}
   11627 
   11628 			retval.stop = input.LT(-1);
   11629 
   11630 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   11631 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   11632 
   11633 		}
   11634 		catch (RecognitionException re) {
   11635 			reportError(re);
   11636 			recover(input,re);
   11637 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   11638 		}
   11639 		finally {
   11640 			// do for sure before leaving
   11641 		}
   11642 		return retval;
   11643 	}
   11644 	// $ANTLR end "insn_format21s"
   11645 
   11646 
   11647 	public static class insn_format21t_return extends ParserRuleReturnScope {
   11648 		CommonTree tree;
   11649 		@Override
   11650 		public CommonTree getTree() { return tree; }
   11651 	};
   11652 
   11653 
   11654 	// $ANTLR start "insn_format21t"
   11655 	// smaliParser.g:937:1: insn_format21t : INSTRUCTION_FORMAT21t REGISTER COMMA label_ref -> ^( I_STATEMENT_FORMAT21t[$start, \"I_STATEMENT_FORMAT21t\"] INSTRUCTION_FORMAT21t REGISTER label_ref ) ;
   11656 	public final smaliParser.insn_format21t_return insn_format21t() throws RecognitionException {
   11657 		smaliParser.insn_format21t_return retval = new smaliParser.insn_format21t_return();
   11658 		retval.start = input.LT(1);
   11659 
   11660 		CommonTree root_0 = null;
   11661 
   11662 		Token INSTRUCTION_FORMAT21t335=null;
   11663 		Token REGISTER336=null;
   11664 		Token COMMA337=null;
   11665 		ParserRuleReturnScope label_ref338 =null;
   11666 
   11667 		CommonTree INSTRUCTION_FORMAT21t335_tree=null;
   11668 		CommonTree REGISTER336_tree=null;
   11669 		CommonTree COMMA337_tree=null;
   11670 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   11671 		RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER");
   11672 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21t");
   11673 		RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref");
   11674 
   11675 		try {
   11676 			// smaliParser.g:938:3: ( INSTRUCTION_FORMAT21t REGISTER COMMA label_ref -> ^( I_STATEMENT_FORMAT21t[$start, \"I_STATEMENT_FORMAT21t\"] INSTRUCTION_FORMAT21t REGISTER label_ref ) )
   11677 			// smaliParser.g:939:5: INSTRUCTION_FORMAT21t REGISTER COMMA label_ref
   11678 			{
   11679 			INSTRUCTION_FORMAT21t335=(Token)match(input,INSTRUCTION_FORMAT21t,FOLLOW_INSTRUCTION_FORMAT21t_in_insn_format21t4566);
   11680 			stream_INSTRUCTION_FORMAT21t.add(INSTRUCTION_FORMAT21t335);
   11681 
   11682 			REGISTER336=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21t4568);
   11683 			stream_REGISTER.add(REGISTER336);
   11684 
   11685 			COMMA337=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21t4570);
   11686 			stream_COMMA.add(COMMA337);
   11687 
   11688 			pushFollow(FOLLOW_label_ref_in_insn_format21t4572);
   11689 			label_ref338=label_ref();
   11690 			state._fsp--;
   11691 
   11692 			stream_label_ref.add(label_ref338.getTree());
   11693 			// AST REWRITE
   11694 			// elements: INSTRUCTION_FORMAT21t, label_ref, REGISTER
   11695 			// token labels:
   11696 			// rule labels: retval
   11697 			// token list labels:
   11698 			// rule list labels:
   11699 			// wildcard labels:
   11700 			retval.tree = root_0;
   11701 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   11702 
   11703 			root_0 = (CommonTree)adaptor.nil();
   11704 			// 940:5: -> ^( I_STATEMENT_FORMAT21t[$start, \"I_STATEMENT_FORMAT21t\"] INSTRUCTION_FORMAT21t REGISTER label_ref )
   11705 			{
   11706 				// smaliParser.g:940:8: ^( I_STATEMENT_FORMAT21t[$start, \"I_STATEMENT_FORMAT21t\"] INSTRUCTION_FORMAT21t REGISTER label_ref )
   11707 				{
   11708 				CommonTree root_1 = (CommonTree)adaptor.nil();
   11709 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21t, (retval.start), "I_STATEMENT_FORMAT21t"), root_1);
   11710 				adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21t.nextNode());
   11711 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   11712 				adaptor.addChild(root_1, stream_label_ref.nextTree());
   11713 				adaptor.addChild(root_0, root_1);
   11714 				}
   11715 
   11716 			}
   11717 
   11718 
   11719 			retval.tree = root_0;
   11720 
   11721 			}
   11722 
   11723 			retval.stop = input.LT(-1);
   11724 
   11725 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   11726 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   11727 
   11728 		}
   11729 		catch (RecognitionException re) {
   11730 			reportError(re);
   11731 			recover(input,re);
   11732 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   11733 		}
   11734 		finally {
   11735 			// do for sure before leaving
   11736 		}
   11737 		return retval;
   11738 	}
   11739 	// $ANTLR end "insn_format21t"
   11740 
   11741 
   11742 	public static class insn_format22b_return extends ParserRuleReturnScope {
   11743 		CommonTree tree;
   11744 		@Override
   11745 		public CommonTree getTree() { return tree; }
   11746 	};
   11747 
   11748 
   11749 	// $ANTLR start "insn_format22b"
   11750 	// smaliParser.g:942:1: insn_format22b : INSTRUCTION_FORMAT22b REGISTER COMMA REGISTER COMMA integral_literal -> ^( I_STATEMENT_FORMAT22b[$start, \"I_STATEMENT_FORMAT22b\"] INSTRUCTION_FORMAT22b REGISTER REGISTER integral_literal ) ;
   11751 	public final smaliParser.insn_format22b_return insn_format22b() throws RecognitionException {
   11752 		smaliParser.insn_format22b_return retval = new smaliParser.insn_format22b_return();
   11753 		retval.start = input.LT(1);
   11754 
   11755 		CommonTree root_0 = null;
   11756 
   11757 		Token INSTRUCTION_FORMAT22b339=null;
   11758 		Token REGISTER340=null;
   11759 		Token COMMA341=null;
   11760 		Token REGISTER342=null;
   11761 		Token COMMA343=null;
   11762 		ParserRuleReturnScope integral_literal344 =null;
   11763 
   11764 		CommonTree INSTRUCTION_FORMAT22b339_tree=null;
   11765 		CommonTree REGISTER340_tree=null;
   11766 		CommonTree COMMA341_tree=null;
   11767 		CommonTree REGISTER342_tree=null;
   11768 		CommonTree COMMA343_tree=null;
   11769 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   11770 		RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER");
   11771 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22b=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22b");
   11772 		RewriteRuleSubtreeStream stream_integral_literal=new RewriteRuleSubtreeStream(adaptor,"rule integral_literal");
   11773 
   11774 		try {
   11775 			// smaliParser.g:943:3: ( INSTRUCTION_FORMAT22b REGISTER COMMA REGISTER COMMA integral_literal -> ^( I_STATEMENT_FORMAT22b[$start, \"I_STATEMENT_FORMAT22b\"] INSTRUCTION_FORMAT22b REGISTER REGISTER integral_literal ) )
   11776 			// smaliParser.g:944:5: INSTRUCTION_FORMAT22b REGISTER COMMA REGISTER COMMA integral_literal
   11777 			{
   11778 			INSTRUCTION_FORMAT22b339=(Token)match(input,INSTRUCTION_FORMAT22b,FOLLOW_INSTRUCTION_FORMAT22b_in_insn_format22b4604);
   11779 			stream_INSTRUCTION_FORMAT22b.add(INSTRUCTION_FORMAT22b339);
   11780 
   11781 			REGISTER340=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22b4606);
   11782 			stream_REGISTER.add(REGISTER340);
   11783 
   11784 			COMMA341=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22b4608);
   11785 			stream_COMMA.add(COMMA341);
   11786 
   11787 			REGISTER342=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22b4610);
   11788 			stream_REGISTER.add(REGISTER342);
   11789 
   11790 			COMMA343=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22b4612);
   11791 			stream_COMMA.add(COMMA343);
   11792 
   11793 			pushFollow(FOLLOW_integral_literal_in_insn_format22b4614);
   11794 			integral_literal344=integral_literal();
   11795 			state._fsp--;
   11796 
   11797 			stream_integral_literal.add(integral_literal344.getTree());
   11798 			// AST REWRITE
   11799 			// elements: REGISTER, REGISTER, integral_literal, INSTRUCTION_FORMAT22b
   11800 			// token labels:
   11801 			// rule labels: retval
   11802 			// token list labels:
   11803 			// rule list labels:
   11804 			// wildcard labels:
   11805 			retval.tree = root_0;
   11806 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   11807 
   11808 			root_0 = (CommonTree)adaptor.nil();
   11809 			// 945:5: -> ^( I_STATEMENT_FORMAT22b[$start, \"I_STATEMENT_FORMAT22b\"] INSTRUCTION_FORMAT22b REGISTER REGISTER integral_literal )
   11810 			{
   11811 				// smaliParser.g:945:8: ^( I_STATEMENT_FORMAT22b[$start, \"I_STATEMENT_FORMAT22b\"] INSTRUCTION_FORMAT22b REGISTER REGISTER integral_literal )
   11812 				{
   11813 				CommonTree root_1 = (CommonTree)adaptor.nil();
   11814 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT22b, (retval.start), "I_STATEMENT_FORMAT22b"), root_1);
   11815 				adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT22b.nextNode());
   11816 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   11817 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   11818 				adaptor.addChild(root_1, stream_integral_literal.nextTree());
   11819 				adaptor.addChild(root_0, root_1);
   11820 				}
   11821 
   11822 			}
   11823 
   11824 
   11825 			retval.tree = root_0;
   11826 
   11827 			}
   11828 
   11829 			retval.stop = input.LT(-1);
   11830 
   11831 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   11832 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   11833 
   11834 		}
   11835 		catch (RecognitionException re) {
   11836 			reportError(re);
   11837 			recover(input,re);
   11838 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   11839 		}
   11840 		finally {
   11841 			// do for sure before leaving
   11842 		}
   11843 		return retval;
   11844 	}
   11845 	// $ANTLR end "insn_format22b"
   11846 
   11847 
   11848 	public static class insn_format22c_field_return extends ParserRuleReturnScope {
   11849 		CommonTree tree;
   11850 		@Override
   11851 		public CommonTree getTree() { return tree; }
   11852 	};
   11853 
   11854 
   11855 	// $ANTLR start "insn_format22c_field"
   11856 	// smaliParser.g:947:1: insn_format22c_field : INSTRUCTION_FORMAT22c_FIELD REGISTER COMMA REGISTER COMMA field_reference -> ^( I_STATEMENT_FORMAT22c_FIELD[$start, \"I_STATEMENT_FORMAT22c_FIELD\"] INSTRUCTION_FORMAT22c_FIELD REGISTER REGISTER field_reference ) ;
   11857 	public final smaliParser.insn_format22c_field_return insn_format22c_field() throws RecognitionException {
   11858 		smaliParser.insn_format22c_field_return retval = new smaliParser.insn_format22c_field_return();
   11859 		retval.start = input.LT(1);
   11860 
   11861 		CommonTree root_0 = null;
   11862 
   11863 		Token INSTRUCTION_FORMAT22c_FIELD345=null;
   11864 		Token REGISTER346=null;
   11865 		Token COMMA347=null;
   11866 		Token REGISTER348=null;
   11867 		Token COMMA349=null;
   11868 		ParserRuleReturnScope field_reference350 =null;
   11869 
   11870 		CommonTree INSTRUCTION_FORMAT22c_FIELD345_tree=null;
   11871 		CommonTree REGISTER346_tree=null;
   11872 		CommonTree COMMA347_tree=null;
   11873 		CommonTree REGISTER348_tree=null;
   11874 		CommonTree COMMA349_tree=null;
   11875 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   11876 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22c_FIELD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22c_FIELD");
   11877 		RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER");
   11878 		RewriteRuleSubtreeStream stream_field_reference=new RewriteRuleSubtreeStream(adaptor,"rule field_reference");
   11879 
   11880 		try {
   11881 			// smaliParser.g:948:3: ( INSTRUCTION_FORMAT22c_FIELD REGISTER COMMA REGISTER COMMA field_reference -> ^( I_STATEMENT_FORMAT22c_FIELD[$start, \"I_STATEMENT_FORMAT22c_FIELD\"] INSTRUCTION_FORMAT22c_FIELD REGISTER REGISTER field_reference ) )
   11882 			// smaliParser.g:949:5: INSTRUCTION_FORMAT22c_FIELD REGISTER COMMA REGISTER COMMA field_reference
   11883 			{
   11884 			INSTRUCTION_FORMAT22c_FIELD345=(Token)match(input,INSTRUCTION_FORMAT22c_FIELD,FOLLOW_INSTRUCTION_FORMAT22c_FIELD_in_insn_format22c_field4648);
   11885 			stream_INSTRUCTION_FORMAT22c_FIELD.add(INSTRUCTION_FORMAT22c_FIELD345);
   11886 
   11887 			REGISTER346=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_field4650);
   11888 			stream_REGISTER.add(REGISTER346);
   11889 
   11890 			COMMA347=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22c_field4652);
   11891 			stream_COMMA.add(COMMA347);
   11892 
   11893 			REGISTER348=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_field4654);
   11894 			stream_REGISTER.add(REGISTER348);
   11895 
   11896 			COMMA349=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22c_field4656);
   11897 			stream_COMMA.add(COMMA349);
   11898 
   11899 			pushFollow(FOLLOW_field_reference_in_insn_format22c_field4658);
   11900 			field_reference350=field_reference();
   11901 			state._fsp--;
   11902 
   11903 			stream_field_reference.add(field_reference350.getTree());
   11904 			// AST REWRITE
   11905 			// elements: INSTRUCTION_FORMAT22c_FIELD, REGISTER, field_reference, REGISTER
   11906 			// token labels:
   11907 			// rule labels: retval
   11908 			// token list labels:
   11909 			// rule list labels:
   11910 			// wildcard labels:
   11911 			retval.tree = root_0;
   11912 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   11913 
   11914 			root_0 = (CommonTree)adaptor.nil();
   11915 			// 950:5: -> ^( I_STATEMENT_FORMAT22c_FIELD[$start, \"I_STATEMENT_FORMAT22c_FIELD\"] INSTRUCTION_FORMAT22c_FIELD REGISTER REGISTER field_reference )
   11916 			{
   11917 				// smaliParser.g:950:8: ^( I_STATEMENT_FORMAT22c_FIELD[$start, \"I_STATEMENT_FORMAT22c_FIELD\"] INSTRUCTION_FORMAT22c_FIELD REGISTER REGISTER field_reference )
   11918 				{
   11919 				CommonTree root_1 = (CommonTree)adaptor.nil();
   11920 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT22c_FIELD, (retval.start), "I_STATEMENT_FORMAT22c_FIELD"), root_1);
   11921 				adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT22c_FIELD.nextNode());
   11922 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   11923 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   11924 				adaptor.addChild(root_1, stream_field_reference.nextTree());
   11925 				adaptor.addChild(root_0, root_1);
   11926 				}
   11927 
   11928 			}
   11929 
   11930 
   11931 			retval.tree = root_0;
   11932 
   11933 			}
   11934 
   11935 			retval.stop = input.LT(-1);
   11936 
   11937 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   11938 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   11939 
   11940 		}
   11941 		catch (RecognitionException re) {
   11942 			reportError(re);
   11943 			recover(input,re);
   11944 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   11945 		}
   11946 		finally {
   11947 			// do for sure before leaving
   11948 		}
   11949 		return retval;
   11950 	}
   11951 	// $ANTLR end "insn_format22c_field"
   11952 
   11953 
   11954 	public static class insn_format22c_field_odex_return extends ParserRuleReturnScope {
   11955 		CommonTree tree;
   11956 		@Override
   11957 		public CommonTree getTree() { return tree; }
   11958 	};
   11959 
   11960 
   11961 	// $ANTLR start "insn_format22c_field_odex"
   11962 	// smaliParser.g:952:1: insn_format22c_field_odex : INSTRUCTION_FORMAT22c_FIELD_ODEX REGISTER COMMA REGISTER COMMA field_reference -> ^( I_STATEMENT_FORMAT22c_FIELD[$start, \"I_STATEMENT_FORMAT22c_FIELD\"] INSTRUCTION_FORMAT22c_FIELD_ODEX REGISTER REGISTER field_reference ) ;
   11963 	public final smaliParser.insn_format22c_field_odex_return insn_format22c_field_odex() throws RecognitionException {
   11964 		smaliParser.insn_format22c_field_odex_return retval = new smaliParser.insn_format22c_field_odex_return();
   11965 		retval.start = input.LT(1);
   11966 
   11967 		CommonTree root_0 = null;
   11968 
   11969 		Token INSTRUCTION_FORMAT22c_FIELD_ODEX351=null;
   11970 		Token REGISTER352=null;
   11971 		Token COMMA353=null;
   11972 		Token REGISTER354=null;
   11973 		Token COMMA355=null;
   11974 		ParserRuleReturnScope field_reference356 =null;
   11975 
   11976 		CommonTree INSTRUCTION_FORMAT22c_FIELD_ODEX351_tree=null;
   11977 		CommonTree REGISTER352_tree=null;
   11978 		CommonTree COMMA353_tree=null;
   11979 		CommonTree REGISTER354_tree=null;
   11980 		CommonTree COMMA355_tree=null;
   11981 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   11982 		RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER");
   11983 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22c_FIELD_ODEX=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22c_FIELD_ODEX");
   11984 		RewriteRuleSubtreeStream stream_field_reference=new RewriteRuleSubtreeStream(adaptor,"rule field_reference");
   11985 
   11986 		try {
   11987 			// smaliParser.g:953:3: ( INSTRUCTION_FORMAT22c_FIELD_ODEX REGISTER COMMA REGISTER COMMA field_reference -> ^( I_STATEMENT_FORMAT22c_FIELD[$start, \"I_STATEMENT_FORMAT22c_FIELD\"] INSTRUCTION_FORMAT22c_FIELD_ODEX REGISTER REGISTER field_reference ) )
   11988 			// smaliParser.g:954:5: INSTRUCTION_FORMAT22c_FIELD_ODEX REGISTER COMMA REGISTER COMMA field_reference
   11989 			{
   11990 			INSTRUCTION_FORMAT22c_FIELD_ODEX351=(Token)match(input,INSTRUCTION_FORMAT22c_FIELD_ODEX,FOLLOW_INSTRUCTION_FORMAT22c_FIELD_ODEX_in_insn_format22c_field_odex4692);
   11991 			stream_INSTRUCTION_FORMAT22c_FIELD_ODEX.add(INSTRUCTION_FORMAT22c_FIELD_ODEX351);
   11992 
   11993 			REGISTER352=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_field_odex4694);
   11994 			stream_REGISTER.add(REGISTER352);
   11995 
   11996 			COMMA353=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22c_field_odex4696);
   11997 			stream_COMMA.add(COMMA353);
   11998 
   11999 			REGISTER354=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_field_odex4698);
   12000 			stream_REGISTER.add(REGISTER354);
   12001 
   12002 			COMMA355=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22c_field_odex4700);
   12003 			stream_COMMA.add(COMMA355);
   12004 
   12005 			pushFollow(FOLLOW_field_reference_in_insn_format22c_field_odex4702);
   12006 			field_reference356=field_reference();
   12007 			state._fsp--;
   12008 
   12009 			stream_field_reference.add(field_reference356.getTree());
   12010 
   12011 			      if (!allowOdex || opcodes.getOpcodeByName((INSTRUCTION_FORMAT22c_FIELD_ODEX351!=null?INSTRUCTION_FORMAT22c_FIELD_ODEX351.getText():null)) == null || apiLevel >= 14) {
   12012 			        throwOdexedInstructionException(input, (INSTRUCTION_FORMAT22c_FIELD_ODEX351!=null?INSTRUCTION_FORMAT22c_FIELD_ODEX351.getText():null));
   12013 			      }
   12014 
   12015 			// AST REWRITE
   12016 			// elements: INSTRUCTION_FORMAT22c_FIELD_ODEX, field_reference, REGISTER, REGISTER
   12017 			// token labels:
   12018 			// rule labels: retval
   12019 			// token list labels:
   12020 			// rule list labels:
   12021 			// wildcard labels:
   12022 			retval.tree = root_0;
   12023 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   12024 
   12025 			root_0 = (CommonTree)adaptor.nil();
   12026 			// 960:5: -> ^( I_STATEMENT_FORMAT22c_FIELD[$start, \"I_STATEMENT_FORMAT22c_FIELD\"] INSTRUCTION_FORMAT22c_FIELD_ODEX REGISTER REGISTER field_reference )
   12027 			{
   12028 				// smaliParser.g:960:8: ^( I_STATEMENT_FORMAT22c_FIELD[$start, \"I_STATEMENT_FORMAT22c_FIELD\"] INSTRUCTION_FORMAT22c_FIELD_ODEX REGISTER REGISTER field_reference )
   12029 				{
   12030 				CommonTree root_1 = (CommonTree)adaptor.nil();
   12031 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT22c_FIELD, (retval.start), "I_STATEMENT_FORMAT22c_FIELD"), root_1);
   12032 				adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT22c_FIELD_ODEX.nextNode());
   12033 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   12034 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   12035 				adaptor.addChild(root_1, stream_field_reference.nextTree());
   12036 				adaptor.addChild(root_0, root_1);
   12037 				}
   12038 
   12039 			}
   12040 
   12041 
   12042 			retval.tree = root_0;
   12043 
   12044 			}
   12045 
   12046 			retval.stop = input.LT(-1);
   12047 
   12048 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   12049 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   12050 
   12051 		}
   12052 		catch (RecognitionException re) {
   12053 			reportError(re);
   12054 			recover(input,re);
   12055 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   12056 		}
   12057 		finally {
   12058 			// do for sure before leaving
   12059 		}
   12060 		return retval;
   12061 	}
   12062 	// $ANTLR end "insn_format22c_field_odex"
   12063 
   12064 
   12065 	public static class insn_format22c_type_return extends ParserRuleReturnScope {
   12066 		CommonTree tree;
   12067 		@Override
   12068 		public CommonTree getTree() { return tree; }
   12069 	};
   12070 
   12071 
   12072 	// $ANTLR start "insn_format22c_type"
   12073 	// smaliParser.g:962:1: insn_format22c_type : INSTRUCTION_FORMAT22c_TYPE REGISTER COMMA REGISTER COMMA nonvoid_type_descriptor -> ^( I_STATEMENT_FORMAT22c_TYPE[$start, \"I_STATEMENT_FORMAT22c_TYPE\"] INSTRUCTION_FORMAT22c_TYPE REGISTER REGISTER nonvoid_type_descriptor ) ;
   12074 	public final smaliParser.insn_format22c_type_return insn_format22c_type() throws RecognitionException {
   12075 		smaliParser.insn_format22c_type_return retval = new smaliParser.insn_format22c_type_return();
   12076 		retval.start = input.LT(1);
   12077 
   12078 		CommonTree root_0 = null;
   12079 
   12080 		Token INSTRUCTION_FORMAT22c_TYPE357=null;
   12081 		Token REGISTER358=null;
   12082 		Token COMMA359=null;
   12083 		Token REGISTER360=null;
   12084 		Token COMMA361=null;
   12085 		ParserRuleReturnScope nonvoid_type_descriptor362 =null;
   12086 
   12087 		CommonTree INSTRUCTION_FORMAT22c_TYPE357_tree=null;
   12088 		CommonTree REGISTER358_tree=null;
   12089 		CommonTree COMMA359_tree=null;
   12090 		CommonTree REGISTER360_tree=null;
   12091 		CommonTree COMMA361_tree=null;
   12092 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   12093 		RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER");
   12094 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22c_TYPE=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22c_TYPE");
   12095 		RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor");
   12096 
   12097 		try {
   12098 			// smaliParser.g:963:3: ( INSTRUCTION_FORMAT22c_TYPE REGISTER COMMA REGISTER COMMA nonvoid_type_descriptor -> ^( I_STATEMENT_FORMAT22c_TYPE[$start, \"I_STATEMENT_FORMAT22c_TYPE\"] INSTRUCTION_FORMAT22c_TYPE REGISTER REGISTER nonvoid_type_descriptor ) )
   12099 			// smaliParser.g:964:5: INSTRUCTION_FORMAT22c_TYPE REGISTER COMMA REGISTER COMMA nonvoid_type_descriptor
   12100 			{
   12101 			INSTRUCTION_FORMAT22c_TYPE357=(Token)match(input,INSTRUCTION_FORMAT22c_TYPE,FOLLOW_INSTRUCTION_FORMAT22c_TYPE_in_insn_format22c_type4742);
   12102 			stream_INSTRUCTION_FORMAT22c_TYPE.add(INSTRUCTION_FORMAT22c_TYPE357);
   12103 
   12104 			REGISTER358=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_type4744);
   12105 			stream_REGISTER.add(REGISTER358);
   12106 
   12107 			COMMA359=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22c_type4746);
   12108 			stream_COMMA.add(COMMA359);
   12109 
   12110 			REGISTER360=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_type4748);
   12111 			stream_REGISTER.add(REGISTER360);
   12112 
   12113 			COMMA361=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22c_type4750);
   12114 			stream_COMMA.add(COMMA361);
   12115 
   12116 			pushFollow(FOLLOW_nonvoid_type_descriptor_in_insn_format22c_type4752);
   12117 			nonvoid_type_descriptor362=nonvoid_type_descriptor();
   12118 			state._fsp--;
   12119 
   12120 			stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor362.getTree());
   12121 			// AST REWRITE
   12122 			// elements: REGISTER, REGISTER, nonvoid_type_descriptor, INSTRUCTION_FORMAT22c_TYPE
   12123 			// token labels:
   12124 			// rule labels: retval
   12125 			// token list labels:
   12126 			// rule list labels:
   12127 			// wildcard labels:
   12128 			retval.tree = root_0;
   12129 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   12130 
   12131 			root_0 = (CommonTree)adaptor.nil();
   12132 			// 965:5: -> ^( I_STATEMENT_FORMAT22c_TYPE[$start, \"I_STATEMENT_FORMAT22c_TYPE\"] INSTRUCTION_FORMAT22c_TYPE REGISTER REGISTER nonvoid_type_descriptor )
   12133 			{
   12134 				// smaliParser.g:965:8: ^( I_STATEMENT_FORMAT22c_TYPE[$start, \"I_STATEMENT_FORMAT22c_TYPE\"] INSTRUCTION_FORMAT22c_TYPE REGISTER REGISTER nonvoid_type_descriptor )
   12135 				{
   12136 				CommonTree root_1 = (CommonTree)adaptor.nil();
   12137 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT22c_TYPE, (retval.start), "I_STATEMENT_FORMAT22c_TYPE"), root_1);
   12138 				adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT22c_TYPE.nextNode());
   12139 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   12140 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   12141 				adaptor.addChild(root_1, stream_nonvoid_type_descriptor.nextTree());
   12142 				adaptor.addChild(root_0, root_1);
   12143 				}
   12144 
   12145 			}
   12146 
   12147 
   12148 			retval.tree = root_0;
   12149 
   12150 			}
   12151 
   12152 			retval.stop = input.LT(-1);
   12153 
   12154 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   12155 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   12156 
   12157 		}
   12158 		catch (RecognitionException re) {
   12159 			reportError(re);
   12160 			recover(input,re);
   12161 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   12162 		}
   12163 		finally {
   12164 			// do for sure before leaving
   12165 		}
   12166 		return retval;
   12167 	}
   12168 	// $ANTLR end "insn_format22c_type"
   12169 
   12170 
   12171 	public static class insn_format22cs_field_return extends ParserRuleReturnScope {
   12172 		CommonTree tree;
   12173 		@Override
   12174 		public CommonTree getTree() { return tree; }
   12175 	};
   12176 
   12177 
   12178 	// $ANTLR start "insn_format22cs_field"
   12179 	// smaliParser.g:967:1: insn_format22cs_field : INSTRUCTION_FORMAT22cs_FIELD REGISTER COMMA REGISTER COMMA FIELD_OFFSET ;
   12180 	public final smaliParser.insn_format22cs_field_return insn_format22cs_field() throws RecognitionException {
   12181 		smaliParser.insn_format22cs_field_return retval = new smaliParser.insn_format22cs_field_return();
   12182 		retval.start = input.LT(1);
   12183 
   12184 		CommonTree root_0 = null;
   12185 
   12186 		Token INSTRUCTION_FORMAT22cs_FIELD363=null;
   12187 		Token REGISTER364=null;
   12188 		Token COMMA365=null;
   12189 		Token REGISTER366=null;
   12190 		Token COMMA367=null;
   12191 		Token FIELD_OFFSET368=null;
   12192 
   12193 		CommonTree INSTRUCTION_FORMAT22cs_FIELD363_tree=null;
   12194 		CommonTree REGISTER364_tree=null;
   12195 		CommonTree COMMA365_tree=null;
   12196 		CommonTree REGISTER366_tree=null;
   12197 		CommonTree COMMA367_tree=null;
   12198 		CommonTree FIELD_OFFSET368_tree=null;
   12199 
   12200 		try {
   12201 			// smaliParser.g:968:3: ( INSTRUCTION_FORMAT22cs_FIELD REGISTER COMMA REGISTER COMMA FIELD_OFFSET )
   12202 			// smaliParser.g:969:5: INSTRUCTION_FORMAT22cs_FIELD REGISTER COMMA REGISTER COMMA FIELD_OFFSET
   12203 			{
   12204 			root_0 = (CommonTree)adaptor.nil();
   12205 
   12206 
   12207 			INSTRUCTION_FORMAT22cs_FIELD363=(Token)match(input,INSTRUCTION_FORMAT22cs_FIELD,FOLLOW_INSTRUCTION_FORMAT22cs_FIELD_in_insn_format22cs_field4786);
   12208 			INSTRUCTION_FORMAT22cs_FIELD363_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT22cs_FIELD363);
   12209 			adaptor.addChild(root_0, INSTRUCTION_FORMAT22cs_FIELD363_tree);
   12210 
   12211 			REGISTER364=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22cs_field4788);
   12212 			REGISTER364_tree = (CommonTree)adaptor.create(REGISTER364);
   12213 			adaptor.addChild(root_0, REGISTER364_tree);
   12214 
   12215 			COMMA365=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22cs_field4790);
   12216 			COMMA365_tree = (CommonTree)adaptor.create(COMMA365);
   12217 			adaptor.addChild(root_0, COMMA365_tree);
   12218 
   12219 			REGISTER366=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22cs_field4792);
   12220 			REGISTER366_tree = (CommonTree)adaptor.create(REGISTER366);
   12221 			adaptor.addChild(root_0, REGISTER366_tree);
   12222 
   12223 			COMMA367=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22cs_field4794);
   12224 			COMMA367_tree = (CommonTree)adaptor.create(COMMA367);
   12225 			adaptor.addChild(root_0, COMMA367_tree);
   12226 
   12227 			FIELD_OFFSET368=(Token)match(input,FIELD_OFFSET,FOLLOW_FIELD_OFFSET_in_insn_format22cs_field4796);
   12228 			FIELD_OFFSET368_tree = (CommonTree)adaptor.create(FIELD_OFFSET368);
   12229 			adaptor.addChild(root_0, FIELD_OFFSET368_tree);
   12230 
   12231 
   12232 			      throwOdexedInstructionException(input, (INSTRUCTION_FORMAT22cs_FIELD363!=null?INSTRUCTION_FORMAT22cs_FIELD363.getText():null));
   12233 
   12234 			}
   12235 
   12236 			retval.stop = input.LT(-1);
   12237 
   12238 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   12239 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   12240 
   12241 		}
   12242 		catch (RecognitionException re) {
   12243 			reportError(re);
   12244 			recover(input,re);
   12245 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   12246 		}
   12247 		finally {
   12248 			// do for sure before leaving
   12249 		}
   12250 		return retval;
   12251 	}
   12252 	// $ANTLR end "insn_format22cs_field"
   12253 
   12254 
   12255 	public static class insn_format22s_return extends ParserRuleReturnScope {
   12256 		CommonTree tree;
   12257 		@Override
   12258 		public CommonTree getTree() { return tree; }
   12259 	};
   12260 
   12261 
   12262 	// $ANTLR start "insn_format22s"
   12263 	// smaliParser.g:974:1: insn_format22s : instruction_format22s REGISTER COMMA REGISTER COMMA integral_literal -> ^( I_STATEMENT_FORMAT22s[$start, \"I_STATEMENT_FORMAT22s\"] instruction_format22s REGISTER REGISTER integral_literal ) ;
   12264 	public final smaliParser.insn_format22s_return insn_format22s() throws RecognitionException {
   12265 		smaliParser.insn_format22s_return retval = new smaliParser.insn_format22s_return();
   12266 		retval.start = input.LT(1);
   12267 
   12268 		CommonTree root_0 = null;
   12269 
   12270 		Token REGISTER370=null;
   12271 		Token COMMA371=null;
   12272 		Token REGISTER372=null;
   12273 		Token COMMA373=null;
   12274 		ParserRuleReturnScope instruction_format22s369 =null;
   12275 		ParserRuleReturnScope integral_literal374 =null;
   12276 
   12277 		CommonTree REGISTER370_tree=null;
   12278 		CommonTree COMMA371_tree=null;
   12279 		CommonTree REGISTER372_tree=null;
   12280 		CommonTree COMMA373_tree=null;
   12281 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   12282 		RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER");
   12283 		RewriteRuleSubtreeStream stream_instruction_format22s=new RewriteRuleSubtreeStream(adaptor,"rule instruction_format22s");
   12284 		RewriteRuleSubtreeStream stream_integral_literal=new RewriteRuleSubtreeStream(adaptor,"rule integral_literal");
   12285 
   12286 		try {
   12287 			// smaliParser.g:975:3: ( instruction_format22s REGISTER COMMA REGISTER COMMA integral_literal -> ^( I_STATEMENT_FORMAT22s[$start, \"I_STATEMENT_FORMAT22s\"] instruction_format22s REGISTER REGISTER integral_literal ) )
   12288 			// smaliParser.g:976:5: instruction_format22s REGISTER COMMA REGISTER COMMA integral_literal
   12289 			{
   12290 			pushFollow(FOLLOW_instruction_format22s_in_insn_format22s4817);
   12291 			instruction_format22s369=instruction_format22s();
   12292 			state._fsp--;
   12293 
   12294 			stream_instruction_format22s.add(instruction_format22s369.getTree());
   12295 			REGISTER370=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22s4819);
   12296 			stream_REGISTER.add(REGISTER370);
   12297 
   12298 			COMMA371=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22s4821);
   12299 			stream_COMMA.add(COMMA371);
   12300 
   12301 			REGISTER372=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22s4823);
   12302 			stream_REGISTER.add(REGISTER372);
   12303 
   12304 			COMMA373=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22s4825);
   12305 			stream_COMMA.add(COMMA373);
   12306 
   12307 			pushFollow(FOLLOW_integral_literal_in_insn_format22s4827);
   12308 			integral_literal374=integral_literal();
   12309 			state._fsp--;
   12310 
   12311 			stream_integral_literal.add(integral_literal374.getTree());
   12312 			// AST REWRITE
   12313 			// elements: REGISTER, REGISTER, instruction_format22s, integral_literal
   12314 			// token labels:
   12315 			// rule labels: retval
   12316 			// token list labels:
   12317 			// rule list labels:
   12318 			// wildcard labels:
   12319 			retval.tree = root_0;
   12320 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   12321 
   12322 			root_0 = (CommonTree)adaptor.nil();
   12323 			// 977:5: -> ^( I_STATEMENT_FORMAT22s[$start, \"I_STATEMENT_FORMAT22s\"] instruction_format22s REGISTER REGISTER integral_literal )
   12324 			{
   12325 				// smaliParser.g:977:8: ^( I_STATEMENT_FORMAT22s[$start, \"I_STATEMENT_FORMAT22s\"] instruction_format22s REGISTER REGISTER integral_literal )
   12326 				{
   12327 				CommonTree root_1 = (CommonTree)adaptor.nil();
   12328 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT22s, (retval.start), "I_STATEMENT_FORMAT22s"), root_1);
   12329 				adaptor.addChild(root_1, stream_instruction_format22s.nextTree());
   12330 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   12331 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   12332 				adaptor.addChild(root_1, stream_integral_literal.nextTree());
   12333 				adaptor.addChild(root_0, root_1);
   12334 				}
   12335 
   12336 			}
   12337 
   12338 
   12339 			retval.tree = root_0;
   12340 
   12341 			}
   12342 
   12343 			retval.stop = input.LT(-1);
   12344 
   12345 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   12346 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   12347 
   12348 		}
   12349 		catch (RecognitionException re) {
   12350 			reportError(re);
   12351 			recover(input,re);
   12352 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   12353 		}
   12354 		finally {
   12355 			// do for sure before leaving
   12356 		}
   12357 		return retval;
   12358 	}
   12359 	// $ANTLR end "insn_format22s"
   12360 
   12361 
   12362 	public static class insn_format22t_return extends ParserRuleReturnScope {
   12363 		CommonTree tree;
   12364 		@Override
   12365 		public CommonTree getTree() { return tree; }
   12366 	};
   12367 
   12368 
   12369 	// $ANTLR start "insn_format22t"
   12370 	// smaliParser.g:979:1: insn_format22t : INSTRUCTION_FORMAT22t REGISTER COMMA REGISTER COMMA label_ref -> ^( I_STATEMENT_FORMAT22t[$start, \"I_STATEMENT_FFORMAT22t\"] INSTRUCTION_FORMAT22t REGISTER REGISTER label_ref ) ;
   12371 	public final smaliParser.insn_format22t_return insn_format22t() throws RecognitionException {
   12372 		smaliParser.insn_format22t_return retval = new smaliParser.insn_format22t_return();
   12373 		retval.start = input.LT(1);
   12374 
   12375 		CommonTree root_0 = null;
   12376 
   12377 		Token INSTRUCTION_FORMAT22t375=null;
   12378 		Token REGISTER376=null;
   12379 		Token COMMA377=null;
   12380 		Token REGISTER378=null;
   12381 		Token COMMA379=null;
   12382 		ParserRuleReturnScope label_ref380 =null;
   12383 
   12384 		CommonTree INSTRUCTION_FORMAT22t375_tree=null;
   12385 		CommonTree REGISTER376_tree=null;
   12386 		CommonTree COMMA377_tree=null;
   12387 		CommonTree REGISTER378_tree=null;
   12388 		CommonTree COMMA379_tree=null;
   12389 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   12390 		RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER");
   12391 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22t");
   12392 		RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref");
   12393 
   12394 		try {
   12395 			// smaliParser.g:980:3: ( INSTRUCTION_FORMAT22t REGISTER COMMA REGISTER COMMA label_ref -> ^( I_STATEMENT_FORMAT22t[$start, \"I_STATEMENT_FFORMAT22t\"] INSTRUCTION_FORMAT22t REGISTER REGISTER label_ref ) )
   12396 			// smaliParser.g:981:5: INSTRUCTION_FORMAT22t REGISTER COMMA REGISTER COMMA label_ref
   12397 			{
   12398 			INSTRUCTION_FORMAT22t375=(Token)match(input,INSTRUCTION_FORMAT22t,FOLLOW_INSTRUCTION_FORMAT22t_in_insn_format22t4861);
   12399 			stream_INSTRUCTION_FORMAT22t.add(INSTRUCTION_FORMAT22t375);
   12400 
   12401 			REGISTER376=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22t4863);
   12402 			stream_REGISTER.add(REGISTER376);
   12403 
   12404 			COMMA377=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22t4865);
   12405 			stream_COMMA.add(COMMA377);
   12406 
   12407 			REGISTER378=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22t4867);
   12408 			stream_REGISTER.add(REGISTER378);
   12409 
   12410 			COMMA379=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22t4869);
   12411 			stream_COMMA.add(COMMA379);
   12412 
   12413 			pushFollow(FOLLOW_label_ref_in_insn_format22t4871);
   12414 			label_ref380=label_ref();
   12415 			state._fsp--;
   12416 
   12417 			stream_label_ref.add(label_ref380.getTree());
   12418 			// AST REWRITE
   12419 			// elements: REGISTER, INSTRUCTION_FORMAT22t, REGISTER, label_ref
   12420 			// token labels:
   12421 			// rule labels: retval
   12422 			// token list labels:
   12423 			// rule list labels:
   12424 			// wildcard labels:
   12425 			retval.tree = root_0;
   12426 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   12427 
   12428 			root_0 = (CommonTree)adaptor.nil();
   12429 			// 982:5: -> ^( I_STATEMENT_FORMAT22t[$start, \"I_STATEMENT_FFORMAT22t\"] INSTRUCTION_FORMAT22t REGISTER REGISTER label_ref )
   12430 			{
   12431 				// smaliParser.g:982:8: ^( I_STATEMENT_FORMAT22t[$start, \"I_STATEMENT_FFORMAT22t\"] INSTRUCTION_FORMAT22t REGISTER REGISTER label_ref )
   12432 				{
   12433 				CommonTree root_1 = (CommonTree)adaptor.nil();
   12434 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT22t, (retval.start), "I_STATEMENT_FFORMAT22t"), root_1);
   12435 				adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT22t.nextNode());
   12436 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   12437 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   12438 				adaptor.addChild(root_1, stream_label_ref.nextTree());
   12439 				adaptor.addChild(root_0, root_1);
   12440 				}
   12441 
   12442 			}
   12443 
   12444 
   12445 			retval.tree = root_0;
   12446 
   12447 			}
   12448 
   12449 			retval.stop = input.LT(-1);
   12450 
   12451 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   12452 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   12453 
   12454 		}
   12455 		catch (RecognitionException re) {
   12456 			reportError(re);
   12457 			recover(input,re);
   12458 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   12459 		}
   12460 		finally {
   12461 			// do for sure before leaving
   12462 		}
   12463 		return retval;
   12464 	}
   12465 	// $ANTLR end "insn_format22t"
   12466 
   12467 
   12468 	public static class insn_format22x_return extends ParserRuleReturnScope {
   12469 		CommonTree tree;
   12470 		@Override
   12471 		public CommonTree getTree() { return tree; }
   12472 	};
   12473 
   12474 
   12475 	// $ANTLR start "insn_format22x"
   12476 	// smaliParser.g:984:1: insn_format22x : INSTRUCTION_FORMAT22x REGISTER COMMA REGISTER -> ^( I_STATEMENT_FORMAT22x[$start, \"I_STATEMENT_FORMAT22x\"] INSTRUCTION_FORMAT22x REGISTER REGISTER ) ;
   12477 	public final smaliParser.insn_format22x_return insn_format22x() throws RecognitionException {
   12478 		smaliParser.insn_format22x_return retval = new smaliParser.insn_format22x_return();
   12479 		retval.start = input.LT(1);
   12480 
   12481 		CommonTree root_0 = null;
   12482 
   12483 		Token INSTRUCTION_FORMAT22x381=null;
   12484 		Token REGISTER382=null;
   12485 		Token COMMA383=null;
   12486 		Token REGISTER384=null;
   12487 
   12488 		CommonTree INSTRUCTION_FORMAT22x381_tree=null;
   12489 		CommonTree REGISTER382_tree=null;
   12490 		CommonTree COMMA383_tree=null;
   12491 		CommonTree REGISTER384_tree=null;
   12492 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   12493 		RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER");
   12494 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22x");
   12495 
   12496 		try {
   12497 			// smaliParser.g:985:3: ( INSTRUCTION_FORMAT22x REGISTER COMMA REGISTER -> ^( I_STATEMENT_FORMAT22x[$start, \"I_STATEMENT_FORMAT22x\"] INSTRUCTION_FORMAT22x REGISTER REGISTER ) )
   12498 			// smaliParser.g:986:5: INSTRUCTION_FORMAT22x REGISTER COMMA REGISTER
   12499 			{
   12500 			INSTRUCTION_FORMAT22x381=(Token)match(input,INSTRUCTION_FORMAT22x,FOLLOW_INSTRUCTION_FORMAT22x_in_insn_format22x4905);
   12501 			stream_INSTRUCTION_FORMAT22x.add(INSTRUCTION_FORMAT22x381);
   12502 
   12503 			REGISTER382=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22x4907);
   12504 			stream_REGISTER.add(REGISTER382);
   12505 
   12506 			COMMA383=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22x4909);
   12507 			stream_COMMA.add(COMMA383);
   12508 
   12509 			REGISTER384=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22x4911);
   12510 			stream_REGISTER.add(REGISTER384);
   12511 
   12512 			// AST REWRITE
   12513 			// elements: REGISTER, REGISTER, INSTRUCTION_FORMAT22x
   12514 			// token labels:
   12515 			// rule labels: retval
   12516 			// token list labels:
   12517 			// rule list labels:
   12518 			// wildcard labels:
   12519 			retval.tree = root_0;
   12520 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   12521 
   12522 			root_0 = (CommonTree)adaptor.nil();
   12523 			// 987:5: -> ^( I_STATEMENT_FORMAT22x[$start, \"I_STATEMENT_FORMAT22x\"] INSTRUCTION_FORMAT22x REGISTER REGISTER )
   12524 			{
   12525 				// smaliParser.g:987:8: ^( I_STATEMENT_FORMAT22x[$start, \"I_STATEMENT_FORMAT22x\"] INSTRUCTION_FORMAT22x REGISTER REGISTER )
   12526 				{
   12527 				CommonTree root_1 = (CommonTree)adaptor.nil();
   12528 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT22x, (retval.start), "I_STATEMENT_FORMAT22x"), root_1);
   12529 				adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT22x.nextNode());
   12530 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   12531 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   12532 				adaptor.addChild(root_0, root_1);
   12533 				}
   12534 
   12535 			}
   12536 
   12537 
   12538 			retval.tree = root_0;
   12539 
   12540 			}
   12541 
   12542 			retval.stop = input.LT(-1);
   12543 
   12544 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   12545 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   12546 
   12547 		}
   12548 		catch (RecognitionException re) {
   12549 			reportError(re);
   12550 			recover(input,re);
   12551 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   12552 		}
   12553 		finally {
   12554 			// do for sure before leaving
   12555 		}
   12556 		return retval;
   12557 	}
   12558 	// $ANTLR end "insn_format22x"
   12559 
   12560 
   12561 	public static class insn_format23x_return extends ParserRuleReturnScope {
   12562 		CommonTree tree;
   12563 		@Override
   12564 		public CommonTree getTree() { return tree; }
   12565 	};
   12566 
   12567 
   12568 	// $ANTLR start "insn_format23x"
   12569 	// smaliParser.g:989:1: insn_format23x : INSTRUCTION_FORMAT23x REGISTER COMMA REGISTER COMMA REGISTER -> ^( I_STATEMENT_FORMAT23x[$start, \"I_STATEMENT_FORMAT23x\"] INSTRUCTION_FORMAT23x REGISTER REGISTER REGISTER ) ;
   12570 	public final smaliParser.insn_format23x_return insn_format23x() throws RecognitionException {
   12571 		smaliParser.insn_format23x_return retval = new smaliParser.insn_format23x_return();
   12572 		retval.start = input.LT(1);
   12573 
   12574 		CommonTree root_0 = null;
   12575 
   12576 		Token INSTRUCTION_FORMAT23x385=null;
   12577 		Token REGISTER386=null;
   12578 		Token COMMA387=null;
   12579 		Token REGISTER388=null;
   12580 		Token COMMA389=null;
   12581 		Token REGISTER390=null;
   12582 
   12583 		CommonTree INSTRUCTION_FORMAT23x385_tree=null;
   12584 		CommonTree REGISTER386_tree=null;
   12585 		CommonTree COMMA387_tree=null;
   12586 		CommonTree REGISTER388_tree=null;
   12587 		CommonTree COMMA389_tree=null;
   12588 		CommonTree REGISTER390_tree=null;
   12589 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   12590 		RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER");
   12591 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT23x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT23x");
   12592 
   12593 		try {
   12594 			// smaliParser.g:990:3: ( INSTRUCTION_FORMAT23x REGISTER COMMA REGISTER COMMA REGISTER -> ^( I_STATEMENT_FORMAT23x[$start, \"I_STATEMENT_FORMAT23x\"] INSTRUCTION_FORMAT23x REGISTER REGISTER REGISTER ) )
   12595 			// smaliParser.g:991:5: INSTRUCTION_FORMAT23x REGISTER COMMA REGISTER COMMA REGISTER
   12596 			{
   12597 			INSTRUCTION_FORMAT23x385=(Token)match(input,INSTRUCTION_FORMAT23x,FOLLOW_INSTRUCTION_FORMAT23x_in_insn_format23x4943);
   12598 			stream_INSTRUCTION_FORMAT23x.add(INSTRUCTION_FORMAT23x385);
   12599 
   12600 			REGISTER386=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format23x4945);
   12601 			stream_REGISTER.add(REGISTER386);
   12602 
   12603 			COMMA387=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format23x4947);
   12604 			stream_COMMA.add(COMMA387);
   12605 
   12606 			REGISTER388=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format23x4949);
   12607 			stream_REGISTER.add(REGISTER388);
   12608 
   12609 			COMMA389=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format23x4951);
   12610 			stream_COMMA.add(COMMA389);
   12611 
   12612 			REGISTER390=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format23x4953);
   12613 			stream_REGISTER.add(REGISTER390);
   12614 
   12615 			// AST REWRITE
   12616 			// elements: REGISTER, REGISTER, INSTRUCTION_FORMAT23x, REGISTER
   12617 			// token labels:
   12618 			// rule labels: retval
   12619 			// token list labels:
   12620 			// rule list labels:
   12621 			// wildcard labels:
   12622 			retval.tree = root_0;
   12623 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   12624 
   12625 			root_0 = (CommonTree)adaptor.nil();
   12626 			// 992:5: -> ^( I_STATEMENT_FORMAT23x[$start, \"I_STATEMENT_FORMAT23x\"] INSTRUCTION_FORMAT23x REGISTER REGISTER REGISTER )
   12627 			{
   12628 				// smaliParser.g:992:8: ^( I_STATEMENT_FORMAT23x[$start, \"I_STATEMENT_FORMAT23x\"] INSTRUCTION_FORMAT23x REGISTER REGISTER REGISTER )
   12629 				{
   12630 				CommonTree root_1 = (CommonTree)adaptor.nil();
   12631 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT23x, (retval.start), "I_STATEMENT_FORMAT23x"), root_1);
   12632 				adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT23x.nextNode());
   12633 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   12634 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   12635 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   12636 				adaptor.addChild(root_0, root_1);
   12637 				}
   12638 
   12639 			}
   12640 
   12641 
   12642 			retval.tree = root_0;
   12643 
   12644 			}
   12645 
   12646 			retval.stop = input.LT(-1);
   12647 
   12648 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   12649 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   12650 
   12651 		}
   12652 		catch (RecognitionException re) {
   12653 			reportError(re);
   12654 			recover(input,re);
   12655 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   12656 		}
   12657 		finally {
   12658 			// do for sure before leaving
   12659 		}
   12660 		return retval;
   12661 	}
   12662 	// $ANTLR end "insn_format23x"
   12663 
   12664 
   12665 	public static class insn_format30t_return extends ParserRuleReturnScope {
   12666 		CommonTree tree;
   12667 		@Override
   12668 		public CommonTree getTree() { return tree; }
   12669 	};
   12670 
   12671 
   12672 	// $ANTLR start "insn_format30t"
   12673 	// smaliParser.g:994:1: insn_format30t : INSTRUCTION_FORMAT30t label_ref -> ^( I_STATEMENT_FORMAT30t[$start, \"I_STATEMENT_FORMAT30t\"] INSTRUCTION_FORMAT30t label_ref ) ;
   12674 	public final smaliParser.insn_format30t_return insn_format30t() throws RecognitionException {
   12675 		smaliParser.insn_format30t_return retval = new smaliParser.insn_format30t_return();
   12676 		retval.start = input.LT(1);
   12677 
   12678 		CommonTree root_0 = null;
   12679 
   12680 		Token INSTRUCTION_FORMAT30t391=null;
   12681 		ParserRuleReturnScope label_ref392 =null;
   12682 
   12683 		CommonTree INSTRUCTION_FORMAT30t391_tree=null;
   12684 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT30t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT30t");
   12685 		RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref");
   12686 
   12687 		try {
   12688 			// smaliParser.g:995:3: ( INSTRUCTION_FORMAT30t label_ref -> ^( I_STATEMENT_FORMAT30t[$start, \"I_STATEMENT_FORMAT30t\"] INSTRUCTION_FORMAT30t label_ref ) )
   12689 			// smaliParser.g:996:5: INSTRUCTION_FORMAT30t label_ref
   12690 			{
   12691 			INSTRUCTION_FORMAT30t391=(Token)match(input,INSTRUCTION_FORMAT30t,FOLLOW_INSTRUCTION_FORMAT30t_in_insn_format30t4987);
   12692 			stream_INSTRUCTION_FORMAT30t.add(INSTRUCTION_FORMAT30t391);
   12693 
   12694 			pushFollow(FOLLOW_label_ref_in_insn_format30t4989);
   12695 			label_ref392=label_ref();
   12696 			state._fsp--;
   12697 
   12698 			stream_label_ref.add(label_ref392.getTree());
   12699 			// AST REWRITE
   12700 			// elements: INSTRUCTION_FORMAT30t, label_ref
   12701 			// token labels:
   12702 			// rule labels: retval
   12703 			// token list labels:
   12704 			// rule list labels:
   12705 			// wildcard labels:
   12706 			retval.tree = root_0;
   12707 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   12708 
   12709 			root_0 = (CommonTree)adaptor.nil();
   12710 			// 997:5: -> ^( I_STATEMENT_FORMAT30t[$start, \"I_STATEMENT_FORMAT30t\"] INSTRUCTION_FORMAT30t label_ref )
   12711 			{
   12712 				// smaliParser.g:997:8: ^( I_STATEMENT_FORMAT30t[$start, \"I_STATEMENT_FORMAT30t\"] INSTRUCTION_FORMAT30t label_ref )
   12713 				{
   12714 				CommonTree root_1 = (CommonTree)adaptor.nil();
   12715 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT30t, (retval.start), "I_STATEMENT_FORMAT30t"), root_1);
   12716 				adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT30t.nextNode());
   12717 				adaptor.addChild(root_1, stream_label_ref.nextTree());
   12718 				adaptor.addChild(root_0, root_1);
   12719 				}
   12720 
   12721 			}
   12722 
   12723 
   12724 			retval.tree = root_0;
   12725 
   12726 			}
   12727 
   12728 			retval.stop = input.LT(-1);
   12729 
   12730 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   12731 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   12732 
   12733 		}
   12734 		catch (RecognitionException re) {
   12735 			reportError(re);
   12736 			recover(input,re);
   12737 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   12738 		}
   12739 		finally {
   12740 			// do for sure before leaving
   12741 		}
   12742 		return retval;
   12743 	}
   12744 	// $ANTLR end "insn_format30t"
   12745 
   12746 
   12747 	public static class insn_format31c_return extends ParserRuleReturnScope {
   12748 		CommonTree tree;
   12749 		@Override
   12750 		public CommonTree getTree() { return tree; }
   12751 	};
   12752 
   12753 
   12754 	// $ANTLR start "insn_format31c"
   12755 	// smaliParser.g:999:1: insn_format31c : INSTRUCTION_FORMAT31c REGISTER COMMA STRING_LITERAL -> ^( I_STATEMENT_FORMAT31c[$start, \"I_STATEMENT_FORMAT31c\"] INSTRUCTION_FORMAT31c REGISTER STRING_LITERAL ) ;
   12756 	public final smaliParser.insn_format31c_return insn_format31c() throws RecognitionException {
   12757 		smaliParser.insn_format31c_return retval = new smaliParser.insn_format31c_return();
   12758 		retval.start = input.LT(1);
   12759 
   12760 		CommonTree root_0 = null;
   12761 
   12762 		Token INSTRUCTION_FORMAT31c393=null;
   12763 		Token REGISTER394=null;
   12764 		Token COMMA395=null;
   12765 		Token STRING_LITERAL396=null;
   12766 
   12767 		CommonTree INSTRUCTION_FORMAT31c393_tree=null;
   12768 		CommonTree REGISTER394_tree=null;
   12769 		CommonTree COMMA395_tree=null;
   12770 		CommonTree STRING_LITERAL396_tree=null;
   12771 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   12772 		RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER");
   12773 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT31c=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT31c");
   12774 		RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL");
   12775 
   12776 		try {
   12777 			// smaliParser.g:1000:3: ( INSTRUCTION_FORMAT31c REGISTER COMMA STRING_LITERAL -> ^( I_STATEMENT_FORMAT31c[$start, \"I_STATEMENT_FORMAT31c\"] INSTRUCTION_FORMAT31c REGISTER STRING_LITERAL ) )
   12778 			// smaliParser.g:1001:5: INSTRUCTION_FORMAT31c REGISTER COMMA STRING_LITERAL
   12779 			{
   12780 			INSTRUCTION_FORMAT31c393=(Token)match(input,INSTRUCTION_FORMAT31c,FOLLOW_INSTRUCTION_FORMAT31c_in_insn_format31c5019);
   12781 			stream_INSTRUCTION_FORMAT31c.add(INSTRUCTION_FORMAT31c393);
   12782 
   12783 			REGISTER394=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format31c5021);
   12784 			stream_REGISTER.add(REGISTER394);
   12785 
   12786 			COMMA395=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format31c5023);
   12787 			stream_COMMA.add(COMMA395);
   12788 
   12789 			STRING_LITERAL396=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_insn_format31c5025);
   12790 			stream_STRING_LITERAL.add(STRING_LITERAL396);
   12791 
   12792 			// AST REWRITE
   12793 			// elements: REGISTER, STRING_LITERAL, INSTRUCTION_FORMAT31c
   12794 			// token labels:
   12795 			// rule labels: retval
   12796 			// token list labels:
   12797 			// rule list labels:
   12798 			// wildcard labels:
   12799 			retval.tree = root_0;
   12800 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   12801 
   12802 			root_0 = (CommonTree)adaptor.nil();
   12803 			// 1002:5: -> ^( I_STATEMENT_FORMAT31c[$start, \"I_STATEMENT_FORMAT31c\"] INSTRUCTION_FORMAT31c REGISTER STRING_LITERAL )
   12804 			{
   12805 				// smaliParser.g:1002:7: ^( I_STATEMENT_FORMAT31c[$start, \"I_STATEMENT_FORMAT31c\"] INSTRUCTION_FORMAT31c REGISTER STRING_LITERAL )
   12806 				{
   12807 				CommonTree root_1 = (CommonTree)adaptor.nil();
   12808 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT31c, (retval.start), "I_STATEMENT_FORMAT31c"), root_1);
   12809 				adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT31c.nextNode());
   12810 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   12811 				adaptor.addChild(root_1, stream_STRING_LITERAL.nextNode());
   12812 				adaptor.addChild(root_0, root_1);
   12813 				}
   12814 
   12815 			}
   12816 
   12817 
   12818 			retval.tree = root_0;
   12819 
   12820 			}
   12821 
   12822 			retval.stop = input.LT(-1);
   12823 
   12824 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   12825 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   12826 
   12827 		}
   12828 		catch (RecognitionException re) {
   12829 			reportError(re);
   12830 			recover(input,re);
   12831 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   12832 		}
   12833 		finally {
   12834 			// do for sure before leaving
   12835 		}
   12836 		return retval;
   12837 	}
   12838 	// $ANTLR end "insn_format31c"
   12839 
   12840 
   12841 	public static class insn_format31i_return extends ParserRuleReturnScope {
   12842 		CommonTree tree;
   12843 		@Override
   12844 		public CommonTree getTree() { return tree; }
   12845 	};
   12846 
   12847 
   12848 	// $ANTLR start "insn_format31i"
   12849 	// smaliParser.g:1004:1: insn_format31i : instruction_format31i REGISTER COMMA fixed_32bit_literal -> ^( I_STATEMENT_FORMAT31i[$start, \"I_STATEMENT_FORMAT31i\"] instruction_format31i REGISTER fixed_32bit_literal ) ;
   12850 	public final smaliParser.insn_format31i_return insn_format31i() throws RecognitionException {
   12851 		smaliParser.insn_format31i_return retval = new smaliParser.insn_format31i_return();
   12852 		retval.start = input.LT(1);
   12853 
   12854 		CommonTree root_0 = null;
   12855 
   12856 		Token REGISTER398=null;
   12857 		Token COMMA399=null;
   12858 		ParserRuleReturnScope instruction_format31i397 =null;
   12859 		ParserRuleReturnScope fixed_32bit_literal400 =null;
   12860 
   12861 		CommonTree REGISTER398_tree=null;
   12862 		CommonTree COMMA399_tree=null;
   12863 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   12864 		RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER");
   12865 		RewriteRuleSubtreeStream stream_fixed_32bit_literal=new RewriteRuleSubtreeStream(adaptor,"rule fixed_32bit_literal");
   12866 		RewriteRuleSubtreeStream stream_instruction_format31i=new RewriteRuleSubtreeStream(adaptor,"rule instruction_format31i");
   12867 
   12868 		try {
   12869 			// smaliParser.g:1005:3: ( instruction_format31i REGISTER COMMA fixed_32bit_literal -> ^( I_STATEMENT_FORMAT31i[$start, \"I_STATEMENT_FORMAT31i\"] instruction_format31i REGISTER fixed_32bit_literal ) )
   12870 			// smaliParser.g:1006:5: instruction_format31i REGISTER COMMA fixed_32bit_literal
   12871 			{
   12872 			pushFollow(FOLLOW_instruction_format31i_in_insn_format31i5056);
   12873 			instruction_format31i397=instruction_format31i();
   12874 			state._fsp--;
   12875 
   12876 			stream_instruction_format31i.add(instruction_format31i397.getTree());
   12877 			REGISTER398=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format31i5058);
   12878 			stream_REGISTER.add(REGISTER398);
   12879 
   12880 			COMMA399=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format31i5060);
   12881 			stream_COMMA.add(COMMA399);
   12882 
   12883 			pushFollow(FOLLOW_fixed_32bit_literal_in_insn_format31i5062);
   12884 			fixed_32bit_literal400=fixed_32bit_literal();
   12885 			state._fsp--;
   12886 
   12887 			stream_fixed_32bit_literal.add(fixed_32bit_literal400.getTree());
   12888 			// AST REWRITE
   12889 			// elements: instruction_format31i, REGISTER, fixed_32bit_literal
   12890 			// token labels:
   12891 			// rule labels: retval
   12892 			// token list labels:
   12893 			// rule list labels:
   12894 			// wildcard labels:
   12895 			retval.tree = root_0;
   12896 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   12897 
   12898 			root_0 = (CommonTree)adaptor.nil();
   12899 			// 1007:5: -> ^( I_STATEMENT_FORMAT31i[$start, \"I_STATEMENT_FORMAT31i\"] instruction_format31i REGISTER fixed_32bit_literal )
   12900 			{
   12901 				// smaliParser.g:1007:8: ^( I_STATEMENT_FORMAT31i[$start, \"I_STATEMENT_FORMAT31i\"] instruction_format31i REGISTER fixed_32bit_literal )
   12902 				{
   12903 				CommonTree root_1 = (CommonTree)adaptor.nil();
   12904 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT31i, (retval.start), "I_STATEMENT_FORMAT31i"), root_1);
   12905 				adaptor.addChild(root_1, stream_instruction_format31i.nextTree());
   12906 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   12907 				adaptor.addChild(root_1, stream_fixed_32bit_literal.nextTree());
   12908 				adaptor.addChild(root_0, root_1);
   12909 				}
   12910 
   12911 			}
   12912 
   12913 
   12914 			retval.tree = root_0;
   12915 
   12916 			}
   12917 
   12918 			retval.stop = input.LT(-1);
   12919 
   12920 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   12921 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   12922 
   12923 		}
   12924 		catch (RecognitionException re) {
   12925 			reportError(re);
   12926 			recover(input,re);
   12927 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   12928 		}
   12929 		finally {
   12930 			// do for sure before leaving
   12931 		}
   12932 		return retval;
   12933 	}
   12934 	// $ANTLR end "insn_format31i"
   12935 
   12936 
   12937 	public static class insn_format31t_return extends ParserRuleReturnScope {
   12938 		CommonTree tree;
   12939 		@Override
   12940 		public CommonTree getTree() { return tree; }
   12941 	};
   12942 
   12943 
   12944 	// $ANTLR start "insn_format31t"
   12945 	// smaliParser.g:1009:1: insn_format31t : INSTRUCTION_FORMAT31t REGISTER COMMA label_ref -> ^( I_STATEMENT_FORMAT31t[$start, \"I_STATEMENT_FORMAT31t\"] INSTRUCTION_FORMAT31t REGISTER label_ref ) ;
   12946 	public final smaliParser.insn_format31t_return insn_format31t() throws RecognitionException {
   12947 		smaliParser.insn_format31t_return retval = new smaliParser.insn_format31t_return();
   12948 		retval.start = input.LT(1);
   12949 
   12950 		CommonTree root_0 = null;
   12951 
   12952 		Token INSTRUCTION_FORMAT31t401=null;
   12953 		Token REGISTER402=null;
   12954 		Token COMMA403=null;
   12955 		ParserRuleReturnScope label_ref404 =null;
   12956 
   12957 		CommonTree INSTRUCTION_FORMAT31t401_tree=null;
   12958 		CommonTree REGISTER402_tree=null;
   12959 		CommonTree COMMA403_tree=null;
   12960 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   12961 		RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER");
   12962 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT31t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT31t");
   12963 		RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref");
   12964 
   12965 		try {
   12966 			// smaliParser.g:1010:3: ( INSTRUCTION_FORMAT31t REGISTER COMMA label_ref -> ^( I_STATEMENT_FORMAT31t[$start, \"I_STATEMENT_FORMAT31t\"] INSTRUCTION_FORMAT31t REGISTER label_ref ) )
   12967 			// smaliParser.g:1011:5: INSTRUCTION_FORMAT31t REGISTER COMMA label_ref
   12968 			{
   12969 			INSTRUCTION_FORMAT31t401=(Token)match(input,INSTRUCTION_FORMAT31t,FOLLOW_INSTRUCTION_FORMAT31t_in_insn_format31t5094);
   12970 			stream_INSTRUCTION_FORMAT31t.add(INSTRUCTION_FORMAT31t401);
   12971 
   12972 			REGISTER402=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format31t5096);
   12973 			stream_REGISTER.add(REGISTER402);
   12974 
   12975 			COMMA403=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format31t5098);
   12976 			stream_COMMA.add(COMMA403);
   12977 
   12978 			pushFollow(FOLLOW_label_ref_in_insn_format31t5100);
   12979 			label_ref404=label_ref();
   12980 			state._fsp--;
   12981 
   12982 			stream_label_ref.add(label_ref404.getTree());
   12983 			// AST REWRITE
   12984 			// elements: INSTRUCTION_FORMAT31t, REGISTER, label_ref
   12985 			// token labels:
   12986 			// rule labels: retval
   12987 			// token list labels:
   12988 			// rule list labels:
   12989 			// wildcard labels:
   12990 			retval.tree = root_0;
   12991 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   12992 
   12993 			root_0 = (CommonTree)adaptor.nil();
   12994 			// 1012:5: -> ^( I_STATEMENT_FORMAT31t[$start, \"I_STATEMENT_FORMAT31t\"] INSTRUCTION_FORMAT31t REGISTER label_ref )
   12995 			{
   12996 				// smaliParser.g:1012:8: ^( I_STATEMENT_FORMAT31t[$start, \"I_STATEMENT_FORMAT31t\"] INSTRUCTION_FORMAT31t REGISTER label_ref )
   12997 				{
   12998 				CommonTree root_1 = (CommonTree)adaptor.nil();
   12999 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT31t, (retval.start), "I_STATEMENT_FORMAT31t"), root_1);
   13000 				adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT31t.nextNode());
   13001 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   13002 				adaptor.addChild(root_1, stream_label_ref.nextTree());
   13003 				adaptor.addChild(root_0, root_1);
   13004 				}
   13005 
   13006 			}
   13007 
   13008 
   13009 			retval.tree = root_0;
   13010 
   13011 			}
   13012 
   13013 			retval.stop = input.LT(-1);
   13014 
   13015 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   13016 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   13017 
   13018 		}
   13019 		catch (RecognitionException re) {
   13020 			reportError(re);
   13021 			recover(input,re);
   13022 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   13023 		}
   13024 		finally {
   13025 			// do for sure before leaving
   13026 		}
   13027 		return retval;
   13028 	}
   13029 	// $ANTLR end "insn_format31t"
   13030 
   13031 
   13032 	public static class insn_format32x_return extends ParserRuleReturnScope {
   13033 		CommonTree tree;
   13034 		@Override
   13035 		public CommonTree getTree() { return tree; }
   13036 	};
   13037 
   13038 
   13039 	// $ANTLR start "insn_format32x"
   13040 	// smaliParser.g:1014:1: insn_format32x : INSTRUCTION_FORMAT32x REGISTER COMMA REGISTER -> ^( I_STATEMENT_FORMAT32x[$start, \"I_STATEMENT_FORMAT32x\"] INSTRUCTION_FORMAT32x REGISTER REGISTER ) ;
   13041 	public final smaliParser.insn_format32x_return insn_format32x() throws RecognitionException {
   13042 		smaliParser.insn_format32x_return retval = new smaliParser.insn_format32x_return();
   13043 		retval.start = input.LT(1);
   13044 
   13045 		CommonTree root_0 = null;
   13046 
   13047 		Token INSTRUCTION_FORMAT32x405=null;
   13048 		Token REGISTER406=null;
   13049 		Token COMMA407=null;
   13050 		Token REGISTER408=null;
   13051 
   13052 		CommonTree INSTRUCTION_FORMAT32x405_tree=null;
   13053 		CommonTree REGISTER406_tree=null;
   13054 		CommonTree COMMA407_tree=null;
   13055 		CommonTree REGISTER408_tree=null;
   13056 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   13057 		RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER");
   13058 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT32x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT32x");
   13059 
   13060 		try {
   13061 			// smaliParser.g:1015:3: ( INSTRUCTION_FORMAT32x REGISTER COMMA REGISTER -> ^( I_STATEMENT_FORMAT32x[$start, \"I_STATEMENT_FORMAT32x\"] INSTRUCTION_FORMAT32x REGISTER REGISTER ) )
   13062 			// smaliParser.g:1016:5: INSTRUCTION_FORMAT32x REGISTER COMMA REGISTER
   13063 			{
   13064 			INSTRUCTION_FORMAT32x405=(Token)match(input,INSTRUCTION_FORMAT32x,FOLLOW_INSTRUCTION_FORMAT32x_in_insn_format32x5132);
   13065 			stream_INSTRUCTION_FORMAT32x.add(INSTRUCTION_FORMAT32x405);
   13066 
   13067 			REGISTER406=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format32x5134);
   13068 			stream_REGISTER.add(REGISTER406);
   13069 
   13070 			COMMA407=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format32x5136);
   13071 			stream_COMMA.add(COMMA407);
   13072 
   13073 			REGISTER408=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format32x5138);
   13074 			stream_REGISTER.add(REGISTER408);
   13075 
   13076 			// AST REWRITE
   13077 			// elements: INSTRUCTION_FORMAT32x, REGISTER, REGISTER
   13078 			// token labels:
   13079 			// rule labels: retval
   13080 			// token list labels:
   13081 			// rule list labels:
   13082 			// wildcard labels:
   13083 			retval.tree = root_0;
   13084 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   13085 
   13086 			root_0 = (CommonTree)adaptor.nil();
   13087 			// 1017:5: -> ^( I_STATEMENT_FORMAT32x[$start, \"I_STATEMENT_FORMAT32x\"] INSTRUCTION_FORMAT32x REGISTER REGISTER )
   13088 			{
   13089 				// smaliParser.g:1017:8: ^( I_STATEMENT_FORMAT32x[$start, \"I_STATEMENT_FORMAT32x\"] INSTRUCTION_FORMAT32x REGISTER REGISTER )
   13090 				{
   13091 				CommonTree root_1 = (CommonTree)adaptor.nil();
   13092 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT32x, (retval.start), "I_STATEMENT_FORMAT32x"), root_1);
   13093 				adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT32x.nextNode());
   13094 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   13095 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   13096 				adaptor.addChild(root_0, root_1);
   13097 				}
   13098 
   13099 			}
   13100 
   13101 
   13102 			retval.tree = root_0;
   13103 
   13104 			}
   13105 
   13106 			retval.stop = input.LT(-1);
   13107 
   13108 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   13109 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   13110 
   13111 		}
   13112 		catch (RecognitionException re) {
   13113 			reportError(re);
   13114 			recover(input,re);
   13115 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   13116 		}
   13117 		finally {
   13118 			// do for sure before leaving
   13119 		}
   13120 		return retval;
   13121 	}
   13122 	// $ANTLR end "insn_format32x"
   13123 
   13124 
   13125 	public static class insn_format35c_method_return extends ParserRuleReturnScope {
   13126 		CommonTree tree;
   13127 		@Override
   13128 		public CommonTree getTree() { return tree; }
   13129 	};
   13130 
   13131 
   13132 	// $ANTLR start "insn_format35c_method"
   13133 	// smaliParser.g:1019:1: insn_format35c_method : INSTRUCTION_FORMAT35c_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference -> ^( I_STATEMENT_FORMAT35c_METHOD[$start, \"I_STATEMENT_FORMAT35c_METHOD\"] INSTRUCTION_FORMAT35c_METHOD register_list method_reference ) ;
   13134 	public final smaliParser.insn_format35c_method_return insn_format35c_method() throws RecognitionException {
   13135 		smaliParser.insn_format35c_method_return retval = new smaliParser.insn_format35c_method_return();
   13136 		retval.start = input.LT(1);
   13137 
   13138 		CommonTree root_0 = null;
   13139 
   13140 		Token INSTRUCTION_FORMAT35c_METHOD409=null;
   13141 		Token OPEN_BRACE410=null;
   13142 		Token CLOSE_BRACE412=null;
   13143 		Token COMMA413=null;
   13144 		ParserRuleReturnScope register_list411 =null;
   13145 		ParserRuleReturnScope method_reference414 =null;
   13146 
   13147 		CommonTree INSTRUCTION_FORMAT35c_METHOD409_tree=null;
   13148 		CommonTree OPEN_BRACE410_tree=null;
   13149 		CommonTree CLOSE_BRACE412_tree=null;
   13150 		CommonTree COMMA413_tree=null;
   13151 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT35c_METHOD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT35c_METHOD");
   13152 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   13153 		RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
   13154 		RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
   13155 		RewriteRuleSubtreeStream stream_method_reference=new RewriteRuleSubtreeStream(adaptor,"rule method_reference");
   13156 		RewriteRuleSubtreeStream stream_register_list=new RewriteRuleSubtreeStream(adaptor,"rule register_list");
   13157 
   13158 		try {
   13159 			// smaliParser.g:1020:3: ( INSTRUCTION_FORMAT35c_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference -> ^( I_STATEMENT_FORMAT35c_METHOD[$start, \"I_STATEMENT_FORMAT35c_METHOD\"] INSTRUCTION_FORMAT35c_METHOD register_list method_reference ) )
   13160 			// smaliParser.g:1021:5: INSTRUCTION_FORMAT35c_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference
   13161 			{
   13162 			INSTRUCTION_FORMAT35c_METHOD409=(Token)match(input,INSTRUCTION_FORMAT35c_METHOD,FOLLOW_INSTRUCTION_FORMAT35c_METHOD_in_insn_format35c_method5170);
   13163 			stream_INSTRUCTION_FORMAT35c_METHOD.add(INSTRUCTION_FORMAT35c_METHOD409);
   13164 
   13165 			OPEN_BRACE410=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format35c_method5172);
   13166 			stream_OPEN_BRACE.add(OPEN_BRACE410);
   13167 
   13168 			pushFollow(FOLLOW_register_list_in_insn_format35c_method5174);
   13169 			register_list411=register_list();
   13170 			state._fsp--;
   13171 
   13172 			stream_register_list.add(register_list411.getTree());
   13173 			CLOSE_BRACE412=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format35c_method5176);
   13174 			stream_CLOSE_BRACE.add(CLOSE_BRACE412);
   13175 
   13176 			COMMA413=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format35c_method5178);
   13177 			stream_COMMA.add(COMMA413);
   13178 
   13179 			pushFollow(FOLLOW_method_reference_in_insn_format35c_method5180);
   13180 			method_reference414=method_reference();
   13181 			state._fsp--;
   13182 
   13183 			stream_method_reference.add(method_reference414.getTree());
   13184 			// AST REWRITE
   13185 			// elements: INSTRUCTION_FORMAT35c_METHOD, register_list, method_reference
   13186 			// token labels:
   13187 			// rule labels: retval
   13188 			// token list labels:
   13189 			// rule list labels:
   13190 			// wildcard labels:
   13191 			retval.tree = root_0;
   13192 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   13193 
   13194 			root_0 = (CommonTree)adaptor.nil();
   13195 			// 1022:5: -> ^( I_STATEMENT_FORMAT35c_METHOD[$start, \"I_STATEMENT_FORMAT35c_METHOD\"] INSTRUCTION_FORMAT35c_METHOD register_list method_reference )
   13196 			{
   13197 				// smaliParser.g:1022:8: ^( I_STATEMENT_FORMAT35c_METHOD[$start, \"I_STATEMENT_FORMAT35c_METHOD\"] INSTRUCTION_FORMAT35c_METHOD register_list method_reference )
   13198 				{
   13199 				CommonTree root_1 = (CommonTree)adaptor.nil();
   13200 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT35c_METHOD, (retval.start), "I_STATEMENT_FORMAT35c_METHOD"), root_1);
   13201 				adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT35c_METHOD.nextNode());
   13202 				adaptor.addChild(root_1, stream_register_list.nextTree());
   13203 				adaptor.addChild(root_1, stream_method_reference.nextTree());
   13204 				adaptor.addChild(root_0, root_1);
   13205 				}
   13206 
   13207 			}
   13208 
   13209 
   13210 			retval.tree = root_0;
   13211 
   13212 			}
   13213 
   13214 			retval.stop = input.LT(-1);
   13215 
   13216 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   13217 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   13218 
   13219 		}
   13220 		catch (RecognitionException re) {
   13221 			reportError(re);
   13222 			recover(input,re);
   13223 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   13224 		}
   13225 		finally {
   13226 			// do for sure before leaving
   13227 		}
   13228 		return retval;
   13229 	}
   13230 	// $ANTLR end "insn_format35c_method"
   13231 
   13232 
   13233 	public static class insn_format35c_type_return extends ParserRuleReturnScope {
   13234 		CommonTree tree;
   13235 		@Override
   13236 		public CommonTree getTree() { return tree; }
   13237 	};
   13238 
   13239 
   13240 	// $ANTLR start "insn_format35c_type"
   13241 	// smaliParser.g:1024:1: insn_format35c_type : INSTRUCTION_FORMAT35c_TYPE OPEN_BRACE register_list CLOSE_BRACE COMMA nonvoid_type_descriptor -> ^( I_STATEMENT_FORMAT35c_TYPE[$start, \"I_STATEMENT_FORMAT35c_TYPE\"] INSTRUCTION_FORMAT35c_TYPE register_list nonvoid_type_descriptor ) ;
   13242 	public final smaliParser.insn_format35c_type_return insn_format35c_type() throws RecognitionException {
   13243 		smaliParser.insn_format35c_type_return retval = new smaliParser.insn_format35c_type_return();
   13244 		retval.start = input.LT(1);
   13245 
   13246 		CommonTree root_0 = null;
   13247 
   13248 		Token INSTRUCTION_FORMAT35c_TYPE415=null;
   13249 		Token OPEN_BRACE416=null;
   13250 		Token CLOSE_BRACE418=null;
   13251 		Token COMMA419=null;
   13252 		ParserRuleReturnScope register_list417 =null;
   13253 		ParserRuleReturnScope nonvoid_type_descriptor420 =null;
   13254 
   13255 		CommonTree INSTRUCTION_FORMAT35c_TYPE415_tree=null;
   13256 		CommonTree OPEN_BRACE416_tree=null;
   13257 		CommonTree CLOSE_BRACE418_tree=null;
   13258 		CommonTree COMMA419_tree=null;
   13259 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   13260 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT35c_TYPE=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT35c_TYPE");
   13261 		RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
   13262 		RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
   13263 		RewriteRuleSubtreeStream stream_register_list=new RewriteRuleSubtreeStream(adaptor,"rule register_list");
   13264 		RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor");
   13265 
   13266 		try {
   13267 			// smaliParser.g:1025:3: ( INSTRUCTION_FORMAT35c_TYPE OPEN_BRACE register_list CLOSE_BRACE COMMA nonvoid_type_descriptor -> ^( I_STATEMENT_FORMAT35c_TYPE[$start, \"I_STATEMENT_FORMAT35c_TYPE\"] INSTRUCTION_FORMAT35c_TYPE register_list nonvoid_type_descriptor ) )
   13268 			// smaliParser.g:1026:5: INSTRUCTION_FORMAT35c_TYPE OPEN_BRACE register_list CLOSE_BRACE COMMA nonvoid_type_descriptor
   13269 			{
   13270 			INSTRUCTION_FORMAT35c_TYPE415=(Token)match(input,INSTRUCTION_FORMAT35c_TYPE,FOLLOW_INSTRUCTION_FORMAT35c_TYPE_in_insn_format35c_type5212);
   13271 			stream_INSTRUCTION_FORMAT35c_TYPE.add(INSTRUCTION_FORMAT35c_TYPE415);
   13272 
   13273 			OPEN_BRACE416=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format35c_type5214);
   13274 			stream_OPEN_BRACE.add(OPEN_BRACE416);
   13275 
   13276 			pushFollow(FOLLOW_register_list_in_insn_format35c_type5216);
   13277 			register_list417=register_list();
   13278 			state._fsp--;
   13279 
   13280 			stream_register_list.add(register_list417.getTree());
   13281 			CLOSE_BRACE418=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format35c_type5218);
   13282 			stream_CLOSE_BRACE.add(CLOSE_BRACE418);
   13283 
   13284 			COMMA419=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format35c_type5220);
   13285 			stream_COMMA.add(COMMA419);
   13286 
   13287 			pushFollow(FOLLOW_nonvoid_type_descriptor_in_insn_format35c_type5222);
   13288 			nonvoid_type_descriptor420=nonvoid_type_descriptor();
   13289 			state._fsp--;
   13290 
   13291 			stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor420.getTree());
   13292 			// AST REWRITE
   13293 			// elements: register_list, INSTRUCTION_FORMAT35c_TYPE, nonvoid_type_descriptor
   13294 			// token labels:
   13295 			// rule labels: retval
   13296 			// token list labels:
   13297 			// rule list labels:
   13298 			// wildcard labels:
   13299 			retval.tree = root_0;
   13300 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   13301 
   13302 			root_0 = (CommonTree)adaptor.nil();
   13303 			// 1027:5: -> ^( I_STATEMENT_FORMAT35c_TYPE[$start, \"I_STATEMENT_FORMAT35c_TYPE\"] INSTRUCTION_FORMAT35c_TYPE register_list nonvoid_type_descriptor )
   13304 			{
   13305 				// smaliParser.g:1027:8: ^( I_STATEMENT_FORMAT35c_TYPE[$start, \"I_STATEMENT_FORMAT35c_TYPE\"] INSTRUCTION_FORMAT35c_TYPE register_list nonvoid_type_descriptor )
   13306 				{
   13307 				CommonTree root_1 = (CommonTree)adaptor.nil();
   13308 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT35c_TYPE, (retval.start), "I_STATEMENT_FORMAT35c_TYPE"), root_1);
   13309 				adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT35c_TYPE.nextNode());
   13310 				adaptor.addChild(root_1, stream_register_list.nextTree());
   13311 				adaptor.addChild(root_1, stream_nonvoid_type_descriptor.nextTree());
   13312 				adaptor.addChild(root_0, root_1);
   13313 				}
   13314 
   13315 			}
   13316 
   13317 
   13318 			retval.tree = root_0;
   13319 
   13320 			}
   13321 
   13322 			retval.stop = input.LT(-1);
   13323 
   13324 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   13325 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   13326 
   13327 		}
   13328 		catch (RecognitionException re) {
   13329 			reportError(re);
   13330 			recover(input,re);
   13331 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   13332 		}
   13333 		finally {
   13334 			// do for sure before leaving
   13335 		}
   13336 		return retval;
   13337 	}
   13338 	// $ANTLR end "insn_format35c_type"
   13339 
   13340 
   13341 	public static class insn_format35c_method_odex_return extends ParserRuleReturnScope {
   13342 		CommonTree tree;
   13343 		@Override
   13344 		public CommonTree getTree() { return tree; }
   13345 	};
   13346 
   13347 
   13348 	// $ANTLR start "insn_format35c_method_odex"
   13349 	// smaliParser.g:1029:1: insn_format35c_method_odex : INSTRUCTION_FORMAT35c_METHOD_ODEX OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference ;
   13350 	public final smaliParser.insn_format35c_method_odex_return insn_format35c_method_odex() throws RecognitionException {
   13351 		smaliParser.insn_format35c_method_odex_return retval = new smaliParser.insn_format35c_method_odex_return();
   13352 		retval.start = input.LT(1);
   13353 
   13354 		CommonTree root_0 = null;
   13355 
   13356 		Token INSTRUCTION_FORMAT35c_METHOD_ODEX421=null;
   13357 		Token OPEN_BRACE422=null;
   13358 		Token CLOSE_BRACE424=null;
   13359 		Token COMMA425=null;
   13360 		ParserRuleReturnScope register_list423 =null;
   13361 		ParserRuleReturnScope method_reference426 =null;
   13362 
   13363 		CommonTree INSTRUCTION_FORMAT35c_METHOD_ODEX421_tree=null;
   13364 		CommonTree OPEN_BRACE422_tree=null;
   13365 		CommonTree CLOSE_BRACE424_tree=null;
   13366 		CommonTree COMMA425_tree=null;
   13367 
   13368 		try {
   13369 			// smaliParser.g:1030:3: ( INSTRUCTION_FORMAT35c_METHOD_ODEX OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference )
   13370 			// smaliParser.g:1031:5: INSTRUCTION_FORMAT35c_METHOD_ODEX OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference
   13371 			{
   13372 			root_0 = (CommonTree)adaptor.nil();
   13373 
   13374 
   13375 			INSTRUCTION_FORMAT35c_METHOD_ODEX421=(Token)match(input,INSTRUCTION_FORMAT35c_METHOD_ODEX,FOLLOW_INSTRUCTION_FORMAT35c_METHOD_ODEX_in_insn_format35c_method_odex5254);
   13376 			INSTRUCTION_FORMAT35c_METHOD_ODEX421_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT35c_METHOD_ODEX421);
   13377 			adaptor.addChild(root_0, INSTRUCTION_FORMAT35c_METHOD_ODEX421_tree);
   13378 
   13379 			OPEN_BRACE422=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format35c_method_odex5256);
   13380 			OPEN_BRACE422_tree = (CommonTree)adaptor.create(OPEN_BRACE422);
   13381 			adaptor.addChild(root_0, OPEN_BRACE422_tree);
   13382 
   13383 			pushFollow(FOLLOW_register_list_in_insn_format35c_method_odex5258);
   13384 			register_list423=register_list();
   13385 			state._fsp--;
   13386 
   13387 			adaptor.addChild(root_0, register_list423.getTree());
   13388 
   13389 			CLOSE_BRACE424=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format35c_method_odex5260);
   13390 			CLOSE_BRACE424_tree = (CommonTree)adaptor.create(CLOSE_BRACE424);
   13391 			adaptor.addChild(root_0, CLOSE_BRACE424_tree);
   13392 
   13393 			COMMA425=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format35c_method_odex5262);
   13394 			COMMA425_tree = (CommonTree)adaptor.create(COMMA425);
   13395 			adaptor.addChild(root_0, COMMA425_tree);
   13396 
   13397 			pushFollow(FOLLOW_method_reference_in_insn_format35c_method_odex5264);
   13398 			method_reference426=method_reference();
   13399 			state._fsp--;
   13400 
   13401 			adaptor.addChild(root_0, method_reference426.getTree());
   13402 
   13403 
   13404 			      throwOdexedInstructionException(input, (INSTRUCTION_FORMAT35c_METHOD_ODEX421!=null?INSTRUCTION_FORMAT35c_METHOD_ODEX421.getText():null));
   13405 
   13406 			}
   13407 
   13408 			retval.stop = input.LT(-1);
   13409 
   13410 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   13411 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   13412 
   13413 		}
   13414 		catch (RecognitionException re) {
   13415 			reportError(re);
   13416 			recover(input,re);
   13417 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   13418 		}
   13419 		finally {
   13420 			// do for sure before leaving
   13421 		}
   13422 		return retval;
   13423 	}
   13424 	// $ANTLR end "insn_format35c_method_odex"
   13425 
   13426 
   13427 	public static class insn_format35mi_method_return extends ParserRuleReturnScope {
   13428 		CommonTree tree;
   13429 		@Override
   13430 		public CommonTree getTree() { return tree; }
   13431 	};
   13432 
   13433 
   13434 	// $ANTLR start "insn_format35mi_method"
   13435 	// smaliParser.g:1036:1: insn_format35mi_method : INSTRUCTION_FORMAT35mi_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA INLINE_INDEX ;
   13436 	public final smaliParser.insn_format35mi_method_return insn_format35mi_method() throws RecognitionException {
   13437 		smaliParser.insn_format35mi_method_return retval = new smaliParser.insn_format35mi_method_return();
   13438 		retval.start = input.LT(1);
   13439 
   13440 		CommonTree root_0 = null;
   13441 
   13442 		Token INSTRUCTION_FORMAT35mi_METHOD427=null;
   13443 		Token OPEN_BRACE428=null;
   13444 		Token CLOSE_BRACE430=null;
   13445 		Token COMMA431=null;
   13446 		Token INLINE_INDEX432=null;
   13447 		ParserRuleReturnScope register_list429 =null;
   13448 
   13449 		CommonTree INSTRUCTION_FORMAT35mi_METHOD427_tree=null;
   13450 		CommonTree OPEN_BRACE428_tree=null;
   13451 		CommonTree CLOSE_BRACE430_tree=null;
   13452 		CommonTree COMMA431_tree=null;
   13453 		CommonTree INLINE_INDEX432_tree=null;
   13454 
   13455 		try {
   13456 			// smaliParser.g:1037:3: ( INSTRUCTION_FORMAT35mi_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA INLINE_INDEX )
   13457 			// smaliParser.g:1038:5: INSTRUCTION_FORMAT35mi_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA INLINE_INDEX
   13458 			{
   13459 			root_0 = (CommonTree)adaptor.nil();
   13460 
   13461 
   13462 			INSTRUCTION_FORMAT35mi_METHOD427=(Token)match(input,INSTRUCTION_FORMAT35mi_METHOD,FOLLOW_INSTRUCTION_FORMAT35mi_METHOD_in_insn_format35mi_method5285);
   13463 			INSTRUCTION_FORMAT35mi_METHOD427_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT35mi_METHOD427);
   13464 			adaptor.addChild(root_0, INSTRUCTION_FORMAT35mi_METHOD427_tree);
   13465 
   13466 			OPEN_BRACE428=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format35mi_method5287);
   13467 			OPEN_BRACE428_tree = (CommonTree)adaptor.create(OPEN_BRACE428);
   13468 			adaptor.addChild(root_0, OPEN_BRACE428_tree);
   13469 
   13470 			pushFollow(FOLLOW_register_list_in_insn_format35mi_method5289);
   13471 			register_list429=register_list();
   13472 			state._fsp--;
   13473 
   13474 			adaptor.addChild(root_0, register_list429.getTree());
   13475 
   13476 			CLOSE_BRACE430=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format35mi_method5291);
   13477 			CLOSE_BRACE430_tree = (CommonTree)adaptor.create(CLOSE_BRACE430);
   13478 			adaptor.addChild(root_0, CLOSE_BRACE430_tree);
   13479 
   13480 			COMMA431=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format35mi_method5293);
   13481 			COMMA431_tree = (CommonTree)adaptor.create(COMMA431);
   13482 			adaptor.addChild(root_0, COMMA431_tree);
   13483 
   13484 			INLINE_INDEX432=(Token)match(input,INLINE_INDEX,FOLLOW_INLINE_INDEX_in_insn_format35mi_method5295);
   13485 			INLINE_INDEX432_tree = (CommonTree)adaptor.create(INLINE_INDEX432);
   13486 			adaptor.addChild(root_0, INLINE_INDEX432_tree);
   13487 
   13488 
   13489 			      throwOdexedInstructionException(input, (INSTRUCTION_FORMAT35mi_METHOD427!=null?INSTRUCTION_FORMAT35mi_METHOD427.getText():null));
   13490 
   13491 			}
   13492 
   13493 			retval.stop = input.LT(-1);
   13494 
   13495 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   13496 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   13497 
   13498 		}
   13499 		catch (RecognitionException re) {
   13500 			reportError(re);
   13501 			recover(input,re);
   13502 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   13503 		}
   13504 		finally {
   13505 			// do for sure before leaving
   13506 		}
   13507 		return retval;
   13508 	}
   13509 	// $ANTLR end "insn_format35mi_method"
   13510 
   13511 
   13512 	public static class insn_format35ms_method_return extends ParserRuleReturnScope {
   13513 		CommonTree tree;
   13514 		@Override
   13515 		public CommonTree getTree() { return tree; }
   13516 	};
   13517 
   13518 
   13519 	// $ANTLR start "insn_format35ms_method"
   13520 	// smaliParser.g:1043:1: insn_format35ms_method : INSTRUCTION_FORMAT35ms_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA VTABLE_INDEX ;
   13521 	public final smaliParser.insn_format35ms_method_return insn_format35ms_method() throws RecognitionException {
   13522 		smaliParser.insn_format35ms_method_return retval = new smaliParser.insn_format35ms_method_return();
   13523 		retval.start = input.LT(1);
   13524 
   13525 		CommonTree root_0 = null;
   13526 
   13527 		Token INSTRUCTION_FORMAT35ms_METHOD433=null;
   13528 		Token OPEN_BRACE434=null;
   13529 		Token CLOSE_BRACE436=null;
   13530 		Token COMMA437=null;
   13531 		Token VTABLE_INDEX438=null;
   13532 		ParserRuleReturnScope register_list435 =null;
   13533 
   13534 		CommonTree INSTRUCTION_FORMAT35ms_METHOD433_tree=null;
   13535 		CommonTree OPEN_BRACE434_tree=null;
   13536 		CommonTree CLOSE_BRACE436_tree=null;
   13537 		CommonTree COMMA437_tree=null;
   13538 		CommonTree VTABLE_INDEX438_tree=null;
   13539 
   13540 		try {
   13541 			// smaliParser.g:1044:3: ( INSTRUCTION_FORMAT35ms_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA VTABLE_INDEX )
   13542 			// smaliParser.g:1045:5: INSTRUCTION_FORMAT35ms_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA VTABLE_INDEX
   13543 			{
   13544 			root_0 = (CommonTree)adaptor.nil();
   13545 
   13546 
   13547 			INSTRUCTION_FORMAT35ms_METHOD433=(Token)match(input,INSTRUCTION_FORMAT35ms_METHOD,FOLLOW_INSTRUCTION_FORMAT35ms_METHOD_in_insn_format35ms_method5316);
   13548 			INSTRUCTION_FORMAT35ms_METHOD433_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT35ms_METHOD433);
   13549 			adaptor.addChild(root_0, INSTRUCTION_FORMAT35ms_METHOD433_tree);
   13550 
   13551 			OPEN_BRACE434=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format35ms_method5318);
   13552 			OPEN_BRACE434_tree = (CommonTree)adaptor.create(OPEN_BRACE434);
   13553 			adaptor.addChild(root_0, OPEN_BRACE434_tree);
   13554 
   13555 			pushFollow(FOLLOW_register_list_in_insn_format35ms_method5320);
   13556 			register_list435=register_list();
   13557 			state._fsp--;
   13558 
   13559 			adaptor.addChild(root_0, register_list435.getTree());
   13560 
   13561 			CLOSE_BRACE436=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format35ms_method5322);
   13562 			CLOSE_BRACE436_tree = (CommonTree)adaptor.create(CLOSE_BRACE436);
   13563 			adaptor.addChild(root_0, CLOSE_BRACE436_tree);
   13564 
   13565 			COMMA437=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format35ms_method5324);
   13566 			COMMA437_tree = (CommonTree)adaptor.create(COMMA437);
   13567 			adaptor.addChild(root_0, COMMA437_tree);
   13568 
   13569 			VTABLE_INDEX438=(Token)match(input,VTABLE_INDEX,FOLLOW_VTABLE_INDEX_in_insn_format35ms_method5326);
   13570 			VTABLE_INDEX438_tree = (CommonTree)adaptor.create(VTABLE_INDEX438);
   13571 			adaptor.addChild(root_0, VTABLE_INDEX438_tree);
   13572 
   13573 
   13574 			      throwOdexedInstructionException(input, (INSTRUCTION_FORMAT35ms_METHOD433!=null?INSTRUCTION_FORMAT35ms_METHOD433.getText():null));
   13575 
   13576 			}
   13577 
   13578 			retval.stop = input.LT(-1);
   13579 
   13580 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   13581 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   13582 
   13583 		}
   13584 		catch (RecognitionException re) {
   13585 			reportError(re);
   13586 			recover(input,re);
   13587 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   13588 		}
   13589 		finally {
   13590 			// do for sure before leaving
   13591 		}
   13592 		return retval;
   13593 	}
   13594 	// $ANTLR end "insn_format35ms_method"
   13595 
   13596 
   13597 	public static class insn_format3rc_method_return extends ParserRuleReturnScope {
   13598 		CommonTree tree;
   13599 		@Override
   13600 		public CommonTree getTree() { return tree; }
   13601 	};
   13602 
   13603 
   13604 	// $ANTLR start "insn_format3rc_method"
   13605 	// smaliParser.g:1050:1: insn_format3rc_method : INSTRUCTION_FORMAT3rc_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA method_reference -> ^( I_STATEMENT_FORMAT3rc_METHOD[$start, \"I_STATEMENT_FORMAT3rc_METHOD\"] INSTRUCTION_FORMAT3rc_METHOD register_range method_reference ) ;
   13606 	public final smaliParser.insn_format3rc_method_return insn_format3rc_method() throws RecognitionException {
   13607 		smaliParser.insn_format3rc_method_return retval = new smaliParser.insn_format3rc_method_return();
   13608 		retval.start = input.LT(1);
   13609 
   13610 		CommonTree root_0 = null;
   13611 
   13612 		Token INSTRUCTION_FORMAT3rc_METHOD439=null;
   13613 		Token OPEN_BRACE440=null;
   13614 		Token CLOSE_BRACE442=null;
   13615 		Token COMMA443=null;
   13616 		ParserRuleReturnScope register_range441 =null;
   13617 		ParserRuleReturnScope method_reference444 =null;
   13618 
   13619 		CommonTree INSTRUCTION_FORMAT3rc_METHOD439_tree=null;
   13620 		CommonTree OPEN_BRACE440_tree=null;
   13621 		CommonTree CLOSE_BRACE442_tree=null;
   13622 		CommonTree COMMA443_tree=null;
   13623 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   13624 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT3rc_METHOD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT3rc_METHOD");
   13625 		RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
   13626 		RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
   13627 		RewriteRuleSubtreeStream stream_method_reference=new RewriteRuleSubtreeStream(adaptor,"rule method_reference");
   13628 		RewriteRuleSubtreeStream stream_register_range=new RewriteRuleSubtreeStream(adaptor,"rule register_range");
   13629 
   13630 		try {
   13631 			// smaliParser.g:1051:3: ( INSTRUCTION_FORMAT3rc_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA method_reference -> ^( I_STATEMENT_FORMAT3rc_METHOD[$start, \"I_STATEMENT_FORMAT3rc_METHOD\"] INSTRUCTION_FORMAT3rc_METHOD register_range method_reference ) )
   13632 			// smaliParser.g:1052:5: INSTRUCTION_FORMAT3rc_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA method_reference
   13633 			{
   13634 			INSTRUCTION_FORMAT3rc_METHOD439=(Token)match(input,INSTRUCTION_FORMAT3rc_METHOD,FOLLOW_INSTRUCTION_FORMAT3rc_METHOD_in_insn_format3rc_method5347);
   13635 			stream_INSTRUCTION_FORMAT3rc_METHOD.add(INSTRUCTION_FORMAT3rc_METHOD439);
   13636 
   13637 			OPEN_BRACE440=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format3rc_method5349);
   13638 			stream_OPEN_BRACE.add(OPEN_BRACE440);
   13639 
   13640 			pushFollow(FOLLOW_register_range_in_insn_format3rc_method5351);
   13641 			register_range441=register_range();
   13642 			state._fsp--;
   13643 
   13644 			stream_register_range.add(register_range441.getTree());
   13645 			CLOSE_BRACE442=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format3rc_method5353);
   13646 			stream_CLOSE_BRACE.add(CLOSE_BRACE442);
   13647 
   13648 			COMMA443=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format3rc_method5355);
   13649 			stream_COMMA.add(COMMA443);
   13650 
   13651 			pushFollow(FOLLOW_method_reference_in_insn_format3rc_method5357);
   13652 			method_reference444=method_reference();
   13653 			state._fsp--;
   13654 
   13655 			stream_method_reference.add(method_reference444.getTree());
   13656 			// AST REWRITE
   13657 			// elements: register_range, INSTRUCTION_FORMAT3rc_METHOD, method_reference
   13658 			// token labels:
   13659 			// rule labels: retval
   13660 			// token list labels:
   13661 			// rule list labels:
   13662 			// wildcard labels:
   13663 			retval.tree = root_0;
   13664 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   13665 
   13666 			root_0 = (CommonTree)adaptor.nil();
   13667 			// 1053:5: -> ^( I_STATEMENT_FORMAT3rc_METHOD[$start, \"I_STATEMENT_FORMAT3rc_METHOD\"] INSTRUCTION_FORMAT3rc_METHOD register_range method_reference )
   13668 			{
   13669 				// smaliParser.g:1053:8: ^( I_STATEMENT_FORMAT3rc_METHOD[$start, \"I_STATEMENT_FORMAT3rc_METHOD\"] INSTRUCTION_FORMAT3rc_METHOD register_range method_reference )
   13670 				{
   13671 				CommonTree root_1 = (CommonTree)adaptor.nil();
   13672 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT3rc_METHOD, (retval.start), "I_STATEMENT_FORMAT3rc_METHOD"), root_1);
   13673 				adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT3rc_METHOD.nextNode());
   13674 				adaptor.addChild(root_1, stream_register_range.nextTree());
   13675 				adaptor.addChild(root_1, stream_method_reference.nextTree());
   13676 				adaptor.addChild(root_0, root_1);
   13677 				}
   13678 
   13679 			}
   13680 
   13681 
   13682 			retval.tree = root_0;
   13683 
   13684 			}
   13685 
   13686 			retval.stop = input.LT(-1);
   13687 
   13688 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   13689 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   13690 
   13691 		}
   13692 		catch (RecognitionException re) {
   13693 			reportError(re);
   13694 			recover(input,re);
   13695 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   13696 		}
   13697 		finally {
   13698 			// do for sure before leaving
   13699 		}
   13700 		return retval;
   13701 	}
   13702 	// $ANTLR end "insn_format3rc_method"
   13703 
   13704 
   13705 	public static class insn_format3rc_method_odex_return extends ParserRuleReturnScope {
   13706 		CommonTree tree;
   13707 		@Override
   13708 		public CommonTree getTree() { return tree; }
   13709 	};
   13710 
   13711 
   13712 	// $ANTLR start "insn_format3rc_method_odex"
   13713 	// smaliParser.g:1055:1: insn_format3rc_method_odex : INSTRUCTION_FORMAT3rc_METHOD_ODEX OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference ;
   13714 	public final smaliParser.insn_format3rc_method_odex_return insn_format3rc_method_odex() throws RecognitionException {
   13715 		smaliParser.insn_format3rc_method_odex_return retval = new smaliParser.insn_format3rc_method_odex_return();
   13716 		retval.start = input.LT(1);
   13717 
   13718 		CommonTree root_0 = null;
   13719 
   13720 		Token INSTRUCTION_FORMAT3rc_METHOD_ODEX445=null;
   13721 		Token OPEN_BRACE446=null;
   13722 		Token CLOSE_BRACE448=null;
   13723 		Token COMMA449=null;
   13724 		ParserRuleReturnScope register_list447 =null;
   13725 		ParserRuleReturnScope method_reference450 =null;
   13726 
   13727 		CommonTree INSTRUCTION_FORMAT3rc_METHOD_ODEX445_tree=null;
   13728 		CommonTree OPEN_BRACE446_tree=null;
   13729 		CommonTree CLOSE_BRACE448_tree=null;
   13730 		CommonTree COMMA449_tree=null;
   13731 
   13732 		try {
   13733 			// smaliParser.g:1056:3: ( INSTRUCTION_FORMAT3rc_METHOD_ODEX OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference )
   13734 			// smaliParser.g:1057:5: INSTRUCTION_FORMAT3rc_METHOD_ODEX OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference
   13735 			{
   13736 			root_0 = (CommonTree)adaptor.nil();
   13737 
   13738 
   13739 			INSTRUCTION_FORMAT3rc_METHOD_ODEX445=(Token)match(input,INSTRUCTION_FORMAT3rc_METHOD_ODEX,FOLLOW_INSTRUCTION_FORMAT3rc_METHOD_ODEX_in_insn_format3rc_method_odex5389);
   13740 			INSTRUCTION_FORMAT3rc_METHOD_ODEX445_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT3rc_METHOD_ODEX445);
   13741 			adaptor.addChild(root_0, INSTRUCTION_FORMAT3rc_METHOD_ODEX445_tree);
   13742 
   13743 			OPEN_BRACE446=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format3rc_method_odex5391);
   13744 			OPEN_BRACE446_tree = (CommonTree)adaptor.create(OPEN_BRACE446);
   13745 			adaptor.addChild(root_0, OPEN_BRACE446_tree);
   13746 
   13747 			pushFollow(FOLLOW_register_list_in_insn_format3rc_method_odex5393);
   13748 			register_list447=register_list();
   13749 			state._fsp--;
   13750 
   13751 			adaptor.addChild(root_0, register_list447.getTree());
   13752 
   13753 			CLOSE_BRACE448=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format3rc_method_odex5395);
   13754 			CLOSE_BRACE448_tree = (CommonTree)adaptor.create(CLOSE_BRACE448);
   13755 			adaptor.addChild(root_0, CLOSE_BRACE448_tree);
   13756 
   13757 			COMMA449=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format3rc_method_odex5397);
   13758 			COMMA449_tree = (CommonTree)adaptor.create(COMMA449);
   13759 			adaptor.addChild(root_0, COMMA449_tree);
   13760 
   13761 			pushFollow(FOLLOW_method_reference_in_insn_format3rc_method_odex5399);
   13762 			method_reference450=method_reference();
   13763 			state._fsp--;
   13764 
   13765 			adaptor.addChild(root_0, method_reference450.getTree());
   13766 
   13767 
   13768 			      throwOdexedInstructionException(input, (INSTRUCTION_FORMAT3rc_METHOD_ODEX445!=null?INSTRUCTION_FORMAT3rc_METHOD_ODEX445.getText():null));
   13769 
   13770 			}
   13771 
   13772 			retval.stop = input.LT(-1);
   13773 
   13774 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   13775 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   13776 
   13777 		}
   13778 		catch (RecognitionException re) {
   13779 			reportError(re);
   13780 			recover(input,re);
   13781 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   13782 		}
   13783 		finally {
   13784 			// do for sure before leaving
   13785 		}
   13786 		return retval;
   13787 	}
   13788 	// $ANTLR end "insn_format3rc_method_odex"
   13789 
   13790 
   13791 	public static class insn_format3rc_type_return extends ParserRuleReturnScope {
   13792 		CommonTree tree;
   13793 		@Override
   13794 		public CommonTree getTree() { return tree; }
   13795 	};
   13796 
   13797 
   13798 	// $ANTLR start "insn_format3rc_type"
   13799 	// smaliParser.g:1062:1: insn_format3rc_type : INSTRUCTION_FORMAT3rc_TYPE OPEN_BRACE register_range CLOSE_BRACE COMMA nonvoid_type_descriptor -> ^( I_STATEMENT_FORMAT3rc_TYPE[$start, \"I_STATEMENT_FORMAT3rc_TYPE\"] INSTRUCTION_FORMAT3rc_TYPE register_range nonvoid_type_descriptor ) ;
   13800 	public final smaliParser.insn_format3rc_type_return insn_format3rc_type() throws RecognitionException {
   13801 		smaliParser.insn_format3rc_type_return retval = new smaliParser.insn_format3rc_type_return();
   13802 		retval.start = input.LT(1);
   13803 
   13804 		CommonTree root_0 = null;
   13805 
   13806 		Token INSTRUCTION_FORMAT3rc_TYPE451=null;
   13807 		Token OPEN_BRACE452=null;
   13808 		Token CLOSE_BRACE454=null;
   13809 		Token COMMA455=null;
   13810 		ParserRuleReturnScope register_range453 =null;
   13811 		ParserRuleReturnScope nonvoid_type_descriptor456 =null;
   13812 
   13813 		CommonTree INSTRUCTION_FORMAT3rc_TYPE451_tree=null;
   13814 		CommonTree OPEN_BRACE452_tree=null;
   13815 		CommonTree CLOSE_BRACE454_tree=null;
   13816 		CommonTree COMMA455_tree=null;
   13817 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   13818 		RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
   13819 		RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
   13820 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT3rc_TYPE=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT3rc_TYPE");
   13821 		RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor");
   13822 		RewriteRuleSubtreeStream stream_register_range=new RewriteRuleSubtreeStream(adaptor,"rule register_range");
   13823 
   13824 		try {
   13825 			// smaliParser.g:1063:3: ( INSTRUCTION_FORMAT3rc_TYPE OPEN_BRACE register_range CLOSE_BRACE COMMA nonvoid_type_descriptor -> ^( I_STATEMENT_FORMAT3rc_TYPE[$start, \"I_STATEMENT_FORMAT3rc_TYPE\"] INSTRUCTION_FORMAT3rc_TYPE register_range nonvoid_type_descriptor ) )
   13826 			// smaliParser.g:1064:5: INSTRUCTION_FORMAT3rc_TYPE OPEN_BRACE register_range CLOSE_BRACE COMMA nonvoid_type_descriptor
   13827 			{
   13828 			INSTRUCTION_FORMAT3rc_TYPE451=(Token)match(input,INSTRUCTION_FORMAT3rc_TYPE,FOLLOW_INSTRUCTION_FORMAT3rc_TYPE_in_insn_format3rc_type5420);
   13829 			stream_INSTRUCTION_FORMAT3rc_TYPE.add(INSTRUCTION_FORMAT3rc_TYPE451);
   13830 
   13831 			OPEN_BRACE452=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format3rc_type5422);
   13832 			stream_OPEN_BRACE.add(OPEN_BRACE452);
   13833 
   13834 			pushFollow(FOLLOW_register_range_in_insn_format3rc_type5424);
   13835 			register_range453=register_range();
   13836 			state._fsp--;
   13837 
   13838 			stream_register_range.add(register_range453.getTree());
   13839 			CLOSE_BRACE454=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format3rc_type5426);
   13840 			stream_CLOSE_BRACE.add(CLOSE_BRACE454);
   13841 
   13842 			COMMA455=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format3rc_type5428);
   13843 			stream_COMMA.add(COMMA455);
   13844 
   13845 			pushFollow(FOLLOW_nonvoid_type_descriptor_in_insn_format3rc_type5430);
   13846 			nonvoid_type_descriptor456=nonvoid_type_descriptor();
   13847 			state._fsp--;
   13848 
   13849 			stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor456.getTree());
   13850 			// AST REWRITE
   13851 			// elements: nonvoid_type_descriptor, INSTRUCTION_FORMAT3rc_TYPE, register_range
   13852 			// token labels:
   13853 			// rule labels: retval
   13854 			// token list labels:
   13855 			// rule list labels:
   13856 			// wildcard labels:
   13857 			retval.tree = root_0;
   13858 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   13859 
   13860 			root_0 = (CommonTree)adaptor.nil();
   13861 			// 1065:5: -> ^( I_STATEMENT_FORMAT3rc_TYPE[$start, \"I_STATEMENT_FORMAT3rc_TYPE\"] INSTRUCTION_FORMAT3rc_TYPE register_range nonvoid_type_descriptor )
   13862 			{
   13863 				// smaliParser.g:1065:8: ^( I_STATEMENT_FORMAT3rc_TYPE[$start, \"I_STATEMENT_FORMAT3rc_TYPE\"] INSTRUCTION_FORMAT3rc_TYPE register_range nonvoid_type_descriptor )
   13864 				{
   13865 				CommonTree root_1 = (CommonTree)adaptor.nil();
   13866 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT3rc_TYPE, (retval.start), "I_STATEMENT_FORMAT3rc_TYPE"), root_1);
   13867 				adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT3rc_TYPE.nextNode());
   13868 				adaptor.addChild(root_1, stream_register_range.nextTree());
   13869 				adaptor.addChild(root_1, stream_nonvoid_type_descriptor.nextTree());
   13870 				adaptor.addChild(root_0, root_1);
   13871 				}
   13872 
   13873 			}
   13874 
   13875 
   13876 			retval.tree = root_0;
   13877 
   13878 			}
   13879 
   13880 			retval.stop = input.LT(-1);
   13881 
   13882 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   13883 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   13884 
   13885 		}
   13886 		catch (RecognitionException re) {
   13887 			reportError(re);
   13888 			recover(input,re);
   13889 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   13890 		}
   13891 		finally {
   13892 			// do for sure before leaving
   13893 		}
   13894 		return retval;
   13895 	}
   13896 	// $ANTLR end "insn_format3rc_type"
   13897 
   13898 
   13899 	public static class insn_format3rmi_method_return extends ParserRuleReturnScope {
   13900 		CommonTree tree;
   13901 		@Override
   13902 		public CommonTree getTree() { return tree; }
   13903 	};
   13904 
   13905 
   13906 	// $ANTLR start "insn_format3rmi_method"
   13907 	// smaliParser.g:1067:1: insn_format3rmi_method : INSTRUCTION_FORMAT3rmi_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA INLINE_INDEX ;
   13908 	public final smaliParser.insn_format3rmi_method_return insn_format3rmi_method() throws RecognitionException {
   13909 		smaliParser.insn_format3rmi_method_return retval = new smaliParser.insn_format3rmi_method_return();
   13910 		retval.start = input.LT(1);
   13911 
   13912 		CommonTree root_0 = null;
   13913 
   13914 		Token INSTRUCTION_FORMAT3rmi_METHOD457=null;
   13915 		Token OPEN_BRACE458=null;
   13916 		Token CLOSE_BRACE460=null;
   13917 		Token COMMA461=null;
   13918 		Token INLINE_INDEX462=null;
   13919 		ParserRuleReturnScope register_range459 =null;
   13920 
   13921 		CommonTree INSTRUCTION_FORMAT3rmi_METHOD457_tree=null;
   13922 		CommonTree OPEN_BRACE458_tree=null;
   13923 		CommonTree CLOSE_BRACE460_tree=null;
   13924 		CommonTree COMMA461_tree=null;
   13925 		CommonTree INLINE_INDEX462_tree=null;
   13926 
   13927 		try {
   13928 			// smaliParser.g:1068:3: ( INSTRUCTION_FORMAT3rmi_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA INLINE_INDEX )
   13929 			// smaliParser.g:1069:5: INSTRUCTION_FORMAT3rmi_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA INLINE_INDEX
   13930 			{
   13931 			root_0 = (CommonTree)adaptor.nil();
   13932 
   13933 
   13934 			INSTRUCTION_FORMAT3rmi_METHOD457=(Token)match(input,INSTRUCTION_FORMAT3rmi_METHOD,FOLLOW_INSTRUCTION_FORMAT3rmi_METHOD_in_insn_format3rmi_method5462);
   13935 			INSTRUCTION_FORMAT3rmi_METHOD457_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT3rmi_METHOD457);
   13936 			adaptor.addChild(root_0, INSTRUCTION_FORMAT3rmi_METHOD457_tree);
   13937 
   13938 			OPEN_BRACE458=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format3rmi_method5464);
   13939 			OPEN_BRACE458_tree = (CommonTree)adaptor.create(OPEN_BRACE458);
   13940 			adaptor.addChild(root_0, OPEN_BRACE458_tree);
   13941 
   13942 			pushFollow(FOLLOW_register_range_in_insn_format3rmi_method5466);
   13943 			register_range459=register_range();
   13944 			state._fsp--;
   13945 
   13946 			adaptor.addChild(root_0, register_range459.getTree());
   13947 
   13948 			CLOSE_BRACE460=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format3rmi_method5468);
   13949 			CLOSE_BRACE460_tree = (CommonTree)adaptor.create(CLOSE_BRACE460);
   13950 			adaptor.addChild(root_0, CLOSE_BRACE460_tree);
   13951 
   13952 			COMMA461=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format3rmi_method5470);
   13953 			COMMA461_tree = (CommonTree)adaptor.create(COMMA461);
   13954 			adaptor.addChild(root_0, COMMA461_tree);
   13955 
   13956 			INLINE_INDEX462=(Token)match(input,INLINE_INDEX,FOLLOW_INLINE_INDEX_in_insn_format3rmi_method5472);
   13957 			INLINE_INDEX462_tree = (CommonTree)adaptor.create(INLINE_INDEX462);
   13958 			adaptor.addChild(root_0, INLINE_INDEX462_tree);
   13959 
   13960 
   13961 			      throwOdexedInstructionException(input, (INSTRUCTION_FORMAT3rmi_METHOD457!=null?INSTRUCTION_FORMAT3rmi_METHOD457.getText():null));
   13962 
   13963 			}
   13964 
   13965 			retval.stop = input.LT(-1);
   13966 
   13967 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   13968 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   13969 
   13970 		}
   13971 		catch (RecognitionException re) {
   13972 			reportError(re);
   13973 			recover(input,re);
   13974 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   13975 		}
   13976 		finally {
   13977 			// do for sure before leaving
   13978 		}
   13979 		return retval;
   13980 	}
   13981 	// $ANTLR end "insn_format3rmi_method"
   13982 
   13983 
   13984 	public static class insn_format3rms_method_return extends ParserRuleReturnScope {
   13985 		CommonTree tree;
   13986 		@Override
   13987 		public CommonTree getTree() { return tree; }
   13988 	};
   13989 
   13990 
   13991 	// $ANTLR start "insn_format3rms_method"
   13992 	// smaliParser.g:1074:1: insn_format3rms_method : INSTRUCTION_FORMAT3rms_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA VTABLE_INDEX ;
   13993 	public final smaliParser.insn_format3rms_method_return insn_format3rms_method() throws RecognitionException {
   13994 		smaliParser.insn_format3rms_method_return retval = new smaliParser.insn_format3rms_method_return();
   13995 		retval.start = input.LT(1);
   13996 
   13997 		CommonTree root_0 = null;
   13998 
   13999 		Token INSTRUCTION_FORMAT3rms_METHOD463=null;
   14000 		Token OPEN_BRACE464=null;
   14001 		Token CLOSE_BRACE466=null;
   14002 		Token COMMA467=null;
   14003 		Token VTABLE_INDEX468=null;
   14004 		ParserRuleReturnScope register_range465 =null;
   14005 
   14006 		CommonTree INSTRUCTION_FORMAT3rms_METHOD463_tree=null;
   14007 		CommonTree OPEN_BRACE464_tree=null;
   14008 		CommonTree CLOSE_BRACE466_tree=null;
   14009 		CommonTree COMMA467_tree=null;
   14010 		CommonTree VTABLE_INDEX468_tree=null;
   14011 
   14012 		try {
   14013 			// smaliParser.g:1075:3: ( INSTRUCTION_FORMAT3rms_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA VTABLE_INDEX )
   14014 			// smaliParser.g:1076:5: INSTRUCTION_FORMAT3rms_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA VTABLE_INDEX
   14015 			{
   14016 			root_0 = (CommonTree)adaptor.nil();
   14017 
   14018 
   14019 			INSTRUCTION_FORMAT3rms_METHOD463=(Token)match(input,INSTRUCTION_FORMAT3rms_METHOD,FOLLOW_INSTRUCTION_FORMAT3rms_METHOD_in_insn_format3rms_method5493);
   14020 			INSTRUCTION_FORMAT3rms_METHOD463_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT3rms_METHOD463);
   14021 			adaptor.addChild(root_0, INSTRUCTION_FORMAT3rms_METHOD463_tree);
   14022 
   14023 			OPEN_BRACE464=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format3rms_method5495);
   14024 			OPEN_BRACE464_tree = (CommonTree)adaptor.create(OPEN_BRACE464);
   14025 			adaptor.addChild(root_0, OPEN_BRACE464_tree);
   14026 
   14027 			pushFollow(FOLLOW_register_range_in_insn_format3rms_method5497);
   14028 			register_range465=register_range();
   14029 			state._fsp--;
   14030 
   14031 			adaptor.addChild(root_0, register_range465.getTree());
   14032 
   14033 			CLOSE_BRACE466=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format3rms_method5499);
   14034 			CLOSE_BRACE466_tree = (CommonTree)adaptor.create(CLOSE_BRACE466);
   14035 			adaptor.addChild(root_0, CLOSE_BRACE466_tree);
   14036 
   14037 			COMMA467=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format3rms_method5501);
   14038 			COMMA467_tree = (CommonTree)adaptor.create(COMMA467);
   14039 			adaptor.addChild(root_0, COMMA467_tree);
   14040 
   14041 			VTABLE_INDEX468=(Token)match(input,VTABLE_INDEX,FOLLOW_VTABLE_INDEX_in_insn_format3rms_method5503);
   14042 			VTABLE_INDEX468_tree = (CommonTree)adaptor.create(VTABLE_INDEX468);
   14043 			adaptor.addChild(root_0, VTABLE_INDEX468_tree);
   14044 
   14045 
   14046 			      throwOdexedInstructionException(input, (INSTRUCTION_FORMAT3rms_METHOD463!=null?INSTRUCTION_FORMAT3rms_METHOD463.getText():null));
   14047 
   14048 			}
   14049 
   14050 			retval.stop = input.LT(-1);
   14051 
   14052 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   14053 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   14054 
   14055 		}
   14056 		catch (RecognitionException re) {
   14057 			reportError(re);
   14058 			recover(input,re);
   14059 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   14060 		}
   14061 		finally {
   14062 			// do for sure before leaving
   14063 		}
   14064 		return retval;
   14065 	}
   14066 	// $ANTLR end "insn_format3rms_method"
   14067 
   14068 
   14069 	public static class insn_format45cc_method_return extends ParserRuleReturnScope {
   14070 		CommonTree tree;
   14071 		@Override
   14072 		public CommonTree getTree() { return tree; }
   14073 	};
   14074 
   14075 
   14076 	// $ANTLR start "insn_format45cc_method"
   14077 	// smaliParser.g:1081:1: insn_format45cc_method : INSTRUCTION_FORMAT45cc_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference COMMA method_prototype -> ^( I_STATEMENT_FORMAT45cc_METHOD[$start, \"I_STATEMENT_FORMAT45cc_METHOD\"] INSTRUCTION_FORMAT45cc_METHOD register_list method_reference method_prototype ) ;
   14078 	public final smaliParser.insn_format45cc_method_return insn_format45cc_method() throws RecognitionException {
   14079 		smaliParser.insn_format45cc_method_return retval = new smaliParser.insn_format45cc_method_return();
   14080 		retval.start = input.LT(1);
   14081 
   14082 		CommonTree root_0 = null;
   14083 
   14084 		Token INSTRUCTION_FORMAT45cc_METHOD469=null;
   14085 		Token OPEN_BRACE470=null;
   14086 		Token CLOSE_BRACE472=null;
   14087 		Token COMMA473=null;
   14088 		Token COMMA475=null;
   14089 		ParserRuleReturnScope register_list471 =null;
   14090 		ParserRuleReturnScope method_reference474 =null;
   14091 		ParserRuleReturnScope method_prototype476 =null;
   14092 
   14093 		CommonTree INSTRUCTION_FORMAT45cc_METHOD469_tree=null;
   14094 		CommonTree OPEN_BRACE470_tree=null;
   14095 		CommonTree CLOSE_BRACE472_tree=null;
   14096 		CommonTree COMMA473_tree=null;
   14097 		CommonTree COMMA475_tree=null;
   14098 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   14099 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT45cc_METHOD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT45cc_METHOD");
   14100 		RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
   14101 		RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
   14102 		RewriteRuleSubtreeStream stream_method_reference=new RewriteRuleSubtreeStream(adaptor,"rule method_reference");
   14103 		RewriteRuleSubtreeStream stream_method_prototype=new RewriteRuleSubtreeStream(adaptor,"rule method_prototype");
   14104 		RewriteRuleSubtreeStream stream_register_list=new RewriteRuleSubtreeStream(adaptor,"rule register_list");
   14105 
   14106 		try {
   14107 			// smaliParser.g:1082:3: ( INSTRUCTION_FORMAT45cc_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference COMMA method_prototype -> ^( I_STATEMENT_FORMAT45cc_METHOD[$start, \"I_STATEMENT_FORMAT45cc_METHOD\"] INSTRUCTION_FORMAT45cc_METHOD register_list method_reference method_prototype ) )
   14108 			// smaliParser.g:1083:5: INSTRUCTION_FORMAT45cc_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference COMMA method_prototype
   14109 			{
   14110 			INSTRUCTION_FORMAT45cc_METHOD469=(Token)match(input,INSTRUCTION_FORMAT45cc_METHOD,FOLLOW_INSTRUCTION_FORMAT45cc_METHOD_in_insn_format45cc_method5524);
   14111 			stream_INSTRUCTION_FORMAT45cc_METHOD.add(INSTRUCTION_FORMAT45cc_METHOD469);
   14112 
   14113 			OPEN_BRACE470=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format45cc_method5526);
   14114 			stream_OPEN_BRACE.add(OPEN_BRACE470);
   14115 
   14116 			pushFollow(FOLLOW_register_list_in_insn_format45cc_method5528);
   14117 			register_list471=register_list();
   14118 			state._fsp--;
   14119 
   14120 			stream_register_list.add(register_list471.getTree());
   14121 			CLOSE_BRACE472=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format45cc_method5530);
   14122 			stream_CLOSE_BRACE.add(CLOSE_BRACE472);
   14123 
   14124 			COMMA473=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format45cc_method5532);
   14125 			stream_COMMA.add(COMMA473);
   14126 
   14127 			pushFollow(FOLLOW_method_reference_in_insn_format45cc_method5534);
   14128 			method_reference474=method_reference();
   14129 			state._fsp--;
   14130 
   14131 			stream_method_reference.add(method_reference474.getTree());
   14132 			COMMA475=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format45cc_method5536);
   14133 			stream_COMMA.add(COMMA475);
   14134 
   14135 			pushFollow(FOLLOW_method_prototype_in_insn_format45cc_method5538);
   14136 			method_prototype476=method_prototype();
   14137 			state._fsp--;
   14138 
   14139 			stream_method_prototype.add(method_prototype476.getTree());
   14140 			// AST REWRITE
   14141 			// elements: method_reference, method_prototype, INSTRUCTION_FORMAT45cc_METHOD, register_list
   14142 			// token labels:
   14143 			// rule labels: retval
   14144 			// token list labels:
   14145 			// rule list labels:
   14146 			// wildcard labels:
   14147 			retval.tree = root_0;
   14148 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   14149 
   14150 			root_0 = (CommonTree)adaptor.nil();
   14151 			// 1084:5: -> ^( I_STATEMENT_FORMAT45cc_METHOD[$start, \"I_STATEMENT_FORMAT45cc_METHOD\"] INSTRUCTION_FORMAT45cc_METHOD register_list method_reference method_prototype )
   14152 			{
   14153 				// smaliParser.g:1084:8: ^( I_STATEMENT_FORMAT45cc_METHOD[$start, \"I_STATEMENT_FORMAT45cc_METHOD\"] INSTRUCTION_FORMAT45cc_METHOD register_list method_reference method_prototype )
   14154 				{
   14155 				CommonTree root_1 = (CommonTree)adaptor.nil();
   14156 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT45cc_METHOD, (retval.start), "I_STATEMENT_FORMAT45cc_METHOD"), root_1);
   14157 				adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT45cc_METHOD.nextNode());
   14158 				adaptor.addChild(root_1, stream_register_list.nextTree());
   14159 				adaptor.addChild(root_1, stream_method_reference.nextTree());
   14160 				adaptor.addChild(root_1, stream_method_prototype.nextTree());
   14161 				adaptor.addChild(root_0, root_1);
   14162 				}
   14163 
   14164 			}
   14165 
   14166 
   14167 			retval.tree = root_0;
   14168 
   14169 			}
   14170 
   14171 			retval.stop = input.LT(-1);
   14172 
   14173 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   14174 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   14175 
   14176 		}
   14177 		catch (RecognitionException re) {
   14178 			reportError(re);
   14179 			recover(input,re);
   14180 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   14181 		}
   14182 		finally {
   14183 			// do for sure before leaving
   14184 		}
   14185 		return retval;
   14186 	}
   14187 	// $ANTLR end "insn_format45cc_method"
   14188 
   14189 
   14190 	public static class insn_format4rcc_method_return extends ParserRuleReturnScope {
   14191 		CommonTree tree;
   14192 		@Override
   14193 		public CommonTree getTree() { return tree; }
   14194 	};
   14195 
   14196 
   14197 	// $ANTLR start "insn_format4rcc_method"
   14198 	// smaliParser.g:1086:1: insn_format4rcc_method : INSTRUCTION_FORMAT4rcc_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA method_reference COMMA method_prototype -> ^( I_STATEMENT_FORMAT4rcc_METHOD[$start, \"I_STATEMENT_FORMAT4rcc_METHOD\"] INSTRUCTION_FORMAT4rcc_METHOD register_range method_reference method_prototype ) ;
   14199 	public final smaliParser.insn_format4rcc_method_return insn_format4rcc_method() throws RecognitionException {
   14200 		smaliParser.insn_format4rcc_method_return retval = new smaliParser.insn_format4rcc_method_return();
   14201 		retval.start = input.LT(1);
   14202 
   14203 		CommonTree root_0 = null;
   14204 
   14205 		Token INSTRUCTION_FORMAT4rcc_METHOD477=null;
   14206 		Token OPEN_BRACE478=null;
   14207 		Token CLOSE_BRACE480=null;
   14208 		Token COMMA481=null;
   14209 		Token COMMA483=null;
   14210 		ParserRuleReturnScope register_range479 =null;
   14211 		ParserRuleReturnScope method_reference482 =null;
   14212 		ParserRuleReturnScope method_prototype484 =null;
   14213 
   14214 		CommonTree INSTRUCTION_FORMAT4rcc_METHOD477_tree=null;
   14215 		CommonTree OPEN_BRACE478_tree=null;
   14216 		CommonTree CLOSE_BRACE480_tree=null;
   14217 		CommonTree COMMA481_tree=null;
   14218 		CommonTree COMMA483_tree=null;
   14219 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   14220 		RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
   14221 		RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
   14222 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT4rcc_METHOD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT4rcc_METHOD");
   14223 		RewriteRuleSubtreeStream stream_method_reference=new RewriteRuleSubtreeStream(adaptor,"rule method_reference");
   14224 		RewriteRuleSubtreeStream stream_method_prototype=new RewriteRuleSubtreeStream(adaptor,"rule method_prototype");
   14225 		RewriteRuleSubtreeStream stream_register_range=new RewriteRuleSubtreeStream(adaptor,"rule register_range");
   14226 
   14227 		try {
   14228 			// smaliParser.g:1087:3: ( INSTRUCTION_FORMAT4rcc_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA method_reference COMMA method_prototype -> ^( I_STATEMENT_FORMAT4rcc_METHOD[$start, \"I_STATEMENT_FORMAT4rcc_METHOD\"] INSTRUCTION_FORMAT4rcc_METHOD register_range method_reference method_prototype ) )
   14229 			// smaliParser.g:1088:5: INSTRUCTION_FORMAT4rcc_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA method_reference COMMA method_prototype
   14230 			{
   14231 			INSTRUCTION_FORMAT4rcc_METHOD477=(Token)match(input,INSTRUCTION_FORMAT4rcc_METHOD,FOLLOW_INSTRUCTION_FORMAT4rcc_METHOD_in_insn_format4rcc_method5572);
   14232 			stream_INSTRUCTION_FORMAT4rcc_METHOD.add(INSTRUCTION_FORMAT4rcc_METHOD477);
   14233 
   14234 			OPEN_BRACE478=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format4rcc_method5574);
   14235 			stream_OPEN_BRACE.add(OPEN_BRACE478);
   14236 
   14237 			pushFollow(FOLLOW_register_range_in_insn_format4rcc_method5576);
   14238 			register_range479=register_range();
   14239 			state._fsp--;
   14240 
   14241 			stream_register_range.add(register_range479.getTree());
   14242 			CLOSE_BRACE480=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format4rcc_method5578);
   14243 			stream_CLOSE_BRACE.add(CLOSE_BRACE480);
   14244 
   14245 			COMMA481=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format4rcc_method5580);
   14246 			stream_COMMA.add(COMMA481);
   14247 
   14248 			pushFollow(FOLLOW_method_reference_in_insn_format4rcc_method5582);
   14249 			method_reference482=method_reference();
   14250 			state._fsp--;
   14251 
   14252 			stream_method_reference.add(method_reference482.getTree());
   14253 			COMMA483=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format4rcc_method5584);
   14254 			stream_COMMA.add(COMMA483);
   14255 
   14256 			pushFollow(FOLLOW_method_prototype_in_insn_format4rcc_method5586);
   14257 			method_prototype484=method_prototype();
   14258 			state._fsp--;
   14259 
   14260 			stream_method_prototype.add(method_prototype484.getTree());
   14261 			// AST REWRITE
   14262 			// elements: register_range, INSTRUCTION_FORMAT4rcc_METHOD, method_reference, method_prototype
   14263 			// token labels:
   14264 			// rule labels: retval
   14265 			// token list labels:
   14266 			// rule list labels:
   14267 			// wildcard labels:
   14268 			retval.tree = root_0;
   14269 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   14270 
   14271 			root_0 = (CommonTree)adaptor.nil();
   14272 			// 1089:5: -> ^( I_STATEMENT_FORMAT4rcc_METHOD[$start, \"I_STATEMENT_FORMAT4rcc_METHOD\"] INSTRUCTION_FORMAT4rcc_METHOD register_range method_reference method_prototype )
   14273 			{
   14274 				// smaliParser.g:1089:8: ^( I_STATEMENT_FORMAT4rcc_METHOD[$start, \"I_STATEMENT_FORMAT4rcc_METHOD\"] INSTRUCTION_FORMAT4rcc_METHOD register_range method_reference method_prototype )
   14275 				{
   14276 				CommonTree root_1 = (CommonTree)adaptor.nil();
   14277 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT4rcc_METHOD, (retval.start), "I_STATEMENT_FORMAT4rcc_METHOD"), root_1);
   14278 				adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT4rcc_METHOD.nextNode());
   14279 				adaptor.addChild(root_1, stream_register_range.nextTree());
   14280 				adaptor.addChild(root_1, stream_method_reference.nextTree());
   14281 				adaptor.addChild(root_1, stream_method_prototype.nextTree());
   14282 				adaptor.addChild(root_0, root_1);
   14283 				}
   14284 
   14285 			}
   14286 
   14287 
   14288 			retval.tree = root_0;
   14289 
   14290 			}
   14291 
   14292 			retval.stop = input.LT(-1);
   14293 
   14294 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   14295 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   14296 
   14297 		}
   14298 		catch (RecognitionException re) {
   14299 			reportError(re);
   14300 			recover(input,re);
   14301 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   14302 		}
   14303 		finally {
   14304 			// do for sure before leaving
   14305 		}
   14306 		return retval;
   14307 	}
   14308 	// $ANTLR end "insn_format4rcc_method"
   14309 
   14310 
   14311 	public static class insn_format51l_return extends ParserRuleReturnScope {
   14312 		CommonTree tree;
   14313 		@Override
   14314 		public CommonTree getTree() { return tree; }
   14315 	};
   14316 
   14317 
   14318 	// $ANTLR start "insn_format51l"
   14319 	// smaliParser.g:1091:1: insn_format51l : INSTRUCTION_FORMAT51l REGISTER COMMA fixed_literal -> ^( I_STATEMENT_FORMAT51l[$start, \"I_STATEMENT_FORMAT51l\"] INSTRUCTION_FORMAT51l REGISTER fixed_literal ) ;
   14320 	public final smaliParser.insn_format51l_return insn_format51l() throws RecognitionException {
   14321 		smaliParser.insn_format51l_return retval = new smaliParser.insn_format51l_return();
   14322 		retval.start = input.LT(1);
   14323 
   14324 		CommonTree root_0 = null;
   14325 
   14326 		Token INSTRUCTION_FORMAT51l485=null;
   14327 		Token REGISTER486=null;
   14328 		Token COMMA487=null;
   14329 		ParserRuleReturnScope fixed_literal488 =null;
   14330 
   14331 		CommonTree INSTRUCTION_FORMAT51l485_tree=null;
   14332 		CommonTree REGISTER486_tree=null;
   14333 		CommonTree COMMA487_tree=null;
   14334 		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
   14335 		RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER");
   14336 		RewriteRuleTokenStream stream_INSTRUCTION_FORMAT51l=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT51l");
   14337 		RewriteRuleSubtreeStream stream_fixed_literal=new RewriteRuleSubtreeStream(adaptor,"rule fixed_literal");
   14338 
   14339 		try {
   14340 			// smaliParser.g:1092:3: ( INSTRUCTION_FORMAT51l REGISTER COMMA fixed_literal -> ^( I_STATEMENT_FORMAT51l[$start, \"I_STATEMENT_FORMAT51l\"] INSTRUCTION_FORMAT51l REGISTER fixed_literal ) )
   14341 			// smaliParser.g:1093:5: INSTRUCTION_FORMAT51l REGISTER COMMA fixed_literal
   14342 			{
   14343 			INSTRUCTION_FORMAT51l485=(Token)match(input,INSTRUCTION_FORMAT51l,FOLLOW_INSTRUCTION_FORMAT51l_in_insn_format51l5620);
   14344 			stream_INSTRUCTION_FORMAT51l.add(INSTRUCTION_FORMAT51l485);
   14345 
   14346 			REGISTER486=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format51l5622);
   14347 			stream_REGISTER.add(REGISTER486);
   14348 
   14349 			COMMA487=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format51l5624);
   14350 			stream_COMMA.add(COMMA487);
   14351 
   14352 			pushFollow(FOLLOW_fixed_literal_in_insn_format51l5626);
   14353 			fixed_literal488=fixed_literal();
   14354 			state._fsp--;
   14355 
   14356 			stream_fixed_literal.add(fixed_literal488.getTree());
   14357 			// AST REWRITE
   14358 			// elements: REGISTER, INSTRUCTION_FORMAT51l, fixed_literal
   14359 			// token labels:
   14360 			// rule labels: retval
   14361 			// token list labels:
   14362 			// rule list labels:
   14363 			// wildcard labels:
   14364 			retval.tree = root_0;
   14365 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   14366 
   14367 			root_0 = (CommonTree)adaptor.nil();
   14368 			// 1094:5: -> ^( I_STATEMENT_FORMAT51l[$start, \"I_STATEMENT_FORMAT51l\"] INSTRUCTION_FORMAT51l REGISTER fixed_literal )
   14369 			{
   14370 				// smaliParser.g:1094:8: ^( I_STATEMENT_FORMAT51l[$start, \"I_STATEMENT_FORMAT51l\"] INSTRUCTION_FORMAT51l REGISTER fixed_literal )
   14371 				{
   14372 				CommonTree root_1 = (CommonTree)adaptor.nil();
   14373 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT51l, (retval.start), "I_STATEMENT_FORMAT51l"), root_1);
   14374 				adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT51l.nextNode());
   14375 				adaptor.addChild(root_1, stream_REGISTER.nextNode());
   14376 				adaptor.addChild(root_1, stream_fixed_literal.nextTree());
   14377 				adaptor.addChild(root_0, root_1);
   14378 				}
   14379 
   14380 			}
   14381 
   14382 
   14383 			retval.tree = root_0;
   14384 
   14385 			}
   14386 
   14387 			retval.stop = input.LT(-1);
   14388 
   14389 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   14390 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   14391 
   14392 		}
   14393 		catch (RecognitionException re) {
   14394 			reportError(re);
   14395 			recover(input,re);
   14396 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   14397 		}
   14398 		finally {
   14399 			// do for sure before leaving
   14400 		}
   14401 		return retval;
   14402 	}
   14403 	// $ANTLR end "insn_format51l"
   14404 
   14405 
   14406 	public static class insn_array_data_directive_return extends ParserRuleReturnScope {
   14407 		CommonTree tree;
   14408 		@Override
   14409 		public CommonTree getTree() { return tree; }
   14410 	};
   14411 
   14412 
   14413 	// $ANTLR start "insn_array_data_directive"
   14414 	// smaliParser.g:1096:1: insn_array_data_directive : ARRAY_DATA_DIRECTIVE parsed_integer_literal ( fixed_literal )* END_ARRAY_DATA_DIRECTIVE -> ^( I_STATEMENT_ARRAY_DATA[$start, \"I_STATEMENT_ARRAY_DATA\"] ^( I_ARRAY_ELEMENT_SIZE parsed_integer_literal ) ^( I_ARRAY_ELEMENTS ( fixed_literal )* ) ) ;
   14415 	public final smaliParser.insn_array_data_directive_return insn_array_data_directive() throws RecognitionException {
   14416 		smaliParser.insn_array_data_directive_return retval = new smaliParser.insn_array_data_directive_return();
   14417 		retval.start = input.LT(1);
   14418 
   14419 		CommonTree root_0 = null;
   14420 
   14421 		Token ARRAY_DATA_DIRECTIVE489=null;
   14422 		Token END_ARRAY_DATA_DIRECTIVE492=null;
   14423 		ParserRuleReturnScope parsed_integer_literal490 =null;
   14424 		ParserRuleReturnScope fixed_literal491 =null;
   14425 
   14426 		CommonTree ARRAY_DATA_DIRECTIVE489_tree=null;
   14427 		CommonTree END_ARRAY_DATA_DIRECTIVE492_tree=null;
   14428 		RewriteRuleTokenStream stream_END_ARRAY_DATA_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_ARRAY_DATA_DIRECTIVE");
   14429 		RewriteRuleTokenStream stream_ARRAY_DATA_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token ARRAY_DATA_DIRECTIVE");
   14430 		RewriteRuleSubtreeStream stream_parsed_integer_literal=new RewriteRuleSubtreeStream(adaptor,"rule parsed_integer_literal");
   14431 		RewriteRuleSubtreeStream stream_fixed_literal=new RewriteRuleSubtreeStream(adaptor,"rule fixed_literal");
   14432 
   14433 		try {
   14434 			// smaliParser.g:1097:3: ( ARRAY_DATA_DIRECTIVE parsed_integer_literal ( fixed_literal )* END_ARRAY_DATA_DIRECTIVE -> ^( I_STATEMENT_ARRAY_DATA[$start, \"I_STATEMENT_ARRAY_DATA\"] ^( I_ARRAY_ELEMENT_SIZE parsed_integer_literal ) ^( I_ARRAY_ELEMENTS ( fixed_literal )* ) ) )
   14435 			// smaliParser.g:1097:5: ARRAY_DATA_DIRECTIVE parsed_integer_literal ( fixed_literal )* END_ARRAY_DATA_DIRECTIVE
   14436 			{
   14437 			ARRAY_DATA_DIRECTIVE489=(Token)match(input,ARRAY_DATA_DIRECTIVE,FOLLOW_ARRAY_DATA_DIRECTIVE_in_insn_array_data_directive5653);
   14438 			stream_ARRAY_DATA_DIRECTIVE.add(ARRAY_DATA_DIRECTIVE489);
   14439 
   14440 			pushFollow(FOLLOW_parsed_integer_literal_in_insn_array_data_directive5659);
   14441 			parsed_integer_literal490=parsed_integer_literal();
   14442 			state._fsp--;
   14443 
   14444 			stream_parsed_integer_literal.add(parsed_integer_literal490.getTree());
   14445 
   14446 			        int elementWidth = (parsed_integer_literal490!=null?((smaliParser.parsed_integer_literal_return)parsed_integer_literal490).value:0);
   14447 			        if (elementWidth != 4 && elementWidth != 8 && elementWidth != 1 && elementWidth != 2) {
   14448 			            throw new SemanticException(input, (retval.start), "Invalid element width: %d. Must be 1, 2, 4 or 8", elementWidth);
   14449 			        }
   14450 
   14451 			// smaliParser.g:1105:5: ( fixed_literal )*
   14452 			loop52:
   14453 			while (true) {
   14454 				int alt52=2;
   14455 				int LA52_0 = input.LA(1);
   14456 				if ( ((LA52_0 >= BOOL_LITERAL && LA52_0 <= BYTE_LITERAL)||LA52_0==CHAR_LITERAL||(LA52_0 >= DOUBLE_LITERAL && LA52_0 <= DOUBLE_LITERAL_OR_ID)||(LA52_0 >= FLOAT_LITERAL && LA52_0 <= FLOAT_LITERAL_OR_ID)||LA52_0==LONG_LITERAL||LA52_0==NEGATIVE_INTEGER_LITERAL||LA52_0==POSITIVE_INTEGER_LITERAL||LA52_0==SHORT_LITERAL) ) {
   14457 					alt52=1;
   14458 				}
   14459 
   14460 				switch (alt52) {
   14461 				case 1 :
   14462 					// smaliParser.g:1105:5: fixed_literal
   14463 					{
   14464 					pushFollow(FOLLOW_fixed_literal_in_insn_array_data_directive5671);
   14465 					fixed_literal491=fixed_literal();
   14466 					state._fsp--;
   14467 
   14468 					stream_fixed_literal.add(fixed_literal491.getTree());
   14469 					}
   14470 					break;
   14471 
   14472 				default :
   14473 					break loop52;
   14474 				}
   14475 			}
   14476 
   14477 			END_ARRAY_DATA_DIRECTIVE492=(Token)match(input,END_ARRAY_DATA_DIRECTIVE,FOLLOW_END_ARRAY_DATA_DIRECTIVE_in_insn_array_data_directive5674);
   14478 			stream_END_ARRAY_DATA_DIRECTIVE.add(END_ARRAY_DATA_DIRECTIVE492);
   14479 
   14480 			// AST REWRITE
   14481 			// elements: parsed_integer_literal, fixed_literal
   14482 			// token labels:
   14483 			// rule labels: retval
   14484 			// token list labels:
   14485 			// rule list labels:
   14486 			// wildcard labels:
   14487 			retval.tree = root_0;
   14488 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   14489 
   14490 			root_0 = (CommonTree)adaptor.nil();
   14491 			// 1107:5: -> ^( I_STATEMENT_ARRAY_DATA[$start, \"I_STATEMENT_ARRAY_DATA\"] ^( I_ARRAY_ELEMENT_SIZE parsed_integer_literal ) ^( I_ARRAY_ELEMENTS ( fixed_literal )* ) )
   14492 			{
   14493 				// smaliParser.g:1107:8: ^( I_STATEMENT_ARRAY_DATA[$start, \"I_STATEMENT_ARRAY_DATA\"] ^( I_ARRAY_ELEMENT_SIZE parsed_integer_literal ) ^( I_ARRAY_ELEMENTS ( fixed_literal )* ) )
   14494 				{
   14495 				CommonTree root_1 = (CommonTree)adaptor.nil();
   14496 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_ARRAY_DATA, (retval.start), "I_STATEMENT_ARRAY_DATA"), root_1);
   14497 				// smaliParser.g:1107:67: ^( I_ARRAY_ELEMENT_SIZE parsed_integer_literal )
   14498 				{
   14499 				CommonTree root_2 = (CommonTree)adaptor.nil();
   14500 				root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ARRAY_ELEMENT_SIZE, "I_ARRAY_ELEMENT_SIZE"), root_2);
   14501 				adaptor.addChild(root_2, stream_parsed_integer_literal.nextTree());
   14502 				adaptor.addChild(root_1, root_2);
   14503 				}
   14504 
   14505 				// smaliParser.g:1108:8: ^( I_ARRAY_ELEMENTS ( fixed_literal )* )
   14506 				{
   14507 				CommonTree root_2 = (CommonTree)adaptor.nil();
   14508 				root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ARRAY_ELEMENTS, "I_ARRAY_ELEMENTS"), root_2);
   14509 				// smaliParser.g:1108:27: ( fixed_literal )*
   14510 				while ( stream_fixed_literal.hasNext() ) {
   14511 					adaptor.addChild(root_2, stream_fixed_literal.nextTree());
   14512 				}
   14513 				stream_fixed_literal.reset();
   14514 
   14515 				adaptor.addChild(root_1, root_2);
   14516 				}
   14517 
   14518 				adaptor.addChild(root_0, root_1);
   14519 				}
   14520 
   14521 			}
   14522 
   14523 
   14524 			retval.tree = root_0;
   14525 
   14526 			}
   14527 
   14528 			retval.stop = input.LT(-1);
   14529 
   14530 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   14531 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   14532 
   14533 		}
   14534 		catch (RecognitionException re) {
   14535 			reportError(re);
   14536 			recover(input,re);
   14537 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   14538 		}
   14539 		finally {
   14540 			// do for sure before leaving
   14541 		}
   14542 		return retval;
   14543 	}
   14544 	// $ANTLR end "insn_array_data_directive"
   14545 
   14546 
   14547 	public static class insn_packed_switch_directive_return extends ParserRuleReturnScope {
   14548 		CommonTree tree;
   14549 		@Override
   14550 		public CommonTree getTree() { return tree; }
   14551 	};
   14552 
   14553 
   14554 	// $ANTLR start "insn_packed_switch_directive"
   14555 	// smaliParser.g:1110:1: insn_packed_switch_directive : PACKED_SWITCH_DIRECTIVE fixed_32bit_literal ( label_ref )* END_PACKED_SWITCH_DIRECTIVE -> ^( I_STATEMENT_PACKED_SWITCH[$start, \"I_STATEMENT_PACKED_SWITCH\"] ^( I_PACKED_SWITCH_START_KEY[$start, \"I_PACKED_SWITCH_START_KEY\"] fixed_32bit_literal ) ^( I_PACKED_SWITCH_ELEMENTS[$start, \"I_PACKED_SWITCH_ELEMENTS\"] ( label_ref )* ) ) ;
   14556 	public final smaliParser.insn_packed_switch_directive_return insn_packed_switch_directive() throws RecognitionException {
   14557 		smaliParser.insn_packed_switch_directive_return retval = new smaliParser.insn_packed_switch_directive_return();
   14558 		retval.start = input.LT(1);
   14559 
   14560 		CommonTree root_0 = null;
   14561 
   14562 		Token PACKED_SWITCH_DIRECTIVE493=null;
   14563 		Token END_PACKED_SWITCH_DIRECTIVE496=null;
   14564 		ParserRuleReturnScope fixed_32bit_literal494 =null;
   14565 		ParserRuleReturnScope label_ref495 =null;
   14566 
   14567 		CommonTree PACKED_SWITCH_DIRECTIVE493_tree=null;
   14568 		CommonTree END_PACKED_SWITCH_DIRECTIVE496_tree=null;
   14569 		RewriteRuleTokenStream stream_END_PACKED_SWITCH_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_PACKED_SWITCH_DIRECTIVE");
   14570 		RewriteRuleTokenStream stream_PACKED_SWITCH_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token PACKED_SWITCH_DIRECTIVE");
   14571 		RewriteRuleSubtreeStream stream_fixed_32bit_literal=new RewriteRuleSubtreeStream(adaptor,"rule fixed_32bit_literal");
   14572 		RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref");
   14573 
   14574 		try {
   14575 			// smaliParser.g:1111:5: ( PACKED_SWITCH_DIRECTIVE fixed_32bit_literal ( label_ref )* END_PACKED_SWITCH_DIRECTIVE -> ^( I_STATEMENT_PACKED_SWITCH[$start, \"I_STATEMENT_PACKED_SWITCH\"] ^( I_PACKED_SWITCH_START_KEY[$start, \"I_PACKED_SWITCH_START_KEY\"] fixed_32bit_literal ) ^( I_PACKED_SWITCH_ELEMENTS[$start, \"I_PACKED_SWITCH_ELEMENTS\"] ( label_ref )* ) ) )
   14576 			// smaliParser.g:1111:9: PACKED_SWITCH_DIRECTIVE fixed_32bit_literal ( label_ref )* END_PACKED_SWITCH_DIRECTIVE
   14577 			{
   14578 			PACKED_SWITCH_DIRECTIVE493=(Token)match(input,PACKED_SWITCH_DIRECTIVE,FOLLOW_PACKED_SWITCH_DIRECTIVE_in_insn_packed_switch_directive5720);
   14579 			stream_PACKED_SWITCH_DIRECTIVE.add(PACKED_SWITCH_DIRECTIVE493);
   14580 
   14581 			pushFollow(FOLLOW_fixed_32bit_literal_in_insn_packed_switch_directive5726);
   14582 			fixed_32bit_literal494=fixed_32bit_literal();
   14583 			state._fsp--;
   14584 
   14585 			stream_fixed_32bit_literal.add(fixed_32bit_literal494.getTree());
   14586 			// smaliParser.g:1113:5: ( label_ref )*
   14587 			loop53:
   14588 			while (true) {
   14589 				int alt53=2;
   14590 				int LA53_0 = input.LA(1);
   14591 				if ( (LA53_0==COLON) ) {
   14592 					alt53=1;
   14593 				}
   14594 
   14595 				switch (alt53) {
   14596 				case 1 :
   14597 					// smaliParser.g:1113:5: label_ref
   14598 					{
   14599 					pushFollow(FOLLOW_label_ref_in_insn_packed_switch_directive5732);
   14600 					label_ref495=label_ref();
   14601 					state._fsp--;
   14602 
   14603 					stream_label_ref.add(label_ref495.getTree());
   14604 					}
   14605 					break;
   14606 
   14607 				default :
   14608 					break loop53;
   14609 				}
   14610 			}
   14611 
   14612 			END_PACKED_SWITCH_DIRECTIVE496=(Token)match(input,END_PACKED_SWITCH_DIRECTIVE,FOLLOW_END_PACKED_SWITCH_DIRECTIVE_in_insn_packed_switch_directive5739);
   14613 			stream_END_PACKED_SWITCH_DIRECTIVE.add(END_PACKED_SWITCH_DIRECTIVE496);
   14614 
   14615 			// AST REWRITE
   14616 			// elements: fixed_32bit_literal, label_ref
   14617 			// token labels:
   14618 			// rule labels: retval
   14619 			// token list labels:
   14620 			// rule list labels:
   14621 			// wildcard labels:
   14622 			retval.tree = root_0;
   14623 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   14624 
   14625 			root_0 = (CommonTree)adaptor.nil();
   14626 			// 1115:5: -> ^( I_STATEMENT_PACKED_SWITCH[$start, \"I_STATEMENT_PACKED_SWITCH\"] ^( I_PACKED_SWITCH_START_KEY[$start, \"I_PACKED_SWITCH_START_KEY\"] fixed_32bit_literal ) ^( I_PACKED_SWITCH_ELEMENTS[$start, \"I_PACKED_SWITCH_ELEMENTS\"] ( label_ref )* ) )
   14627 			{
   14628 				// smaliParser.g:1115:8: ^( I_STATEMENT_PACKED_SWITCH[$start, \"I_STATEMENT_PACKED_SWITCH\"] ^( I_PACKED_SWITCH_START_KEY[$start, \"I_PACKED_SWITCH_START_KEY\"] fixed_32bit_literal ) ^( I_PACKED_SWITCH_ELEMENTS[$start, \"I_PACKED_SWITCH_ELEMENTS\"] ( label_ref )* ) )
   14629 				{
   14630 				CommonTree root_1 = (CommonTree)adaptor.nil();
   14631 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_PACKED_SWITCH, (retval.start), "I_STATEMENT_PACKED_SWITCH"), root_1);
   14632 				// smaliParser.g:1116:10: ^( I_PACKED_SWITCH_START_KEY[$start, \"I_PACKED_SWITCH_START_KEY\"] fixed_32bit_literal )
   14633 				{
   14634 				CommonTree root_2 = (CommonTree)adaptor.nil();
   14635 				root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_PACKED_SWITCH_START_KEY, (retval.start), "I_PACKED_SWITCH_START_KEY"), root_2);
   14636 				adaptor.addChild(root_2, stream_fixed_32bit_literal.nextTree());
   14637 				adaptor.addChild(root_1, root_2);
   14638 				}
   14639 
   14640 				// smaliParser.g:1117:10: ^( I_PACKED_SWITCH_ELEMENTS[$start, \"I_PACKED_SWITCH_ELEMENTS\"] ( label_ref )* )
   14641 				{
   14642 				CommonTree root_2 = (CommonTree)adaptor.nil();
   14643 				root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_PACKED_SWITCH_ELEMENTS, (retval.start), "I_PACKED_SWITCH_ELEMENTS"), root_2);
   14644 				// smaliParser.g:1118:11: ( label_ref )*
   14645 				while ( stream_label_ref.hasNext() ) {
   14646 					adaptor.addChild(root_2, stream_label_ref.nextTree());
   14647 				}
   14648 				stream_label_ref.reset();
   14649 
   14650 				adaptor.addChild(root_1, root_2);
   14651 				}
   14652 
   14653 				adaptor.addChild(root_0, root_1);
   14654 				}
   14655 
   14656 			}
   14657 
   14658 
   14659 			retval.tree = root_0;
   14660 
   14661 			}
   14662 
   14663 			retval.stop = input.LT(-1);
   14664 
   14665 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   14666 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   14667 
   14668 		}
   14669 		catch (RecognitionException re) {
   14670 			reportError(re);
   14671 			recover(input,re);
   14672 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   14673 		}
   14674 		finally {
   14675 			// do for sure before leaving
   14676 		}
   14677 		return retval;
   14678 	}
   14679 	// $ANTLR end "insn_packed_switch_directive"
   14680 
   14681 
   14682 	public static class insn_sparse_switch_directive_return extends ParserRuleReturnScope {
   14683 		CommonTree tree;
   14684 		@Override
   14685 		public CommonTree getTree() { return tree; }
   14686 	};
   14687 
   14688 
   14689 	// $ANTLR start "insn_sparse_switch_directive"
   14690 	// smaliParser.g:1121:1: insn_sparse_switch_directive : SPARSE_SWITCH_DIRECTIVE ( fixed_32bit_literal ARROW label_ref )* END_SPARSE_SWITCH_DIRECTIVE -> ^( I_STATEMENT_SPARSE_SWITCH[$start, \"I_STATEMENT_SPARSE_SWITCH\"] ^( I_SPARSE_SWITCH_ELEMENTS[$start, \"I_SPARSE_SWITCH_ELEMENTS\"] ( fixed_32bit_literal label_ref )* ) ) ;
   14691 	public final smaliParser.insn_sparse_switch_directive_return insn_sparse_switch_directive() throws RecognitionException {
   14692 		smaliParser.insn_sparse_switch_directive_return retval = new smaliParser.insn_sparse_switch_directive_return();
   14693 		retval.start = input.LT(1);
   14694 
   14695 		CommonTree root_0 = null;
   14696 
   14697 		Token SPARSE_SWITCH_DIRECTIVE497=null;
   14698 		Token ARROW499=null;
   14699 		Token END_SPARSE_SWITCH_DIRECTIVE501=null;
   14700 		ParserRuleReturnScope fixed_32bit_literal498 =null;
   14701 		ParserRuleReturnScope label_ref500 =null;
   14702 
   14703 		CommonTree SPARSE_SWITCH_DIRECTIVE497_tree=null;
   14704 		CommonTree ARROW499_tree=null;
   14705 		CommonTree END_SPARSE_SWITCH_DIRECTIVE501_tree=null;
   14706 		RewriteRuleTokenStream stream_ARROW=new RewriteRuleTokenStream(adaptor,"token ARROW");
   14707 		RewriteRuleTokenStream stream_SPARSE_SWITCH_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token SPARSE_SWITCH_DIRECTIVE");
   14708 		RewriteRuleTokenStream stream_END_SPARSE_SWITCH_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_SPARSE_SWITCH_DIRECTIVE");
   14709 		RewriteRuleSubtreeStream stream_fixed_32bit_literal=new RewriteRuleSubtreeStream(adaptor,"rule fixed_32bit_literal");
   14710 		RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref");
   14711 
   14712 		try {
   14713 			// smaliParser.g:1122:3: ( SPARSE_SWITCH_DIRECTIVE ( fixed_32bit_literal ARROW label_ref )* END_SPARSE_SWITCH_DIRECTIVE -> ^( I_STATEMENT_SPARSE_SWITCH[$start, \"I_STATEMENT_SPARSE_SWITCH\"] ^( I_SPARSE_SWITCH_ELEMENTS[$start, \"I_SPARSE_SWITCH_ELEMENTS\"] ( fixed_32bit_literal label_ref )* ) ) )
   14714 			// smaliParser.g:1122:7: SPARSE_SWITCH_DIRECTIVE ( fixed_32bit_literal ARROW label_ref )* END_SPARSE_SWITCH_DIRECTIVE
   14715 			{
   14716 			SPARSE_SWITCH_DIRECTIVE497=(Token)match(input,SPARSE_SWITCH_DIRECTIVE,FOLLOW_SPARSE_SWITCH_DIRECTIVE_in_insn_sparse_switch_directive5813);
   14717 			stream_SPARSE_SWITCH_DIRECTIVE.add(SPARSE_SWITCH_DIRECTIVE497);
   14718 
   14719 			// smaliParser.g:1123:5: ( fixed_32bit_literal ARROW label_ref )*
   14720 			loop54:
   14721 			while (true) {
   14722 				int alt54=2;
   14723 				int LA54_0 = input.LA(1);
   14724 				if ( ((LA54_0 >= BOOL_LITERAL && LA54_0 <= BYTE_LITERAL)||LA54_0==CHAR_LITERAL||(LA54_0 >= FLOAT_LITERAL && LA54_0 <= FLOAT_LITERAL_OR_ID)||LA54_0==LONG_LITERAL||LA54_0==NEGATIVE_INTEGER_LITERAL||LA54_0==POSITIVE_INTEGER_LITERAL||LA54_0==SHORT_LITERAL) ) {
   14725 					alt54=1;
   14726 				}
   14727 
   14728 				switch (alt54) {
   14729 				case 1 :
   14730 					// smaliParser.g:1123:6: fixed_32bit_literal ARROW label_ref
   14731 					{
   14732 					pushFollow(FOLLOW_fixed_32bit_literal_in_insn_sparse_switch_directive5820);
   14733 					fixed_32bit_literal498=fixed_32bit_literal();
   14734 					state._fsp--;
   14735 
   14736 					stream_fixed_32bit_literal.add(fixed_32bit_literal498.getTree());
   14737 					ARROW499=(Token)match(input,ARROW,FOLLOW_ARROW_in_insn_sparse_switch_directive5822);
   14738 					stream_ARROW.add(ARROW499);
   14739 
   14740 					pushFollow(FOLLOW_label_ref_in_insn_sparse_switch_directive5824);
   14741 					label_ref500=label_ref();
   14742 					state._fsp--;
   14743 
   14744 					stream_label_ref.add(label_ref500.getTree());
   14745 					}
   14746 					break;
   14747 
   14748 				default :
   14749 					break loop54;
   14750 				}
   14751 			}
   14752 
   14753 			END_SPARSE_SWITCH_DIRECTIVE501=(Token)match(input,END_SPARSE_SWITCH_DIRECTIVE,FOLLOW_END_SPARSE_SWITCH_DIRECTIVE_in_insn_sparse_switch_directive5832);
   14754 			stream_END_SPARSE_SWITCH_DIRECTIVE.add(END_SPARSE_SWITCH_DIRECTIVE501);
   14755 
   14756 			// AST REWRITE
   14757 			// elements: fixed_32bit_literal, label_ref
   14758 			// token labels:
   14759 			// rule labels: retval
   14760 			// token list labels:
   14761 			// rule list labels:
   14762 			// wildcard labels:
   14763 			retval.tree = root_0;
   14764 			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
   14765 
   14766 			root_0 = (CommonTree)adaptor.nil();
   14767 			// 1125:5: -> ^( I_STATEMENT_SPARSE_SWITCH[$start, \"I_STATEMENT_SPARSE_SWITCH\"] ^( I_SPARSE_SWITCH_ELEMENTS[$start, \"I_SPARSE_SWITCH_ELEMENTS\"] ( fixed_32bit_literal label_ref )* ) )
   14768 			{
   14769 				// smaliParser.g:1125:8: ^( I_STATEMENT_SPARSE_SWITCH[$start, \"I_STATEMENT_SPARSE_SWITCH\"] ^( I_SPARSE_SWITCH_ELEMENTS[$start, \"I_SPARSE_SWITCH_ELEMENTS\"] ( fixed_32bit_literal label_ref )* ) )
   14770 				{
   14771 				CommonTree root_1 = (CommonTree)adaptor.nil();
   14772 				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_SPARSE_SWITCH, (retval.start), "I_STATEMENT_SPARSE_SWITCH"), root_1);
   14773 				// smaliParser.g:1126:8: ^( I_SPARSE_SWITCH_ELEMENTS[$start, \"I_SPARSE_SWITCH_ELEMENTS\"] ( fixed_32bit_literal label_ref )* )
   14774 				{
   14775 				CommonTree root_2 = (CommonTree)adaptor.nil();
   14776 				root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_SPARSE_SWITCH_ELEMENTS, (retval.start), "I_SPARSE_SWITCH_ELEMENTS"), root_2);
   14777 				// smaliParser.g:1126:71: ( fixed_32bit_literal label_ref )*
   14778 				while ( stream_fixed_32bit_literal.hasNext()||stream_label_ref.hasNext() ) {
   14779 					adaptor.addChild(root_2, stream_fixed_32bit_literal.nextTree());
   14780 					adaptor.addChild(root_2, stream_label_ref.nextTree());
   14781 				}
   14782 				stream_fixed_32bit_literal.reset();
   14783 				stream_label_ref.reset();
   14784 
   14785 				adaptor.addChild(root_1, root_2);
   14786 				}
   14787 
   14788 				adaptor.addChild(root_0, root_1);
   14789 				}
   14790 
   14791 			}
   14792 
   14793 
   14794 			retval.tree = root_0;
   14795 
   14796 			}
   14797 
   14798 			retval.stop = input.LT(-1);
   14799 
   14800 			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
   14801 			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   14802 
   14803 		}
   14804 		catch (RecognitionException re) {
   14805 			reportError(re);
   14806 			recover(input,re);
   14807 			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   14808 		}
   14809 		finally {
   14810 			// do for sure before leaving
   14811 		}
   14812 		return retval;
   14813 	}
   14814 	// $ANTLR end "insn_sparse_switch_directive"
   14815 
   14816 	// Delegated rules
   14817 
   14818 
   14819 	protected DFA30 dfa30 = new DFA30(this);
   14820 	protected DFA38 dfa38 = new DFA38(this);
   14821 	protected DFA40 dfa40 = new DFA40(this);
   14822 	static final String DFA30_eotS =
   14823 		"\55\uffff";
   14824 	static final String DFA30_eofS =
   14825 		"\55\uffff";
   14826 	static final String DFA30_minS =
   14827 		"\1\4\52\23\2\uffff";
   14828 	static final String DFA30_maxS =
   14829 		"\1\u00c6\12\u00b4\1\u00b7\37\u00b4\2\uffff";
   14830 	static final String DFA30_acceptS =
   14831 		"\53\uffff\1\1\1\2";
   14832 	static final String DFA30_specialS =
   14833 		"\55\uffff}>";
   14834 	static final String[] DFA30_transitionS = {
   14835 			"\1\2\1\uffff\1\16\3\uffff\1\10\14\uffff\1\7\17\uffff\1\6\2\uffff\1\17"+
   14836 			"\1\20\1\21\1\uffff\1\22\1\uffff\1\23\2\uffff\1\24\1\25\1\26\1\27\3\uffff"+
   14837 			"\1\30\1\uffff\1\31\1\32\1\33\1\34\1\uffff\1\35\1\36\1\uffff\1\37\3\uffff"+
   14838 			"\1\40\1\41\1\uffff\1\42\1\43\1\44\1\45\1\46\5\uffff\1\47\1\50\1\51\127"+
   14839 			"\uffff\1\52\1\uffff\1\5\1\11\4\uffff\1\13\1\4\1\14\1\uffff\1\12\3\uffff"+
   14840 			"\1\1\5\uffff\1\3\1\15",
   14841 			"\1\53\u00a0\uffff\1\54",
   14842 			"\1\53\u00a0\uffff\1\54",
   14843 			"\1\53\u00a0\uffff\1\54",
   14844 			"\1\53\u00a0\uffff\1\54",
   14845 			"\1\53\u00a0\uffff\1\54",
   14846 			"\1\53\u00a0\uffff\1\54",
   14847 			"\1\53\u00a0\uffff\1\54",
   14848 			"\1\53\u00a0\uffff\1\54",
   14849 			"\1\53\u00a0\uffff\1\54",
   14850 			"\1\53\u00a0\uffff\1\54",
   14851 			"\1\53\u00a0\uffff\1\54\2\uffff\1\13",
   14852 			"\1\53\u00a0\uffff\1\54",
   14853 			"\1\53\u00a0\uffff\1\54",
   14854 			"\1\53\u00a0\uffff\1\54",
   14855 			"\1\53\u00a0\uffff\1\54",
   14856 			"\1\53\u00a0\uffff\1\54",
   14857 			"\1\53\u00a0\uffff\1\54",
   14858 			"\1\53\u00a0\uffff\1\54",
   14859 			"\1\53\u00a0\uffff\1\54",
   14860 			"\1\53\u00a0\uffff\1\54",
   14861 			"\1\53\u00a0\uffff\1\54",
   14862 			"\1\53\u00a0\uffff\1\54",
   14863 			"\1\53\u00a0\uffff\1\54",
   14864 			"\1\53\u00a0\uffff\1\54",
   14865 			"\1\53\u00a0\uffff\1\54",
   14866 			"\1\53\u00a0\uffff\1\54",
   14867 			"\1\53\u00a0\uffff\1\54",
   14868 			"\1\53\u00a0\uffff\1\54",
   14869 			"\1\53\u00a0\uffff\1\54",
   14870 			"\1\53\u00a0\uffff\1\54",
   14871 			"\1\53\u00a0\uffff\1\54",
   14872 			"\1\53\u00a0\uffff\1\54",
   14873 			"\1\53\u00a0\uffff\1\54",
   14874 			"\1\53\u00a0\uffff\1\54",
   14875 			"\1\53\u00a0\uffff\1\54",
   14876 			"\1\53\u00a0\uffff\1\54",
   14877 			"\1\53\u00a0\uffff\1\54",
   14878 			"\1\53\u00a0\uffff\1\54",
   14879 			"\1\53\u00a0\uffff\1\54",
   14880 			"\1\53\u00a0\uffff\1\54",
   14881 			"\1\53\u00a0\uffff\1\54",
   14882 			"\1\53\u00a0\uffff\1\54",
   14883 			"",
   14884 			""
   14885 	};
   14886 
   14887 	static final short[] DFA30_eot = DFA.unpackEncodedString(DFA30_eotS);
   14888 	static final short[] DFA30_eof = DFA.unpackEncodedString(DFA30_eofS);
   14889 	static final char[] DFA30_min = DFA.unpackEncodedStringToUnsignedChars(DFA30_minS);
   14890 	static final char[] DFA30_max = DFA.unpackEncodedStringToUnsignedChars(DFA30_maxS);
   14891 	static final short[] DFA30_accept = DFA.unpackEncodedString(DFA30_acceptS);
   14892 	static final short[] DFA30_special = DFA.unpackEncodedString(DFA30_specialS);
   14893 	static final short[][] DFA30_transition;
   14894 
   14895 	static {
   14896 		int numStates = DFA30_transitionS.length;
   14897 		DFA30_transition = new short[numStates][];
   14898 		for (int i=0; i<numStates; i++) {
   14899 			DFA30_transition[i] = DFA.unpackEncodedString(DFA30_transitionS[i]);
   14900 		}
   14901 	}
   14902 
   14903 	protected class DFA30 extends DFA {
   14904 
   14905 		public DFA30(BaseRecognizer recognizer) {
   14906 			this.recognizer = recognizer;
   14907 			this.decisionNumber = 30;
   14908 			this.eot = DFA30_eot;
   14909 			this.eof = DFA30_eof;
   14910 			this.min = DFA30_min;
   14911 			this.max = DFA30_max;
   14912 			this.accept = DFA30_accept;
   14913 			this.special = DFA30_special;
   14914 			this.transition = DFA30_transition;
   14915 		}
   14916 		@Override
   14917 		public String getDescription() {
   14918 			return "695:7: ( member_name COLON nonvoid_type_descriptor -> ^( I_ENCODED_FIELD ( reference_type_descriptor )? member_name nonvoid_type_descriptor ) | member_name method_prototype -> ^( I_ENCODED_METHOD ( reference_type_descriptor )? member_name method_prototype ) )";
   14919 		}
   14920 	}
   14921 
   14922 	static final String DFA38_eotS =
   14923 		"\62\uffff";
   14924 	static final String DFA38_eofS =
   14925 		"\62\uffff";
   14926 	static final String DFA38_minS =
   14927 		"\1\4\1\5\1\17\52\23\1\uffff\1\4\1\11\2\uffff";
   14928 	static final String DFA38_maxS =
   14929 		"\1\u00c6\1\u00c1\1\u00b9\12\u00b4\1\u00b7\37\u00b4\1\uffff\1\u00c6\1\11"+
   14930 		"\2\uffff";
   14931 	static final String DFA38_acceptS =
   14932 		"\55\uffff\1\1\2\uffff\1\2\1\3";
   14933 	static final String DFA38_specialS =
   14934 		"\62\uffff}>";
   14935 	static final String[] DFA38_transitionS = {
   14936 			"\1\4\1\uffff\1\20\1\uffff\1\2\1\uffff\1\12\4\uffff\1\1\7\uffff\1\11\17"+
   14937 			"\uffff\1\10\2\uffff\1\21\1\22\1\23\1\uffff\1\24\1\uffff\1\25\2\uffff"+
   14938 			"\1\26\1\27\1\30\1\31\3\uffff\1\32\1\uffff\1\33\1\34\1\35\1\36\1\uffff"+
   14939 			"\1\37\1\40\1\uffff\1\41\3\uffff\1\42\1\43\1\uffff\1\44\1\45\1\46\1\47"+
   14940 			"\1\50\5\uffff\1\51\1\52\1\53\127\uffff\1\54\1\uffff\1\7\1\13\4\uffff"+
   14941 			"\1\15\1\6\1\16\1\uffff\1\14\3\uffff\1\3\5\uffff\1\5\1\17",
   14942 			"\1\55\1\uffff\1\55\1\uffff\1\56\2\uffff\2\55\5\uffff\1\55\7\uffff\2"+
   14943 			"\55\5\uffff\1\55\7\uffff\56\55\123\uffff\3\55\7\uffff\2\55\3\uffff\1"+
   14944 			"\55\1\uffff\2\55\2\uffff\2\55",
   14945 			"\1\57\u00a9\uffff\1\57",
   14946 			"\1\60\u00a0\uffff\1\61",
   14947 			"\1\60\u00a0\uffff\1\61",
   14948 			"\1\60\u00a0\uffff\1\61",
   14949 			"\1\60\u00a0\uffff\1\61",
   14950 			"\1\60\u00a0\uffff\1\61",
   14951 			"\1\60\u00a0\uffff\1\61",
   14952 			"\1\60\u00a0\uffff\1\61",
   14953 			"\1\60\u00a0\uffff\1\61",
   14954 			"\1\60\u00a0\uffff\1\61",
   14955 			"\1\60\u00a0\uffff\1\61",
   14956 			"\1\60\u00a0\uffff\1\61\2\uffff\1\15",
   14957 			"\1\60\u00a0\uffff\1\61",
   14958 			"\1\60\u00a0\uffff\1\61",
   14959 			"\1\60\u00a0\uffff\1\61",
   14960 			"\1\60\u00a0\uffff\1\61",
   14961 			"\1\60\u00a0\uffff\1\61",
   14962 			"\1\60\u00a0\uffff\1\61",
   14963 			"\1\60\u00a0\uffff\1\61",
   14964 			"\1\60\u00a0\uffff\1\61",
   14965 			"\1\60\u00a0\uffff\1\61",
   14966 			"\1\60\u00a0\uffff\1\61",
   14967 			"\1\60\u00a0\uffff\1\61",
   14968 			"\1\60\u00a0\uffff\1\61",
   14969 			"\1\60\u00a0\uffff\1\61",
   14970 			"\1\60\u00a0\uffff\1\61",
   14971 			"\1\60\u00a0\uffff\1\61",
   14972 			"\1\60\u00a0\uffff\1\61",
   14973 			"\1\60\u00a0\uffff\1\61",
   14974 			"\1\60\u00a0\uffff\1\61",
   14975 			"\1\60\u00a0\uffff\1\61",
   14976 			"\1\60\u00a0\uffff\1\61",
   14977 			"\1\60\u00a0\uffff\1\61",
   14978 			"\1\60\u00a0\uffff\1\61",
   14979 			"\1\60\u00a0\uffff\1\61",
   14980 			"\1\60\u00a0\uffff\1\61",
   14981 			"\1\60\u00a0\uffff\1\61",
   14982 			"\1\60\u00a0\uffff\1\61",
   14983 			"\1\60\u00a0\uffff\1\61",
   14984 			"\1\60\u00a0\uffff\1\61",
   14985 			"\1\60\u00a0\uffff\1\61",
   14986 			"\1\60\u00a0\uffff\1\61",
   14987 			"\1\60\u00a0\uffff\1\61",
   14988 			"",
   14989 			"\1\4\1\uffff\1\20\3\uffff\1\12\14\uffff\1\11\17\uffff\1\10\2\uffff\1"+
   14990 			"\21\1\22\1\23\1\uffff\1\24\1\uffff\1\25\2\uffff\1\26\1\27\1\30\1\31\3"+
   14991 			"\uffff\1\32\1\uffff\1\33\1\34\1\35\1\36\1\uffff\1\37\1\40\1\uffff\1\41"+
   14992 			"\3\uffff\1\42\1\43\1\uffff\1\44\1\45\1\46\1\47\1\50\5\uffff\1\51\1\52"+
   14993 			"\1\53\127\uffff\1\54\1\uffff\1\7\1\13\4\uffff\1\15\1\6\1\16\1\uffff\1"+
   14994 			"\14\3\uffff\1\3\5\uffff\1\5\1\17",
   14995 			"\1\56",
   14996 			"",
   14997 			""
   14998 	};
   14999 
   15000 	static final short[] DFA38_eot = DFA.unpackEncodedString(DFA38_eotS);
   15001 	static final short[] DFA38_eof = DFA.unpackEncodedString(DFA38_eofS);
   15002 	static final char[] DFA38_min = DFA.unpackEncodedStringToUnsignedChars(DFA38_minS);
   15003 	static final char[] DFA38_max = DFA.unpackEncodedStringToUnsignedChars(DFA38_maxS);
   15004 	static final short[] DFA38_accept = DFA.unpackEncodedString(DFA38_acceptS);
   15005 	static final short[] DFA38_special = DFA.unpackEncodedString(DFA38_specialS);
   15006 	static final short[][] DFA38_transition;
   15007 
   15008 	static {
   15009 		int numStates = DFA38_transitionS.length;
   15010 		DFA38_transition = new short[numStates][];
   15011 		for (int i=0; i<numStates; i++) {
   15012 			DFA38_transition[i] = DFA.unpackEncodedString(DFA38_transitionS[i]);
   15013 		}
   15014 	}
   15015 
   15016 	protected class DFA38 extends DFA {
   15017 
   15018 		public DFA38(BaseRecognizer recognizer) {
   15019 			this.recognizer = recognizer;
   15020 			this.decisionNumber = 38;
   15021 			this.eot = DFA38_eot;
   15022 			this.eof = DFA38_eof;
   15023 			this.min = DFA38_min;
   15024 			this.max = DFA38_max;
   15025 			this.accept = DFA38_accept;
   15026 			this.special = DFA38_special;
   15027 			this.transition = DFA38_transition;
   15028 		}
   15029 		@Override
   15030 		public String getDescription() {
   15031 			return "723:1: verification_error_reference : ( CLASS_DESCRIPTOR | field_reference | method_reference );";
   15032 		}
   15033 	}
   15034 
   15035 	static final String DFA40_eotS =
   15036 		"\103\uffff";
   15037 	static final String DFA40_eofS =
   15038 		"\103\uffff";
   15039 	static final String DFA40_minS =
   15040 		"\1\5\100\uffff\1\0\1\uffff";
   15041 	static final String DFA40_maxS =
   15042 		"\1\u00c1\100\uffff\1\0\1\uffff";
   15043 	static final String DFA40_acceptS =
   15044 		"\1\uffff\1\2\100\uffff\1\1";
   15045 	static final String DFA40_specialS =
   15046 		"\101\uffff\1\0\1\uffff}>";
   15047 	static final String[] DFA40_transitionS = {
   15048 			"\1\101\1\uffff\1\1\4\uffff\2\1\5\uffff\1\1\7\uffff\2\1\1\uffff\1\1\3"+
   15049 			"\uffff\1\1\7\uffff\56\1\123\uffff\3\1\7\uffff\2\1\3\uffff\1\1\1\uffff"+
   15050 			"\2\1\2\uffff\2\1",
   15051 			"",
   15052 			"",
   15053 			"",
   15054 			"",
   15055 			"",
   15056 			"",
   15057 			"",
   15058 			"",
   15059 			"",
   15060 			"",
   15061 			"",
   15062 			"",
   15063 			"",
   15064 			"",
   15065 			"",
   15066 			"",
   15067 			"",
   15068 			"",
   15069 			"",
   15070 			"",
   15071 			"",
   15072 			"",
   15073 			"",
   15074 			"",
   15075 			"",
   15076 			"",
   15077 			"",
   15078 			"",
   15079 			"",
   15080 			"",
   15081 			"",
   15082 			"",
   15083 			"",
   15084 			"",
   15085 			"",
   15086 			"",
   15087 			"",
   15088 			"",
   15089 			"",
   15090 			"",
   15091 			"",
   15092 			"",
   15093 			"",
   15094 			"",
   15095 			"",
   15096 			"",
   15097 			"",
   15098 			"",
   15099 			"",
   15100 			"",
   15101 			"",
   15102 			"",
   15103 			"",
   15104 			"",
   15105 			"",
   15106 			"",
   15107 			"",
   15108 			"",
   15109 			"",
   15110 			"",
   15111 			"",
   15112 			"",
   15113 			"",
   15114 			"",
   15115 			"\1\uffff",
   15116 			""
   15117 	};
   15118 
   15119 	static final short[] DFA40_eot = DFA.unpackEncodedString(DFA40_eotS);
   15120 	static final short[] DFA40_eof = DFA.unpackEncodedString(DFA40_eofS);
   15121 	static final char[] DFA40_min = DFA.unpackEncodedStringToUnsignedChars(DFA40_minS);
   15122 	static final char[] DFA40_max = DFA.unpackEncodedStringToUnsignedChars(DFA40_maxS);
   15123 	static final short[] DFA40_accept = DFA.unpackEncodedString(DFA40_acceptS);
   15124 	static final short[] DFA40_special = DFA.unpackEncodedString(DFA40_specialS);
   15125 	static final short[][] DFA40_transition;
   15126 
   15127 	static {
   15128 		int numStates = DFA40_transitionS.length;
   15129 		DFA40_transition = new short[numStates][];
   15130 		for (int i=0; i<numStates; i++) {
   15131 			DFA40_transition[i] = DFA.unpackEncodedString(DFA40_transitionS[i]);
   15132 		}
   15133 	}
   15134 
   15135 	protected class DFA40 extends DFA {
   15136 
   15137 		public DFA40(BaseRecognizer recognizer) {
   15138 			this.recognizer = recognizer;
   15139 			this.decisionNumber = 40;
   15140 			this.eot = DFA40_eot;
   15141 			this.eof = DFA40_eof;
   15142 			this.min = DFA40_min;
   15143 			this.max = DFA40_max;
   15144 			this.accept = DFA40_accept;
   15145 			this.special = DFA40_special;
   15146 			this.transition = DFA40_transition;
   15147 		}
   15148 		@Override
   15149 		public String getDescription() {
   15150 			return "()* loopback of 741:5: ({...}? annotation )*";
   15151 		}
   15152 		@Override
   15153 		public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
   15154 			TokenStream input = (TokenStream)_input;
   15155 			int _s = s;
   15156 			switch ( s ) {
   15157 					case 0 :
   15158 						int LA40_65 = input.LA(1);
   15159 
   15160 						int index40_65 = input.index();
   15161 						input.rewind();
   15162 						s = -1;
   15163 						if ( ((input.LA(1) == ANNOTATION_DIRECTIVE)) ) {s = 66;}
   15164 						else if ( (true) ) {s = 1;}
   15165 
   15166 						input.seek(index40_65);
   15167 						if ( s>=0 ) return s;
   15168 						break;
   15169 			}
   15170 			NoViableAltException nvae =
   15171 				new NoViableAltException(getDescription(), 40, _s, input);
   15172 			error(nvae);
   15173 			throw nvae;
   15174 		}
   15175 	}
   15176 
   15177 	public static final BitSet FOLLOW_class_spec_in_smali_file1075 = new BitSet(new long[]{0x0000011000010020L,0x0000000000000000L,0x0001000000000000L,0x0000000000000011L});
   15178 	public static final BitSet FOLLOW_super_spec_in_smali_file1086 = new BitSet(new long[]{0x0000011000010020L,0x0000000000000000L,0x0001000000000000L,0x0000000000000011L});
   15179 	public static final BitSet FOLLOW_implements_spec_in_smali_file1094 = new BitSet(new long[]{0x0000011000010020L,0x0000000000000000L,0x0001000000000000L,0x0000000000000011L});
   15180 	public static final BitSet FOLLOW_source_spec_in_smali_file1103 = new BitSet(new long[]{0x0000011000010020L,0x0000000000000000L,0x0001000000000000L,0x0000000000000011L});
   15181 	public static final BitSet FOLLOW_method_in_smali_file1111 = new BitSet(new long[]{0x0000011000010020L,0x0000000000000000L,0x0001000000000000L,0x0000000000000011L});
   15182 	public static final BitSet FOLLOW_field_in_smali_file1117 = new BitSet(new long[]{0x0000011000010020L,0x0000000000000000L,0x0001000000000000L,0x0000000000000011L});
   15183 	public static final BitSet FOLLOW_annotation_in_smali_file1123 = new BitSet(new long[]{0x0000011000010020L,0x0000000000000000L,0x0001000000000000L,0x0000000000000011L});
   15184 	public static final BitSet FOLLOW_EOF_in_smali_file1134 = new BitSet(new long[]{0x0000000000000002L});
   15185 	public static final BitSet FOLLOW_CLASS_DIRECTIVE_in_class_spec1221 = new BitSet(new long[]{0x0000000000008010L});
   15186 	public static final BitSet FOLLOW_access_list_in_class_spec1223 = new BitSet(new long[]{0x0000000000008000L});
   15187 	public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_class_spec1225 = new BitSet(new long[]{0x0000000000000002L});
   15188 	public static final BitSet FOLLOW_SUPER_DIRECTIVE_in_super_spec1243 = new BitSet(new long[]{0x0000000000008000L});
   15189 	public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_super_spec1245 = new BitSet(new long[]{0x0000000000000002L});
   15190 	public static final BitSet FOLLOW_IMPLEMENTS_DIRECTIVE_in_implements_spec1264 = new BitSet(new long[]{0x0000000000008000L});
   15191 	public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_implements_spec1266 = new BitSet(new long[]{0x0000000000000002L});
   15192 	public static final BitSet FOLLOW_SOURCE_DIRECTIVE_in_source_spec1285 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L});
   15193 	public static final BitSet FOLLOW_STRING_LITERAL_in_source_spec1287 = new BitSet(new long[]{0x0000000000000002L});
   15194 	public static final BitSet FOLLOW_ACCESS_SPEC_in_access_list1306 = new BitSet(new long[]{0x0000000000000012L});
   15195 	public static final BitSet FOLLOW_FIELD_DIRECTIVE_in_field1337 = new BitSet(new long[]{0xF4795C8000800450L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L});
   15196 	public static final BitSet FOLLOW_access_list_in_field1339 = new BitSet(new long[]{0xF4795C8000800450L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L});
   15197 	public static final BitSet FOLLOW_member_name_in_field1341 = new BitSet(new long[]{0x0000000000080000L});
   15198 	public static final BitSet FOLLOW_COLON_in_field1343 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0200000000000000L});
   15199 	public static final BitSet FOLLOW_nonvoid_type_descriptor_in_field1345 = new BitSet(new long[]{0x0000000804000022L});
   15200 	public static final BitSet FOLLOW_EQUAL_in_field1348 = new BitSet(new long[]{0xF4795CC200C0CD50L,0x0000000000E0FB16L,0xCB8EC00000000000L,0x000000000000006CL});
   15201 	public static final BitSet FOLLOW_literal_in_field1350 = new BitSet(new long[]{0x0000000004000022L});
   15202 	public static final BitSet FOLLOW_annotation_in_field1363 = new BitSet(new long[]{0x0000000004000022L});
   15203 	public static final BitSet FOLLOW_END_FIELD_DIRECTIVE_in_field1377 = new BitSet(new long[]{0x0000000000000002L});
   15204 	public static final BitSet FOLLOW_METHOD_DIRECTIVE_in_method1488 = new BitSet(new long[]{0xF4795C8000800450L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L});
   15205 	public static final BitSet FOLLOW_access_list_in_method1490 = new BitSet(new long[]{0xF4795C8000800450L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L});
   15206 	public static final BitSet FOLLOW_member_name_in_method1492 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0010000000000000L});
   15207 	public static final BitSet FOLLOW_method_prototype_in_method1494 = new BitSet(new long[]{0xFFFFFC04180830A0L,0x0000000000FFFFFFL,0x3460380000000000L,0x0000000000000003L});
   15208 	public static final BitSet FOLLOW_statements_and_directives_in_method1496 = new BitSet(new long[]{0x0000000010000000L});
   15209 	public static final BitSet FOLLOW_END_METHOD_DIRECTIVE_in_method1502 = new BitSet(new long[]{0x0000000000000002L});
   15210 	public static final BitSet FOLLOW_ordered_method_item_in_statements_and_directives1547 = new BitSet(new long[]{0xFFFFFC04080830A2L,0x0000000000FFFFFFL,0x3460380000000000L,0x0000000000000003L});
   15211 	public static final BitSet FOLLOW_registers_directive_in_statements_and_directives1555 = new BitSet(new long[]{0xFFFFFC04080830A2L,0x0000000000FFFFFFL,0x3460380000000000L,0x0000000000000003L});
   15212 	public static final BitSet FOLLOW_catch_directive_in_statements_and_directives1563 = new BitSet(new long[]{0xFFFFFC04080830A2L,0x0000000000FFFFFFL,0x3460380000000000L,0x0000000000000003L});
   15213 	public static final BitSet FOLLOW_catchall_directive_in_statements_and_directives1571 = new BitSet(new long[]{0xFFFFFC04080830A2L,0x0000000000FFFFFFL,0x3460380000000000L,0x0000000000000003L});
   15214 	public static final BitSet FOLLOW_parameter_directive_in_statements_and_directives1579 = new BitSet(new long[]{0xFFFFFC04080830A2L,0x0000000000FFFFFFL,0x3460380000000000L,0x0000000000000003L});
   15215 	public static final BitSet FOLLOW_annotation_in_statements_and_directives1587 = new BitSet(new long[]{0xFFFFFC04080830A2L,0x0000000000FFFFFFL,0x3460380000000000L,0x0000000000000003L});
   15216 	public static final BitSet FOLLOW_label_in_ordered_method_item1672 = new BitSet(new long[]{0x0000000000000002L});
   15217 	public static final BitSet FOLLOW_instruction_in_ordered_method_item1678 = new BitSet(new long[]{0x0000000000000002L});
   15218 	public static final BitSet FOLLOW_debug_directive_in_ordered_method_item1684 = new BitSet(new long[]{0x0000000000000002L});
   15219 	public static final BitSet FOLLOW_REGISTERS_DIRECTIVE_in_registers_directive1704 = new BitSet(new long[]{0x0000000000004800L,0x0000000000000000L,0x4102400000000000L});
   15220 	public static final BitSet FOLLOW_integral_literal_in_registers_directive1708 = new BitSet(new long[]{0x0000000000000002L});
   15221 	public static final BitSet FOLLOW_LOCALS_DIRECTIVE_in_registers_directive1728 = new BitSet(new long[]{0x0000000000004800L,0x0000000000000000L,0x4102400000000000L});
   15222 	public static final BitSet FOLLOW_integral_literal_in_registers_directive1732 = new BitSet(new long[]{0x0000000000000002L});
   15223 	public static final BitSet FOLLOW_PARAM_LIST_OR_ID_PRIMITIVE_TYPE_in_param_list_or_id1764 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0080000000000000L});
   15224 	public static final BitSet FOLLOW_SIMPLE_NAME_in_simple_name1777 = new BitSet(new long[]{0x0000000000000002L});
   15225 	public static final BitSet FOLLOW_ACCESS_SPEC_in_simple_name1783 = new BitSet(new long[]{0x0000000000000002L});
   15226 	public static final BitSet FOLLOW_VERIFICATION_ERROR_TYPE_in_simple_name1794 = new BitSet(new long[]{0x0000000000000002L});
   15227 	public static final BitSet FOLLOW_POSITIVE_INTEGER_LITERAL_in_simple_name1805 = new BitSet(new long[]{0x0000000000000002L});
   15228 	public static final BitSet FOLLOW_NEGATIVE_INTEGER_LITERAL_in_simple_name1816 = new BitSet(new long[]{0x0000000000000002L});
   15229 	public static final BitSet FOLLOW_FLOAT_LITERAL_OR_ID_in_simple_name1827 = new BitSet(new long[]{0x0000000000000002L});
   15230 	public static final BitSet FOLLOW_DOUBLE_LITERAL_OR_ID_in_simple_name1838 = new BitSet(new long[]{0x0000000000000002L});
   15231 	public static final BitSet FOLLOW_BOOL_LITERAL_in_simple_name1849 = new BitSet(new long[]{0x0000000000000002L});
   15232 	public static final BitSet FOLLOW_NULL_LITERAL_in_simple_name1860 = new BitSet(new long[]{0x0000000000000002L});
   15233 	public static final BitSet FOLLOW_REGISTER_in_simple_name1871 = new BitSet(new long[]{0x0000000000000002L});
   15234 	public static final BitSet FOLLOW_param_list_or_id_in_simple_name1882 = new BitSet(new long[]{0x0000000000000002L});
   15235 	public static final BitSet FOLLOW_PRIMITIVE_TYPE_in_simple_name1892 = new BitSet(new long[]{0x0000000000000002L});
   15236 	public static final BitSet FOLLOW_VOID_TYPE_in_simple_name1903 = new BitSet(new long[]{0x0000000000000002L});
   15237 	public static final BitSet FOLLOW_ANNOTATION_VISIBILITY_in_simple_name1914 = new BitSet(new long[]{0x0000000000000002L});
   15238 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT10t_in_simple_name1925 = new BitSet(new long[]{0x0000000000000002L});
   15239 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT10x_in_simple_name1936 = new BitSet(new long[]{0x0000000000000002L});
   15240 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT10x_ODEX_in_simple_name1947 = new BitSet(new long[]{0x0000000000000002L});
   15241 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT11x_in_simple_name1958 = new BitSet(new long[]{0x0000000000000002L});
   15242 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT12x_OR_ID_in_simple_name1969 = new BitSet(new long[]{0x0000000000000002L});
   15243 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_FIELD_in_simple_name1980 = new BitSet(new long[]{0x0000000000000002L});
   15244 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_FIELD_ODEX_in_simple_name1991 = new BitSet(new long[]{0x0000000000000002L});
   15245 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_STRING_in_simple_name2002 = new BitSet(new long[]{0x0000000000000002L});
   15246 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_TYPE_in_simple_name2013 = new BitSet(new long[]{0x0000000000000002L});
   15247 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT21t_in_simple_name2024 = new BitSet(new long[]{0x0000000000000002L});
   15248 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT22c_FIELD_in_simple_name2035 = new BitSet(new long[]{0x0000000000000002L});
   15249 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT22c_FIELD_ODEX_in_simple_name2046 = new BitSet(new long[]{0x0000000000000002L});
   15250 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT22c_TYPE_in_simple_name2057 = new BitSet(new long[]{0x0000000000000002L});
   15251 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT22cs_FIELD_in_simple_name2068 = new BitSet(new long[]{0x0000000000000002L});
   15252 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT22s_OR_ID_in_simple_name2079 = new BitSet(new long[]{0x0000000000000002L});
   15253 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT22t_in_simple_name2090 = new BitSet(new long[]{0x0000000000000002L});
   15254 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT23x_in_simple_name2101 = new BitSet(new long[]{0x0000000000000002L});
   15255 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT31i_OR_ID_in_simple_name2112 = new BitSet(new long[]{0x0000000000000002L});
   15256 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT31t_in_simple_name2123 = new BitSet(new long[]{0x0000000000000002L});
   15257 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT35c_METHOD_in_simple_name2134 = new BitSet(new long[]{0x0000000000000002L});
   15258 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT35c_METHOD_ODEX_in_simple_name2145 = new BitSet(new long[]{0x0000000000000002L});
   15259 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT35c_TYPE_in_simple_name2156 = new BitSet(new long[]{0x0000000000000002L});
   15260 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT35mi_METHOD_in_simple_name2167 = new BitSet(new long[]{0x0000000000000002L});
   15261 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT35ms_METHOD_in_simple_name2178 = new BitSet(new long[]{0x0000000000000002L});
   15262 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT45cc_METHOD_in_simple_name2189 = new BitSet(new long[]{0x0000000000000002L});
   15263 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT4rcc_METHOD_in_simple_name2200 = new BitSet(new long[]{0x0000000000000002L});
   15264 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT51l_in_simple_name2211 = new BitSet(new long[]{0x0000000000000002L});
   15265 	public static final BitSet FOLLOW_simple_name_in_member_name2226 = new BitSet(new long[]{0x0000000000000002L});
   15266 	public static final BitSet FOLLOW_MEMBER_NAME_in_member_name2232 = new BitSet(new long[]{0x0000000000000002L});
   15267 	public static final BitSet FOLLOW_OPEN_PAREN_in_method_prototype2247 = new BitSet(new long[]{0x0000000000048100L,0x0000000000000000L,0x0280000000000000L});
   15268 	public static final BitSet FOLLOW_param_list_in_method_prototype2249 = new BitSet(new long[]{0x0000000000040000L});
   15269 	public static final BitSet FOLLOW_CLOSE_PAREN_in_method_prototype2251 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0200000000000000L,0x0000000000000040L});
   15270 	public static final BitSet FOLLOW_type_descriptor_in_method_prototype2253 = new BitSet(new long[]{0x0000000000000002L});
   15271 	public static final BitSet FOLLOW_PARAM_LIST_OR_ID_PRIMITIVE_TYPE_in_param_list_or_id_primitive_type2283 = new BitSet(new long[]{0x0000000000000002L});
   15272 	public static final BitSet FOLLOW_param_list_or_id_primitive_type_in_param_list2298 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0080000000000000L});
   15273 	public static final BitSet FOLLOW_nonvoid_type_descriptor_in_param_list2305 = new BitSet(new long[]{0x0000000000008102L,0x0000000000000000L,0x0200000000000000L});
   15274 	public static final BitSet FOLLOW_ARRAY_TYPE_PREFIX_in_array_descriptor2316 = new BitSet(new long[]{0x0000000000008000L,0x0000000000000000L,0x0200000000000000L});
   15275 	public static final BitSet FOLLOW_set_in_array_descriptor2318 = new BitSet(new long[]{0x0000000000000002L});
   15276 	public static final BitSet FOLLOW_VOID_TYPE_in_type_descriptor2334 = new BitSet(new long[]{0x0000000000000002L});
   15277 	public static final BitSet FOLLOW_PRIMITIVE_TYPE_in_type_descriptor2340 = new BitSet(new long[]{0x0000000000000002L});
   15278 	public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_type_descriptor2346 = new BitSet(new long[]{0x0000000000000002L});
   15279 	public static final BitSet FOLLOW_array_descriptor_in_type_descriptor2352 = new BitSet(new long[]{0x0000000000000002L});
   15280 	public static final BitSet FOLLOW_PRIMITIVE_TYPE_in_nonvoid_type_descriptor2362 = new BitSet(new long[]{0x0000000000000002L});
   15281 	public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_nonvoid_type_descriptor2368 = new BitSet(new long[]{0x0000000000000002L});
   15282 	public static final BitSet FOLLOW_array_descriptor_in_nonvoid_type_descriptor2374 = new BitSet(new long[]{0x0000000000000002L});
   15283 	public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_reference_type_descriptor2384 = new BitSet(new long[]{0x0000000000000002L});
   15284 	public static final BitSet FOLLOW_array_descriptor_in_reference_type_descriptor2390 = new BitSet(new long[]{0x0000000000000002L});
   15285 	public static final BitSet FOLLOW_POSITIVE_INTEGER_LITERAL_in_integer_literal2400 = new BitSet(new long[]{0x0000000000000002L});
   15286 	public static final BitSet FOLLOW_NEGATIVE_INTEGER_LITERAL_in_integer_literal2411 = new BitSet(new long[]{0x0000000000000002L});
   15287 	public static final BitSet FOLLOW_FLOAT_LITERAL_OR_ID_in_float_literal2426 = new BitSet(new long[]{0x0000000000000002L});
   15288 	public static final BitSet FOLLOW_FLOAT_LITERAL_in_float_literal2437 = new BitSet(new long[]{0x0000000000000002L});
   15289 	public static final BitSet FOLLOW_DOUBLE_LITERAL_OR_ID_in_double_literal2447 = new BitSet(new long[]{0x0000000000000002L});
   15290 	public static final BitSet FOLLOW_DOUBLE_LITERAL_in_double_literal2458 = new BitSet(new long[]{0x0000000000000002L});
   15291 	public static final BitSet FOLLOW_LONG_LITERAL_in_literal2468 = new BitSet(new long[]{0x0000000000000002L});
   15292 	public static final BitSet FOLLOW_integer_literal_in_literal2474 = new BitSet(new long[]{0x0000000000000002L});
   15293 	public static final BitSet FOLLOW_SHORT_LITERAL_in_literal2480 = new BitSet(new long[]{0x0000000000000002L});
   15294 	public static final BitSet FOLLOW_BYTE_LITERAL_in_literal2486 = new BitSet(new long[]{0x0000000000000002L});
   15295 	public static final BitSet FOLLOW_float_literal_in_literal2492 = new BitSet(new long[]{0x0000000000000002L});
   15296 	public static final BitSet FOLLOW_double_literal_in_literal2498 = new BitSet(new long[]{0x0000000000000002L});
   15297 	public static final BitSet FOLLOW_CHAR_LITERAL_in_literal2504 = new BitSet(new long[]{0x0000000000000002L});
   15298 	public static final BitSet FOLLOW_STRING_LITERAL_in_literal2510 = new BitSet(new long[]{0x0000000000000002L});
   15299 	public static final BitSet FOLLOW_BOOL_LITERAL_in_literal2516 = new BitSet(new long[]{0x0000000000000002L});
   15300 	public static final BitSet FOLLOW_NULL_LITERAL_in_literal2522 = new BitSet(new long[]{0x0000000000000002L});
   15301 	public static final BitSet FOLLOW_array_literal_in_literal2528 = new BitSet(new long[]{0x0000000000000002L});
   15302 	public static final BitSet FOLLOW_subannotation_in_literal2534 = new BitSet(new long[]{0x0000000000000002L});
   15303 	public static final BitSet FOLLOW_type_field_method_literal_in_literal2540 = new BitSet(new long[]{0x0000000000000002L});
   15304 	public static final BitSet FOLLOW_enum_literal_in_literal2546 = new BitSet(new long[]{0x0000000000000002L});
   15305 	public static final BitSet FOLLOW_integer_literal_in_parsed_integer_literal2559 = new BitSet(new long[]{0x0000000000000002L});
   15306 	public static final BitSet FOLLOW_LONG_LITERAL_in_integral_literal2571 = new BitSet(new long[]{0x0000000000000002L});
   15307 	public static final BitSet FOLLOW_integer_literal_in_integral_literal2577 = new BitSet(new long[]{0x0000000000000002L});
   15308 	public static final BitSet FOLLOW_SHORT_LITERAL_in_integral_literal2583 = new BitSet(new long[]{0x0000000000000002L});
   15309 	public static final BitSet FOLLOW_CHAR_LITERAL_in_integral_literal2589 = new BitSet(new long[]{0x0000000000000002L});
   15310 	public static final BitSet FOLLOW_BYTE_LITERAL_in_integral_literal2595 = new BitSet(new long[]{0x0000000000000002L});
   15311 	public static final BitSet FOLLOW_LONG_LITERAL_in_fixed_32bit_literal2605 = new BitSet(new long[]{0x0000000000000002L});
   15312 	public static final BitSet FOLLOW_integer_literal_in_fixed_32bit_literal2611 = new BitSet(new long[]{0x0000000000000002L});
   15313 	public static final BitSet FOLLOW_SHORT_LITERAL_in_fixed_32bit_literal2617 = new BitSet(new long[]{0x0000000000000002L});
   15314 	public static final BitSet FOLLOW_BYTE_LITERAL_in_fixed_32bit_literal2623 = new BitSet(new long[]{0x0000000000000002L});
   15315 	public static final BitSet FOLLOW_float_literal_in_fixed_32bit_literal2629 = new BitSet(new long[]{0x0000000000000002L});
   15316 	public static final BitSet FOLLOW_CHAR_LITERAL_in_fixed_32bit_literal2635 = new BitSet(new long[]{0x0000000000000002L});
   15317 	public static final BitSet FOLLOW_BOOL_LITERAL_in_fixed_32bit_literal2641 = new BitSet(new long[]{0x0000000000000002L});
   15318 	public static final BitSet FOLLOW_integer_literal_in_fixed_literal2651 = new BitSet(new long[]{0x0000000000000002L});
   15319 	public static final BitSet FOLLOW_LONG_LITERAL_in_fixed_literal2657 = new BitSet(new long[]{0x0000000000000002L});
   15320 	public static final BitSet FOLLOW_SHORT_LITERAL_in_fixed_literal2663 = new BitSet(new long[]{0x0000000000000002L});
   15321 	public static final BitSet FOLLOW_BYTE_LITERAL_in_fixed_literal2669 = new BitSet(new long[]{0x0000000000000002L});
   15322 	public static final BitSet FOLLOW_float_literal_in_fixed_literal2675 = new BitSet(new long[]{0x0000000000000002L});
   15323 	public static final BitSet FOLLOW_double_literal_in_fixed_literal2681 = new BitSet(new long[]{0x0000000000000002L});
   15324 	public static final BitSet FOLLOW_CHAR_LITERAL_in_fixed_literal2687 = new BitSet(new long[]{0x0000000000000002L});
   15325 	public static final BitSet FOLLOW_BOOL_LITERAL_in_fixed_literal2693 = new BitSet(new long[]{0x0000000000000002L});
   15326 	public static final BitSet FOLLOW_OPEN_BRACE_in_array_literal2703 = new BitSet(new long[]{0xF4795CC200C2CD50L,0x0000000000E0FB16L,0xCB8EC00000000000L,0x000000000000006CL});
   15327 	public static final BitSet FOLLOW_literal_in_array_literal2706 = new BitSet(new long[]{0x0000000000120000L});
   15328 	public static final BitSet FOLLOW_COMMA_in_array_literal2709 = new BitSet(new long[]{0xF4795CC200C0CD50L,0x0000000000E0FB16L,0xCB8EC00000000000L,0x000000000000006CL});
   15329 	public static final BitSet FOLLOW_literal_in_array_literal2711 = new BitSet(new long[]{0x0000000000120000L});
   15330 	public static final BitSet FOLLOW_CLOSE_BRACE_in_array_literal2719 = new BitSet(new long[]{0x0000000000000002L});
   15331 	public static final BitSet FOLLOW_simple_name_in_annotation_element2743 = new BitSet(new long[]{0x0000000800000000L});
   15332 	public static final BitSet FOLLOW_EQUAL_in_annotation_element2745 = new BitSet(new long[]{0xF4795CC200C0CD50L,0x0000000000E0FB16L,0xCB8EC00000000000L,0x000000000000006CL});
   15333 	public static final BitSet FOLLOW_literal_in_annotation_element2747 = new BitSet(new long[]{0x0000000000000002L});
   15334 	public static final BitSet FOLLOW_ANNOTATION_DIRECTIVE_in_annotation2772 = new BitSet(new long[]{0x0000000000000040L});
   15335 	public static final BitSet FOLLOW_ANNOTATION_VISIBILITY_in_annotation2774 = new BitSet(new long[]{0x0000000000008000L});
   15336 	public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_annotation2776 = new BitSet(new long[]{0xF4795C8001800450L,0x0000000000E0FB16L,0x8B86000000000000L,0x0000000000000060L});
   15337 	public static final BitSet FOLLOW_annotation_element_in_annotation2782 = new BitSet(new long[]{0xF4795C8001800450L,0x0000000000E0FB16L,0x8B86000000000000L,0x0000000000000060L});
   15338 	public static final BitSet FOLLOW_END_ANNOTATION_DIRECTIVE_in_annotation2785 = new BitSet(new long[]{0x0000000000000002L});
   15339 	public static final BitSet FOLLOW_SUBANNOTATION_DIRECTIVE_in_subannotation2818 = new BitSet(new long[]{0x0000000000008000L});
   15340 	public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_subannotation2820 = new BitSet(new long[]{0xF4795C8100800450L,0x0000000000E0FB16L,0x8B86000000000000L,0x0000000000000060L});
   15341 	public static final BitSet FOLLOW_annotation_element_in_subannotation2822 = new BitSet(new long[]{0xF4795C8100800450L,0x0000000000E0FB16L,0x8B86000000000000L,0x0000000000000060L});
   15342 	public static final BitSet FOLLOW_END_SUBANNOTATION_DIRECTIVE_in_subannotation2825 = new BitSet(new long[]{0x0000000000000002L});
   15343 	public static final BitSet FOLLOW_ENUM_DIRECTIVE_in_enum_literal2852 = new BitSet(new long[]{0xF4795C8000808550L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L});
   15344 	public static final BitSet FOLLOW_field_reference_in_enum_literal2854 = new BitSet(new long[]{0x0000000000000002L});
   15345 	public static final BitSet FOLLOW_reference_type_descriptor_in_type_field_method_literal2874 = new BitSet(new long[]{0x0000000000000002L});
   15346 	public static final BitSet FOLLOW_reference_type_descriptor_in_type_field_method_literal2883 = new BitSet(new long[]{0x0000000000000200L});
   15347 	public static final BitSet FOLLOW_ARROW_in_type_field_method_literal2885 = new BitSet(new long[]{0xF4795C8000800450L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L});
   15348 	public static final BitSet FOLLOW_member_name_in_type_field_method_literal2897 = new BitSet(new long[]{0x0000000000080000L});
   15349 	public static final BitSet FOLLOW_COLON_in_type_field_method_literal2899 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0200000000000000L});
   15350 	public static final BitSet FOLLOW_nonvoid_type_descriptor_in_type_field_method_literal2901 = new BitSet(new long[]{0x0000000000000002L});
   15351 	public static final BitSet FOLLOW_member_name_in_type_field_method_literal2924 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0010000000000000L});
   15352 	public static final BitSet FOLLOW_method_prototype_in_type_field_method_literal2926 = new BitSet(new long[]{0x0000000000000002L});
   15353 	public static final BitSet FOLLOW_PRIMITIVE_TYPE_in_type_field_method_literal2959 = new BitSet(new long[]{0x0000000000000002L});
   15354 	public static final BitSet FOLLOW_VOID_TYPE_in_type_field_method_literal2965 = new BitSet(new long[]{0x0000000000000002L});
   15355 	public static final BitSet FOLLOW_reference_type_descriptor_in_method_reference2976 = new BitSet(new long[]{0x0000000000000200L});
   15356 	public static final BitSet FOLLOW_ARROW_in_method_reference2978 = new BitSet(new long[]{0xF4795C8000800450L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L});
   15357 	public static final BitSet FOLLOW_member_name_in_method_reference2982 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0010000000000000L});
   15358 	public static final BitSet FOLLOW_method_prototype_in_method_reference2984 = new BitSet(new long[]{0x0000000000000002L});
   15359 	public static final BitSet FOLLOW_reference_type_descriptor_in_field_reference3006 = new BitSet(new long[]{0x0000000000000200L});
   15360 	public static final BitSet FOLLOW_ARROW_in_field_reference3008 = new BitSet(new long[]{0xF4795C8000800450L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L});
   15361 	public static final BitSet FOLLOW_member_name_in_field_reference3012 = new BitSet(new long[]{0x0000000000080000L});
   15362 	public static final BitSet FOLLOW_COLON_in_field_reference3014 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0200000000000000L});
   15363 	public static final BitSet FOLLOW_nonvoid_type_descriptor_in_field_reference3016 = new BitSet(new long[]{0x0000000000000002L});
   15364 	public static final BitSet FOLLOW_COLON_in_label3037 = new BitSet(new long[]{0xF4795C8000800450L,0x0000000000E0FB16L,0x8B86000000000000L,0x0000000000000060L});
   15365 	public static final BitSet FOLLOW_simple_name_in_label3039 = new BitSet(new long[]{0x0000000000000002L});
   15366 	public static final BitSet FOLLOW_COLON_in_label_ref3058 = new BitSet(new long[]{0xF4795C8000800450L,0x0000000000E0FB16L,0x8B86000000000000L,0x0000000000000060L});
   15367 	public static final BitSet FOLLOW_simple_name_in_label_ref3060 = new BitSet(new long[]{0x0000000000000002L});
   15368 	public static final BitSet FOLLOW_REGISTER_in_register_list3074 = new BitSet(new long[]{0x0000000000100002L});
   15369 	public static final BitSet FOLLOW_COMMA_in_register_list3077 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15370 	public static final BitSet FOLLOW_REGISTER_in_register_list3079 = new BitSet(new long[]{0x0000000000100002L});
   15371 	public static final BitSet FOLLOW_REGISTER_in_register_range3114 = new BitSet(new long[]{0x0000000000200002L});
   15372 	public static final BitSet FOLLOW_DOTDOT_in_register_range3117 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15373 	public static final BitSet FOLLOW_REGISTER_in_register_range3121 = new BitSet(new long[]{0x0000000000000002L});
   15374 	public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_verification_error_reference3150 = new BitSet(new long[]{0x0000000000000002L});
   15375 	public static final BitSet FOLLOW_field_reference_in_verification_error_reference3154 = new BitSet(new long[]{0x0000000000000002L});
   15376 	public static final BitSet FOLLOW_method_reference_in_verification_error_reference3158 = new BitSet(new long[]{0x0000000000000002L});
   15377 	public static final BitSet FOLLOW_CATCH_DIRECTIVE_in_catch_directive3168 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0200000000000000L});
   15378 	public static final BitSet FOLLOW_nonvoid_type_descriptor_in_catch_directive3170 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0008000000000000L});
   15379 	public static final BitSet FOLLOW_OPEN_BRACE_in_catch_directive3172 = new BitSet(new long[]{0x0000000000080000L});
   15380 	public static final BitSet FOLLOW_label_ref_in_catch_directive3176 = new BitSet(new long[]{0x0000000000200000L});
   15381 	public static final BitSet FOLLOW_DOTDOT_in_catch_directive3178 = new BitSet(new long[]{0x0000000000080000L});
   15382 	public static final BitSet FOLLOW_label_ref_in_catch_directive3182 = new BitSet(new long[]{0x0000000000020000L});
   15383 	public static final BitSet FOLLOW_CLOSE_BRACE_in_catch_directive3184 = new BitSet(new long[]{0x0000000000080000L});
   15384 	public static final BitSet FOLLOW_label_ref_in_catch_directive3188 = new BitSet(new long[]{0x0000000000000002L});
   15385 	public static final BitSet FOLLOW_CATCHALL_DIRECTIVE_in_catchall_directive3220 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0008000000000000L});
   15386 	public static final BitSet FOLLOW_OPEN_BRACE_in_catchall_directive3222 = new BitSet(new long[]{0x0000000000080000L});
   15387 	public static final BitSet FOLLOW_label_ref_in_catchall_directive3226 = new BitSet(new long[]{0x0000000000200000L});
   15388 	public static final BitSet FOLLOW_DOTDOT_in_catchall_directive3228 = new BitSet(new long[]{0x0000000000080000L});
   15389 	public static final BitSet FOLLOW_label_ref_in_catchall_directive3232 = new BitSet(new long[]{0x0000000000020000L});
   15390 	public static final BitSet FOLLOW_CLOSE_BRACE_in_catchall_directive3234 = new BitSet(new long[]{0x0000000000080000L});
   15391 	public static final BitSet FOLLOW_label_ref_in_catchall_directive3238 = new BitSet(new long[]{0x0000000000000002L});
   15392 	public static final BitSet FOLLOW_PARAMETER_DIRECTIVE_in_parameter_directive3277 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15393 	public static final BitSet FOLLOW_REGISTER_in_parameter_directive3279 = new BitSet(new long[]{0x0000000040100022L});
   15394 	public static final BitSet FOLLOW_COMMA_in_parameter_directive3282 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L});
   15395 	public static final BitSet FOLLOW_STRING_LITERAL_in_parameter_directive3284 = new BitSet(new long[]{0x0000000040000022L});
   15396 	public static final BitSet FOLLOW_annotation_in_parameter_directive3295 = new BitSet(new long[]{0x0000000040000022L});
   15397 	public static final BitSet FOLLOW_END_PARAMETER_DIRECTIVE_in_parameter_directive3308 = new BitSet(new long[]{0x0000000000000002L});
   15398 	public static final BitSet FOLLOW_line_directive_in_debug_directive3381 = new BitSet(new long[]{0x0000000000000002L});
   15399 	public static final BitSet FOLLOW_local_directive_in_debug_directive3387 = new BitSet(new long[]{0x0000000000000002L});
   15400 	public static final BitSet FOLLOW_end_local_directive_in_debug_directive3393 = new BitSet(new long[]{0x0000000000000002L});
   15401 	public static final BitSet FOLLOW_restart_local_directive_in_debug_directive3399 = new BitSet(new long[]{0x0000000000000002L});
   15402 	public static final BitSet FOLLOW_prologue_directive_in_debug_directive3405 = new BitSet(new long[]{0x0000000000000002L});
   15403 	public static final BitSet FOLLOW_epilogue_directive_in_debug_directive3411 = new BitSet(new long[]{0x0000000000000002L});
   15404 	public static final BitSet FOLLOW_source_directive_in_debug_directive3417 = new BitSet(new long[]{0x0000000000000002L});
   15405 	public static final BitSet FOLLOW_LINE_DIRECTIVE_in_line_directive3427 = new BitSet(new long[]{0x0000000000004800L,0x0000000000000000L,0x4102400000000000L});
   15406 	public static final BitSet FOLLOW_integral_literal_in_line_directive3429 = new BitSet(new long[]{0x0000000000000002L});
   15407 	public static final BitSet FOLLOW_LOCAL_DIRECTIVE_in_local_directive3452 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15408 	public static final BitSet FOLLOW_REGISTER_in_local_directive3454 = new BitSet(new long[]{0x0000000000100002L});
   15409 	public static final BitSet FOLLOW_COMMA_in_local_directive3457 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0004000000000000L,0x0000000000000004L});
   15410 	public static final BitSet FOLLOW_NULL_LITERAL_in_local_directive3460 = new BitSet(new long[]{0x0000000000080000L});
   15411 	public static final BitSet FOLLOW_STRING_LITERAL_in_local_directive3466 = new BitSet(new long[]{0x0000000000080000L});
   15412 	public static final BitSet FOLLOW_COLON_in_local_directive3469 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0200000000000000L,0x0000000000000040L});
   15413 	public static final BitSet FOLLOW_VOID_TYPE_in_local_directive3472 = new BitSet(new long[]{0x0000000000100002L});
   15414 	public static final BitSet FOLLOW_nonvoid_type_descriptor_in_local_directive3476 = new BitSet(new long[]{0x0000000000100002L});
   15415 	public static final BitSet FOLLOW_COMMA_in_local_directive3510 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L});
   15416 	public static final BitSet FOLLOW_STRING_LITERAL_in_local_directive3514 = new BitSet(new long[]{0x0000000000000002L});
   15417 	public static final BitSet FOLLOW_END_LOCAL_DIRECTIVE_in_end_local_directive3556 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15418 	public static final BitSet FOLLOW_REGISTER_in_end_local_directive3558 = new BitSet(new long[]{0x0000000000000002L});
   15419 	public static final BitSet FOLLOW_RESTART_LOCAL_DIRECTIVE_in_restart_local_directive3581 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15420 	public static final BitSet FOLLOW_REGISTER_in_restart_local_directive3583 = new BitSet(new long[]{0x0000000000000002L});
   15421 	public static final BitSet FOLLOW_PROLOGUE_DIRECTIVE_in_prologue_directive3606 = new BitSet(new long[]{0x0000000000000002L});
   15422 	public static final BitSet FOLLOW_EPILOGUE_DIRECTIVE_in_epilogue_directive3627 = new BitSet(new long[]{0x0000000000000002L});
   15423 	public static final BitSet FOLLOW_SOURCE_DIRECTIVE_in_source_directive3648 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L});
   15424 	public static final BitSet FOLLOW_STRING_LITERAL_in_source_directive3650 = new BitSet(new long[]{0x0000000000000002L});
   15425 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT12x_in_instruction_format12x3675 = new BitSet(new long[]{0x0000000000000002L});
   15426 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT12x_OR_ID_in_instruction_format12x3681 = new BitSet(new long[]{0x0000000000000002L});
   15427 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT22s_in_instruction_format22s3696 = new BitSet(new long[]{0x0000000000000002L});
   15428 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT22s_OR_ID_in_instruction_format22s3702 = new BitSet(new long[]{0x0000000000000002L});
   15429 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT31i_in_instruction_format31i3717 = new BitSet(new long[]{0x0000000000000002L});
   15430 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT31i_OR_ID_in_instruction_format31i3723 = new BitSet(new long[]{0x0000000000000002L});
   15431 	public static final BitSet FOLLOW_insn_format10t_in_instruction3740 = new BitSet(new long[]{0x0000000000000002L});
   15432 	public static final BitSet FOLLOW_insn_format10x_in_instruction3746 = new BitSet(new long[]{0x0000000000000002L});
   15433 	public static final BitSet FOLLOW_insn_format10x_odex_in_instruction3752 = new BitSet(new long[]{0x0000000000000002L});
   15434 	public static final BitSet FOLLOW_insn_format11n_in_instruction3758 = new BitSet(new long[]{0x0000000000000002L});
   15435 	public static final BitSet FOLLOW_insn_format11x_in_instruction3764 = new BitSet(new long[]{0x0000000000000002L});
   15436 	public static final BitSet FOLLOW_insn_format12x_in_instruction3770 = new BitSet(new long[]{0x0000000000000002L});
   15437 	public static final BitSet FOLLOW_insn_format20bc_in_instruction3776 = new BitSet(new long[]{0x0000000000000002L});
   15438 	public static final BitSet FOLLOW_insn_format20t_in_instruction3782 = new BitSet(new long[]{0x0000000000000002L});
   15439 	public static final BitSet FOLLOW_insn_format21c_field_in_instruction3788 = new BitSet(new long[]{0x0000000000000002L});
   15440 	public static final BitSet FOLLOW_insn_format21c_field_odex_in_instruction3794 = new BitSet(new long[]{0x0000000000000002L});
   15441 	public static final BitSet FOLLOW_insn_format21c_string_in_instruction3800 = new BitSet(new long[]{0x0000000000000002L});
   15442 	public static final BitSet FOLLOW_insn_format21c_type_in_instruction3806 = new BitSet(new long[]{0x0000000000000002L});
   15443 	public static final BitSet FOLLOW_insn_format21ih_in_instruction3812 = new BitSet(new long[]{0x0000000000000002L});
   15444 	public static final BitSet FOLLOW_insn_format21lh_in_instruction3818 = new BitSet(new long[]{0x0000000000000002L});
   15445 	public static final BitSet FOLLOW_insn_format21s_in_instruction3824 = new BitSet(new long[]{0x0000000000000002L});
   15446 	public static final BitSet FOLLOW_insn_format21t_in_instruction3830 = new BitSet(new long[]{0x0000000000000002L});
   15447 	public static final BitSet FOLLOW_insn_format22b_in_instruction3836 = new BitSet(new long[]{0x0000000000000002L});
   15448 	public static final BitSet FOLLOW_insn_format22c_field_in_instruction3842 = new BitSet(new long[]{0x0000000000000002L});
   15449 	public static final BitSet FOLLOW_insn_format22c_field_odex_in_instruction3848 = new BitSet(new long[]{0x0000000000000002L});
   15450 	public static final BitSet FOLLOW_insn_format22c_type_in_instruction3854 = new BitSet(new long[]{0x0000000000000002L});
   15451 	public static final BitSet FOLLOW_insn_format22cs_field_in_instruction3860 = new BitSet(new long[]{0x0000000000000002L});
   15452 	public static final BitSet FOLLOW_insn_format22s_in_instruction3866 = new BitSet(new long[]{0x0000000000000002L});
   15453 	public static final BitSet FOLLOW_insn_format22t_in_instruction3872 = new BitSet(new long[]{0x0000000000000002L});
   15454 	public static final BitSet FOLLOW_insn_format22x_in_instruction3878 = new BitSet(new long[]{0x0000000000000002L});
   15455 	public static final BitSet FOLLOW_insn_format23x_in_instruction3884 = new BitSet(new long[]{0x0000000000000002L});
   15456 	public static final BitSet FOLLOW_insn_format30t_in_instruction3890 = new BitSet(new long[]{0x0000000000000002L});
   15457 	public static final BitSet FOLLOW_insn_format31c_in_instruction3896 = new BitSet(new long[]{0x0000000000000002L});
   15458 	public static final BitSet FOLLOW_insn_format31i_in_instruction3902 = new BitSet(new long[]{0x0000000000000002L});
   15459 	public static final BitSet FOLLOW_insn_format31t_in_instruction3908 = new BitSet(new long[]{0x0000000000000002L});
   15460 	public static final BitSet FOLLOW_insn_format32x_in_instruction3914 = new BitSet(new long[]{0x0000000000000002L});
   15461 	public static final BitSet FOLLOW_insn_format35c_method_in_instruction3920 = new BitSet(new long[]{0x0000000000000002L});
   15462 	public static final BitSet FOLLOW_insn_format35c_type_in_instruction3926 = new BitSet(new long[]{0x0000000000000002L});
   15463 	public static final BitSet FOLLOW_insn_format35c_method_odex_in_instruction3932 = new BitSet(new long[]{0x0000000000000002L});
   15464 	public static final BitSet FOLLOW_insn_format35mi_method_in_instruction3938 = new BitSet(new long[]{0x0000000000000002L});
   15465 	public static final BitSet FOLLOW_insn_format35ms_method_in_instruction3944 = new BitSet(new long[]{0x0000000000000002L});
   15466 	public static final BitSet FOLLOW_insn_format3rc_method_in_instruction3950 = new BitSet(new long[]{0x0000000000000002L});
   15467 	public static final BitSet FOLLOW_insn_format3rc_method_odex_in_instruction3956 = new BitSet(new long[]{0x0000000000000002L});
   15468 	public static final BitSet FOLLOW_insn_format3rc_type_in_instruction3962 = new BitSet(new long[]{0x0000000000000002L});
   15469 	public static final BitSet FOLLOW_insn_format3rmi_method_in_instruction3968 = new BitSet(new long[]{0x0000000000000002L});
   15470 	public static final BitSet FOLLOW_insn_format3rms_method_in_instruction3974 = new BitSet(new long[]{0x0000000000000002L});
   15471 	public static final BitSet FOLLOW_insn_format45cc_method_in_instruction3980 = new BitSet(new long[]{0x0000000000000002L});
   15472 	public static final BitSet FOLLOW_insn_format4rcc_method_in_instruction3986 = new BitSet(new long[]{0x0000000000000002L});
   15473 	public static final BitSet FOLLOW_insn_format51l_in_instruction3992 = new BitSet(new long[]{0x0000000000000002L});
   15474 	public static final BitSet FOLLOW_insn_array_data_directive_in_instruction3998 = new BitSet(new long[]{0x0000000000000002L});
   15475 	public static final BitSet FOLLOW_insn_packed_switch_directive_in_instruction4004 = new BitSet(new long[]{0x0000000000000002L});
   15476 	public static final BitSet FOLLOW_insn_sparse_switch_directive_in_instruction4010 = new BitSet(new long[]{0x0000000000000002L});
   15477 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT10t_in_insn_format10t4030 = new BitSet(new long[]{0x0000000000080000L});
   15478 	public static final BitSet FOLLOW_label_ref_in_insn_format10t4032 = new BitSet(new long[]{0x0000000000000002L});
   15479 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT10x_in_insn_format10x4062 = new BitSet(new long[]{0x0000000000000002L});
   15480 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT10x_ODEX_in_insn_format10x_odex4090 = new BitSet(new long[]{0x0000000000000002L});
   15481 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT11n_in_insn_format11n4111 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15482 	public static final BitSet FOLLOW_REGISTER_in_insn_format11n4113 = new BitSet(new long[]{0x0000000000100000L});
   15483 	public static final BitSet FOLLOW_COMMA_in_insn_format11n4115 = new BitSet(new long[]{0x0000000000004800L,0x0000000000000000L,0x4102400000000000L});
   15484 	public static final BitSet FOLLOW_integral_literal_in_insn_format11n4117 = new BitSet(new long[]{0x0000000000000002L});
   15485 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT11x_in_insn_format11x4149 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15486 	public static final BitSet FOLLOW_REGISTER_in_insn_format11x4151 = new BitSet(new long[]{0x0000000000000002L});
   15487 	public static final BitSet FOLLOW_instruction_format12x_in_insn_format12x4181 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15488 	public static final BitSet FOLLOW_REGISTER_in_insn_format12x4183 = new BitSet(new long[]{0x0000000000100000L});
   15489 	public static final BitSet FOLLOW_COMMA_in_insn_format12x4185 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15490 	public static final BitSet FOLLOW_REGISTER_in_insn_format12x4187 = new BitSet(new long[]{0x0000000000000002L});
   15491 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT20bc_in_insn_format20bc4219 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000020L});
   15492 	public static final BitSet FOLLOW_VERIFICATION_ERROR_TYPE_in_insn_format20bc4221 = new BitSet(new long[]{0x0000000000100000L});
   15493 	public static final BitSet FOLLOW_COMMA_in_insn_format20bc4223 = new BitSet(new long[]{0xF4795C8000808550L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L});
   15494 	public static final BitSet FOLLOW_verification_error_reference_in_insn_format20bc4225 = new BitSet(new long[]{0x0000000000000002L});
   15495 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT20t_in_insn_format20t4262 = new BitSet(new long[]{0x0000000000080000L});
   15496 	public static final BitSet FOLLOW_label_ref_in_insn_format20t4264 = new BitSet(new long[]{0x0000000000000002L});
   15497 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_FIELD_in_insn_format21c_field4294 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15498 	public static final BitSet FOLLOW_REGISTER_in_insn_format21c_field4296 = new BitSet(new long[]{0x0000000000100000L});
   15499 	public static final BitSet FOLLOW_COMMA_in_insn_format21c_field4298 = new BitSet(new long[]{0xF4795C8000808550L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L});
   15500 	public static final BitSet FOLLOW_field_reference_in_insn_format21c_field4300 = new BitSet(new long[]{0x0000000000000002L});
   15501 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_FIELD_ODEX_in_insn_format21c_field_odex4332 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15502 	public static final BitSet FOLLOW_REGISTER_in_insn_format21c_field_odex4334 = new BitSet(new long[]{0x0000000000100000L});
   15503 	public static final BitSet FOLLOW_COMMA_in_insn_format21c_field_odex4336 = new BitSet(new long[]{0xF4795C8000808550L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L});
   15504 	public static final BitSet FOLLOW_field_reference_in_insn_format21c_field_odex4338 = new BitSet(new long[]{0x0000000000000002L});
   15505 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_STRING_in_insn_format21c_string4376 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15506 	public static final BitSet FOLLOW_REGISTER_in_insn_format21c_string4378 = new BitSet(new long[]{0x0000000000100000L});
   15507 	public static final BitSet FOLLOW_COMMA_in_insn_format21c_string4380 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L});
   15508 	public static final BitSet FOLLOW_STRING_LITERAL_in_insn_format21c_string4382 = new BitSet(new long[]{0x0000000000000002L});
   15509 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_TYPE_in_insn_format21c_type4414 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15510 	public static final BitSet FOLLOW_REGISTER_in_insn_format21c_type4416 = new BitSet(new long[]{0x0000000000100000L});
   15511 	public static final BitSet FOLLOW_COMMA_in_insn_format21c_type4418 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0200000000000000L});
   15512 	public static final BitSet FOLLOW_nonvoid_type_descriptor_in_insn_format21c_type4420 = new BitSet(new long[]{0x0000000000000002L});
   15513 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT21ih_in_insn_format21ih4452 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15514 	public static final BitSet FOLLOW_REGISTER_in_insn_format21ih4454 = new BitSet(new long[]{0x0000000000100000L});
   15515 	public static final BitSet FOLLOW_COMMA_in_insn_format21ih4456 = new BitSet(new long[]{0x000000C000004C00L,0x0000000000000000L,0x4102400000000000L});
   15516 	public static final BitSet FOLLOW_fixed_32bit_literal_in_insn_format21ih4458 = new BitSet(new long[]{0x0000000000000002L});
   15517 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT21lh_in_insn_format21lh4490 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15518 	public static final BitSet FOLLOW_REGISTER_in_insn_format21lh4492 = new BitSet(new long[]{0x0000000000100000L});
   15519 	public static final BitSet FOLLOW_COMMA_in_insn_format21lh4494 = new BitSet(new long[]{0x000000C000004C00L,0x0000000000000000L,0x4102400000000000L});
   15520 	public static final BitSet FOLLOW_fixed_32bit_literal_in_insn_format21lh4496 = new BitSet(new long[]{0x0000000000000002L});
   15521 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT21s_in_insn_format21s4528 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15522 	public static final BitSet FOLLOW_REGISTER_in_insn_format21s4530 = new BitSet(new long[]{0x0000000000100000L});
   15523 	public static final BitSet FOLLOW_COMMA_in_insn_format21s4532 = new BitSet(new long[]{0x0000000000004800L,0x0000000000000000L,0x4102400000000000L});
   15524 	public static final BitSet FOLLOW_integral_literal_in_insn_format21s4534 = new BitSet(new long[]{0x0000000000000002L});
   15525 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT21t_in_insn_format21t4566 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15526 	public static final BitSet FOLLOW_REGISTER_in_insn_format21t4568 = new BitSet(new long[]{0x0000000000100000L});
   15527 	public static final BitSet FOLLOW_COMMA_in_insn_format21t4570 = new BitSet(new long[]{0x0000000000080000L});
   15528 	public static final BitSet FOLLOW_label_ref_in_insn_format21t4572 = new BitSet(new long[]{0x0000000000000002L});
   15529 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT22b_in_insn_format22b4604 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15530 	public static final BitSet FOLLOW_REGISTER_in_insn_format22b4606 = new BitSet(new long[]{0x0000000000100000L});
   15531 	public static final BitSet FOLLOW_COMMA_in_insn_format22b4608 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15532 	public static final BitSet FOLLOW_REGISTER_in_insn_format22b4610 = new BitSet(new long[]{0x0000000000100000L});
   15533 	public static final BitSet FOLLOW_COMMA_in_insn_format22b4612 = new BitSet(new long[]{0x0000000000004800L,0x0000000000000000L,0x4102400000000000L});
   15534 	public static final BitSet FOLLOW_integral_literal_in_insn_format22b4614 = new BitSet(new long[]{0x0000000000000002L});
   15535 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT22c_FIELD_in_insn_format22c_field4648 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15536 	public static final BitSet FOLLOW_REGISTER_in_insn_format22c_field4650 = new BitSet(new long[]{0x0000000000100000L});
   15537 	public static final BitSet FOLLOW_COMMA_in_insn_format22c_field4652 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15538 	public static final BitSet FOLLOW_REGISTER_in_insn_format22c_field4654 = new BitSet(new long[]{0x0000000000100000L});
   15539 	public static final BitSet FOLLOW_COMMA_in_insn_format22c_field4656 = new BitSet(new long[]{0xF4795C8000808550L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L});
   15540 	public static final BitSet FOLLOW_field_reference_in_insn_format22c_field4658 = new BitSet(new long[]{0x0000000000000002L});
   15541 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT22c_FIELD_ODEX_in_insn_format22c_field_odex4692 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15542 	public static final BitSet FOLLOW_REGISTER_in_insn_format22c_field_odex4694 = new BitSet(new long[]{0x0000000000100000L});
   15543 	public static final BitSet FOLLOW_COMMA_in_insn_format22c_field_odex4696 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15544 	public static final BitSet FOLLOW_REGISTER_in_insn_format22c_field_odex4698 = new BitSet(new long[]{0x0000000000100000L});
   15545 	public static final BitSet FOLLOW_COMMA_in_insn_format22c_field_odex4700 = new BitSet(new long[]{0xF4795C8000808550L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L});
   15546 	public static final BitSet FOLLOW_field_reference_in_insn_format22c_field_odex4702 = new BitSet(new long[]{0x0000000000000002L});
   15547 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT22c_TYPE_in_insn_format22c_type4742 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15548 	public static final BitSet FOLLOW_REGISTER_in_insn_format22c_type4744 = new BitSet(new long[]{0x0000000000100000L});
   15549 	public static final BitSet FOLLOW_COMMA_in_insn_format22c_type4746 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15550 	public static final BitSet FOLLOW_REGISTER_in_insn_format22c_type4748 = new BitSet(new long[]{0x0000000000100000L});
   15551 	public static final BitSet FOLLOW_COMMA_in_insn_format22c_type4750 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0200000000000000L});
   15552 	public static final BitSet FOLLOW_nonvoid_type_descriptor_in_insn_format22c_type4752 = new BitSet(new long[]{0x0000000000000002L});
   15553 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT22cs_FIELD_in_insn_format22cs_field4786 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15554 	public static final BitSet FOLLOW_REGISTER_in_insn_format22cs_field4788 = new BitSet(new long[]{0x0000000000100000L});
   15555 	public static final BitSet FOLLOW_COMMA_in_insn_format22cs_field4790 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15556 	public static final BitSet FOLLOW_REGISTER_in_insn_format22cs_field4792 = new BitSet(new long[]{0x0000000000100000L});
   15557 	public static final BitSet FOLLOW_COMMA_in_insn_format22cs_field4794 = new BitSet(new long[]{0x0000002000000000L});
   15558 	public static final BitSet FOLLOW_FIELD_OFFSET_in_insn_format22cs_field4796 = new BitSet(new long[]{0x0000000000000002L});
   15559 	public static final BitSet FOLLOW_instruction_format22s_in_insn_format22s4817 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15560 	public static final BitSet FOLLOW_REGISTER_in_insn_format22s4819 = new BitSet(new long[]{0x0000000000100000L});
   15561 	public static final BitSet FOLLOW_COMMA_in_insn_format22s4821 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15562 	public static final BitSet FOLLOW_REGISTER_in_insn_format22s4823 = new BitSet(new long[]{0x0000000000100000L});
   15563 	public static final BitSet FOLLOW_COMMA_in_insn_format22s4825 = new BitSet(new long[]{0x0000000000004800L,0x0000000000000000L,0x4102400000000000L});
   15564 	public static final BitSet FOLLOW_integral_literal_in_insn_format22s4827 = new BitSet(new long[]{0x0000000000000002L});
   15565 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT22t_in_insn_format22t4861 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15566 	public static final BitSet FOLLOW_REGISTER_in_insn_format22t4863 = new BitSet(new long[]{0x0000000000100000L});
   15567 	public static final BitSet FOLLOW_COMMA_in_insn_format22t4865 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15568 	public static final BitSet FOLLOW_REGISTER_in_insn_format22t4867 = new BitSet(new long[]{0x0000000000100000L});
   15569 	public static final BitSet FOLLOW_COMMA_in_insn_format22t4869 = new BitSet(new long[]{0x0000000000080000L});
   15570 	public static final BitSet FOLLOW_label_ref_in_insn_format22t4871 = new BitSet(new long[]{0x0000000000000002L});
   15571 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT22x_in_insn_format22x4905 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15572 	public static final BitSet FOLLOW_REGISTER_in_insn_format22x4907 = new BitSet(new long[]{0x0000000000100000L});
   15573 	public static final BitSet FOLLOW_COMMA_in_insn_format22x4909 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15574 	public static final BitSet FOLLOW_REGISTER_in_insn_format22x4911 = new BitSet(new long[]{0x0000000000000002L});
   15575 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT23x_in_insn_format23x4943 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15576 	public static final BitSet FOLLOW_REGISTER_in_insn_format23x4945 = new BitSet(new long[]{0x0000000000100000L});
   15577 	public static final BitSet FOLLOW_COMMA_in_insn_format23x4947 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15578 	public static final BitSet FOLLOW_REGISTER_in_insn_format23x4949 = new BitSet(new long[]{0x0000000000100000L});
   15579 	public static final BitSet FOLLOW_COMMA_in_insn_format23x4951 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15580 	public static final BitSet FOLLOW_REGISTER_in_insn_format23x4953 = new BitSet(new long[]{0x0000000000000002L});
   15581 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT30t_in_insn_format30t4987 = new BitSet(new long[]{0x0000000000080000L});
   15582 	public static final BitSet FOLLOW_label_ref_in_insn_format30t4989 = new BitSet(new long[]{0x0000000000000002L});
   15583 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT31c_in_insn_format31c5019 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15584 	public static final BitSet FOLLOW_REGISTER_in_insn_format31c5021 = new BitSet(new long[]{0x0000000000100000L});
   15585 	public static final BitSet FOLLOW_COMMA_in_insn_format31c5023 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L});
   15586 	public static final BitSet FOLLOW_STRING_LITERAL_in_insn_format31c5025 = new BitSet(new long[]{0x0000000000000002L});
   15587 	public static final BitSet FOLLOW_instruction_format31i_in_insn_format31i5056 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15588 	public static final BitSet FOLLOW_REGISTER_in_insn_format31i5058 = new BitSet(new long[]{0x0000000000100000L});
   15589 	public static final BitSet FOLLOW_COMMA_in_insn_format31i5060 = new BitSet(new long[]{0x000000C000004C00L,0x0000000000000000L,0x4102400000000000L});
   15590 	public static final BitSet FOLLOW_fixed_32bit_literal_in_insn_format31i5062 = new BitSet(new long[]{0x0000000000000002L});
   15591 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT31t_in_insn_format31t5094 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15592 	public static final BitSet FOLLOW_REGISTER_in_insn_format31t5096 = new BitSet(new long[]{0x0000000000100000L});
   15593 	public static final BitSet FOLLOW_COMMA_in_insn_format31t5098 = new BitSet(new long[]{0x0000000000080000L});
   15594 	public static final BitSet FOLLOW_label_ref_in_insn_format31t5100 = new BitSet(new long[]{0x0000000000000002L});
   15595 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT32x_in_insn_format32x5132 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15596 	public static final BitSet FOLLOW_REGISTER_in_insn_format32x5134 = new BitSet(new long[]{0x0000000000100000L});
   15597 	public static final BitSet FOLLOW_COMMA_in_insn_format32x5136 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15598 	public static final BitSet FOLLOW_REGISTER_in_insn_format32x5138 = new BitSet(new long[]{0x0000000000000002L});
   15599 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT35c_METHOD_in_insn_format35c_method5170 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0008000000000000L});
   15600 	public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format35c_method5172 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0800000000000000L});
   15601 	public static final BitSet FOLLOW_register_list_in_insn_format35c_method5174 = new BitSet(new long[]{0x0000000000020000L});
   15602 	public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format35c_method5176 = new BitSet(new long[]{0x0000000000100000L});
   15603 	public static final BitSet FOLLOW_COMMA_in_insn_format35c_method5178 = new BitSet(new long[]{0xF4795C8000808550L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L});
   15604 	public static final BitSet FOLLOW_method_reference_in_insn_format35c_method5180 = new BitSet(new long[]{0x0000000000000002L});
   15605 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT35c_TYPE_in_insn_format35c_type5212 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0008000000000000L});
   15606 	public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format35c_type5214 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0800000000000000L});
   15607 	public static final BitSet FOLLOW_register_list_in_insn_format35c_type5216 = new BitSet(new long[]{0x0000000000020000L});
   15608 	public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format35c_type5218 = new BitSet(new long[]{0x0000000000100000L});
   15609 	public static final BitSet FOLLOW_COMMA_in_insn_format35c_type5220 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0200000000000000L});
   15610 	public static final BitSet FOLLOW_nonvoid_type_descriptor_in_insn_format35c_type5222 = new BitSet(new long[]{0x0000000000000002L});
   15611 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT35c_METHOD_ODEX_in_insn_format35c_method_odex5254 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0008000000000000L});
   15612 	public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format35c_method_odex5256 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0800000000000000L});
   15613 	public static final BitSet FOLLOW_register_list_in_insn_format35c_method_odex5258 = new BitSet(new long[]{0x0000000000020000L});
   15614 	public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format35c_method_odex5260 = new BitSet(new long[]{0x0000000000100000L});
   15615 	public static final BitSet FOLLOW_COMMA_in_insn_format35c_method_odex5262 = new BitSet(new long[]{0xF4795C8000808550L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L});
   15616 	public static final BitSet FOLLOW_method_reference_in_insn_format35c_method_odex5264 = new BitSet(new long[]{0x0000000000000002L});
   15617 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT35mi_METHOD_in_insn_format35mi_method5285 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0008000000000000L});
   15618 	public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format35mi_method5287 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0800000000000000L});
   15619 	public static final BitSet FOLLOW_register_list_in_insn_format35mi_method5289 = new BitSet(new long[]{0x0000000000020000L});
   15620 	public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format35mi_method5291 = new BitSet(new long[]{0x0000000000100000L});
   15621 	public static final BitSet FOLLOW_COMMA_in_insn_format35mi_method5293 = new BitSet(new long[]{0x0000020000000000L});
   15622 	public static final BitSet FOLLOW_INLINE_INDEX_in_insn_format35mi_method5295 = new BitSet(new long[]{0x0000000000000002L});
   15623 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT35ms_METHOD_in_insn_format35ms_method5316 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0008000000000000L});
   15624 	public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format35ms_method5318 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0800000000000000L});
   15625 	public static final BitSet FOLLOW_register_list_in_insn_format35ms_method5320 = new BitSet(new long[]{0x0000000000020000L});
   15626 	public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format35ms_method5322 = new BitSet(new long[]{0x0000000000100000L});
   15627 	public static final BitSet FOLLOW_COMMA_in_insn_format35ms_method5324 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000080L});
   15628 	public static final BitSet FOLLOW_VTABLE_INDEX_in_insn_format35ms_method5326 = new BitSet(new long[]{0x0000000000000002L});
   15629 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT3rc_METHOD_in_insn_format3rc_method5347 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0008000000000000L});
   15630 	public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format3rc_method5349 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0800000000000000L});
   15631 	public static final BitSet FOLLOW_register_range_in_insn_format3rc_method5351 = new BitSet(new long[]{0x0000000000020000L});
   15632 	public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format3rc_method5353 = new BitSet(new long[]{0x0000000000100000L});
   15633 	public static final BitSet FOLLOW_COMMA_in_insn_format3rc_method5355 = new BitSet(new long[]{0xF4795C8000808550L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L});
   15634 	public static final BitSet FOLLOW_method_reference_in_insn_format3rc_method5357 = new BitSet(new long[]{0x0000000000000002L});
   15635 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT3rc_METHOD_ODEX_in_insn_format3rc_method_odex5389 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0008000000000000L});
   15636 	public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format3rc_method_odex5391 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0800000000000000L});
   15637 	public static final BitSet FOLLOW_register_list_in_insn_format3rc_method_odex5393 = new BitSet(new long[]{0x0000000000020000L});
   15638 	public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format3rc_method_odex5395 = new BitSet(new long[]{0x0000000000100000L});
   15639 	public static final BitSet FOLLOW_COMMA_in_insn_format3rc_method_odex5397 = new BitSet(new long[]{0xF4795C8000808550L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L});
   15640 	public static final BitSet FOLLOW_method_reference_in_insn_format3rc_method_odex5399 = new BitSet(new long[]{0x0000000000000002L});
   15641 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT3rc_TYPE_in_insn_format3rc_type5420 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0008000000000000L});
   15642 	public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format3rc_type5422 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0800000000000000L});
   15643 	public static final BitSet FOLLOW_register_range_in_insn_format3rc_type5424 = new BitSet(new long[]{0x0000000000020000L});
   15644 	public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format3rc_type5426 = new BitSet(new long[]{0x0000000000100000L});
   15645 	public static final BitSet FOLLOW_COMMA_in_insn_format3rc_type5428 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0200000000000000L});
   15646 	public static final BitSet FOLLOW_nonvoid_type_descriptor_in_insn_format3rc_type5430 = new BitSet(new long[]{0x0000000000000002L});
   15647 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT3rmi_METHOD_in_insn_format3rmi_method5462 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0008000000000000L});
   15648 	public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format3rmi_method5464 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0800000000000000L});
   15649 	public static final BitSet FOLLOW_register_range_in_insn_format3rmi_method5466 = new BitSet(new long[]{0x0000000000020000L});
   15650 	public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format3rmi_method5468 = new BitSet(new long[]{0x0000000000100000L});
   15651 	public static final BitSet FOLLOW_COMMA_in_insn_format3rmi_method5470 = new BitSet(new long[]{0x0000020000000000L});
   15652 	public static final BitSet FOLLOW_INLINE_INDEX_in_insn_format3rmi_method5472 = new BitSet(new long[]{0x0000000000000002L});
   15653 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT3rms_METHOD_in_insn_format3rms_method5493 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0008000000000000L});
   15654 	public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format3rms_method5495 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0800000000000000L});
   15655 	public static final BitSet FOLLOW_register_range_in_insn_format3rms_method5497 = new BitSet(new long[]{0x0000000000020000L});
   15656 	public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format3rms_method5499 = new BitSet(new long[]{0x0000000000100000L});
   15657 	public static final BitSet FOLLOW_COMMA_in_insn_format3rms_method5501 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000080L});
   15658 	public static final BitSet FOLLOW_VTABLE_INDEX_in_insn_format3rms_method5503 = new BitSet(new long[]{0x0000000000000002L});
   15659 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT45cc_METHOD_in_insn_format45cc_method5524 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0008000000000000L});
   15660 	public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format45cc_method5526 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0800000000000000L});
   15661 	public static final BitSet FOLLOW_register_list_in_insn_format45cc_method5528 = new BitSet(new long[]{0x0000000000020000L});
   15662 	public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format45cc_method5530 = new BitSet(new long[]{0x0000000000100000L});
   15663 	public static final BitSet FOLLOW_COMMA_in_insn_format45cc_method5532 = new BitSet(new long[]{0xF4795C8000808550L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L});
   15664 	public static final BitSet FOLLOW_method_reference_in_insn_format45cc_method5534 = new BitSet(new long[]{0x0000000000100000L});
   15665 	public static final BitSet FOLLOW_COMMA_in_insn_format45cc_method5536 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0010000000000000L});
   15666 	public static final BitSet FOLLOW_method_prototype_in_insn_format45cc_method5538 = new BitSet(new long[]{0x0000000000000002L});
   15667 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT4rcc_METHOD_in_insn_format4rcc_method5572 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0008000000000000L});
   15668 	public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format4rcc_method5574 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0800000000000000L});
   15669 	public static final BitSet FOLLOW_register_range_in_insn_format4rcc_method5576 = new BitSet(new long[]{0x0000000000020000L});
   15670 	public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format4rcc_method5578 = new BitSet(new long[]{0x0000000000100000L});
   15671 	public static final BitSet FOLLOW_COMMA_in_insn_format4rcc_method5580 = new BitSet(new long[]{0xF4795C8000808550L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L});
   15672 	public static final BitSet FOLLOW_method_reference_in_insn_format4rcc_method5582 = new BitSet(new long[]{0x0000000000100000L});
   15673 	public static final BitSet FOLLOW_COMMA_in_insn_format4rcc_method5584 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0010000000000000L});
   15674 	public static final BitSet FOLLOW_method_prototype_in_insn_format4rcc_method5586 = new BitSet(new long[]{0x0000000000000002L});
   15675 	public static final BitSet FOLLOW_INSTRUCTION_FORMAT51l_in_insn_format51l5620 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
   15676 	public static final BitSet FOLLOW_REGISTER_in_insn_format51l5622 = new BitSet(new long[]{0x0000000000100000L});
   15677 	public static final BitSet FOLLOW_COMMA_in_insn_format51l5624 = new BitSet(new long[]{0x000000C000C04C00L,0x0000000000000000L,0x4102400000000000L});
   15678 	public static final BitSet FOLLOW_fixed_literal_in_insn_format51l5626 = new BitSet(new long[]{0x0000000000000002L});
   15679 	public static final BitSet FOLLOW_ARRAY_DATA_DIRECTIVE_in_insn_array_data_directive5653 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0102000000000000L});
   15680 	public static final BitSet FOLLOW_parsed_integer_literal_in_insn_array_data_directive5659 = new BitSet(new long[]{0x000000C002C04C00L,0x0000000000000000L,0x4102400000000000L});
   15681 	public static final BitSet FOLLOW_fixed_literal_in_insn_array_data_directive5671 = new BitSet(new long[]{0x000000C002C04C00L,0x0000000000000000L,0x4102400000000000L});
   15682 	public static final BitSet FOLLOW_END_ARRAY_DATA_DIRECTIVE_in_insn_array_data_directive5674 = new BitSet(new long[]{0x0000000000000002L});
   15683 	public static final BitSet FOLLOW_PACKED_SWITCH_DIRECTIVE_in_insn_packed_switch_directive5720 = new BitSet(new long[]{0x000000C000004C00L,0x0000000000000000L,0x4102400000000000L});
   15684 	public static final BitSet FOLLOW_fixed_32bit_literal_in_insn_packed_switch_directive5726 = new BitSet(new long[]{0x0000000020080000L});
   15685 	public static final BitSet FOLLOW_label_ref_in_insn_packed_switch_directive5732 = new BitSet(new long[]{0x0000000020080000L});
   15686 	public static final BitSet FOLLOW_END_PACKED_SWITCH_DIRECTIVE_in_insn_packed_switch_directive5739 = new BitSet(new long[]{0x0000000000000002L});
   15687 	public static final BitSet FOLLOW_SPARSE_SWITCH_DIRECTIVE_in_insn_sparse_switch_directive5813 = new BitSet(new long[]{0x000000C080004C00L,0x0000000000000000L,0x4102400000000000L});
   15688 	public static final BitSet FOLLOW_fixed_32bit_literal_in_insn_sparse_switch_directive5820 = new BitSet(new long[]{0x0000000000000200L});
   15689 	public static final BitSet FOLLOW_ARROW_in_insn_sparse_switch_directive5822 = new BitSet(new long[]{0x0000000000080000L});
   15690 	public static final BitSet FOLLOW_label_ref_in_insn_sparse_switch_directive5824 = new BitSet(new long[]{0x000000C080004C00L,0x0000000000000000L,0x4102400000000000L});
   15691 	public static final BitSet FOLLOW_END_SPARSE_SWITCH_DIRECTIVE_in_insn_sparse_switch_directive5832 = new BitSet(new long[]{0x0000000000000002L});
   15692 }
   15693