/** \file
 *  This OBJC source file was generated by $ANTLR version ${project.version} ${buildNumber}
 *
 *     -  From the grammar source file : SimpleC.g
 *     -                            On : 2011-05-06 15:09:17
 *     -                for the parser : SimpleCParserParser
 *
 * Editing it, at least manually, is not wise.
 *
 * ObjC language generator and runtime by Alan Condit, acondit|hereisanat|ipns|dotgoeshere|com.
 *
 *
*/
// $ANTLR ${project.version} ${buildNumber} SimpleC.g 2011-05-06 15:09:17


/* -----------------------------------------
 * Include the ANTLR3 generated header file.
 */
#import "SimpleCParser.h"
/* ----------------------------------------- */


/* ============================================================================= */
/* =============================================================================
 * Start of recognizer
 */
#pragma mark Cyclic DFA implementation start DFA2
@implementation DFA2
const static NSInteger dfa2_eot[13] =
    {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
const static NSInteger dfa2_eof[13] =
    {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
const static unichar dfa2_min[13] =
    {9,14,18,9,0,14,17,10,0,0,9,14,10};
const static unichar dfa2_max[13] =
    {24,14,23,24,0,14,23,22,0,0,24,14,22};
const static NSInteger dfa2_accept[13] =
    {-1,-1,-1,-1,1,-1,-1,-1,2,3,-1,-1,-1};
const static NSInteger dfa2_special[13] =
    {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
const static NSInteger dfa2_transition[] = {};
const static NSInteger dfa2_transition0[] = {9, -1, -1, -1, -1, -1, 8};
const static NSInteger dfa2_transition1[] = {10, -1, -1, -1, -1, -1, -1, 
 -1, -1, -1, -1, -1, 6};
const static NSInteger dfa2_transition2[] = {5, -1, -1, -1, -1, 5, -1, 5, 
 -1, -1, -1, -1, -1, 6, -1, 5};
const static NSInteger dfa2_transition3[] = {11, -1, -1, -1, -1, 11, -1, 
 11, -1, -1, -1, -1, -1, -1, -1, 11};
const static NSInteger dfa2_transition4[] = {3, -1, -1, -1, -1, 4};
const static NSInteger dfa2_transition5[] = {1, -1, -1, -1, -1, 1, -1, 1, 
 -1, -1, -1, -1, -1, -1, -1, 1};
const static NSInteger dfa2_transition6[] = {7};
const static NSInteger dfa2_transition7[] = {12};
const static NSInteger dfa2_transition8[] = {2};


+ (id) newDFA2WithRecognizer:(ANTLRBaseRecognizer *)aRecognizer
{
    return [[[DFA2 alloc] initWithRecognizer:aRecognizer] retain];
}

- (id) initWithRecognizer:(ANTLRBaseRecognizer *) theRecognizer
{
    self = [super initWithRecognizer:theRecognizer];
    if ( self != nil ) {
        decisionNumber = 2;
        eot = dfa2_eot;
        eof = dfa2_eof;
        min = dfa2_min;
        max = dfa2_max;
        accept = dfa2_accept;
        special = dfa2_special;
        if (!(transition = calloc(13, sizeof(void*)))) {
            [self release];
            return nil;
        }
        len = 13;
        transition[0] = dfa2_transition5;
        transition[1] = dfa2_transition8;
        transition[2] = dfa2_transition4;
        transition[3] = dfa2_transition2;

        transition[4] = dfa2_transition6;
        transition[5] = dfa2_transition0;
        transition[6] = dfa2_transition1;


        transition[7] = dfa2_transition3;
        transition[8] = dfa2_transition7;
        transition[9] = dfa2_transition1;
    }
    return self;
}

- (void) dealloc
{
    free(transition);
    [super dealloc];
}

- (NSString *) description
{
    return @"20:1: declaration : ( variable | functionHeader K_SEMICOLON -> ^( FUNC_DECL functionHeader ) | functionHeader block -> ^( FUNC_DEF functionHeader block ) );";
}


@end /* end DFA2 implementation */

#pragma mark Cyclic DFA implementation end DFA2


#pragma mark Bitsets
static ANTLRBitSet *FOLLOW_declaration_in_program85;
static const unsigned long long FOLLOW_declaration_in_program85_data[] = { 0x0000000001014202LL};
static ANTLRBitSet *FOLLOW_variable_in_declaration105;
static const unsigned long long FOLLOW_variable_in_declaration105_data[] = { 0x0000000000000002LL};
static ANTLRBitSet *FOLLOW_functionHeader_in_declaration115;
static const unsigned long long FOLLOW_functionHeader_in_declaration115_data[] = { 0x0000000000800000LL};
static ANTLRBitSet *FOLLOW_K_SEMICOLON_in_declaration117;
static const unsigned long long FOLLOW_K_SEMICOLON_in_declaration117_data[] = { 0x0000000000000002LL};
static ANTLRBitSet *FOLLOW_functionHeader_in_declaration135;
static const unsigned long long FOLLOW_functionHeader_in_declaration135_data[] = { 0x0000000000020000LL};
static ANTLRBitSet *FOLLOW_block_in_declaration137;
static const unsigned long long FOLLOW_block_in_declaration137_data[] = { 0x0000000000000002LL};
static ANTLRBitSet *FOLLOW_type_in_variable166;
static const unsigned long long FOLLOW_type_in_variable166_data[] = { 0x0000000000004000LL};
static ANTLRBitSet *FOLLOW_declarator_in_variable168;
static const unsigned long long FOLLOW_declarator_in_variable168_data[] = { 0x0000000000800000LL};
static ANTLRBitSet *FOLLOW_K_SEMICOLON_in_variable170;
static const unsigned long long FOLLOW_K_SEMICOLON_in_variable170_data[] = { 0x0000000000000002LL};
static ANTLRBitSet *FOLLOW_K_ID_in_declarator199;
static const unsigned long long FOLLOW_K_ID_in_declarator199_data[] = { 0x0000000000000002LL};
static ANTLRBitSet *FOLLOW_type_in_functionHeader219;
static const unsigned long long FOLLOW_type_in_functionHeader219_data[] = { 0x0000000000004000LL};
static ANTLRBitSet *FOLLOW_K_ID_in_functionHeader221;
static const unsigned long long FOLLOW_K_ID_in_functionHeader221_data[] = { 0x0000000000040000LL};
static ANTLRBitSet *FOLLOW_K_LCURVE_in_functionHeader223;
static const unsigned long long FOLLOW_K_LCURVE_in_functionHeader223_data[] = { 0x0000000001414200LL};
static ANTLRBitSet *FOLLOW_formalParameter_in_functionHeader227;
static const unsigned long long FOLLOW_formalParameter_in_functionHeader227_data[] = { 0x0000000000400400LL};
static ANTLRBitSet *FOLLOW_K_COMMA_in_functionHeader231;
static const unsigned long long FOLLOW_K_COMMA_in_functionHeader231_data[] = { 0x0000000001014200LL};
static ANTLRBitSet *FOLLOW_formalParameter_in_functionHeader233;
static const unsigned long long FOLLOW_formalParameter_in_functionHeader233_data[] = { 0x0000000000400400LL};
static ANTLRBitSet *FOLLOW_K_RCURVE_in_functionHeader241;
static const unsigned long long FOLLOW_K_RCURVE_in_functionHeader241_data[] = { 0x0000000000000002LL};
static ANTLRBitSet *FOLLOW_type_in_formalParameter281;
static const unsigned long long FOLLOW_type_in_formalParameter281_data[] = { 0x0000000000004000LL};
static ANTLRBitSet *FOLLOW_declarator_in_formalParameter283;
static const unsigned long long FOLLOW_declarator_in_formalParameter283_data[] = { 0x0000000000000002LL};
static ANTLRBitSet *FOLLOW_K_LCURLY_in_block376;
static const unsigned long long FOLLOW_K_LCURLY_in_block376_data[] = { 0x0000000001A7E200LL};
static ANTLRBitSet *FOLLOW_variable_in_block390;
static const unsigned long long FOLLOW_variable_in_block390_data[] = { 0x0000000001A7E200LL};
static ANTLRBitSet *FOLLOW_stat_in_block405;
static const unsigned long long FOLLOW_stat_in_block405_data[] = { 0x0000000000A6E000LL};
static ANTLRBitSet *FOLLOW_K_RCURLY_in_block416;
static const unsigned long long FOLLOW_K_RCURLY_in_block416_data[] = { 0x0000000000000002LL};
static ANTLRBitSet *FOLLOW_forStat_in_stat449;
static const unsigned long long FOLLOW_forStat_in_stat449_data[] = { 0x0000000000000002LL};
static ANTLRBitSet *FOLLOW_expr_in_stat457;
static const unsigned long long FOLLOW_expr_in_stat457_data[] = { 0x0000000000800000LL};
static ANTLRBitSet *FOLLOW_K_SEMICOLON_in_stat459;
static const unsigned long long FOLLOW_K_SEMICOLON_in_stat459_data[] = { 0x0000000000000002LL};
static ANTLRBitSet *FOLLOW_block_in_stat468;
static const unsigned long long FOLLOW_block_in_stat468_data[] = { 0x0000000000000002LL};
static ANTLRBitSet *FOLLOW_assignStat_in_stat476;
static const unsigned long long FOLLOW_assignStat_in_stat476_data[] = { 0x0000000000800000LL};
static ANTLRBitSet *FOLLOW_K_SEMICOLON_in_stat478;
static const unsigned long long FOLLOW_K_SEMICOLON_in_stat478_data[] = { 0x0000000000000002LL};
static ANTLRBitSet *FOLLOW_K_SEMICOLON_in_stat487;
static const unsigned long long FOLLOW_K_SEMICOLON_in_stat487_data[] = { 0x0000000000000002LL};
static ANTLRBitSet *FOLLOW_K_FOR_in_forStat507;
static const unsigned long long FOLLOW_K_FOR_in_forStat507_data[] = { 0x0000000000040000LL};
static ANTLRBitSet *FOLLOW_K_LCURVE_in_forStat509;
static const unsigned long long FOLLOW_K_LCURVE_in_forStat509_data[] = { 0x0000000000004000LL};
static ANTLRBitSet *FOLLOW_assignStat_in_forStat513;
static const unsigned long long FOLLOW_assignStat_in_forStat513_data[] = { 0x0000000000800000LL};
static ANTLRBitSet *FOLLOW_K_SEMICOLON_in_forStat515;
static const unsigned long long FOLLOW_K_SEMICOLON_in_forStat515_data[] = { 0x000000000004C000LL};
static ANTLRBitSet *FOLLOW_expr_in_forStat517;
static const unsigned long long FOLLOW_expr_in_forStat517_data[] = { 0x0000000000800000LL};
static ANTLRBitSet *FOLLOW_K_SEMICOLON_in_forStat519;
static const unsigned long long FOLLOW_K_SEMICOLON_in_forStat519_data[] = { 0x0000000000004000LL};
static ANTLRBitSet *FOLLOW_assignStat_in_forStat523;
static const unsigned long long FOLLOW_assignStat_in_forStat523_data[] = { 0x0000000000400000LL};
static ANTLRBitSet *FOLLOW_K_RCURVE_in_forStat525;
static const unsigned long long FOLLOW_K_RCURVE_in_forStat525_data[] = { 0x0000000000020000LL};
static ANTLRBitSet *FOLLOW_block_in_forStat527;
static const unsigned long long FOLLOW_block_in_forStat527_data[] = { 0x0000000000000002LL};
static ANTLRBitSet *FOLLOW_K_ID_in_assignStat570;
static const unsigned long long FOLLOW_K_ID_in_assignStat570_data[] = { 0x0000000000000800LL};
static ANTLRBitSet *FOLLOW_K_EQ_in_assignStat572;
static const unsigned long long FOLLOW_K_EQ_in_assignStat572_data[] = { 0x000000000004C000LL};
static ANTLRBitSet *FOLLOW_expr_in_assignStat574;
static const unsigned long long FOLLOW_expr_in_assignStat574_data[] = { 0x0000000000000002LL};
static ANTLRBitSet *FOLLOW_condExpr_in_expr598;
static const unsigned long long FOLLOW_condExpr_in_expr598_data[] = { 0x0000000000000002LL};
static ANTLRBitSet *FOLLOW_aexpr_in_condExpr617;
static const unsigned long long FOLLOW_aexpr_in_condExpr617_data[] = { 0x0000000000081002LL};
static ANTLRBitSet *FOLLOW_K_EQEQ_in_condExpr622;
static const unsigned long long FOLLOW_K_EQEQ_in_condExpr622_data[] = { 0x000000000004C000LL};
static ANTLRBitSet *FOLLOW_K_LT_in_condExpr627;
static const unsigned long long FOLLOW_K_LT_in_condExpr627_data[] = { 0x000000000004C000LL};
static ANTLRBitSet *FOLLOW_aexpr_in_condExpr631;
static const unsigned long long FOLLOW_aexpr_in_condExpr631_data[] = { 0x0000000000000002LL};
static ANTLRBitSet *FOLLOW_atom_in_aexpr653;
static const unsigned long long FOLLOW_atom_in_aexpr653_data[] = { 0x0000000000100002LL};
static ANTLRBitSet *FOLLOW_K_PLUS_in_aexpr657;
static const unsigned long long FOLLOW_K_PLUS_in_aexpr657_data[] = { 0x000000000004C000LL};
static ANTLRBitSet *FOLLOW_atom_in_aexpr660;
static const unsigned long long FOLLOW_atom_in_aexpr660_data[] = { 0x0000000000100002LL};
static ANTLRBitSet *FOLLOW_K_ID_in_atom680;
static const unsigned long long FOLLOW_K_ID_in_atom680_data[] = { 0x0000000000000002LL};
static ANTLRBitSet *FOLLOW_K_INT_in_atom694;
static const unsigned long long FOLLOW_K_INT_in_atom694_data[] = { 0x0000000000000002LL};
static ANTLRBitSet *FOLLOW_K_LCURVE_in_atom708;
static const unsigned long long FOLLOW_K_LCURVE_in_atom708_data[] = { 0x000000000004C000LL};
static ANTLRBitSet *FOLLOW_expr_in_atom710;
static const unsigned long long FOLLOW_expr_in_atom710_data[] = { 0x0000000000400000LL};
static ANTLRBitSet *FOLLOW_K_RCURVE_in_atom712;
static const unsigned long long FOLLOW_K_RCURVE_in_atom712_data[] = { 0x0000000000000002LL};


#pragma mark Dynamic Global Scopes

#pragma mark Dynamic Rule Scopes

#pragma mark Rule Return Scopes start
@implementation SimpleCParser_program_return /* returnScope */
/* AST returnScope.synthesize */
@synthesize tree; /* start of synthesize -- OBJC-Line 1837 */
+ (SimpleCParser_program_return *)newSimpleCParser_program_return
{
    return [[[SimpleCParser_program_return alloc] init] retain];
}

- (id) init
{
    self = [super init];
    return self;
}

/* AST returnScope.methods */
- (ANTLRCommonTree *)getTree
{
    return tree;
}

- (void) setTree:(ANTLRCommonTree *)aTree
{
    if (tree != aTree) {
        if (tree != nil) [tree release];
        if (aTree != nil) [aTree retain];
        tree = aTree;
    }
}

- (void) dealloc
{
    self.tree = nil;
    [super dealloc];
}


@end /* end of returnScope implementation */


@implementation SimpleCParser_declaration_return /* returnScope */
/* AST returnScope.synthesize */
@synthesize tree; /* start of synthesize -- OBJC-Line 1837 */
+ (SimpleCParser_declaration_return *)newSimpleCParser_declaration_return
{
    return [[[SimpleCParser_declaration_return alloc] init] retain];
}

- (id) init
{
    self = [super init];
    return self;
}

/* AST returnScope.methods */
- (ANTLRCommonTree *)getTree
{
    return tree;
}

- (void) setTree:(ANTLRCommonTree *)aTree
{
    if (tree != aTree) {
        if (tree != nil) [tree release];
        if (aTree != nil) [aTree retain];
        tree = aTree;
    }
}

- (void) dealloc
{
    self.tree = nil;
    [super dealloc];
}


@end /* end of returnScope implementation */


@implementation SimpleCParser_variable_return /* returnScope */
/* AST returnScope.synthesize */
@synthesize tree; /* start of synthesize -- OBJC-Line 1837 */
+ (SimpleCParser_variable_return *)newSimpleCParser_variable_return
{
    return [[[SimpleCParser_variable_return alloc] init] retain];
}

- (id) init
{
    self = [super init];
    return self;
}

/* AST returnScope.methods */
- (ANTLRCommonTree *)getTree
{
    return tree;
}

- (void) setTree:(ANTLRCommonTree *)aTree
{
    if (tree != aTree) {
        if (tree != nil) [tree release];
        if (aTree != nil) [aTree retain];
        tree = aTree;
    }
}

- (void) dealloc
{
    self.tree = nil;
    [super dealloc];
}


@end /* end of returnScope implementation */


@implementation SimpleCParser_declarator_return /* returnScope */
/* AST returnScope.synthesize */
@synthesize tree; /* start of synthesize -- OBJC-Line 1837 */
+ (SimpleCParser_declarator_return *)newSimpleCParser_declarator_return
{
    return [[[SimpleCParser_declarator_return alloc] init] retain];
}

- (id) init
{
    self = [super init];
    return self;
}

/* AST returnScope.methods */
- (ANTLRCommonTree *)getTree
{
    return tree;
}

- (void) setTree:(ANTLRCommonTree *)aTree
{
    if (tree != aTree) {
        if (tree != nil) [tree release];
        if (aTree != nil) [aTree retain];
        tree = aTree;
    }
}

- (void) dealloc
{
    self.tree = nil;
    [super dealloc];
}


@end /* end of returnScope implementation */


@implementation SimpleCParser_functionHeader_return /* returnScope */
/* AST returnScope.synthesize */
@synthesize tree; /* start of synthesize -- OBJC-Line 1837 */
+ (SimpleCParser_functionHeader_return *)newSimpleCParser_functionHeader_return
{
    return [[[SimpleCParser_functionHeader_return alloc] init] retain];
}

- (id) init
{
    self = [super init];
    return self;
}

/* AST returnScope.methods */
- (ANTLRCommonTree *)getTree
{
    return tree;
}

- (void) setTree:(ANTLRCommonTree *)aTree
{
    if (tree != aTree) {
        if (tree != nil) [tree release];
        if (aTree != nil) [aTree retain];
        tree = aTree;
    }
}

- (void) dealloc
{
    self.tree = nil;
    [super dealloc];
}


@end /* end of returnScope implementation */


@implementation SimpleCParser_formalParameter_return /* returnScope */
/* AST returnScope.synthesize */
@synthesize tree; /* start of synthesize -- OBJC-Line 1837 */
+ (SimpleCParser_formalParameter_return *)newSimpleCParser_formalParameter_return
{
    return [[[SimpleCParser_formalParameter_return alloc] init] retain];
}

- (id) init
{
    self = [super init];
    return self;
}

/* AST returnScope.methods */
- (ANTLRCommonTree *)getTree
{
    return tree;
}

- (void) setTree:(ANTLRCommonTree *)aTree
{
    if (tree != aTree) {
        if (tree != nil) [tree release];
        if (aTree != nil) [aTree retain];
        tree = aTree;
    }
}

- (void) dealloc
{
    self.tree = nil;
    [super dealloc];
}


@end /* end of returnScope implementation */


@implementation SimpleCParser_type_return /* returnScope */
/* AST returnScope.synthesize */
@synthesize tree; /* start of synthesize -- OBJC-Line 1837 */
+ (SimpleCParser_type_return *)newSimpleCParser_type_return
{
    return [[[SimpleCParser_type_return alloc] init] retain];
}

- (id) init
{
    self = [super init];
    return self;
}

/* AST returnScope.methods */
- (ANTLRCommonTree *)getTree
{
    return tree;
}

- (void) setTree:(ANTLRCommonTree *)aTree
{
    if (tree != aTree) {
        if (tree != nil) [tree release];
        if (aTree != nil) [aTree retain];
        tree = aTree;
    }
}

- (void) dealloc
{
    self.tree = nil;
    [super dealloc];
}


@end /* end of returnScope implementation */


@implementation SimpleCParser_block_return /* returnScope */
/* AST returnScope.synthesize */
@synthesize tree; /* start of synthesize -- OBJC-Line 1837 */
+ (SimpleCParser_block_return *)newSimpleCParser_block_return
{
    return [[[SimpleCParser_block_return alloc] init] retain];
}

- (id) init
{
    self = [super init];
    return self;
}

/* AST returnScope.methods */
- (ANTLRCommonTree *)getTree
{
    return tree;
}

- (void) setTree:(ANTLRCommonTree *)aTree
{
    if (tree != aTree) {
        if (tree != nil) [tree release];
        if (aTree != nil) [aTree retain];
        tree = aTree;
    }
}

- (void) dealloc
{
    self.tree = nil;
    [super dealloc];
}


@end /* end of returnScope implementation */


@implementation SimpleCParser_stat_return /* returnScope */
/* AST returnScope.synthesize */
@synthesize tree; /* start of synthesize -- OBJC-Line 1837 */
+ (SimpleCParser_stat_return *)newSimpleCParser_stat_return
{
    return [[[SimpleCParser_stat_return alloc] init] retain];
}

- (id) init
{
    self = [super init];
    return self;
}

/* AST returnScope.methods */
- (ANTLRCommonTree *)getTree
{
    return tree;
}

- (void) setTree:(ANTLRCommonTree *)aTree
{
    if (tree != aTree) {
        if (tree != nil) [tree release];
        if (aTree != nil) [aTree retain];
        tree = aTree;
    }
}

- (void) dealloc
{
    self.tree = nil;
    [super dealloc];
}


@end /* end of returnScope implementation */


@implementation SimpleCParser_forStat_return /* returnScope */
/* AST returnScope.synthesize */
@synthesize tree; /* start of synthesize -- OBJC-Line 1837 */
+ (SimpleCParser_forStat_return *)newSimpleCParser_forStat_return
{
    return [[[SimpleCParser_forStat_return alloc] init] retain];
}

- (id) init
{
    self = [super init];
    return self;
}

/* AST returnScope.methods */
- (ANTLRCommonTree *)getTree
{
    return tree;
}

- (void) setTree:(ANTLRCommonTree *)aTree
{
    if (tree != aTree) {
        if (tree != nil) [tree release];
        if (aTree != nil) [aTree retain];
        tree = aTree;
    }
}

- (void) dealloc
{
    self.tree = nil;
    [super dealloc];
}


@end /* end of returnScope implementation */


@implementation SimpleCParser_assignStat_return /* returnScope */
/* AST returnScope.synthesize */
@synthesize tree; /* start of synthesize -- OBJC-Line 1837 */
+ (SimpleCParser_assignStat_return *)newSimpleCParser_assignStat_return
{
    return [[[SimpleCParser_assignStat_return alloc] init] retain];
}

- (id) init
{
    self = [super init];
    return self;
}

/* AST returnScope.methods */
- (ANTLRCommonTree *)getTree
{
    return tree;
}

- (void) setTree:(ANTLRCommonTree *)aTree
{
    if (tree != aTree) {
        if (tree != nil) [tree release];
        if (aTree != nil) [aTree retain];
        tree = aTree;
    }
}

- (void) dealloc
{
    self.tree = nil;
    [super dealloc];
}


@end /* end of returnScope implementation */


@implementation SimpleCParser_expr_return /* returnScope */
/* AST returnScope.synthesize */
@synthesize tree; /* start of synthesize -- OBJC-Line 1837 */
+ (SimpleCParser_expr_return *)newSimpleCParser_expr_return
{
    return [[[SimpleCParser_expr_return alloc] init] retain];
}

- (id) init
{
    self = [super init];
    return self;
}

/* AST returnScope.methods */
- (ANTLRCommonTree *)getTree
{
    return tree;
}

- (void) setTree:(ANTLRCommonTree *)aTree
{
    if (tree != aTree) {
        if (tree != nil) [tree release];
        if (aTree != nil) [aTree retain];
        tree = aTree;
    }
}

- (void) dealloc
{
    self.tree = nil;
    [super dealloc];
}


@end /* end of returnScope implementation */


@implementation SimpleCParser_condExpr_return /* returnScope */
/* AST returnScope.synthesize */
@synthesize tree; /* start of synthesize -- OBJC-Line 1837 */
+ (SimpleCParser_condExpr_return *)newSimpleCParser_condExpr_return
{
    return [[[SimpleCParser_condExpr_return alloc] init] retain];
}

- (id) init
{
    self = [super init];
    return self;
}

/* AST returnScope.methods */
- (ANTLRCommonTree *)getTree
{
    return tree;
}

- (void) setTree:(ANTLRCommonTree *)aTree
{
    if (tree != aTree) {
        if (tree != nil) [tree release];
        if (aTree != nil) [aTree retain];
        tree = aTree;
    }
}

- (void) dealloc
{
    self.tree = nil;
    [super dealloc];
}


@end /* end of returnScope implementation */


@implementation SimpleCParser_aexpr_return /* returnScope */
/* AST returnScope.synthesize */
@synthesize tree; /* start of synthesize -- OBJC-Line 1837 */
+ (SimpleCParser_aexpr_return *)newSimpleCParser_aexpr_return
{
    return [[[SimpleCParser_aexpr_return alloc] init] retain];
}

- (id) init
{
    self = [super init];
    return self;
}

/* AST returnScope.methods */
- (ANTLRCommonTree *)getTree
{
    return tree;
}

- (void) setTree:(ANTLRCommonTree *)aTree
{
    if (tree != aTree) {
        if (tree != nil) [tree release];
        if (aTree != nil) [aTree retain];
        tree = aTree;
    }
}

- (void) dealloc
{
    self.tree = nil;
    [super dealloc];
}


@end /* end of returnScope implementation */


@implementation SimpleCParser_atom_return /* returnScope */
/* AST returnScope.synthesize */
@synthesize tree; /* start of synthesize -- OBJC-Line 1837 */
+ (SimpleCParser_atom_return *)newSimpleCParser_atom_return
{
    return [[[SimpleCParser_atom_return alloc] init] retain];
}

- (id) init
{
    self = [super init];
    return self;
}

/* AST returnScope.methods */
- (ANTLRCommonTree *)getTree
{
    return tree;
}

- (void) setTree:(ANTLRCommonTree *)aTree
{
    if (tree != aTree) {
        if (tree != nil) [tree release];
        if (aTree != nil) [aTree retain];
        tree = aTree;
    }
}

- (void) dealloc
{
    self.tree = nil;
    [super dealloc];
}


@end /* end of returnScope implementation */


//#pragma mark Rule return scopes start
//

#pragma mark Rule return scopes start

@implementation SimpleCParser  // line 637

/* ObjC start of ruleAttributeScope */
#pragma mark Dynamic Rule Scopes
/* ObjC end of ruleAttributeScope */
#pragma mark global Attribute Scopes
/* ObjC start globalAttributeScope */
/* ObjC end globalAttributeScope */
/* ObjC start actions.(actionScope).synthesize */
/* ObjC end actions.(actionScope).synthesize */
/* ObjC start synthesize() */
/* AST genericParser.synthesize */
/* AST parserProperties */
@synthesize treeAdaptor;
/* ObjC end synthesize() */

+ (void) initialize
{
    #pragma mark Bitsets
    FOLLOW_declaration_in_program85 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_declaration_in_program85_data Count:(NSUInteger)1] retain];
    FOLLOW_variable_in_declaration105 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_variable_in_declaration105_data Count:(NSUInteger)1] retain];
    FOLLOW_functionHeader_in_declaration115 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_functionHeader_in_declaration115_data Count:(NSUInteger)1] retain];
    FOLLOW_K_SEMICOLON_in_declaration117 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_K_SEMICOLON_in_declaration117_data Count:(NSUInteger)1] retain];
    FOLLOW_functionHeader_in_declaration135 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_functionHeader_in_declaration135_data Count:(NSUInteger)1] retain];
    FOLLOW_block_in_declaration137 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_block_in_declaration137_data Count:(NSUInteger)1] retain];
    FOLLOW_type_in_variable166 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_type_in_variable166_data Count:(NSUInteger)1] retain];
    FOLLOW_declarator_in_variable168 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_declarator_in_variable168_data Count:(NSUInteger)1] retain];
    FOLLOW_K_SEMICOLON_in_variable170 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_K_SEMICOLON_in_variable170_data Count:(NSUInteger)1] retain];
    FOLLOW_K_ID_in_declarator199 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_K_ID_in_declarator199_data Count:(NSUInteger)1] retain];
    FOLLOW_type_in_functionHeader219 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_type_in_functionHeader219_data Count:(NSUInteger)1] retain];
    FOLLOW_K_ID_in_functionHeader221 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_K_ID_in_functionHeader221_data Count:(NSUInteger)1] retain];
    FOLLOW_K_LCURVE_in_functionHeader223 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_K_LCURVE_in_functionHeader223_data Count:(NSUInteger)1] retain];
    FOLLOW_formalParameter_in_functionHeader227 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_formalParameter_in_functionHeader227_data Count:(NSUInteger)1] retain];
    FOLLOW_K_COMMA_in_functionHeader231 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_K_COMMA_in_functionHeader231_data Count:(NSUInteger)1] retain];
    FOLLOW_formalParameter_in_functionHeader233 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_formalParameter_in_functionHeader233_data Count:(NSUInteger)1] retain];
    FOLLOW_K_RCURVE_in_functionHeader241 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_K_RCURVE_in_functionHeader241_data Count:(NSUInteger)1] retain];
    FOLLOW_type_in_formalParameter281 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_type_in_formalParameter281_data Count:(NSUInteger)1] retain];
    FOLLOW_declarator_in_formalParameter283 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_declarator_in_formalParameter283_data Count:(NSUInteger)1] retain];
    FOLLOW_K_LCURLY_in_block376 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_K_LCURLY_in_block376_data Count:(NSUInteger)1] retain];
    FOLLOW_variable_in_block390 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_variable_in_block390_data Count:(NSUInteger)1] retain];
    FOLLOW_stat_in_block405 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_stat_in_block405_data Count:(NSUInteger)1] retain];
    FOLLOW_K_RCURLY_in_block416 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_K_RCURLY_in_block416_data Count:(NSUInteger)1] retain];
    FOLLOW_forStat_in_stat449 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_forStat_in_stat449_data Count:(NSUInteger)1] retain];
    FOLLOW_expr_in_stat457 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_expr_in_stat457_data Count:(NSUInteger)1] retain];
    FOLLOW_K_SEMICOLON_in_stat459 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_K_SEMICOLON_in_stat459_data Count:(NSUInteger)1] retain];
    FOLLOW_block_in_stat468 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_block_in_stat468_data Count:(NSUInteger)1] retain];
    FOLLOW_assignStat_in_stat476 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_assignStat_in_stat476_data Count:(NSUInteger)1] retain];
    FOLLOW_K_SEMICOLON_in_stat478 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_K_SEMICOLON_in_stat478_data Count:(NSUInteger)1] retain];
    FOLLOW_K_SEMICOLON_in_stat487 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_K_SEMICOLON_in_stat487_data Count:(NSUInteger)1] retain];
    FOLLOW_K_FOR_in_forStat507 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_K_FOR_in_forStat507_data Count:(NSUInteger)1] retain];
    FOLLOW_K_LCURVE_in_forStat509 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_K_LCURVE_in_forStat509_data Count:(NSUInteger)1] retain];
    FOLLOW_assignStat_in_forStat513 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_assignStat_in_forStat513_data Count:(NSUInteger)1] retain];
    FOLLOW_K_SEMICOLON_in_forStat515 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_K_SEMICOLON_in_forStat515_data Count:(NSUInteger)1] retain];
    FOLLOW_expr_in_forStat517 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_expr_in_forStat517_data Count:(NSUInteger)1] retain];
    FOLLOW_K_SEMICOLON_in_forStat519 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_K_SEMICOLON_in_forStat519_data Count:(NSUInteger)1] retain];
    FOLLOW_assignStat_in_forStat523 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_assignStat_in_forStat523_data Count:(NSUInteger)1] retain];
    FOLLOW_K_RCURVE_in_forStat525 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_K_RCURVE_in_forStat525_data Count:(NSUInteger)1] retain];
    FOLLOW_block_in_forStat527 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_block_in_forStat527_data Count:(NSUInteger)1] retain];
    FOLLOW_K_ID_in_assignStat570 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_K_ID_in_assignStat570_data Count:(NSUInteger)1] retain];
    FOLLOW_K_EQ_in_assignStat572 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_K_EQ_in_assignStat572_data Count:(NSUInteger)1] retain];
    FOLLOW_expr_in_assignStat574 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_expr_in_assignStat574_data Count:(NSUInteger)1] retain];
    FOLLOW_condExpr_in_expr598 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_condExpr_in_expr598_data Count:(NSUInteger)1] retain];
    FOLLOW_aexpr_in_condExpr617 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_aexpr_in_condExpr617_data Count:(NSUInteger)1] retain];
    FOLLOW_K_EQEQ_in_condExpr622 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_K_EQEQ_in_condExpr622_data Count:(NSUInteger)1] retain];
    FOLLOW_K_LT_in_condExpr627 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_K_LT_in_condExpr627_data Count:(NSUInteger)1] retain];
    FOLLOW_aexpr_in_condExpr631 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_aexpr_in_condExpr631_data Count:(NSUInteger)1] retain];
    FOLLOW_atom_in_aexpr653 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_atom_in_aexpr653_data Count:(NSUInteger)1] retain];
    FOLLOW_K_PLUS_in_aexpr657 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_K_PLUS_in_aexpr657_data Count:(NSUInteger)1] retain];
    FOLLOW_atom_in_aexpr660 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_atom_in_aexpr660_data Count:(NSUInteger)1] retain];
    FOLLOW_K_ID_in_atom680 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_K_ID_in_atom680_data Count:(NSUInteger)1] retain];
    FOLLOW_K_INT_in_atom694 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_K_INT_in_atom694_data Count:(NSUInteger)1] retain];
    FOLLOW_K_LCURVE_in_atom708 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_K_LCURVE_in_atom708_data Count:(NSUInteger)1] retain];
    FOLLOW_expr_in_atom710 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_expr_in_atom710_data Count:(NSUInteger)1] retain];
    FOLLOW_K_RCURVE_in_atom712 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)FOLLOW_K_RCURVE_in_atom712_data Count:(NSUInteger)1] retain];

    [ANTLRBaseRecognizer setTokenNames:[[AMutableArray arrayWithObjects:@"<invalid>", @"<EOR>", @"<DOWN>", @"<UP>", 
 @"ARG_DEF", @"BLOCK", @"FUNC_DECL", @"FUNC_DEF", @"FUNC_HDR", @"K_CHAR", 
 @"K_COMMA", @"K_EQ", @"K_EQEQ", @"K_FOR", @"K_ID", @"K_INT", @"K_INT_TYPE", 
 @"K_LCURLY", @"K_LCURVE", @"K_LT", @"K_PLUS", @"K_RCURLY", @"K_RCURVE", 
 @"K_SEMICOLON", @"K_VOID", @"VAR_DEF", @"WS", nil] retain]];
    [ANTLRBaseRecognizer setGrammarFileName:@"SimpleC.g"];
}

+ (SimpleCParser *)newSimpleCParser:(id<ANTLRTokenStream>)aStream
{
    return [[SimpleCParser alloc] initWithTokenStream:aStream];


}

- (id) initWithTokenStream:(id<ANTLRTokenStream>)aStream
{
    self = [super initWithTokenStream:aStream State:[[ANTLRRecognizerSharedState newANTLRRecognizerSharedStateWithRuleLen:15+1] retain]];
    if ( self != nil ) {


        dfa2 = [DFA2 newDFA2WithRecognizer:self];
        /* start of actions-actionScope-init */
        /* start of init */
        /* AST genericParser.init */
        [self setTreeAdaptor:[[ANTLRCommonTreeAdaptor newTreeAdaptor] retain]];
    }
    return self;
}

- (void) dealloc
{
    [dfa2 release];
    /* AST genericParser.dealloc */
    [self setTreeAdaptor:nil];

    [super dealloc];
}

/* ObjC start members */
/* ObjC end members */
/* ObjC start actions.(actionScope).methods */
/* ObjC end actions.(actionScope).methods */
/* ObjC start methods() */
/* AST genericParser.methods */
/* AST parserMethods */
- (id<ANTLRTreeAdaptor>) getTreeAdaptor
{
	return treeAdaptor;
}

- (void) setTreeAdaptor:(id<ANTLRTreeAdaptor>)aTreeAdaptor
{
	if (aTreeAdaptor != treeAdaptor) {
		treeAdaptor = aTreeAdaptor;
	}
}
/* ObjC end methods() */
/* ObjC start rules */
/*
 * $ANTLR start program
 * SimpleC.g:16:1: program : ( declaration )+ ;
 */
- (SimpleCParser_program_return *) program
{
    /* my ruleScopeSetUp */
    /* Terence's stuff */

    /* AST ruleDeclarations */
    SimpleCParser_program_return * retval = [SimpleCParser_program_return newSimpleCParser_program_return];
    [retval setStart:[input LT:1]];


    ANTLRCommonTree *root_0 = nil;

    @try {
        /* AST ruleLabelDefs */
         SimpleCParser_declaration_return * declaration1 = nil ;
         

        // SimpleC.g:17:5: ( ( declaration )+ ) // ruleBlockSingleAlt
        // SimpleC.g:17:9: ( declaration )+ // alt
        {
        root_0 = (ANTLRCommonTree *)[[[treeAdaptor class] newEmptyTree] retain];


        // SimpleC.g:17:9: ( declaration )+ // positiveClosureBlock
        NSInteger cnt1 = 0;
        do {
            NSInteger alt1 = 2;
            NSInteger LA1_0 = [input LA:1];
            if ( (LA1_0==K_CHAR||LA1_0==K_ID||LA1_0==K_INT_TYPE||LA1_0==K_VOID) ) {
                alt1=1;
            }


            switch (alt1) {
                case 1 : ;
                    // SimpleC.g:17:9: declaration // alt
                    {
                    /* ASTParser ruleRef */
                    /* ruleRef */
                    [self pushFollow:FOLLOW_declaration_in_program85];
                    declaration1 = [self declaration];

                    [self popFollow];


                    [treeAdaptor addChild:[declaration1 getTree] toTree:root_0];

                    }
                    break;

                default :
                    if ( cnt1 >= 1 )
                        goto loop1;
                    ANTLREarlyExitException *eee =
                        [ANTLREarlyExitException newException:input decisionNumber:1];
                    @throw eee;
            }
            cnt1++;
        } while (YES);
        loop1: ;


        }

        /* ASTParser ruleCleanUp */
        /* AST ruleCleanUp */
        // token+rule list labels
        [retval setStop:[input LT:-1]];


            retval.tree = (ANTLRCommonTree *)[treeAdaptor rulePostProcessing:root_0];
            [treeAdaptor setTokenBoundaries:retval.tree From:retval.start To:retval.stopToken];

    }
    @catch (ANTLRRecognitionException *re) {
        [self reportError:re];
        [self recover:input Exception:re];
        /* ASTParser rule.setErrorReturnValue */
        retval.tree = (ANTLRCommonTree *)[treeAdaptor errorNode:input From:retval.start To:[input LT:-1] Exception:re];

    }

    @finally {
        /* Terence's stuff */

    }
    return retval;
}
/* $ANTLR end program */

/*
 * $ANTLR start declaration
 * SimpleC.g:20:1: declaration : ( variable | functionHeader K_SEMICOLON -> ^( FUNC_DECL functionHeader ) | functionHeader block -> ^( FUNC_DEF functionHeader block ) );
 */
- (SimpleCParser_declaration_return *) declaration
{
    /* my ruleScopeSetUp */
    /* Terence's stuff */

    /* AST ruleDeclarations */
    SimpleCParser_declaration_return * retval = [SimpleCParser_declaration_return newSimpleCParser_declaration_return];
    [retval setStart:[input LT:1]];


    ANTLRCommonTree *root_0 = nil;

    @try {
        /* AST ruleLabelDefs */
        ANTLRCommonToken *K_SEMICOLON4 = nil;
         SimpleCParser_variable_return * variable2 = nil ;
         
         SimpleCParser_functionHeader_return * functionHeader3 = nil ;
         
         SimpleCParser_functionHeader_return * functionHeader5 = nil ;
         
         SimpleCParser_block_return * block6 = nil ;
         

        ANTLRCommonTree *K_SEMICOLON4_tree=nil;
        ANTLRRewriteRuleTokenStream *stream_K_SEMICOLON =
            [[ANTLRRewriteRuleTokenStream newANTLRRewriteRuleTokenStream:treeAdaptor
                                                             description:@"token K_SEMICOLON"] retain];
        ANTLRRewriteRuleSubtreeStream *stream_functionHeader =
            [[ANTLRRewriteRuleSubtreeStream newANTLRRewriteRuleSubtreeStream:treeAdaptor
                                                                description:@"rule functionHeader"] retain];
        ANTLRRewriteRuleSubtreeStream *stream_block =
            [[ANTLRRewriteRuleSubtreeStream newANTLRRewriteRuleSubtreeStream:treeAdaptor
                                                                description:@"rule block"] retain];
        // SimpleC.g:21:5: ( variable | functionHeader K_SEMICOLON -> ^( FUNC_DECL functionHeader ) | functionHeader block -> ^( FUNC_DEF functionHeader block ) ) //ruleblock
        NSInteger alt2=3;
        alt2 = [dfa2 predict:input];
        switch (alt2) {
            case 1 : ;
                // SimpleC.g:21:9: variable // alt
                {
                root_0 = (ANTLRCommonTree *)[[[treeAdaptor class] newEmptyTree] retain];


                /* ASTParser ruleRef */
                /* ruleRef */
                [self pushFollow:FOLLOW_variable_in_declaration105];
                variable2 = [self variable];

                [self popFollow];


                [treeAdaptor addChild:[variable2 getTree] toTree:root_0];

                }
                break;
            case 2 : ;
                // SimpleC.g:22:9: functionHeader K_SEMICOLON // alt
                {
                /* ruleRef */
                [self pushFollow:FOLLOW_functionHeader_in_declaration115];
                functionHeader3 = [self functionHeader];

                [self popFollow];


                [stream_functionHeader addElement:[functionHeader3 getTree]];

                K_SEMICOLON4=(ANTLRCommonToken *)[self match:input TokenType:K_SEMICOLON Follow:FOLLOW_K_SEMICOLON_in_declaration117];  
                    [stream_K_SEMICOLON addElement:K_SEMICOLON4];


                // AST REWRITE
                // elements: functionHeader
                // token labels: 
                // rule labels: retval
                // token list labels: 
                // rule list labels: 
                // wildcard labels: 
                retval.tree = root_0;

                ANTLRRewriteRuleSubtreeStream *stream_retval =
                    [[ANTLRRewriteRuleSubtreeStream newANTLRRewriteRuleSubtreeStream:treeAdaptor
                        description:@"token retval" element:retval!=nil?[retval getTree]:nil] retain];

                root_0 = (ANTLRCommonTree *)[[[treeAdaptor class] newEmptyTree] retain];

                // 22:36: -> ^( FUNC_DECL functionHeader )
                {
                    // SimpleC.g:22:39: ^( FUNC_DECL functionHeader )
                    {
                        ANTLRCommonTree *root_1 = (ANTLRCommonTree *)[[[treeAdaptor class] newEmptyTree] retain];
                        root_1 = (ANTLRCommonTree *)[treeAdaptor becomeRoot:
                                [treeAdaptor createTree:FUNC_DECL Text:@"FUNC_DECL"]
                         old:root_1];

                        [treeAdaptor addChild:[stream_functionHeader nextTree] toTree:root_1];

                        [treeAdaptor addChild:root_1 toTree:root_0];
                    }

                }


                retval.tree = root_0;


                }
                break;
            case 3 : ;
                // SimpleC.g:23:9: functionHeader block // alt
                {
                /* ruleRef */
                [self pushFollow:FOLLOW_functionHeader_in_declaration135];
                functionHeader5 = [self functionHeader];

                [self popFollow];


                [stream_functionHeader addElement:[functionHeader5 getTree]];

                /* ruleRef */
                [self pushFollow:FOLLOW_block_in_declaration137];
                block6 = [self block];

                [self popFollow];


                [stream_block addElement:[block6 getTree]];

                // AST REWRITE
                // elements: functionHeader, block
                // token labels: 
                // rule labels: retval
                // token list labels: 
                // rule list labels: 
                // wildcard labels: 
                retval.tree = root_0;

                ANTLRRewriteRuleSubtreeStream *stream_retval =
                    [[ANTLRRewriteRuleSubtreeStream newANTLRRewriteRuleSubtreeStream:treeAdaptor
                        description:@"token retval" element:retval!=nil?[retval getTree]:nil] retain];

                root_0 = (ANTLRCommonTree *)[[[treeAdaptor class] newEmptyTree] retain];

                // 23:30: -> ^( FUNC_DEF functionHeader block )
                {
                    // SimpleC.g:23:33: ^( FUNC_DEF functionHeader block )
                    {
                        ANTLRCommonTree *root_1 = (ANTLRCommonTree *)[[[treeAdaptor class] newEmptyTree] retain];
                        root_1 = (ANTLRCommonTree *)[treeAdaptor becomeRoot:
                                [treeAdaptor createTree:FUNC_DEF Text:@"FUNC_DEF"]
                         old:root_1];

                        [treeAdaptor addChild:[stream_functionHeader nextTree] toTree:root_1];

                        [treeAdaptor addChild:[stream_block nextTree] toTree:root_1];

                        [treeAdaptor addChild:root_1 toTree:root_0];
                    }

                }


                retval.tree = root_0;


                }
                break;

        }
        /* ASTParser ruleCleanUp */
        /* AST ruleCleanUp */
        // token+rule list labels
        [retval setStop:[input LT:-1]];


        [stream_K_SEMICOLON release];
        [stream_functionHeader release];
        [stream_block release];

            retval.tree = (ANTLRCommonTree *)[treeAdaptor rulePostProcessing:root_0];
            [treeAdaptor setTokenBoundaries:retval.tree From:retval.start To:retval.stopToken];

    }
    @catch (ANTLRRecognitionException *re) {
        [self reportError:re];
        [self recover:input Exception:re];
        /* ASTParser rule.setErrorReturnValue */
        retval.tree = (ANTLRCommonTree *)[treeAdaptor errorNode:input From:retval.start To:[input LT:-1] Exception:re];

    }

    @finally {
        /* Terence's stuff */

    }
    return retval;
}
/* $ANTLR end declaration */

/*
 * $ANTLR start variable
 * SimpleC.g:26:1: variable : type declarator K_SEMICOLON -> ^( VAR_DEF type declarator ) ;
 */
- (SimpleCParser_variable_return *) variable
{
    /* my ruleScopeSetUp */
    /* Terence's stuff */

    /* AST ruleDeclarations */
    SimpleCParser_variable_return * retval = [SimpleCParser_variable_return newSimpleCParser_variable_return];
    [retval setStart:[input LT:1]];


    ANTLRCommonTree *root_0 = nil;

    @try {
        /* AST ruleLabelDefs */
        ANTLRCommonToken *K_SEMICOLON9 = nil;
         SimpleCParser_type_return * type7 = nil ;
         
         SimpleCParser_declarator_return * declarator8 = nil ;
         

        ANTLRCommonTree *K_SEMICOLON9_tree=nil;
        ANTLRRewriteRuleTokenStream *stream_K_SEMICOLON =
            [[ANTLRRewriteRuleTokenStream newANTLRRewriteRuleTokenStream:treeAdaptor
                                                             description:@"token K_SEMICOLON"] retain];
        ANTLRRewriteRuleSubtreeStream *stream_declarator =
            [[ANTLRRewriteRuleSubtreeStream newANTLRRewriteRuleSubtreeStream:treeAdaptor
                                                                description:@"rule declarator"] retain];
        ANTLRRewriteRuleSubtreeStream *stream_type =
            [[ANTLRRewriteRuleSubtreeStream newANTLRRewriteRuleSubtreeStream:treeAdaptor
                                                                description:@"rule type"] retain];
        // SimpleC.g:27:5: ( type declarator K_SEMICOLON -> ^( VAR_DEF type declarator ) ) // ruleBlockSingleAlt
        // SimpleC.g:27:9: type declarator K_SEMICOLON // alt
        {
        /* ruleRef */
        [self pushFollow:FOLLOW_type_in_variable166];
        type7 = [self type];

        [self popFollow];


        [stream_type addElement:[type7 getTree]];

        /* ruleRef */
        [self pushFollow:FOLLOW_declarator_in_variable168];
        declarator8 = [self declarator];

        [self popFollow];


        [stream_declarator addElement:[declarator8 getTree]];

        K_SEMICOLON9=(ANTLRCommonToken *)[self match:input TokenType:K_SEMICOLON Follow:FOLLOW_K_SEMICOLON_in_variable170];  
            [stream_K_SEMICOLON addElement:K_SEMICOLON9];


        // AST REWRITE
        // elements: declarator, type
        // token labels: 
        // rule labels: retval
        // token list labels: 
        // rule list labels: 
        // wildcard labels: 
        retval.tree = root_0;

        ANTLRRewriteRuleSubtreeStream *stream_retval =
            [[ANTLRRewriteRuleSubtreeStream newANTLRRewriteRuleSubtreeStream:treeAdaptor
                description:@"token retval" element:retval!=nil?[retval getTree]:nil] retain];

        root_0 = (ANTLRCommonTree *)[[[treeAdaptor class] newEmptyTree] retain];

        // 27:37: -> ^( VAR_DEF type declarator )
        {
            // SimpleC.g:27:40: ^( VAR_DEF type declarator )
            {
                ANTLRCommonTree *root_1 = (ANTLRCommonTree *)[[[treeAdaptor class] newEmptyTree] retain];
                root_1 = (ANTLRCommonTree *)[treeAdaptor becomeRoot:
                        [treeAdaptor createTree:VAR_DEF Text:@"VAR_DEF"]
                 old:root_1];

                [treeAdaptor addChild:[stream_type nextTree] toTree:root_1];

                [treeAdaptor addChild:[stream_declarator nextTree] toTree:root_1];

                [treeAdaptor addChild:root_1 toTree:root_0];
            }

        }


        retval.tree = root_0;


        }

        /* ASTParser ruleCleanUp */
        /* AST ruleCleanUp */
        // token+rule list labels
        [retval setStop:[input LT:-1]];


        [stream_K_SEMICOLON release];
        [stream_declarator release];
        [stream_type release];

            retval.tree = (ANTLRCommonTree *)[treeAdaptor rulePostProcessing:root_0];
            [treeAdaptor setTokenBoundaries:retval.tree From:retval.start To:retval.stopToken];

    }
    @catch (ANTLRRecognitionException *re) {
        [self reportError:re];
        [self recover:input Exception:re];
        /* ASTParser rule.setErrorReturnValue */
        retval.tree = (ANTLRCommonTree *)[treeAdaptor errorNode:input From:retval.start To:[input LT:-1] Exception:re];

    }

    @finally {
        /* Terence's stuff */

    }
    return retval;
}
/* $ANTLR end variable */

/*
 * $ANTLR start declarator
 * SimpleC.g:30:1: declarator : K_ID ;
 */
- (SimpleCParser_declarator_return *) declarator
{
    /* my ruleScopeSetUp */
    /* Terence's stuff */

    /* AST ruleDeclarations */
    SimpleCParser_declarator_return * retval = [SimpleCParser_declarator_return newSimpleCParser_declarator_return];
    [retval setStart:[input LT:1]];


    ANTLRCommonTree *root_0 = nil;

    @try {
        /* AST ruleLabelDefs */
        ANTLRCommonToken *K_ID10 = nil;

        ANTLRCommonTree *K_ID10_tree=nil;

        // SimpleC.g:31:5: ( K_ID ) // ruleBlockSingleAlt
        // SimpleC.g:31:9: K_ID // alt
        {
        root_0 = (ANTLRCommonTree *)[[[treeAdaptor class] newEmptyTree] retain];


        /* ASTParser tokenRef */
        K_ID10=(ANTLRCommonToken *)[self match:input TokenType:K_ID Follow:FOLLOW_K_ID_in_declarator199]; 
        K_ID10_tree = /* ASTParser createNodeFromToken */
        (ANTLRCommonTree *)[[treeAdaptor create:K_ID10] retain]
        ;
        [treeAdaptor addChild:K_ID10_tree  toTree:root_0];


        }

        /* ASTParser ruleCleanUp */
        /* AST ruleCleanUp */
        // token+rule list labels
        [retval setStop:[input LT:-1]];


            retval.tree = (ANTLRCommonTree *)[treeAdaptor rulePostProcessing:root_0];
            [treeAdaptor setTokenBoundaries:retval.tree From:retval.start To:retval.stopToken];

    }
    @catch (ANTLRRecognitionException *re) {
        [self reportError:re];
        [self recover:input Exception:re];
        /* ASTParser rule.setErrorReturnValue */
        retval.tree = (ANTLRCommonTree *)[treeAdaptor errorNode:input From:retval.start To:[input LT:-1] Exception:re];

    }

    @finally {
        /* Terence's stuff */

    }
    return retval;
}
/* $ANTLR end declarator */

/*
 * $ANTLR start functionHeader
 * SimpleC.g:34:1: functionHeader : type K_ID K_LCURVE ( formalParameter ( K_COMMA formalParameter )* )? K_RCURVE -> ^( FUNC_HDR type K_ID ( formalParameter )+ ) ;
 */
- (SimpleCParser_functionHeader_return *) functionHeader
{
    /* my ruleScopeSetUp */
    /* Terence's stuff */

    /* AST ruleDeclarations */
    SimpleCParser_functionHeader_return * retval = [SimpleCParser_functionHeader_return newSimpleCParser_functionHeader_return];
    [retval setStart:[input LT:1]];


    ANTLRCommonTree *root_0 = nil;

    @try {
        /* AST ruleLabelDefs */
        ANTLRCommonToken *K_ID12 = nil;
        ANTLRCommonToken *K_LCURVE13 = nil;
        ANTLRCommonToken *K_COMMA15 = nil;
        ANTLRCommonToken *K_RCURVE17 = nil;
         SimpleCParser_type_return * type11 = nil ;
         
         SimpleCParser_formalParameter_return * formalParameter14 = nil ;
         
         SimpleCParser_formalParameter_return * formalParameter16 = nil ;
         

        ANTLRCommonTree *K_ID12_tree=nil;
        ANTLRCommonTree *K_LCURVE13_tree=nil;
        ANTLRCommonTree *K_COMMA15_tree=nil;
        ANTLRCommonTree *K_RCURVE17_tree=nil;
        ANTLRRewriteRuleTokenStream *stream_K_ID =
            [[ANTLRRewriteRuleTokenStream newANTLRRewriteRuleTokenStream:treeAdaptor
                                                             description:@"token K_ID"] retain];
        ANTLRRewriteRuleTokenStream *stream_K_LCURVE =
            [[ANTLRRewriteRuleTokenStream newANTLRRewriteRuleTokenStream:treeAdaptor
                                                             description:@"token K_LCURVE"] retain];
        ANTLRRewriteRuleTokenStream *stream_K_RCURVE =
            [[ANTLRRewriteRuleTokenStream newANTLRRewriteRuleTokenStream:treeAdaptor
                                                             description:@"token K_RCURVE"] retain];
        ANTLRRewriteRuleTokenStream *stream_K_COMMA =
            [[ANTLRRewriteRuleTokenStream newANTLRRewriteRuleTokenStream:treeAdaptor
                                                             description:@"token K_COMMA"] retain];
        ANTLRRewriteRuleSubtreeStream *stream_formalParameter =
            [[ANTLRRewriteRuleSubtreeStream newANTLRRewriteRuleSubtreeStream:treeAdaptor
                                                                description:@"rule formalParameter"] retain];
        ANTLRRewriteRuleSubtreeStream *stream_type =
            [[ANTLRRewriteRuleSubtreeStream newANTLRRewriteRuleSubtreeStream:treeAdaptor
                                                                description:@"rule type"] retain];
        // SimpleC.g:35:5: ( type K_ID K_LCURVE ( formalParameter ( K_COMMA formalParameter )* )? K_RCURVE -> ^( FUNC_HDR type K_ID ( formalParameter )+ ) ) // ruleBlockSingleAlt
        // SimpleC.g:35:9: type K_ID K_LCURVE ( formalParameter ( K_COMMA formalParameter )* )? K_RCURVE // alt
        {
        /* ruleRef */
        [self pushFollow:FOLLOW_type_in_functionHeader219];
        type11 = [self type];

        [self popFollow];


        [stream_type addElement:[type11 getTree]];

        K_ID12=(ANTLRCommonToken *)[self match:input TokenType:K_ID Follow:FOLLOW_K_ID_in_functionHeader221];  
            [stream_K_ID addElement:K_ID12];


        K_LCURVE13=(ANTLRCommonToken *)[self match:input TokenType:K_LCURVE Follow:FOLLOW_K_LCURVE_in_functionHeader223];  
            [stream_K_LCURVE addElement:K_LCURVE13];


        // SimpleC.g:35:28: ( formalParameter ( K_COMMA formalParameter )* )? // block
        NSInteger alt4=2;
        NSInteger LA4_0 = [input LA:1];

        if ( (LA4_0==K_CHAR||LA4_0==K_ID||LA4_0==K_INT_TYPE||LA4_0==K_VOID) ) {
            alt4=1;
        }
        switch (alt4) {
            case 1 : ;
                // SimpleC.g:35:30: formalParameter ( K_COMMA formalParameter )* // alt
                {
                /* ruleRef */
                [self pushFollow:FOLLOW_formalParameter_in_functionHeader227];
                formalParameter14 = [self formalParameter];

                [self popFollow];


                [stream_formalParameter addElement:[formalParameter14 getTree]];

                do {
                    NSInteger alt3=2;
                    NSInteger LA3_0 = [input LA:1];
                    if ( (LA3_0==K_COMMA) ) {
                        alt3=1;
                    }


                    switch (alt3) {
                        case 1 : ;
                            // SimpleC.g:35:48: K_COMMA formalParameter // alt
                            {
                            K_COMMA15=(ANTLRCommonToken *)[self match:input TokenType:K_COMMA Follow:FOLLOW_K_COMMA_in_functionHeader231];  
                                [stream_K_COMMA addElement:K_COMMA15];


                            /* ruleRef */
                            [self pushFollow:FOLLOW_formalParameter_in_functionHeader233];
                            formalParameter16 = [self formalParameter];

                            [self popFollow];


                            [stream_formalParameter addElement:[formalParameter16 getTree]];

                            }
                            break;

                        default :
                            goto loop3;
                    }
                } while (YES);
                loop3: ;


                }
                break;

        }


        K_RCURVE17=(ANTLRCommonToken *)[self match:input TokenType:K_RCURVE Follow:FOLLOW_K_RCURVE_in_functionHeader241];  
            [stream_K_RCURVE addElement:K_RCURVE17];


        // AST REWRITE
        // elements: formalParameter, type, K_ID
        // token labels: 
        // rule labels: retval
        // token list labels: 
        // rule list labels: 
        // wildcard labels: 
        retval.tree = root_0;

        ANTLRRewriteRuleSubtreeStream *stream_retval =
            [[ANTLRRewriteRuleSubtreeStream newANTLRRewriteRuleSubtreeStream:treeAdaptor
                description:@"token retval" element:retval!=nil?[retval getTree]:nil] retain];

        root_0 = (ANTLRCommonTree *)[[[treeAdaptor class] newEmptyTree] retain];

        // 36:9: -> ^( FUNC_HDR type K_ID ( formalParameter )+ )
        {
            // SimpleC.g:36:12: ^( FUNC_HDR type K_ID ( formalParameter )+ )
            {
                ANTLRCommonTree *root_1 = (ANTLRCommonTree *)[[[treeAdaptor class] newEmptyTree] retain];
                root_1 = (ANTLRCommonTree *)[treeAdaptor becomeRoot:
                        [treeAdaptor createTree:FUNC_HDR Text:@"FUNC_HDR"]
                 old:root_1];

                [treeAdaptor addChild:[stream_type nextTree] toTree:root_1];

                 // TODO: args: 
                [treeAdaptor addChild:
                            [stream_K_ID nextNode]
                 toTree:root_1];

                // SimpleC.g:36:33: ( formalParameter )+
                {
                if ( !([stream_formalParameter hasNext]) ) {
                    @throw [ANTLRRewriteEarlyExitException newException];
                }
                while ( [stream_formalParameter hasNext] ) {
                    [treeAdaptor addChild:[stream_formalParameter nextTree] toTree:root_1];

                }
                [stream_formalParameter reset];

                }
                [treeAdaptor addChild:root_1 toTree:root_0];
            }

        }


        retval.tree = root_0;


        }

        /* ASTParser ruleCleanUp */
        /* AST ruleCleanUp */
        // token+rule list labels
        [retval setStop:[input LT:-1]];


        [stream_K_ID release];
        [stream_K_LCURVE release];
        [stream_K_RCURVE release];
        [stream_K_COMMA release];
        [stream_formalParameter release];
        [stream_type release];

            retval.tree = (ANTLRCommonTree *)[treeAdaptor rulePostProcessing:root_0];
            [treeAdaptor setTokenBoundaries:retval.tree From:retval.start To:retval.stopToken];

    }
    @catch (ANTLRRecognitionException *re) {
        [self reportError:re];
        [self recover:input Exception:re];
        /* ASTParser rule.setErrorReturnValue */
        retval.tree = (ANTLRCommonTree *)[treeAdaptor errorNode:input From:retval.start To:[input LT:-1] Exception:re];

    }

    @finally {
        /* Terence's stuff */

    }
    return retval;
}
/* $ANTLR end functionHeader */

/*
 * $ANTLR start formalParameter
 * SimpleC.g:39:1: formalParameter : type declarator -> ^( ARG_DEF type declarator ) ;
 */
- (SimpleCParser_formalParameter_return *) formalParameter
{
    /* my ruleScopeSetUp */
    /* Terence's stuff */

    /* AST ruleDeclarations */
    SimpleCParser_formalParameter_return * retval = [SimpleCParser_formalParameter_return newSimpleCParser_formalParameter_return];
    [retval setStart:[input LT:1]];


    ANTLRCommonTree *root_0 = nil;

    @try {
        /* AST ruleLabelDefs */
         SimpleCParser_type_return * type18 = nil ;
         
         SimpleCParser_declarator_return * declarator19 = nil ;
         

        ANTLRRewriteRuleSubtreeStream *stream_declarator =
            [[ANTLRRewriteRuleSubtreeStream newANTLRRewriteRuleSubtreeStream:treeAdaptor
                                                                description:@"rule declarator"] retain];
        ANTLRRewriteRuleSubtreeStream *stream_type =
            [[ANTLRRewriteRuleSubtreeStream newANTLRRewriteRuleSubtreeStream:treeAdaptor
                                                                description:@"rule type"] retain];
        // SimpleC.g:40:5: ( type declarator -> ^( ARG_DEF type declarator ) ) // ruleBlockSingleAlt
        // SimpleC.g:40:9: type declarator // alt
        {
        /* ruleRef */
        [self pushFollow:FOLLOW_type_in_formalParameter281];
        type18 = [self type];

        [self popFollow];


        [stream_type addElement:[type18 getTree]];

        /* ruleRef */
        [self pushFollow:FOLLOW_declarator_in_formalParameter283];
        declarator19 = [self declarator];

        [self popFollow];


        [stream_declarator addElement:[declarator19 getTree]];

        // AST REWRITE
        // elements: declarator, type
        // token labels: 
        // rule labels: retval
        // token list labels: 
        // rule list labels: 
        // wildcard labels: 
        retval.tree = root_0;

        ANTLRRewriteRuleSubtreeStream *stream_retval =
            [[ANTLRRewriteRuleSubtreeStream newANTLRRewriteRuleSubtreeStream:treeAdaptor
                description:@"token retval" element:retval!=nil?[retval getTree]:nil] retain];

        root_0 = (ANTLRCommonTree *)[[[treeAdaptor class] newEmptyTree] retain];

        // 40:25: -> ^( ARG_DEF type declarator )
        {
            // SimpleC.g:40:28: ^( ARG_DEF type declarator )
            {
                ANTLRCommonTree *root_1 = (ANTLRCommonTree *)[[[treeAdaptor class] newEmptyTree] retain];
                root_1 = (ANTLRCommonTree *)[treeAdaptor becomeRoot:
                        [treeAdaptor createTree:ARG_DEF Text:@"ARG_DEF"]
                 old:root_1];

                [treeAdaptor addChild:[stream_type nextTree] toTree:root_1];

                [treeAdaptor addChild:[stream_declarator nextTree] toTree:root_1];

                [treeAdaptor addChild:root_1 toTree:root_0];
            }

        }


        retval.tree = root_0;


        }

        /* ASTParser ruleCleanUp */
        /* AST ruleCleanUp */
        // token+rule list labels
        [retval setStop:[input LT:-1]];


        [stream_declarator release];
        [stream_type release];

            retval.tree = (ANTLRCommonTree *)[treeAdaptor rulePostProcessing:root_0];
            [treeAdaptor setTokenBoundaries:retval.tree From:retval.start To:retval.stopToken];

    }
    @catch (ANTLRRecognitionException *re) {
        [self reportError:re];
        [self recover:input Exception:re];
        /* ASTParser rule.setErrorReturnValue */
        retval.tree = (ANTLRCommonTree *)[treeAdaptor errorNode:input From:retval.start To:[input LT:-1] Exception:re];

    }

    @finally {
        /* Terence's stuff */

    }
    return retval;
}
/* $ANTLR end formalParameter */

/*
 * $ANTLR start type
 * SimpleC.g:43:1: type : ( K_INT_TYPE | K_CHAR | K_VOID | K_ID );
 */
- (SimpleCParser_type_return *) type
{
    /* my ruleScopeSetUp */
    /* Terence's stuff */

    /* AST ruleDeclarations */
    SimpleCParser_type_return * retval = [SimpleCParser_type_return newSimpleCParser_type_return];
    [retval setStart:[input LT:1]];


    ANTLRCommonTree *root_0 = nil;

    @try {
        /* AST ruleLabelDefs */
        ANTLRCommonToken *set20 = nil;

        ANTLRCommonTree *set20_tree=nil;

        // SimpleC.g:44:5: ( K_INT_TYPE | K_CHAR | K_VOID | K_ID ) // ruleBlockSingleAlt
        // SimpleC.g: // alt
        {
        root_0 = (ANTLRCommonTree *)[[[treeAdaptor class] newEmptyTree] retain];


        /* ASTParser matchRuleBlockSet */
        /* ASTParser matchSet */
        set20 = (ANTLRCommonToken *)[input LT:1]; /* matchSet */

        if ([input LA:1] == K_CHAR||[input LA:1] == K_ID||[input LA:1] == K_INT_TYPE||[input LA:1] == K_VOID) {
            [input consume];
            [treeAdaptor addChild:/* ASTParser createNodeFromToken */
            (ANTLRCommonTree *)[[treeAdaptor create:set20] retain]
             toTree:root_0 ];
            [state setIsErrorRecovery:NO];
        } else {
            ANTLRMismatchedSetException *mse = [ANTLRMismatchedSetException newException:nil stream:input];
            @throw mse;
        }


        }

        /* ASTParser ruleCleanUp */
        /* AST ruleCleanUp */
        // token+rule list labels
        [retval setStop:[input LT:-1]];


            retval.tree = (ANTLRCommonTree *)[treeAdaptor rulePostProcessing:root_0];
            [treeAdaptor setTokenBoundaries:retval.tree From:retval.start To:retval.stopToken];

    }
    @catch (ANTLRRecognitionException *re) {
        [self reportError:re];
        [self recover:input Exception:re];
        /* ASTParser rule.setErrorReturnValue */
        retval.tree = (ANTLRCommonTree *)[treeAdaptor errorNode:input From:retval.start To:[input LT:-1] Exception:re];

    }

    @finally {
        /* Terence's stuff */

    }
    return retval;
}
/* $ANTLR end type */

/*
 * $ANTLR start block
 * SimpleC.g:50:1: block : lc= K_LCURLY ( variable )* ( stat )* K_RCURLY -> ^( BLOCK[$lc,@\"BLOCK\"] ( variable )* ( stat )* ) ;
 */
- (SimpleCParser_block_return *) block
{
    /* my ruleScopeSetUp */
    /* Terence's stuff */

    /* AST ruleDeclarations */
    SimpleCParser_block_return * retval = [SimpleCParser_block_return newSimpleCParser_block_return];
    [retval setStart:[input LT:1]];


    ANTLRCommonTree *root_0 = nil;

    @try {
        /* AST ruleLabelDefs */
        ANTLRCommonToken *lc = nil;
        ANTLRCommonToken *K_RCURLY23 = nil;
         SimpleCParser_variable_return * variable21 = nil ;
         
         SimpleCParser_stat_return * stat22 = nil ;
         

        ANTLRCommonTree *lc_tree=nil;
        ANTLRCommonTree *K_RCURLY23_tree=nil;
        ANTLRRewriteRuleTokenStream *stream_K_LCURLY =
            [[ANTLRRewriteRuleTokenStream newANTLRRewriteRuleTokenStream:treeAdaptor
                                                             description:@"token K_LCURLY"] retain];
        ANTLRRewriteRuleTokenStream *stream_K_RCURLY =
            [[ANTLRRewriteRuleTokenStream newANTLRRewriteRuleTokenStream:treeAdaptor
                                                             description:@"token K_RCURLY"] retain];
        ANTLRRewriteRuleSubtreeStream *stream_variable =
            [[ANTLRRewriteRuleSubtreeStream newANTLRRewriteRuleSubtreeStream:treeAdaptor
                                                                description:@"rule variable"] retain];
        ANTLRRewriteRuleSubtreeStream *stream_stat =
            [[ANTLRRewriteRuleSubtreeStream newANTLRRewriteRuleSubtreeStream:treeAdaptor
                                                                description:@"rule stat"] retain];
        // SimpleC.g:51:5: (lc= K_LCURLY ( variable )* ( stat )* K_RCURLY -> ^( BLOCK[$lc,@\"BLOCK\"] ( variable )* ( stat )* ) ) // ruleBlockSingleAlt
        // SimpleC.g:51:9: lc= K_LCURLY ( variable )* ( stat )* K_RCURLY // alt
        {
        lc=(ANTLRCommonToken *)[self match:input TokenType:K_LCURLY Follow:FOLLOW_K_LCURLY_in_block376];  
            [stream_K_LCURLY addElement:lc];


        do {
            NSInteger alt5=2;
            NSInteger LA5_0 = [input LA:1];
            if ( (LA5_0==K_ID) ) {
                NSInteger LA5_2 = [input LA:2];
                if ( (LA5_2==K_ID) ) {
                    alt5=1;
                }


            }
            else if ( (LA5_0==K_CHAR||LA5_0==K_INT_TYPE||LA5_0==K_VOID) ) {
                alt5=1;
            }


            switch (alt5) {
                case 1 : ;
                    // SimpleC.g:52:13: variable // alt
                    {
                    /* ruleRef */
                    [self pushFollow:FOLLOW_variable_in_block390];
                    variable21 = [self variable];

                    [self popFollow];


                    [stream_variable addElement:[variable21 getTree]];

                    }
                    break;

                default :
                    goto loop5;
            }
        } while (YES);
        loop5: ;


        do {
            NSInteger alt6=2;
            NSInteger LA6_0 = [input LA:1];
            if ( ((LA6_0 >= K_FOR && LA6_0 <= K_INT)||(LA6_0 >= K_LCURLY && LA6_0 <= K_LCURVE)||LA6_0==K_SEMICOLON) ) {
                alt6=1;
            }


            switch (alt6) {
                case 1 : ;
                    // SimpleC.g:53:13: stat // alt
                    {
                    /* ruleRef */
                    [self pushFollow:FOLLOW_stat_in_block405];
                    stat22 = [self stat];

                    [self popFollow];


                    [stream_stat addElement:[stat22 getTree]];

                    }
                    break;

                default :
                    goto loop6;
            }
        } while (YES);
        loop6: ;


        K_RCURLY23=(ANTLRCommonToken *)[self match:input TokenType:K_RCURLY Follow:FOLLOW_K_RCURLY_in_block416];  
            [stream_K_RCURLY addElement:K_RCURLY23];


        // AST REWRITE
        // elements: stat, variable
        // token labels: 
        // rule labels: retval
        // token list labels: 
        // rule list labels: 
        // wildcard labels: 
        retval.tree = root_0;

        ANTLRRewriteRuleSubtreeStream *stream_retval =
            [[ANTLRRewriteRuleSubtreeStream newANTLRRewriteRuleSubtreeStream:treeAdaptor
                description:@"token retval" element:retval!=nil?[retval getTree]:nil] retain];

        root_0 = (ANTLRCommonTree *)[[[treeAdaptor class] newEmptyTree] retain];

        // 55:9: -> ^( BLOCK[$lc,@\"BLOCK\"] ( variable )* ( stat )* )
        {
            // SimpleC.g:55:12: ^( BLOCK[$lc,@\"BLOCK\"] ( variable )* ( stat )* )
            {
                ANTLRCommonTree *root_1 = (ANTLRCommonTree *)[[[treeAdaptor class] newEmptyTree] retain];
                root_1 = (ANTLRCommonTree *)[treeAdaptor becomeRoot:
                        [treeAdaptor createTree:BLOCK FromToken:lc Text:@"BLOCK"]
                 old:root_1];

                // SimpleC.g:55:34: ( variable )*
                while ( [stream_variable hasNext] ) {
                    [treeAdaptor addChild:[stream_variable nextTree] toTree:root_1];

                }
                [stream_variable reset];

                // SimpleC.g:55:44: ( stat )*
                while ( [stream_stat hasNext] ) {
                    [treeAdaptor addChild:[stream_stat nextTree] toTree:root_1];

                }
                [stream_stat reset];

                [treeAdaptor addChild:root_1 toTree:root_0];
            }

        }


        retval.tree = root_0;


        }

        /* ASTParser ruleCleanUp */
        /* AST ruleCleanUp */
        // token+rule list labels
        [retval setStop:[input LT:-1]];


        [stream_K_LCURLY release];
        [stream_K_RCURLY release];
        [stream_variable release];
        [stream_stat release];

            retval.tree = (ANTLRCommonTree *)[treeAdaptor rulePostProcessing:root_0];
            [treeAdaptor setTokenBoundaries:retval.tree From:retval.start To:retval.stopToken];

    }
    @catch (ANTLRRecognitionException *re) {
        [self reportError:re];
        [self recover:input Exception:re];
        /* ASTParser rule.setErrorReturnValue */
        retval.tree = (ANTLRCommonTree *)[treeAdaptor errorNode:input From:retval.start To:[input LT:-1] Exception:re];

    }

    @finally {
        /* Terence's stuff */

    }
    return retval;
}
/* $ANTLR end block */

/*
 * $ANTLR start stat
 * SimpleC.g:58:1: stat : ( forStat | expr K_SEMICOLON !| block | assignStat K_SEMICOLON !| K_SEMICOLON !);
 */
- (SimpleCParser_stat_return *) stat
{
    /* my ruleScopeSetUp */
    /* Terence's stuff */

    /* AST ruleDeclarations */
    SimpleCParser_stat_return * retval = [SimpleCParser_stat_return newSimpleCParser_stat_return];
    [retval setStart:[input LT:1]];


    ANTLRCommonTree *root_0 = nil;

    @try {
        /* AST ruleLabelDefs */
        ANTLRCommonToken *K_SEMICOLON26 = nil;
        ANTLRCommonToken *K_SEMICOLON29 = nil;
        ANTLRCommonToken *K_SEMICOLON30 = nil;
         SimpleCParser_forStat_return * forStat24 = nil ;
         
         SimpleCParser_expr_return * expr25 = nil ;
         
         SimpleCParser_block_return * block27 = nil ;
         
         SimpleCParser_assignStat_return * assignStat28 = nil ;
         

        ANTLRCommonTree *K_SEMICOLON26_tree=nil;
        ANTLRCommonTree *K_SEMICOLON29_tree=nil;
        ANTLRCommonTree *K_SEMICOLON30_tree=nil;

        // SimpleC.g:58:5: ( forStat | expr K_SEMICOLON !| block | assignStat K_SEMICOLON !| K_SEMICOLON !) //ruleblock
        NSInteger alt7=5;
        unichar charLA7 = [input LA:1];
        switch (charLA7) {
            case K_FOR: ;
                {
                alt7=1;
                }
                break;
            case K_ID: ;
                {
                NSInteger LA7_2 = [input LA:2];

                if ( (LA7_2==K_EQ) ) {
                    alt7=4;
                }
                else if ( (LA7_2==K_EQEQ||(LA7_2 >= K_LT && LA7_2 <= K_PLUS)||LA7_2==K_SEMICOLON) ) {
                    alt7=2;
                }
                else {
                    ANTLRNoViableAltException *nvae = [ANTLRNoViableAltException newException:7 state:2 stream:input];
                    nvae.c = LA7_2;
                    @throw nvae;

                }
                }
                break;
            case K_INT: ;
            case K_LCURVE: ;
                {
                alt7=2;
                }
                break;
            case K_LCURLY: ;
                {
                alt7=3;
                }
                break;
            case K_SEMICOLON: ;
                {
                alt7=5;
                }
                break;

        default: ;
            ANTLRNoViableAltException *nvae = [ANTLRNoViableAltException newException:7 state:0 stream:input];
            nvae.c = charLA7;
            @throw nvae;

        }

        switch (alt7) {
            case 1 : ;
                // SimpleC.g:58:7: forStat // alt
                {
                root_0 = (ANTLRCommonTree *)[[[treeAdaptor class] newEmptyTree] retain];


                /* ASTParser ruleRef */
                /* ruleRef */
                [self pushFollow:FOLLOW_forStat_in_stat449];
                forStat24 = [self forStat];

                [self popFollow];


                [treeAdaptor addChild:[forStat24 getTree] toTree:root_0];

                }
                break;
            case 2 : ;
                // SimpleC.g:59:7: expr K_SEMICOLON ! // alt
                {
                root_0 = (ANTLRCommonTree *)[[[treeAdaptor class] newEmptyTree] retain];


                /* ASTParser ruleRef */
                /* ruleRef */
                [self pushFollow:FOLLOW_expr_in_stat457];
                expr25 = [self expr];

                [self popFollow];


                [treeAdaptor addChild:[expr25 getTree] toTree:root_0];

                K_SEMICOLON26=(ANTLRCommonToken *)[self match:input TokenType:K_SEMICOLON Follow:FOLLOW_K_SEMICOLON_in_stat459]; 

                }
                break;
            case 3 : ;
                // SimpleC.g:60:7: block // alt
                {
                root_0 = (ANTLRCommonTree *)[[[treeAdaptor class] newEmptyTree] retain];


                /* ASTParser ruleRef */
                /* ruleRef */
                [self pushFollow:FOLLOW_block_in_stat468];
                block27 = [self block];

                [self popFollow];


                [treeAdaptor addChild:[block27 getTree] toTree:root_0];

                }
                break;
            case 4 : ;
                // SimpleC.g:61:7: assignStat K_SEMICOLON ! // alt
                {
                root_0 = (ANTLRCommonTree *)[[[treeAdaptor class] newEmptyTree] retain];


                /* ASTParser ruleRef */
                /* ruleRef */
                [self pushFollow:FOLLOW_assignStat_in_stat476];
                assignStat28 = [self assignStat];

                [self popFollow];


                [treeAdaptor addChild:[assignStat28 getTree] toTree:root_0];

                K_SEMICOLON29=(ANTLRCommonToken *)[self match:input TokenType:K_SEMICOLON Follow:FOLLOW_K_SEMICOLON_in_stat478]; 

                }
                break;
            case 5 : ;
                // SimpleC.g:62:7: K_SEMICOLON ! // alt
                {
                root_0 = (ANTLRCommonTree *)[[[treeAdaptor class] newEmptyTree] retain];


                K_SEMICOLON30=(ANTLRCommonToken *)[self match:input TokenType:K_SEMICOLON Follow:FOLLOW_K_SEMICOLON_in_stat487]; 

                }
                break;

        }
        /* ASTParser ruleCleanUp */
        /* AST ruleCleanUp */
        // token+rule list labels
        [retval setStop:[input LT:-1]];


            retval.tree = (ANTLRCommonTree *)[treeAdaptor rulePostProcessing:root_0];
            [treeAdaptor setTokenBoundaries:retval.tree From:retval.start To:retval.stopToken];

    }
    @catch (ANTLRRecognitionException *re) {
        [self reportError:re];
        [self recover:input Exception:re];
        /* ASTParser rule.setErrorReturnValue */
        retval.tree = (ANTLRCommonTree *)[treeAdaptor errorNode:input From:retval.start To:[input LT:-1] Exception:re];

    }

    @finally {
        /* Terence's stuff */

    }
    return retval;
}
/* $ANTLR end stat */

/*
 * $ANTLR start forStat
 * SimpleC.g:65:1: forStat : K_FOR K_LCURVE start= assignStat K_SEMICOLON expr K_SEMICOLON next= assignStat K_RCURVE block -> ^( K_FOR $start expr $next block ) ;
 */
- (SimpleCParser_forStat_return *) forStat
{
    /* my ruleScopeSetUp */
    /* Terence's stuff */

    /* AST ruleDeclarations */
    SimpleCParser_forStat_return * retval = [SimpleCParser_forStat_return newSimpleCParser_forStat_return];
    [retval setStart:[input LT:1]];


    ANTLRCommonTree *root_0 = nil;

    @try {
        /* AST ruleLabelDefs */
        ANTLRCommonToken *K_FOR31 = nil;
        ANTLRCommonToken *K_LCURVE32 = nil;
        ANTLRCommonToken *K_SEMICOLON33 = nil;
        ANTLRCommonToken *K_SEMICOLON35 = nil;
        ANTLRCommonToken *K_RCURVE36 = nil;
         SimpleCParser_assignStat_return * start = nil ;
         
         SimpleCParser_assignStat_return * next = nil ;
         
         SimpleCParser_expr_return * expr34 = nil ;
         
         SimpleCParser_block_return * block37 = nil ;
         

        ANTLRCommonTree *K_FOR31_tree=nil;
        ANTLRCommonTree *K_LCURVE32_tree=nil;
        ANTLRCommonTree *K_SEMICOLON33_tree=nil;
        ANTLRCommonTree *K_SEMICOLON35_tree=nil;
        ANTLRCommonTree *K_RCURVE36_tree=nil;
        ANTLRRewriteRuleTokenStream *stream_K_LCURVE =
            [[ANTLRRewriteRuleTokenStream newANTLRRewriteRuleTokenStream:treeAdaptor
                                                             description:@"token K_LCURVE"] retain];
        ANTLRRewriteRuleTokenStream *stream_K_RCURVE =
            [[ANTLRRewriteRuleTokenStream newANTLRRewriteRuleTokenStream:treeAdaptor
                                                             description:@"token K_RCURVE"] retain];
        ANTLRRewriteRuleTokenStream *stream_K_SEMICOLON =
            [[ANTLRRewriteRuleTokenStream newANTLRRewriteRuleTokenStream:treeAdaptor
                                                             description:@"token K_SEMICOLON"] retain];
        ANTLRRewriteRuleTokenStream *stream_K_FOR =
            [[ANTLRRewriteRuleTokenStream newANTLRRewriteRuleTokenStream:treeAdaptor
                                                             description:@"token K_FOR"] retain];
        ANTLRRewriteRuleSubtreeStream *stream_assignStat =
            [[ANTLRRewriteRuleSubtreeStream newANTLRRewriteRuleSubtreeStream:treeAdaptor
                                                                description:@"rule assignStat"] retain];
        ANTLRRewriteRuleSubtreeStream *stream_block =
            [[ANTLRRewriteRuleSubtreeStream newANTLRRewriteRuleSubtreeStream:treeAdaptor
                                                                description:@"rule block"] retain];
        ANTLRRewriteRuleSubtreeStream *stream_expr =
            [[ANTLRRewriteRuleSubtreeStream newANTLRRewriteRuleSubtreeStream:treeAdaptor
                                                                description:@"rule expr"] retain];
        // SimpleC.g:66:5: ( K_FOR K_LCURVE start= assignStat K_SEMICOLON expr K_SEMICOLON next= assignStat K_RCURVE block -> ^( K_FOR $start expr $next block ) ) // ruleBlockSingleAlt
        // SimpleC.g:66:9: K_FOR K_LCURVE start= assignStat K_SEMICOLON expr K_SEMICOLON next= assignStat K_RCURVE block // alt
        {
        K_FOR31=(ANTLRCommonToken *)[self match:input TokenType:K_FOR Follow:FOLLOW_K_FOR_in_forStat507];  
            [stream_K_FOR addElement:K_FOR31];


        K_LCURVE32=(ANTLRCommonToken *)[self match:input TokenType:K_LCURVE Follow:FOLLOW_K_LCURVE_in_forStat509];  
            [stream_K_LCURVE addElement:K_LCURVE32];


        /* ruleRef */
        [self pushFollow:FOLLOW_assignStat_in_forStat513];
        start = [self assignStat];

        [self popFollow];


        [stream_assignStat addElement:[start getTree]];

        K_SEMICOLON33=(ANTLRCommonToken *)[self match:input TokenType:K_SEMICOLON Follow:FOLLOW_K_SEMICOLON_in_forStat515];  
            [stream_K_SEMICOLON addElement:K_SEMICOLON33];


        /* ruleRef */
        [self pushFollow:FOLLOW_expr_in_forStat517];
        expr34 = [self expr];

        [self popFollow];


        [stream_expr addElement:[expr34 getTree]];

        K_SEMICOLON35=(ANTLRCommonToken *)[self match:input TokenType:K_SEMICOLON Follow:FOLLOW_K_SEMICOLON_in_forStat519];  
            [stream_K_SEMICOLON addElement:K_SEMICOLON35];


        /* ruleRef */
        [self pushFollow:FOLLOW_assignStat_in_forStat523];
        next = [self assignStat];

        [self popFollow];


        [stream_assignStat addElement:[next getTree]];

        K_RCURVE36=(ANTLRCommonToken *)[self match:input TokenType:K_RCURVE Follow:FOLLOW_K_RCURVE_in_forStat525];  
            [stream_K_RCURVE addElement:K_RCURVE36];


        /* ruleRef */
        [self pushFollow:FOLLOW_block_in_forStat527];
        block37 = [self block];

        [self popFollow];


        [stream_block addElement:[block37 getTree]];

        // AST REWRITE
        // elements: start, next, expr, block, K_FOR
        // token labels: 
        // rule labels: retval, start, next
        // token list labels: 
        // rule list labels: 
        // wildcard labels: 
        retval.tree = root_0;

        ANTLRRewriteRuleSubtreeStream *stream_retval =
            [[ANTLRRewriteRuleSubtreeStream newANTLRRewriteRuleSubtreeStream:treeAdaptor
                description:@"token retval" element:retval!=nil?[retval getTree]:nil] retain];
        ANTLRRewriteRuleSubtreeStream *stream_start =
            [[ANTLRRewriteRuleSubtreeStream newANTLRRewriteRuleSubtreeStream:treeAdaptor
                description:@"token start" element:start!=nil?[start getTree]:nil] retain];
        ANTLRRewriteRuleSubtreeStream *stream_next =
            [[ANTLRRewriteRuleSubtreeStream newANTLRRewriteRuleSubtreeStream:treeAdaptor
                description:@"token next" element:next!=nil?[next getTree]:nil] retain];

        root_0 = (ANTLRCommonTree *)[[[treeAdaptor class] newEmptyTree] retain];

        // 67:9: -> ^( K_FOR $start expr $next block )
        {
            // SimpleC.g:67:12: ^( K_FOR $start expr $next block )
            {
                ANTLRCommonTree *root_1 = (ANTLRCommonTree *)[[[treeAdaptor class] newEmptyTree] retain];
                root_1 = (ANTLRCommonTree *)[treeAdaptor becomeRoot:
                            [stream_K_FOR nextNode]
                 old:root_1];

                [treeAdaptor addChild:[stream_start nextTree] toTree:root_1];

                [treeAdaptor addChild:[stream_expr nextTree] toTree:root_1];

                [treeAdaptor addChild:[stream_next nextTree] toTree:root_1];

                [treeAdaptor addChild:[stream_block nextTree] toTree:root_1];

                [treeAdaptor addChild:root_1 toTree:root_0];
            }

        }


        retval.tree = root_0;


        }

        /* ASTParser ruleCleanUp */
        /* AST ruleCleanUp */
        // token+rule list labels
        [retval setStop:[input LT:-1]];


        [stream_K_LCURVE release];
        [stream_K_RCURVE release];
        [stream_K_SEMICOLON release];
        [stream_K_FOR release];
        [stream_assignStat release];
        [stream_block release];
        [stream_expr release];

            retval.tree = (ANTLRCommonTree *)[treeAdaptor rulePostProcessing:root_0];
            [treeAdaptor setTokenBoundaries:retval.tree From:retval.start To:retval.stopToken];

    }
    @catch (ANTLRRecognitionException *re) {
        [self reportError:re];
        [self recover:input Exception:re];
        /* ASTParser rule.setErrorReturnValue */
        retval.tree = (ANTLRCommonTree *)[treeAdaptor errorNode:input From:retval.start To:[input LT:-1] Exception:re];

    }

    @finally {
        /* Terence's stuff */

    }
    return retval;
}
/* $ANTLR end forStat */

/*
 * $ANTLR start assignStat
 * SimpleC.g:70:1: assignStat : K_ID K_EQ expr -> ^( K_EQ K_ID expr ) ;
 */
- (SimpleCParser_assignStat_return *) assignStat
{
    /* my ruleScopeSetUp */
    /* Terence's stuff */

    /* AST ruleDeclarations */
    SimpleCParser_assignStat_return * retval = [SimpleCParser_assignStat_return newSimpleCParser_assignStat_return];
    [retval setStart:[input LT:1]];


    ANTLRCommonTree *root_0 = nil;

    @try {
        /* AST ruleLabelDefs */
        ANTLRCommonToken *K_ID38 = nil;
        ANTLRCommonToken *K_EQ39 = nil;
         SimpleCParser_expr_return * expr40 = nil ;
         

        ANTLRCommonTree *K_ID38_tree=nil;
        ANTLRCommonTree *K_EQ39_tree=nil;
        ANTLRRewriteRuleTokenStream *stream_K_ID =
            [[ANTLRRewriteRuleTokenStream newANTLRRewriteRuleTokenStream:treeAdaptor
                                                             description:@"token K_ID"] retain];
        ANTLRRewriteRuleTokenStream *stream_K_EQ =
            [[ANTLRRewriteRuleTokenStream newANTLRRewriteRuleTokenStream:treeAdaptor
                                                             description:@"token K_EQ"] retain];
        ANTLRRewriteRuleSubtreeStream *stream_expr =
            [[ANTLRRewriteRuleSubtreeStream newANTLRRewriteRuleSubtreeStream:treeAdaptor
                                                                description:@"rule expr"] retain];
        // SimpleC.g:71:5: ( K_ID K_EQ expr -> ^( K_EQ K_ID expr ) ) // ruleBlockSingleAlt
        // SimpleC.g:71:9: K_ID K_EQ expr // alt
        {
        K_ID38=(ANTLRCommonToken *)[self match:input TokenType:K_ID Follow:FOLLOW_K_ID_in_assignStat570];  
            [stream_K_ID addElement:K_ID38];


        K_EQ39=(ANTLRCommonToken *)[self match:input TokenType:K_EQ Follow:FOLLOW_K_EQ_in_assignStat572];  
            [stream_K_EQ addElement:K_EQ39];


        /* ruleRef */
        [self pushFollow:FOLLOW_expr_in_assignStat574];
        expr40 = [self expr];

        [self popFollow];


        [stream_expr addElement:[expr40 getTree]];

        // AST REWRITE
        // elements: K_ID, K_EQ, expr
        // token labels: 
        // rule labels: retval
        // token list labels: 
        // rule list labels: 
        // wildcard labels: 
        retval.tree = root_0;

        ANTLRRewriteRuleSubtreeStream *stream_retval =
            [[ANTLRRewriteRuleSubtreeStream newANTLRRewriteRuleSubtreeStream:treeAdaptor
                description:@"token retval" element:retval!=nil?[retval getTree]:nil] retain];

        root_0 = (ANTLRCommonTree *)[[[treeAdaptor class] newEmptyTree] retain];

        // 71:24: -> ^( K_EQ K_ID expr )
        {
            // SimpleC.g:71:27: ^( K_EQ K_ID expr )
            {
                ANTLRCommonTree *root_1 = (ANTLRCommonTree *)[[[treeAdaptor class] newEmptyTree] retain];
                root_1 = (ANTLRCommonTree *)[treeAdaptor becomeRoot:
                            [stream_K_EQ nextNode]
                 old:root_1];

                 // TODO: args: 
                [treeAdaptor addChild:
                            [stream_K_ID nextNode]
                 toTree:root_1];

                [treeAdaptor addChild:[stream_expr nextTree] toTree:root_1];

                [treeAdaptor addChild:root_1 toTree:root_0];
            }

        }


        retval.tree = root_0;


        }

        /* ASTParser ruleCleanUp */
        /* AST ruleCleanUp */
        // token+rule list labels
        [retval setStop:[input LT:-1]];


        [stream_K_ID release];
        [stream_K_EQ release];
        [stream_expr release];

            retval.tree = (ANTLRCommonTree *)[treeAdaptor rulePostProcessing:root_0];
            [treeAdaptor setTokenBoundaries:retval.tree From:retval.start To:retval.stopToken];

    }
    @catch (ANTLRRecognitionException *re) {
        [self reportError:re];
        [self recover:input Exception:re];
        /* ASTParser rule.setErrorReturnValue */
        retval.tree = (ANTLRCommonTree *)[treeAdaptor errorNode:input From:retval.start To:[input LT:-1] Exception:re];

    }

    @finally {
        /* Terence's stuff */

    }
    return retval;
}
/* $ANTLR end assignStat */

/*
 * $ANTLR start expr
 * SimpleC.g:74:1: expr : condExpr ;
 */
- (SimpleCParser_expr_return *) expr
{
    /* my ruleScopeSetUp */
    /* Terence's stuff */

    /* AST ruleDeclarations */
    SimpleCParser_expr_return * retval = [SimpleCParser_expr_return newSimpleCParser_expr_return];
    [retval setStart:[input LT:1]];


    ANTLRCommonTree *root_0 = nil;

    @try {
        /* AST ruleLabelDefs */
         SimpleCParser_condExpr_return * condExpr41 = nil ;
         

        // SimpleC.g:74:5: ( condExpr ) // ruleBlockSingleAlt
        // SimpleC.g:74:9: condExpr // alt
        {
        root_0 = (ANTLRCommonTree *)[[[treeAdaptor class] newEmptyTree] retain];


        /* ASTParser ruleRef */
        /* ruleRef */
        [self pushFollow:FOLLOW_condExpr_in_expr598];
        condExpr41 = [self condExpr];

        [self popFollow];


        [treeAdaptor addChild:[condExpr41 getTree] toTree:root_0];

        }

        /* ASTParser ruleCleanUp */
        /* AST ruleCleanUp */
        // token+rule list labels
        [retval setStop:[input LT:-1]];


            retval.tree = (ANTLRCommonTree *)[treeAdaptor rulePostProcessing:root_0];
            [treeAdaptor setTokenBoundaries:retval.tree From:retval.start To:retval.stopToken];

    }
    @catch (ANTLRRecognitionException *re) {
        [self reportError:re];
        [self recover:input Exception:re];
        /* ASTParser rule.setErrorReturnValue */
        retval.tree = (ANTLRCommonTree *)[treeAdaptor errorNode:input From:retval.start To:[input LT:-1] Exception:re];

    }

    @finally {
        /* Terence's stuff */

    }
    return retval;
}
/* $ANTLR end expr */

/*
 * $ANTLR start condExpr
 * SimpleC.g:77:1: condExpr : aexpr ( ( K_EQEQ ^| K_LT ^) aexpr )? ;
 */
- (SimpleCParser_condExpr_return *) condExpr
{
    /* my ruleScopeSetUp */
    /* Terence's stuff */

    /* AST ruleDeclarations */
    SimpleCParser_condExpr_return * retval = [SimpleCParser_condExpr_return newSimpleCParser_condExpr_return];
    [retval setStart:[input LT:1]];


    ANTLRCommonTree *root_0 = nil;

    @try {
        /* AST ruleLabelDefs */
        ANTLRCommonToken *K_EQEQ43 = nil;
        ANTLRCommonToken *K_LT44 = nil;
         SimpleCParser_aexpr_return * aexpr42 = nil ;
         
         SimpleCParser_aexpr_return * aexpr45 = nil ;
         

        ANTLRCommonTree *K_EQEQ43_tree=nil;
        ANTLRCommonTree *K_LT44_tree=nil;

        // SimpleC.g:78:5: ( aexpr ( ( K_EQEQ ^| K_LT ^) aexpr )? ) // ruleBlockSingleAlt
        // SimpleC.g:78:9: aexpr ( ( K_EQEQ ^| K_LT ^) aexpr )? // alt
        {
        root_0 = (ANTLRCommonTree *)[[[treeAdaptor class] newEmptyTree] retain];


        /* ASTParser ruleRef */
        /* ruleRef */
        [self pushFollow:FOLLOW_aexpr_in_condExpr617];
        aexpr42 = [self aexpr];

        [self popFollow];


        [treeAdaptor addChild:[aexpr42 getTree] toTree:root_0];

        // SimpleC.g:78:15: ( ( K_EQEQ ^| K_LT ^) aexpr )? // block
        NSInteger alt9=2;
        NSInteger LA9_0 = [input LA:1];

        if ( (LA9_0==K_EQEQ||LA9_0==K_LT) ) {
            alt9=1;
        }
        switch (alt9) {
            case 1 : ;
                // SimpleC.g:78:17: ( K_EQEQ ^| K_LT ^) aexpr // alt
                {
                // SimpleC.g:78:17: ( K_EQEQ ^| K_LT ^) // block
                NSInteger alt8=2;
                NSInteger LA8_0 = [input LA:1];

                if ( (LA8_0==K_EQEQ) ) {
                    alt8=1;
                }
                else if ( (LA8_0==K_LT) ) {
                    alt8=2;
                }
                else {
                    ANTLRNoViableAltException *nvae = [ANTLRNoViableAltException newException:8 state:0 stream:input];
                    nvae.c = LA8_0;
                    @throw nvae;

                }
                switch (alt8) {
                    case 1 : ;
                        // SimpleC.g:78:18: K_EQEQ ^ // alt
                        {
                        K_EQEQ43=(ANTLRCommonToken *)[self match:input TokenType:K_EQEQ Follow:FOLLOW_K_EQEQ_in_condExpr622]; 
                        K_EQEQ43_tree = /* ASTParser createNodeFromToken */
                        (ANTLRCommonTree *)[[treeAdaptor create:K_EQEQ43] retain]
                        ;
                        root_0 = (ANTLRCommonTree *)[treeAdaptor becomeRoot:K_EQEQ43_tree old:root_0];


                        }
                        break;
                    case 2 : ;
                        // SimpleC.g:78:28: K_LT ^ // alt
                        {
                        K_LT44=(ANTLRCommonToken *)[self match:input TokenType:K_LT Follow:FOLLOW_K_LT_in_condExpr627]; 
                        K_LT44_tree = /* ASTParser createNodeFromToken */
                        (ANTLRCommonTree *)[[treeAdaptor create:K_LT44] retain]
                        ;
                        root_0 = (ANTLRCommonTree *)[treeAdaptor becomeRoot:K_LT44_tree old:root_0];


                        }
                        break;

                }


                /* ASTParser ruleRef */
                /* ruleRef */
                [self pushFollow:FOLLOW_aexpr_in_condExpr631];
                aexpr45 = [self aexpr];

                [self popFollow];


                [treeAdaptor addChild:[aexpr45 getTree] toTree:root_0];

                }
                break;

        }


        }

        /* ASTParser ruleCleanUp */
        /* AST ruleCleanUp */
        // token+rule list labels
        [retval setStop:[input LT:-1]];


            retval.tree = (ANTLRCommonTree *)[treeAdaptor rulePostProcessing:root_0];
            [treeAdaptor setTokenBoundaries:retval.tree From:retval.start To:retval.stopToken];

    }
    @catch (ANTLRRecognitionException *re) {
        [self reportError:re];
        [self recover:input Exception:re];
        /* ASTParser rule.setErrorReturnValue */
        retval.tree = (ANTLRCommonTree *)[treeAdaptor errorNode:input From:retval.start To:[input LT:-1] Exception:re];

    }

    @finally {
        /* Terence's stuff */

    }
    return retval;
}
/* $ANTLR end condExpr */

/*
 * $ANTLR start aexpr
 * SimpleC.g:81:1: aexpr : atom ( K_PLUS ^ atom )* ;
 */
- (SimpleCParser_aexpr_return *) aexpr
{
    /* my ruleScopeSetUp */
    /* Terence's stuff */

    /* AST ruleDeclarations */
    SimpleCParser_aexpr_return * retval = [SimpleCParser_aexpr_return newSimpleCParser_aexpr_return];
    [retval setStart:[input LT:1]];


    ANTLRCommonTree *root_0 = nil;

    @try {
        /* AST ruleLabelDefs */
        ANTLRCommonToken *K_PLUS47 = nil;
         SimpleCParser_atom_return * atom46 = nil ;
         
         SimpleCParser_atom_return * atom48 = nil ;
         

        ANTLRCommonTree *K_PLUS47_tree=nil;

        // SimpleC.g:82:5: ( atom ( K_PLUS ^ atom )* ) // ruleBlockSingleAlt
        // SimpleC.g:82:9: atom ( K_PLUS ^ atom )* // alt
        {
        root_0 = (ANTLRCommonTree *)[[[treeAdaptor class] newEmptyTree] retain];


        /* ASTParser ruleRef */
        /* ruleRef */
        [self pushFollow:FOLLOW_atom_in_aexpr653];
        atom46 = [self atom];

        [self popFollow];


        [treeAdaptor addChild:[atom46 getTree] toTree:root_0];

        do {
            NSInteger alt10=2;
            NSInteger LA10_0 = [input LA:1];
            if ( (LA10_0==K_PLUS) ) {
                alt10=1;
            }


            switch (alt10) {
                case 1 : ;
                    // SimpleC.g:82:16: K_PLUS ^ atom // alt
                    {
                    K_PLUS47=(ANTLRCommonToken *)[self match:input TokenType:K_PLUS Follow:FOLLOW_K_PLUS_in_aexpr657]; 
                    K_PLUS47_tree = /* ASTParser createNodeFromToken */
                    (ANTLRCommonTree *)[[treeAdaptor create:K_PLUS47] retain]
                    ;
                    root_0 = (ANTLRCommonTree *)[treeAdaptor becomeRoot:K_PLUS47_tree old:root_0];


                    /* ASTParser ruleRef */
                    /* ruleRef */
                    [self pushFollow:FOLLOW_atom_in_aexpr660];
                    atom48 = [self atom];

                    [self popFollow];


                    [treeAdaptor addChild:[atom48 getTree] toTree:root_0];

                    }
                    break;

                default :
                    goto loop10;
            }
        } while (YES);
        loop10: ;


        }

        /* ASTParser ruleCleanUp */
        /* AST ruleCleanUp */
        // token+rule list labels
        [retval setStop:[input LT:-1]];


            retval.tree = (ANTLRCommonTree *)[treeAdaptor rulePostProcessing:root_0];
            [treeAdaptor setTokenBoundaries:retval.tree From:retval.start To:retval.stopToken];

    }
    @catch (ANTLRRecognitionException *re) {
        [self reportError:re];
        [self recover:input Exception:re];
        /* ASTParser rule.setErrorReturnValue */
        retval.tree = (ANTLRCommonTree *)[treeAdaptor errorNode:input From:retval.start To:[input LT:-1] Exception:re];

    }

    @finally {
        /* Terence's stuff */

    }
    return retval;
}
/* $ANTLR end aexpr */

/*
 * $ANTLR start atom
 * SimpleC.g:85:1: atom : ( K_ID | K_INT | K_LCURVE expr K_RCURVE -> expr );
 */
- (SimpleCParser_atom_return *) atom
{
    /* my ruleScopeSetUp */
    /* Terence's stuff */

    /* AST ruleDeclarations */
    SimpleCParser_atom_return * retval = [SimpleCParser_atom_return newSimpleCParser_atom_return];
    [retval setStart:[input LT:1]];


    ANTLRCommonTree *root_0 = nil;

    @try {
        /* AST ruleLabelDefs */
        ANTLRCommonToken *K_ID49 = nil;
        ANTLRCommonToken *K_INT50 = nil;
        ANTLRCommonToken *K_LCURVE51 = nil;
        ANTLRCommonToken *K_RCURVE53 = nil;
         SimpleCParser_expr_return * expr52 = nil ;
         

        ANTLRCommonTree *K_ID49_tree=nil;
        ANTLRCommonTree *K_INT50_tree=nil;
        ANTLRCommonTree *K_LCURVE51_tree=nil;
        ANTLRCommonTree *K_RCURVE53_tree=nil;
        ANTLRRewriteRuleTokenStream *stream_K_LCURVE =
            [[ANTLRRewriteRuleTokenStream newANTLRRewriteRuleTokenStream:treeAdaptor
                                                             description:@"token K_LCURVE"] retain];
        ANTLRRewriteRuleTokenStream *stream_K_RCURVE =
            [[ANTLRRewriteRuleTokenStream newANTLRRewriteRuleTokenStream:treeAdaptor
                                                             description:@"token K_RCURVE"] retain];
        ANTLRRewriteRuleSubtreeStream *stream_expr =
            [[ANTLRRewriteRuleSubtreeStream newANTLRRewriteRuleSubtreeStream:treeAdaptor
                                                                description:@"rule expr"] retain];
        // SimpleC.g:86:5: ( K_ID | K_INT | K_LCURVE expr K_RCURVE -> expr ) //ruleblock
        NSInteger alt11=3;
        unichar charLA11 = [input LA:1];
        switch (charLA11) {
            case K_ID: ;
                {
                alt11=1;
                }
                break;
            case K_INT: ;
                {
                alt11=2;
                }
                break;
            case K_LCURVE: ;
                {
                alt11=3;
                }
                break;

        default: ;
            ANTLRNoViableAltException *nvae = [ANTLRNoViableAltException newException:11 state:0 stream:input];
            nvae.c = charLA11;
            @throw nvae;

        }

        switch (alt11) {
            case 1 : ;
                // SimpleC.g:86:7: K_ID // alt
                {
                root_0 = (ANTLRCommonTree *)[[[treeAdaptor class] newEmptyTree] retain];


                /* ASTParser tokenRef */
                K_ID49=(ANTLRCommonToken *)[self match:input TokenType:K_ID Follow:FOLLOW_K_ID_in_atom680]; 
                K_ID49_tree = /* ASTParser createNodeFromToken */
                (ANTLRCommonTree *)[[treeAdaptor create:K_ID49] retain]
                ;
                [treeAdaptor addChild:K_ID49_tree  toTree:root_0];


                }
                break;
            case 2 : ;
                // SimpleC.g:87:7: K_INT // alt
                {
                root_0 = (ANTLRCommonTree *)[[[treeAdaptor class] newEmptyTree] retain];


                /* ASTParser tokenRef */
                K_INT50=(ANTLRCommonToken *)[self match:input TokenType:K_INT Follow:FOLLOW_K_INT_in_atom694]; 
                K_INT50_tree = /* ASTParser createNodeFromToken */
                (ANTLRCommonTree *)[[treeAdaptor create:K_INT50] retain]
                ;
                [treeAdaptor addChild:K_INT50_tree  toTree:root_0];


                }
                break;
            case 3 : ;
                // SimpleC.g:88:7: K_LCURVE expr K_RCURVE // alt
                {
                K_LCURVE51=(ANTLRCommonToken *)[self match:input TokenType:K_LCURVE Follow:FOLLOW_K_LCURVE_in_atom708];  
                    [stream_K_LCURVE addElement:K_LCURVE51];


                /* ruleRef */
                [self pushFollow:FOLLOW_expr_in_atom710];
                expr52 = [self expr];

                [self popFollow];


                [stream_expr addElement:[expr52 getTree]];

                K_RCURVE53=(ANTLRCommonToken *)[self match:input TokenType:K_RCURVE Follow:FOLLOW_K_RCURVE_in_atom712];  
                    [stream_K_RCURVE addElement:K_RCURVE53];


                // AST REWRITE
                // elements: expr
                // token labels: 
                // rule labels: retval
                // token list labels: 
                // rule list labels: 
                // wildcard labels: 
                retval.tree = root_0;

                ANTLRRewriteRuleSubtreeStream *stream_retval =
                    [[ANTLRRewriteRuleSubtreeStream newANTLRRewriteRuleSubtreeStream:treeAdaptor
                        description:@"token retval" element:retval!=nil?[retval getTree]:nil] retain];

                root_0 = (ANTLRCommonTree *)[[[treeAdaptor class] newEmptyTree] retain];

                // 88:30: -> expr
                {
                    [treeAdaptor addChild:[stream_expr nextTree] toTree:root_0];

                }


                retval.tree = root_0;


                }
                break;

        }
        /* ASTParser ruleCleanUp */
        /* AST ruleCleanUp */
        // token+rule list labels
        [retval setStop:[input LT:-1]];


        [stream_K_LCURVE release];
        [stream_K_RCURVE release];
        [stream_expr release];

            retval.tree = (ANTLRCommonTree *)[treeAdaptor rulePostProcessing:root_0];
            [treeAdaptor setTokenBoundaries:retval.tree From:retval.start To:retval.stopToken];

    }
    @catch (ANTLRRecognitionException *re) {
        [self reportError:re];
        [self recover:input Exception:re];
        /* ASTParser rule.setErrorReturnValue */
        retval.tree = (ANTLRCommonTree *)[treeAdaptor errorNode:input From:retval.start To:[input LT:-1] Exception:re];

    }

    @finally {
        /* Terence's stuff */

    }
    return retval;
}
/* $ANTLR end atom */
/* ObjC end rules */

@end /* end of SimpleCParser implementation line 692 */