/** \file
 *  This C source file was generated by $ANTLR version 3.4
 *
 *     -  From the grammar source file : ../grammars/belle_sdp.g
 *     -                            On : 2021-05-13 15:53:02
 *     -                for the parser : belle_sdpParserParser
 *
 * Editing it, at least manually, is not wise.
 *
 * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
 *
 *
*/
// [The "BSD license"]
// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
// http://www.temporal-wave.com
// http://www.linkedin.com/in/jimidle
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
// 3. The name of the author may not be used to endorse or promote products
//    derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


/* =============================================================================
 * This is what the grammar programmer asked us to put at the top of every file.
 */

/*
    belle-sip - SIP (RFC3261) library.
    Copyright (C) 2010  Belledonne Communications SARL

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#pragma GCC diagnostic ignored "-Wparentheses"
#pragma GCC diagnostic ignored "-Wunused"
#ifndef __clang__
#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#pragma GCC diagnostic ignored "-Wunused-variable"
#pragma GCC diagnostic ignored "-Wunused-function"
#endif

/* End of Header action.
 * =============================================================================
 */

/* -----------------------------------------
 * Include the ANTLR3 generated header file.
 */
#include    "belle_sdpParser.h"
/* ----------------------------------------- */





/* MACROS that hide the C interface implementations from the
 * generated code, which makes it a little more understandable to the human eye.
 * I am very much against using C pre-processor macros for function calls and bits
 * of code as you cannot see what is happening when single stepping in debuggers
 * and so on. The exception (in my book at least) is for generated code, where you are
 * not maintaining it, but may wish to read and understand it. If you single step it, you know that input()
 * hides some indirect calls, but is always referring to the input stream. This is
 * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig
 * the runtime interfaces without changing the generated code too often, without
 * confusing the reader of the generated output, who may not wish to know the gory
 * details of the interface inheritance.
 */

#define		CTX	ctx

/* Aids in accessing scopes for grammar programmers
 */
#undef	SCOPE_TYPE
#undef	SCOPE_STACK
#undef	SCOPE_TOP
#define	SCOPE_TYPE(scope)   pbelle_sdpParser_##scope##_SCOPE
#define SCOPE_STACK(scope)  pbelle_sdpParser_##scope##Stack
#define	SCOPE_TOP(scope)    ctx->pbelle_sdpParser_##scope##Top
#define	SCOPE_SIZE(scope)		ctx->pbelle_sdpParser_##scope##Stack_limit
#define SCOPE_INSTANCE(scope, i)	(ctx->SCOPE_STACK(scope)->get(ctx->SCOPE_STACK(scope),i))

/* Macros for accessing things in the parser
 */

#undef	    PARSER
#undef	    RECOGNIZER
#undef	    HAVEPARSEDRULE
#undef		MEMOIZE
#undef	    INPUT
#undef	    STRSTREAM
#undef	    HASEXCEPTION
#undef	    EXCEPTION
#undef	    MATCHT
#undef	    MATCHANYT
#undef	    FOLLOWSTACK
#undef	    FOLLOWPUSH
#undef	    FOLLOWPOP
#undef	    PRECOVER
#undef	    PREPORTERROR
#undef	    LA
#undef	    LT
#undef	    CONSTRUCTEX
#undef	    CONSUME
#undef	    MARK
#undef	    REWIND
#undef	    REWINDLAST
#undef	    PERRORRECOVERY
#undef	    HASFAILED
#undef	    FAILEDFLAG
#undef	    RECOVERFROMMISMATCHEDSET
#undef	    RECOVERFROMMISMATCHEDELEMENT
#undef		INDEX
#undef      ADAPTOR
#undef		SEEK
#undef	    RULEMEMO
#undef		DBG

#define	    PARSER				ctx->pParser
#define	    RECOGNIZER				PARSER->rec
#define	    PSRSTATE				RECOGNIZER->state
#define	    HAVEPARSEDRULE(r)			RECOGNIZER->alreadyParsedRule(RECOGNIZER, r)
#define	    MEMOIZE(ri,si)			RECOGNIZER->memoize(RECOGNIZER, ri, si)
#define	    INPUT				PARSER->tstream
#define	    STRSTREAM				INPUT
#define	    ISTREAM				INPUT->istream
#define	    INDEX()				ISTREAM->index(INPUT->istream)
#define	    HASEXCEPTION()			(PSRSTATE->error == ANTLR3_TRUE)
#define	    EXCEPTION				PSRSTATE->exception
#define	    MATCHT(t, fs)			RECOGNIZER->match(RECOGNIZER, t, fs)
#define	    MATCHANYT()				RECOGNIZER->matchAny(RECOGNIZER)
#define	    FOLLOWSTACK				PSRSTATE->following
#ifdef  SKIP_FOLLOW_SETS
#define	    FOLLOWPUSH(x)
#define	    FOLLOWPOP()
#else
#define	    FOLLOWPUSH(x)			FOLLOWSTACK->push(FOLLOWSTACK, ((void *)(&(x))), NULL)
#define	    FOLLOWPOP()				FOLLOWSTACK->pop(FOLLOWSTACK)
#endif
#define	    PRECOVER()				RECOGNIZER->recover(RECOGNIZER)
#define	    PREPORTERROR()			RECOGNIZER->reportError(RECOGNIZER)
#define	    LA(n)				INPUT->istream->_LA(ISTREAM, n)
#define	    LT(n)				INPUT->_LT(INPUT, n)
#define	    CONSTRUCTEX()			RECOGNIZER->exConstruct(RECOGNIZER)
#define	    CONSUME()				ISTREAM->consume(ISTREAM)
#define	    MARK()				ISTREAM->mark(ISTREAM)
#define	    REWIND(m)				ISTREAM->rewind(ISTREAM, m)
#define	    REWINDLAST()			ISTREAM->rewindLast(ISTREAM)
#define	    SEEK(n)				ISTREAM->seek(ISTREAM, n)
#define	    PERRORRECOVERY			PSRSTATE->errorRecovery
#define	    FAILEDFLAG				PSRSTATE->failed
#define	    HASFAILED()				(FAILEDFLAG == ANTLR3_TRUE)
#define	    BACKTRACKING			PSRSTATE->backtracking
#define	    RECOVERFROMMISMATCHEDSET(s)		RECOGNIZER->recoverFromMismatchedSet(RECOGNIZER, s)
#define	    RECOVERFROMMISMATCHEDELEMENT(e)	RECOGNIZER->recoverFromMismatchedElement(RECOGNIZER, s)
#define     ADAPTOR                         ctx->adaptor
#define		RULEMEMO						PSRSTATE->ruleMemo
#define		DBG								RECOGNIZER->debugger


#define		TOKTEXT(tok, txt)				tok, (pANTLR3_UINT8)txt

/* The 4 tokens defined below may well clash with your own #defines or token types. If so
 * then for the present you must use different names for your defines as these are hard coded
 * in the code generator. It would be better not to use such names internally, and maybe
 * we can change this in a forthcoming release. I deliberately do not #undef these
 * here as this will at least give you a redefined error somewhere if they clash.
 */
#define	    UP	    ANTLR3_TOKEN_UP
#define	    DOWN    ANTLR3_TOKEN_DOWN
#define	    EOR	    ANTLR3_TOKEN_EOR
#define	    INVALID ANTLR3_TOKEN_INVALID


/* =============================================================================
 * Functions to create and destroy scopes. First come the rule scopes, followed
 * by the global declared scopes.
 */

/* ruleAttributeScopeFuncDecl(scope)
 */
/* -----------------------------------------------------------------------------
 * Function declarations for creating a belle_sdpParser_session_description scope set
 */
static pbelle_sdpParser_session_description_SCOPE   pbelle_sdpParser_session_descriptionPush(pbelle_sdpParser ctx);
static void ANTLR3_CDECL session_descriptionFree(pbelle_sdpParser_session_description_SCOPE scope);
/* ----------------------------------------------------------------------------- */


/* ruleAttributeScopeFuncs(scope)
 */
/* attributeFuncs(scope)
 */

static void ANTLR3_CDECL session_descriptionFree(pbelle_sdpParser_session_description_SCOPE scope)
{
    ANTLR3_FREE(scope);
}

/** \brief Allocate initial memory for a belle_sdpParser session_description scope variable stack entry and
 *         add it to the top of the stack.
 *
 * \remark
 * By default the structure is freed with ANTLR_FREE(), but you can use the
 * the \@init action to install a pointer to a custom free() routine by
 * adding the code:
 * \code
 *   ctx->pbelle_sdpParser_session_descriptionTop->free = myroutine;
 * \endcode
 *
 * With lots of comments of course! The routine should be declared in
 * \@members { } as:
 * \code
 *   void ANTLR3_CDECL myfunc( pbelle_sdpParser_session_description_SCOPE ptr).
 * \endcode
 *
 * It should perform any custom freeing stuff that you need (call ANTLR_FREE3, not free()
 * NB: It should not free the pointer it is given, which is the scope stack entry itself
 * and will be freed by the function that calls your custom free routine.
 *
 */
static pbelle_sdpParser_session_description_SCOPE
pbelle_sdpParser_session_descriptionPush(pbelle_sdpParser ctx)
{
    /* Pointer used to create a new set of attributes
     */
    pbelle_sdpParser_session_description_SCOPE      newAttributes;

    /* Allocate the memory for a new structure if we need one.
     */
    if (ctx->pbelle_sdpParser_session_descriptionStack->size(ctx->pbelle_sdpParser_session_descriptionStack) > ctx->pbelle_sdpParser_session_descriptionStack_limit)
    {
        // The current limit value was less than the number of scopes available on the stack so
        // we can just reuse one. Our limit tracks the stack count, so the index of the entry we want
        // is one less than that, or conveniently, the current value of limit.
        //
        newAttributes = (pbelle_sdpParser_session_description_SCOPE)ctx->pbelle_sdpParser_session_descriptionStack->get(ctx->pbelle_sdpParser_session_descriptionStack, ctx->pbelle_sdpParser_session_descriptionStack_limit);
    }
    else
    {
        // Need a new allocation
        //
        newAttributes = (pbelle_sdpParser_session_description_SCOPE) ANTLR3_MALLOC(sizeof(belle_sdpParser_session_description_SCOPE));
        if  (newAttributes != NULL)
        {
            /* Standard ANTLR3 library implementation
             */
            ctx->pbelle_sdpParser_session_descriptionStack->push(ctx->pbelle_sdpParser_session_descriptionStack, newAttributes, (void (*)(void *))session_descriptionFree);
        }
    }

    // Blank out any previous free pointer, the user might or might install a new one.
    //
    newAttributes->free = NULL;

    // Indicate the position in the available stack that the current level is at
    //
    ctx->pbelle_sdpParser_session_descriptionStack_limit++;

	/* Return value is the pointer to the new entry, which may be used locally
	 * without de-referencing via the context.
     */
    return  newAttributes;
}




/* ruleAttributeScopeFuncDecl(scope)
 */
/* -----------------------------------------------------------------------------
 * Function declarations for creating a belle_sdpParser_origin scope set
 */
static pbelle_sdpParser_origin_SCOPE   pbelle_sdpParser_originPush(pbelle_sdpParser ctx);
static void ANTLR3_CDECL originFree(pbelle_sdpParser_origin_SCOPE scope);
/* ----------------------------------------------------------------------------- */


/* ruleAttributeScopeFuncs(scope)
 */
/* attributeFuncs(scope)
 */

static void ANTLR3_CDECL originFree(pbelle_sdpParser_origin_SCOPE scope)
{
    ANTLR3_FREE(scope);
}

/** \brief Allocate initial memory for a belle_sdpParser origin scope variable stack entry and
 *         add it to the top of the stack.
 *
 * \remark
 * By default the structure is freed with ANTLR_FREE(), but you can use the
 * the \@init action to install a pointer to a custom free() routine by
 * adding the code:
 * \code
 *   ctx->pbelle_sdpParser_originTop->free = myroutine;
 * \endcode
 *
 * With lots of comments of course! The routine should be declared in
 * \@members { } as:
 * \code
 *   void ANTLR3_CDECL myfunc( pbelle_sdpParser_origin_SCOPE ptr).
 * \endcode
 *
 * It should perform any custom freeing stuff that you need (call ANTLR_FREE3, not free()
 * NB: It should not free the pointer it is given, which is the scope stack entry itself
 * and will be freed by the function that calls your custom free routine.
 *
 */
static pbelle_sdpParser_origin_SCOPE
pbelle_sdpParser_originPush(pbelle_sdpParser ctx)
{
    /* Pointer used to create a new set of attributes
     */
    pbelle_sdpParser_origin_SCOPE      newAttributes;

    /* Allocate the memory for a new structure if we need one.
     */
    if (ctx->pbelle_sdpParser_originStack->size(ctx->pbelle_sdpParser_originStack) > ctx->pbelle_sdpParser_originStack_limit)
    {
        // The current limit value was less than the number of scopes available on the stack so
        // we can just reuse one. Our limit tracks the stack count, so the index of the entry we want
        // is one less than that, or conveniently, the current value of limit.
        //
        newAttributes = (pbelle_sdpParser_origin_SCOPE)ctx->pbelle_sdpParser_originStack->get(ctx->pbelle_sdpParser_originStack, ctx->pbelle_sdpParser_originStack_limit);
    }
    else
    {
        // Need a new allocation
        //
        newAttributes = (pbelle_sdpParser_origin_SCOPE) ANTLR3_MALLOC(sizeof(belle_sdpParser_origin_SCOPE));
        if  (newAttributes != NULL)
        {
            /* Standard ANTLR3 library implementation
             */
            ctx->pbelle_sdpParser_originStack->push(ctx->pbelle_sdpParser_originStack, newAttributes, (void (*)(void *))originFree);
        }
    }

    // Blank out any previous free pointer, the user might or might install a new one.
    //
    newAttributes->free = NULL;

    // Indicate the position in the available stack that the current level is at
    //
    ctx->pbelle_sdpParser_originStack_limit++;

	/* Return value is the pointer to the new entry, which may be used locally
	 * without de-referencing via the context.
     */
    return  newAttributes;
}




/* ruleAttributeScopeFuncDecl(scope)
 */
/* -----------------------------------------------------------------------------
 * Function declarations for creating a belle_sdpParser_info scope set
 */
static pbelle_sdpParser_info_SCOPE   pbelle_sdpParser_infoPush(pbelle_sdpParser ctx);
static void ANTLR3_CDECL infoFree(pbelle_sdpParser_info_SCOPE scope);
/* ----------------------------------------------------------------------------- */


/* ruleAttributeScopeFuncs(scope)
 */
/* attributeFuncs(scope)
 */

static void ANTLR3_CDECL infoFree(pbelle_sdpParser_info_SCOPE scope)
{
    ANTLR3_FREE(scope);
}

/** \brief Allocate initial memory for a belle_sdpParser info scope variable stack entry and
 *         add it to the top of the stack.
 *
 * \remark
 * By default the structure is freed with ANTLR_FREE(), but you can use the
 * the \@init action to install a pointer to a custom free() routine by
 * adding the code:
 * \code
 *   ctx->pbelle_sdpParser_infoTop->free = myroutine;
 * \endcode
 *
 * With lots of comments of course! The routine should be declared in
 * \@members { } as:
 * \code
 *   void ANTLR3_CDECL myfunc( pbelle_sdpParser_info_SCOPE ptr).
 * \endcode
 *
 * It should perform any custom freeing stuff that you need (call ANTLR_FREE3, not free()
 * NB: It should not free the pointer it is given, which is the scope stack entry itself
 * and will be freed by the function that calls your custom free routine.
 *
 */
static pbelle_sdpParser_info_SCOPE
pbelle_sdpParser_infoPush(pbelle_sdpParser ctx)
{
    /* Pointer used to create a new set of attributes
     */
    pbelle_sdpParser_info_SCOPE      newAttributes;

    /* Allocate the memory for a new structure if we need one.
     */
    if (ctx->pbelle_sdpParser_infoStack->size(ctx->pbelle_sdpParser_infoStack) > ctx->pbelle_sdpParser_infoStack_limit)
    {
        // The current limit value was less than the number of scopes available on the stack so
        // we can just reuse one. Our limit tracks the stack count, so the index of the entry we want
        // is one less than that, or conveniently, the current value of limit.
        //
        newAttributes = (pbelle_sdpParser_info_SCOPE)ctx->pbelle_sdpParser_infoStack->get(ctx->pbelle_sdpParser_infoStack, ctx->pbelle_sdpParser_infoStack_limit);
    }
    else
    {
        // Need a new allocation
        //
        newAttributes = (pbelle_sdpParser_info_SCOPE) ANTLR3_MALLOC(sizeof(belle_sdpParser_info_SCOPE));
        if  (newAttributes != NULL)
        {
            /* Standard ANTLR3 library implementation
             */
            ctx->pbelle_sdpParser_infoStack->push(ctx->pbelle_sdpParser_infoStack, newAttributes, (void (*)(void *))infoFree);
        }
    }

    // Blank out any previous free pointer, the user might or might install a new one.
    //
    newAttributes->free = NULL;

    // Indicate the position in the available stack that the current level is at
    //
    ctx->pbelle_sdpParser_infoStack_limit++;

	/* Return value is the pointer to the new entry, which may be used locally
	 * without de-referencing via the context.
     */
    return  newAttributes;
}




/* ruleAttributeScopeFuncDecl(scope)
 */
/* -----------------------------------------------------------------------------
 * Function declarations for creating a belle_sdpParser_email scope set
 */
static pbelle_sdpParser_email_SCOPE   pbelle_sdpParser_emailPush(pbelle_sdpParser ctx);
static void ANTLR3_CDECL emailFree(pbelle_sdpParser_email_SCOPE scope);
/* ----------------------------------------------------------------------------- */


/* ruleAttributeScopeFuncs(scope)
 */
/* attributeFuncs(scope)
 */

static void ANTLR3_CDECL emailFree(pbelle_sdpParser_email_SCOPE scope)
{
    ANTLR3_FREE(scope);
}

/** \brief Allocate initial memory for a belle_sdpParser email scope variable stack entry and
 *         add it to the top of the stack.
 *
 * \remark
 * By default the structure is freed with ANTLR_FREE(), but you can use the
 * the \@init action to install a pointer to a custom free() routine by
 * adding the code:
 * \code
 *   ctx->pbelle_sdpParser_emailTop->free = myroutine;
 * \endcode
 *
 * With lots of comments of course! The routine should be declared in
 * \@members { } as:
 * \code
 *   void ANTLR3_CDECL myfunc( pbelle_sdpParser_email_SCOPE ptr).
 * \endcode
 *
 * It should perform any custom freeing stuff that you need (call ANTLR_FREE3, not free()
 * NB: It should not free the pointer it is given, which is the scope stack entry itself
 * and will be freed by the function that calls your custom free routine.
 *
 */
static pbelle_sdpParser_email_SCOPE
pbelle_sdpParser_emailPush(pbelle_sdpParser ctx)
{
    /* Pointer used to create a new set of attributes
     */
    pbelle_sdpParser_email_SCOPE      newAttributes;

    /* Allocate the memory for a new structure if we need one.
     */
    if (ctx->pbelle_sdpParser_emailStack->size(ctx->pbelle_sdpParser_emailStack) > ctx->pbelle_sdpParser_emailStack_limit)
    {
        // The current limit value was less than the number of scopes available on the stack so
        // we can just reuse one. Our limit tracks the stack count, so the index of the entry we want
        // is one less than that, or conveniently, the current value of limit.
        //
        newAttributes = (pbelle_sdpParser_email_SCOPE)ctx->pbelle_sdpParser_emailStack->get(ctx->pbelle_sdpParser_emailStack, ctx->pbelle_sdpParser_emailStack_limit);
    }
    else
    {
        // Need a new allocation
        //
        newAttributes = (pbelle_sdpParser_email_SCOPE) ANTLR3_MALLOC(sizeof(belle_sdpParser_email_SCOPE));
        if  (newAttributes != NULL)
        {
            /* Standard ANTLR3 library implementation
             */
            ctx->pbelle_sdpParser_emailStack->push(ctx->pbelle_sdpParser_emailStack, newAttributes, (void (*)(void *))emailFree);
        }
    }

    // Blank out any previous free pointer, the user might or might install a new one.
    //
    newAttributes->free = NULL;

    // Indicate the position in the available stack that the current level is at
    //
    ctx->pbelle_sdpParser_emailStack_limit++;

	/* Return value is the pointer to the new entry, which may be used locally
	 * without de-referencing via the context.
     */
    return  newAttributes;
}




/* ruleAttributeScopeFuncDecl(scope)
 */
/* -----------------------------------------------------------------------------
 * Function declarations for creating a belle_sdpParser_connection scope set
 */
static pbelle_sdpParser_connection_SCOPE   pbelle_sdpParser_connectionPush(pbelle_sdpParser ctx);
static void ANTLR3_CDECL connectionFree(pbelle_sdpParser_connection_SCOPE scope);
/* ----------------------------------------------------------------------------- */


/* ruleAttributeScopeFuncs(scope)
 */
/* attributeFuncs(scope)
 */

static void ANTLR3_CDECL connectionFree(pbelle_sdpParser_connection_SCOPE scope)
{
    ANTLR3_FREE(scope);
}

/** \brief Allocate initial memory for a belle_sdpParser connection scope variable stack entry and
 *         add it to the top of the stack.
 *
 * \remark
 * By default the structure is freed with ANTLR_FREE(), but you can use the
 * the \@init action to install a pointer to a custom free() routine by
 * adding the code:
 * \code
 *   ctx->pbelle_sdpParser_connectionTop->free = myroutine;
 * \endcode
 *
 * With lots of comments of course! The routine should be declared in
 * \@members { } as:
 * \code
 *   void ANTLR3_CDECL myfunc( pbelle_sdpParser_connection_SCOPE ptr).
 * \endcode
 *
 * It should perform any custom freeing stuff that you need (call ANTLR_FREE3, not free()
 * NB: It should not free the pointer it is given, which is the scope stack entry itself
 * and will be freed by the function that calls your custom free routine.
 *
 */
static pbelle_sdpParser_connection_SCOPE
pbelle_sdpParser_connectionPush(pbelle_sdpParser ctx)
{
    /* Pointer used to create a new set of attributes
     */
    pbelle_sdpParser_connection_SCOPE      newAttributes;

    /* Allocate the memory for a new structure if we need one.
     */
    if (ctx->pbelle_sdpParser_connectionStack->size(ctx->pbelle_sdpParser_connectionStack) > ctx->pbelle_sdpParser_connectionStack_limit)
    {
        // The current limit value was less than the number of scopes available on the stack so
        // we can just reuse one. Our limit tracks the stack count, so the index of the entry we want
        // is one less than that, or conveniently, the current value of limit.
        //
        newAttributes = (pbelle_sdpParser_connection_SCOPE)ctx->pbelle_sdpParser_connectionStack->get(ctx->pbelle_sdpParser_connectionStack, ctx->pbelle_sdpParser_connectionStack_limit);
    }
    else
    {
        // Need a new allocation
        //
        newAttributes = (pbelle_sdpParser_connection_SCOPE) ANTLR3_MALLOC(sizeof(belle_sdpParser_connection_SCOPE));
        if  (newAttributes != NULL)
        {
            /* Standard ANTLR3 library implementation
             */
            ctx->pbelle_sdpParser_connectionStack->push(ctx->pbelle_sdpParser_connectionStack, newAttributes, (void (*)(void *))connectionFree);
        }
    }

    // Blank out any previous free pointer, the user might or might install a new one.
    //
    newAttributes->free = NULL;

    // Indicate the position in the available stack that the current level is at
    //
    ctx->pbelle_sdpParser_connectionStack_limit++;

	/* Return value is the pointer to the new entry, which may be used locally
	 * without de-referencing via the context.
     */
    return  newAttributes;
}




/* ruleAttributeScopeFuncDecl(scope)
 */
/* -----------------------------------------------------------------------------
 * Function declarations for creating a belle_sdpParser_bandwidth scope set
 */
static pbelle_sdpParser_bandwidth_SCOPE   pbelle_sdpParser_bandwidthPush(pbelle_sdpParser ctx);
static void ANTLR3_CDECL bandwidthFree(pbelle_sdpParser_bandwidth_SCOPE scope);
/* ----------------------------------------------------------------------------- */


/* ruleAttributeScopeFuncs(scope)
 */
/* attributeFuncs(scope)
 */

static void ANTLR3_CDECL bandwidthFree(pbelle_sdpParser_bandwidth_SCOPE scope)
{
    ANTLR3_FREE(scope);
}

/** \brief Allocate initial memory for a belle_sdpParser bandwidth scope variable stack entry and
 *         add it to the top of the stack.
 *
 * \remark
 * By default the structure is freed with ANTLR_FREE(), but you can use the
 * the \@init action to install a pointer to a custom free() routine by
 * adding the code:
 * \code
 *   ctx->pbelle_sdpParser_bandwidthTop->free = myroutine;
 * \endcode
 *
 * With lots of comments of course! The routine should be declared in
 * \@members { } as:
 * \code
 *   void ANTLR3_CDECL myfunc( pbelle_sdpParser_bandwidth_SCOPE ptr).
 * \endcode
 *
 * It should perform any custom freeing stuff that you need (call ANTLR_FREE3, not free()
 * NB: It should not free the pointer it is given, which is the scope stack entry itself
 * and will be freed by the function that calls your custom free routine.
 *
 */
static pbelle_sdpParser_bandwidth_SCOPE
pbelle_sdpParser_bandwidthPush(pbelle_sdpParser ctx)
{
    /* Pointer used to create a new set of attributes
     */
    pbelle_sdpParser_bandwidth_SCOPE      newAttributes;

    /* Allocate the memory for a new structure if we need one.
     */
    if (ctx->pbelle_sdpParser_bandwidthStack->size(ctx->pbelle_sdpParser_bandwidthStack) > ctx->pbelle_sdpParser_bandwidthStack_limit)
    {
        // The current limit value was less than the number of scopes available on the stack so
        // we can just reuse one. Our limit tracks the stack count, so the index of the entry we want
        // is one less than that, or conveniently, the current value of limit.
        //
        newAttributes = (pbelle_sdpParser_bandwidth_SCOPE)ctx->pbelle_sdpParser_bandwidthStack->get(ctx->pbelle_sdpParser_bandwidthStack, ctx->pbelle_sdpParser_bandwidthStack_limit);
    }
    else
    {
        // Need a new allocation
        //
        newAttributes = (pbelle_sdpParser_bandwidth_SCOPE) ANTLR3_MALLOC(sizeof(belle_sdpParser_bandwidth_SCOPE));
        if  (newAttributes != NULL)
        {
            /* Standard ANTLR3 library implementation
             */
            ctx->pbelle_sdpParser_bandwidthStack->push(ctx->pbelle_sdpParser_bandwidthStack, newAttributes, (void (*)(void *))bandwidthFree);
        }
    }

    // Blank out any previous free pointer, the user might or might install a new one.
    //
    newAttributes->free = NULL;

    // Indicate the position in the available stack that the current level is at
    //
    ctx->pbelle_sdpParser_bandwidthStack_limit++;

	/* Return value is the pointer to the new entry, which may be used locally
	 * without de-referencing via the context.
     */
    return  newAttributes;
}




/* ruleAttributeScopeFuncDecl(scope)
 */
/* -----------------------------------------------------------------------------
 * Function declarations for creating a belle_sdpParser_attribute scope set
 */
static pbelle_sdpParser_attribute_SCOPE   pbelle_sdpParser_attributePush(pbelle_sdpParser ctx);
static void ANTLR3_CDECL attributeFree(pbelle_sdpParser_attribute_SCOPE scope);
/* ----------------------------------------------------------------------------- */


/* ruleAttributeScopeFuncs(scope)
 */
/* attributeFuncs(scope)
 */

static void ANTLR3_CDECL attributeFree(pbelle_sdpParser_attribute_SCOPE scope)
{
    ANTLR3_FREE(scope);
}

/** \brief Allocate initial memory for a belle_sdpParser attribute scope variable stack entry and
 *         add it to the top of the stack.
 *
 * \remark
 * By default the structure is freed with ANTLR_FREE(), but you can use the
 * the \@init action to install a pointer to a custom free() routine by
 * adding the code:
 * \code
 *   ctx->pbelle_sdpParser_attributeTop->free = myroutine;
 * \endcode
 *
 * With lots of comments of course! The routine should be declared in
 * \@members { } as:
 * \code
 *   void ANTLR3_CDECL myfunc( pbelle_sdpParser_attribute_SCOPE ptr).
 * \endcode
 *
 * It should perform any custom freeing stuff that you need (call ANTLR_FREE3, not free()
 * NB: It should not free the pointer it is given, which is the scope stack entry itself
 * and will be freed by the function that calls your custom free routine.
 *
 */
static pbelle_sdpParser_attribute_SCOPE
pbelle_sdpParser_attributePush(pbelle_sdpParser ctx)
{
    /* Pointer used to create a new set of attributes
     */
    pbelle_sdpParser_attribute_SCOPE      newAttributes;

    /* Allocate the memory for a new structure if we need one.
     */
    if (ctx->pbelle_sdpParser_attributeStack->size(ctx->pbelle_sdpParser_attributeStack) > ctx->pbelle_sdpParser_attributeStack_limit)
    {
        // The current limit value was less than the number of scopes available on the stack so
        // we can just reuse one. Our limit tracks the stack count, so the index of the entry we want
        // is one less than that, or conveniently, the current value of limit.
        //
        newAttributes = (pbelle_sdpParser_attribute_SCOPE)ctx->pbelle_sdpParser_attributeStack->get(ctx->pbelle_sdpParser_attributeStack, ctx->pbelle_sdpParser_attributeStack_limit);
    }
    else
    {
        // Need a new allocation
        //
        newAttributes = (pbelle_sdpParser_attribute_SCOPE) ANTLR3_MALLOC(sizeof(belle_sdpParser_attribute_SCOPE));
        if  (newAttributes != NULL)
        {
            /* Standard ANTLR3 library implementation
             */
            ctx->pbelle_sdpParser_attributeStack->push(ctx->pbelle_sdpParser_attributeStack, newAttributes, (void (*)(void *))attributeFree);
        }
    }

    // Blank out any previous free pointer, the user might or might install a new one.
    //
    newAttributes->free = NULL;

    // Indicate the position in the available stack that the current level is at
    //
    ctx->pbelle_sdpParser_attributeStack_limit++;

	/* Return value is the pointer to the new entry, which may be used locally
	 * without de-referencing via the context.
     */
    return  newAttributes;
}




/* ruleAttributeScopeFuncDecl(scope)
 */
/* -----------------------------------------------------------------------------
 * Function declarations for creating a belle_sdpParser_rtcp_xr_attribute scope set
 */
static pbelle_sdpParser_rtcp_xr_attribute_SCOPE   pbelle_sdpParser_rtcp_xr_attributePush(pbelle_sdpParser ctx);
static void ANTLR3_CDECL rtcp_xr_attributeFree(pbelle_sdpParser_rtcp_xr_attribute_SCOPE scope);
/* ----------------------------------------------------------------------------- */


/* ruleAttributeScopeFuncs(scope)
 */
/* attributeFuncs(scope)
 */

static void ANTLR3_CDECL rtcp_xr_attributeFree(pbelle_sdpParser_rtcp_xr_attribute_SCOPE scope)
{
    ANTLR3_FREE(scope);
}

/** \brief Allocate initial memory for a belle_sdpParser rtcp_xr_attribute scope variable stack entry and
 *         add it to the top of the stack.
 *
 * \remark
 * By default the structure is freed with ANTLR_FREE(), but you can use the
 * the \@init action to install a pointer to a custom free() routine by
 * adding the code:
 * \code
 *   ctx->pbelle_sdpParser_rtcp_xr_attributeTop->free = myroutine;
 * \endcode
 *
 * With lots of comments of course! The routine should be declared in
 * \@members { } as:
 * \code
 *   void ANTLR3_CDECL myfunc( pbelle_sdpParser_rtcp_xr_attribute_SCOPE ptr).
 * \endcode
 *
 * It should perform any custom freeing stuff that you need (call ANTLR_FREE3, not free()
 * NB: It should not free the pointer it is given, which is the scope stack entry itself
 * and will be freed by the function that calls your custom free routine.
 *
 */
static pbelle_sdpParser_rtcp_xr_attribute_SCOPE
pbelle_sdpParser_rtcp_xr_attributePush(pbelle_sdpParser ctx)
{
    /* Pointer used to create a new set of attributes
     */
    pbelle_sdpParser_rtcp_xr_attribute_SCOPE      newAttributes;

    /* Allocate the memory for a new structure if we need one.
     */
    if (ctx->pbelle_sdpParser_rtcp_xr_attributeStack->size(ctx->pbelle_sdpParser_rtcp_xr_attributeStack) > ctx->pbelle_sdpParser_rtcp_xr_attributeStack_limit)
    {
        // The current limit value was less than the number of scopes available on the stack so
        // we can just reuse one. Our limit tracks the stack count, so the index of the entry we want
        // is one less than that, or conveniently, the current value of limit.
        //
        newAttributes = (pbelle_sdpParser_rtcp_xr_attribute_SCOPE)ctx->pbelle_sdpParser_rtcp_xr_attributeStack->get(ctx->pbelle_sdpParser_rtcp_xr_attributeStack, ctx->pbelle_sdpParser_rtcp_xr_attributeStack_limit);
    }
    else
    {
        // Need a new allocation
        //
        newAttributes = (pbelle_sdpParser_rtcp_xr_attribute_SCOPE) ANTLR3_MALLOC(sizeof(belle_sdpParser_rtcp_xr_attribute_SCOPE));
        if  (newAttributes != NULL)
        {
            /* Standard ANTLR3 library implementation
             */
            ctx->pbelle_sdpParser_rtcp_xr_attributeStack->push(ctx->pbelle_sdpParser_rtcp_xr_attributeStack, newAttributes, (void (*)(void *))rtcp_xr_attributeFree);
        }
    }

    // Blank out any previous free pointer, the user might or might install a new one.
    //
    newAttributes->free = NULL;

    // Indicate the position in the available stack that the current level is at
    //
    ctx->pbelle_sdpParser_rtcp_xr_attributeStack_limit++;

	/* Return value is the pointer to the new entry, which may be used locally
	 * without de-referencing via the context.
     */
    return  newAttributes;
}




/* ruleAttributeScopeFuncDecl(scope)
 */
/* -----------------------------------------------------------------------------
 * Function declarations for creating a belle_sdpParser_rtcp_fb_attribute scope set
 */
static pbelle_sdpParser_rtcp_fb_attribute_SCOPE   pbelle_sdpParser_rtcp_fb_attributePush(pbelle_sdpParser ctx);
static void ANTLR3_CDECL rtcp_fb_attributeFree(pbelle_sdpParser_rtcp_fb_attribute_SCOPE scope);
/* ----------------------------------------------------------------------------- */


/* ruleAttributeScopeFuncs(scope)
 */
/* attributeFuncs(scope)
 */

static void ANTLR3_CDECL rtcp_fb_attributeFree(pbelle_sdpParser_rtcp_fb_attribute_SCOPE scope)
{
    ANTLR3_FREE(scope);
}

/** \brief Allocate initial memory for a belle_sdpParser rtcp_fb_attribute scope variable stack entry and
 *         add it to the top of the stack.
 *
 * \remark
 * By default the structure is freed with ANTLR_FREE(), but you can use the
 * the \@init action to install a pointer to a custom free() routine by
 * adding the code:
 * \code
 *   ctx->pbelle_sdpParser_rtcp_fb_attributeTop->free = myroutine;
 * \endcode
 *
 * With lots of comments of course! The routine should be declared in
 * \@members { } as:
 * \code
 *   void ANTLR3_CDECL myfunc( pbelle_sdpParser_rtcp_fb_attribute_SCOPE ptr).
 * \endcode
 *
 * It should perform any custom freeing stuff that you need (call ANTLR_FREE3, not free()
 * NB: It should not free the pointer it is given, which is the scope stack entry itself
 * and will be freed by the function that calls your custom free routine.
 *
 */
static pbelle_sdpParser_rtcp_fb_attribute_SCOPE
pbelle_sdpParser_rtcp_fb_attributePush(pbelle_sdpParser ctx)
{
    /* Pointer used to create a new set of attributes
     */
    pbelle_sdpParser_rtcp_fb_attribute_SCOPE      newAttributes;

    /* Allocate the memory for a new structure if we need one.
     */
    if (ctx->pbelle_sdpParser_rtcp_fb_attributeStack->size(ctx->pbelle_sdpParser_rtcp_fb_attributeStack) > ctx->pbelle_sdpParser_rtcp_fb_attributeStack_limit)
    {
        // The current limit value was less than the number of scopes available on the stack so
        // we can just reuse one. Our limit tracks the stack count, so the index of the entry we want
        // is one less than that, or conveniently, the current value of limit.
        //
        newAttributes = (pbelle_sdpParser_rtcp_fb_attribute_SCOPE)ctx->pbelle_sdpParser_rtcp_fb_attributeStack->get(ctx->pbelle_sdpParser_rtcp_fb_attributeStack, ctx->pbelle_sdpParser_rtcp_fb_attributeStack_limit);
    }
    else
    {
        // Need a new allocation
        //
        newAttributes = (pbelle_sdpParser_rtcp_fb_attribute_SCOPE) ANTLR3_MALLOC(sizeof(belle_sdpParser_rtcp_fb_attribute_SCOPE));
        if  (newAttributes != NULL)
        {
            /* Standard ANTLR3 library implementation
             */
            ctx->pbelle_sdpParser_rtcp_fb_attributeStack->push(ctx->pbelle_sdpParser_rtcp_fb_attributeStack, newAttributes, (void (*)(void *))rtcp_fb_attributeFree);
        }
    }

    // Blank out any previous free pointer, the user might or might install a new one.
    //
    newAttributes->free = NULL;

    // Indicate the position in the available stack that the current level is at
    //
    ctx->pbelle_sdpParser_rtcp_fb_attributeStack_limit++;

	/* Return value is the pointer to the new entry, which may be used locally
	 * without de-referencing via the context.
     */
    return  newAttributes;
}




/* ruleAttributeScopeFuncDecl(scope)
 */
/* -----------------------------------------------------------------------------
 * Function declarations for creating a belle_sdpParser_media_description scope set
 */
static pbelle_sdpParser_media_description_SCOPE   pbelle_sdpParser_media_descriptionPush(pbelle_sdpParser ctx);
static void ANTLR3_CDECL media_descriptionFree(pbelle_sdpParser_media_description_SCOPE scope);
/* ----------------------------------------------------------------------------- */


/* ruleAttributeScopeFuncs(scope)
 */
/* attributeFuncs(scope)
 */

static void ANTLR3_CDECL media_descriptionFree(pbelle_sdpParser_media_description_SCOPE scope)
{
    ANTLR3_FREE(scope);
}

/** \brief Allocate initial memory for a belle_sdpParser media_description scope variable stack entry and
 *         add it to the top of the stack.
 *
 * \remark
 * By default the structure is freed with ANTLR_FREE(), but you can use the
 * the \@init action to install a pointer to a custom free() routine by
 * adding the code:
 * \code
 *   ctx->pbelle_sdpParser_media_descriptionTop->free = myroutine;
 * \endcode
 *
 * With lots of comments of course! The routine should be declared in
 * \@members { } as:
 * \code
 *   void ANTLR3_CDECL myfunc( pbelle_sdpParser_media_description_SCOPE ptr).
 * \endcode
 *
 * It should perform any custom freeing stuff that you need (call ANTLR_FREE3, not free()
 * NB: It should not free the pointer it is given, which is the scope stack entry itself
 * and will be freed by the function that calls your custom free routine.
 *
 */
static pbelle_sdpParser_media_description_SCOPE
pbelle_sdpParser_media_descriptionPush(pbelle_sdpParser ctx)
{
    /* Pointer used to create a new set of attributes
     */
    pbelle_sdpParser_media_description_SCOPE      newAttributes;

    /* Allocate the memory for a new structure if we need one.
     */
    if (ctx->pbelle_sdpParser_media_descriptionStack->size(ctx->pbelle_sdpParser_media_descriptionStack) > ctx->pbelle_sdpParser_media_descriptionStack_limit)
    {
        // The current limit value was less than the number of scopes available on the stack so
        // we can just reuse one. Our limit tracks the stack count, so the index of the entry we want
        // is one less than that, or conveniently, the current value of limit.
        //
        newAttributes = (pbelle_sdpParser_media_description_SCOPE)ctx->pbelle_sdpParser_media_descriptionStack->get(ctx->pbelle_sdpParser_media_descriptionStack, ctx->pbelle_sdpParser_media_descriptionStack_limit);
    }
    else
    {
        // Need a new allocation
        //
        newAttributes = (pbelle_sdpParser_media_description_SCOPE) ANTLR3_MALLOC(sizeof(belle_sdpParser_media_description_SCOPE));
        if  (newAttributes != NULL)
        {
            /* Standard ANTLR3 library implementation
             */
            ctx->pbelle_sdpParser_media_descriptionStack->push(ctx->pbelle_sdpParser_media_descriptionStack, newAttributes, (void (*)(void *))media_descriptionFree);
        }
    }

    // Blank out any previous free pointer, the user might or might install a new one.
    //
    newAttributes->free = NULL;

    // Indicate the position in the available stack that the current level is at
    //
    ctx->pbelle_sdpParser_media_descriptionStack_limit++;

	/* Return value is the pointer to the new entry, which may be used locally
	 * without de-referencing via the context.
     */
    return  newAttributes;
}




/* ruleAttributeScopeFuncDecl(scope)
 */
/* -----------------------------------------------------------------------------
 * Function declarations for creating a belle_sdpParser_media scope set
 */
static pbelle_sdpParser_media_SCOPE   pbelle_sdpParser_mediaPush(pbelle_sdpParser ctx);
static void ANTLR3_CDECL mediaFree(pbelle_sdpParser_media_SCOPE scope);
/* ----------------------------------------------------------------------------- */


/* ruleAttributeScopeFuncs(scope)
 */
/* attributeFuncs(scope)
 */

static void ANTLR3_CDECL mediaFree(pbelle_sdpParser_media_SCOPE scope)
{
    ANTLR3_FREE(scope);
}

/** \brief Allocate initial memory for a belle_sdpParser media scope variable stack entry and
 *         add it to the top of the stack.
 *
 * \remark
 * By default the structure is freed with ANTLR_FREE(), but you can use the
 * the \@init action to install a pointer to a custom free() routine by
 * adding the code:
 * \code
 *   ctx->pbelle_sdpParser_mediaTop->free = myroutine;
 * \endcode
 *
 * With lots of comments of course! The routine should be declared in
 * \@members { } as:
 * \code
 *   void ANTLR3_CDECL myfunc( pbelle_sdpParser_media_SCOPE ptr).
 * \endcode
 *
 * It should perform any custom freeing stuff that you need (call ANTLR_FREE3, not free()
 * NB: It should not free the pointer it is given, which is the scope stack entry itself
 * and will be freed by the function that calls your custom free routine.
 *
 */
static pbelle_sdpParser_media_SCOPE
pbelle_sdpParser_mediaPush(pbelle_sdpParser ctx)
{
    /* Pointer used to create a new set of attributes
     */
    pbelle_sdpParser_media_SCOPE      newAttributes;

    /* Allocate the memory for a new structure if we need one.
     */
    if (ctx->pbelle_sdpParser_mediaStack->size(ctx->pbelle_sdpParser_mediaStack) > ctx->pbelle_sdpParser_mediaStack_limit)
    {
        // The current limit value was less than the number of scopes available on the stack so
        // we can just reuse one. Our limit tracks the stack count, so the index of the entry we want
        // is one less than that, or conveniently, the current value of limit.
        //
        newAttributes = (pbelle_sdpParser_media_SCOPE)ctx->pbelle_sdpParser_mediaStack->get(ctx->pbelle_sdpParser_mediaStack, ctx->pbelle_sdpParser_mediaStack_limit);
    }
    else
    {
        // Need a new allocation
        //
        newAttributes = (pbelle_sdpParser_media_SCOPE) ANTLR3_MALLOC(sizeof(belle_sdpParser_media_SCOPE));
        if  (newAttributes != NULL)
        {
            /* Standard ANTLR3 library implementation
             */
            ctx->pbelle_sdpParser_mediaStack->push(ctx->pbelle_sdpParser_mediaStack, newAttributes, (void (*)(void *))mediaFree);
        }
    }

    // Blank out any previous free pointer, the user might or might install a new one.
    //
    newAttributes->free = NULL;

    // Indicate the position in the available stack that the current level is at
    //
    ctx->pbelle_sdpParser_mediaStack_limit++;

	/* Return value is the pointer to the new entry, which may be used locally
	 * without de-referencing via the context.
     */
    return  newAttributes;
}




/* ruleAttributeScopeFuncDecl(scope)
 */
/* -----------------------------------------------------------------------------
 * Function declarations for creating a belle_sdpParser_fmt scope set
 */
static pbelle_sdpParser_fmt_SCOPE   pbelle_sdpParser_fmtPush(pbelle_sdpParser ctx);
static void ANTLR3_CDECL fmtFree(pbelle_sdpParser_fmt_SCOPE scope);
/* ----------------------------------------------------------------------------- */


/* ruleAttributeScopeFuncs(scope)
 */
/* attributeFuncs(scope)
 */

static void ANTLR3_CDECL fmtFree(pbelle_sdpParser_fmt_SCOPE scope)
{
    ANTLR3_FREE(scope);
}

/** \brief Allocate initial memory for a belle_sdpParser fmt scope variable stack entry and
 *         add it to the top of the stack.
 *
 * \remark
 * By default the structure is freed with ANTLR_FREE(), but you can use the
 * the \@init action to install a pointer to a custom free() routine by
 * adding the code:
 * \code
 *   ctx->pbelle_sdpParser_fmtTop->free = myroutine;
 * \endcode
 *
 * With lots of comments of course! The routine should be declared in
 * \@members { } as:
 * \code
 *   void ANTLR3_CDECL myfunc( pbelle_sdpParser_fmt_SCOPE ptr).
 * \endcode
 *
 * It should perform any custom freeing stuff that you need (call ANTLR_FREE3, not free()
 * NB: It should not free the pointer it is given, which is the scope stack entry itself
 * and will be freed by the function that calls your custom free routine.
 *
 */
static pbelle_sdpParser_fmt_SCOPE
pbelle_sdpParser_fmtPush(pbelle_sdpParser ctx)
{
    /* Pointer used to create a new set of attributes
     */
    pbelle_sdpParser_fmt_SCOPE      newAttributes;

    /* Allocate the memory for a new structure if we need one.
     */
    if (ctx->pbelle_sdpParser_fmtStack->size(ctx->pbelle_sdpParser_fmtStack) > ctx->pbelle_sdpParser_fmtStack_limit)
    {
        // The current limit value was less than the number of scopes available on the stack so
        // we can just reuse one. Our limit tracks the stack count, so the index of the entry we want
        // is one less than that, or conveniently, the current value of limit.
        //
        newAttributes = (pbelle_sdpParser_fmt_SCOPE)ctx->pbelle_sdpParser_fmtStack->get(ctx->pbelle_sdpParser_fmtStack, ctx->pbelle_sdpParser_fmtStack_limit);
    }
    else
    {
        // Need a new allocation
        //
        newAttributes = (pbelle_sdpParser_fmt_SCOPE) ANTLR3_MALLOC(sizeof(belle_sdpParser_fmt_SCOPE));
        if  (newAttributes != NULL)
        {
            /* Standard ANTLR3 library implementation
             */
            ctx->pbelle_sdpParser_fmtStack->push(ctx->pbelle_sdpParser_fmtStack, newAttributes, (void (*)(void *))fmtFree);
        }
    }

    // Blank out any previous free pointer, the user might or might install a new one.
    //
    newAttributes->free = NULL;

    // Indicate the position in the available stack that the current level is at
    //
    ctx->pbelle_sdpParser_fmtStack_limit++;

	/* Return value is the pointer to the new entry, which may be used locally
	 * without de-referencing via the context.
     */
    return  newAttributes;
}







/* ============================================================================= */

/* =============================================================================
 * Start of recognizer
 */


/** \brief Table of all token names in symbolic order, mainly used for
 *         error reporting.
 */
pANTLR3_UINT8   belle_sdpParserTokenNames[32+4]
     = {
        (pANTLR3_UINT8) "<invalid>",       /* String to print to indicate an invalid token */
        (pANTLR3_UINT8) "<EOR>",
        (pANTLR3_UINT8) "<DOWN>",
        (pANTLR3_UINT8) "<UP>",
        (pANTLR3_UINT8) "COLON",
        (pANTLR3_UINT8) "COMMA",
        (pANTLR3_UINT8) "COMMON_CHAR",
        (pANTLR3_UINT8) "CR",
        (pANTLR3_UINT8) "DASH",
        (pANTLR3_UINT8) "DIGIT",
        (pANTLR3_UINT8) "DOT",
        (pANTLR3_UINT8) "EQUAL",
        (pANTLR3_UINT8) "HEX_CHAR",
        (pANTLR3_UINT8) "LF",
        (pANTLR3_UINT8) "LQUOTE",
        (pANTLR3_UINT8) "OCTET",
        (pANTLR3_UINT8) "POS_DIGIT",
        (pANTLR3_UINT8) "RQUOTE",
        (pANTLR3_UINT8) "SLASH",
        (pANTLR3_UINT8) "SPACE",
        (pANTLR3_UINT8) "STAR",
        (pANTLR3_UINT8) "ZERO",
        (pANTLR3_UINT8) "'!'",
        (pANTLR3_UINT8) "'#'",
        (pANTLR3_UINT8) "'$'",
        (pANTLR3_UINT8) "'%'",
        (pANTLR3_UINT8) "'&'",
        (pANTLR3_UINT8) "'+'",
        (pANTLR3_UINT8) "'\\''",
        (pANTLR3_UINT8) "'^'",
        (pANTLR3_UINT8) "'_'",
        (pANTLR3_UINT8) "'`'",
        (pANTLR3_UINT8) "'{'",
        (pANTLR3_UINT8) "'|'",
        (pANTLR3_UINT8) "'}'",
        (pANTLR3_UINT8) "'~'"
       };


/* ruleAttributeScopeFuncMacro(scope)
 */
/** Function for popping the top value from a pbelle_sdpParser_session_descriptionStack
 */
void
pbelle_sdpParser_session_descriptionPop(pbelle_sdpParser ctx)
{
    // First see if the user defined a function they want to be called when a
    // scope is popped/freed.
    //
	// If the user supplied the scope entries with a free function,then call it first
	//
    if	(SCOPE_TOP(session_description)->free != NULL)
	{
        SCOPE_TOP(session_description)->free(SCOPE_TOP(session_description));
	}

    // Now we decrement the scope's upper limit bound. We do not actually pop the scope as
    // we want to reuse scope entries if we do continuous push and pops. Most scopes don't
    // next too far so we don't want to keep freeing and allocating them
    //
    ctx->pbelle_sdpParser_session_descriptionStack_limit--;
    SCOPE_TOP(session_description) = (pbelle_sdpParser_session_description_SCOPE)(ctx->pbelle_sdpParser_session_descriptionStack->get(ctx->pbelle_sdpParser_session_descriptionStack, ctx->pbelle_sdpParser_session_descriptionStack_limit - 1));
}


/* ruleAttributeScopeFuncMacro(scope)
 */
/** Function for popping the top value from a pbelle_sdpParser_originStack
 */
void
pbelle_sdpParser_originPop(pbelle_sdpParser ctx)
{
    // First see if the user defined a function they want to be called when a
    // scope is popped/freed.
    //
	// If the user supplied the scope entries with a free function,then call it first
	//
    if	(SCOPE_TOP(origin)->free != NULL)
	{
        SCOPE_TOP(origin)->free(SCOPE_TOP(origin));
	}

    // Now we decrement the scope's upper limit bound. We do not actually pop the scope as
    // we want to reuse scope entries if we do continuous push and pops. Most scopes don't
    // next too far so we don't want to keep freeing and allocating them
    //
    ctx->pbelle_sdpParser_originStack_limit--;
    SCOPE_TOP(origin) = (pbelle_sdpParser_origin_SCOPE)(ctx->pbelle_sdpParser_originStack->get(ctx->pbelle_sdpParser_originStack, ctx->pbelle_sdpParser_originStack_limit - 1));
}


/* ruleAttributeScopeFuncMacro(scope)
 */
/** Function for popping the top value from a pbelle_sdpParser_infoStack
 */
void
pbelle_sdpParser_infoPop(pbelle_sdpParser ctx)
{
    // First see if the user defined a function they want to be called when a
    // scope is popped/freed.
    //
	// If the user supplied the scope entries with a free function,then call it first
	//
    if	(SCOPE_TOP(info)->free != NULL)
	{
        SCOPE_TOP(info)->free(SCOPE_TOP(info));
	}

    // Now we decrement the scope's upper limit bound. We do not actually pop the scope as
    // we want to reuse scope entries if we do continuous push and pops. Most scopes don't
    // next too far so we don't want to keep freeing and allocating them
    //
    ctx->pbelle_sdpParser_infoStack_limit--;
    SCOPE_TOP(info) = (pbelle_sdpParser_info_SCOPE)(ctx->pbelle_sdpParser_infoStack->get(ctx->pbelle_sdpParser_infoStack, ctx->pbelle_sdpParser_infoStack_limit - 1));
}


/* ruleAttributeScopeFuncMacro(scope)
 */
/** Function for popping the top value from a pbelle_sdpParser_emailStack
 */
void
pbelle_sdpParser_emailPop(pbelle_sdpParser ctx)
{
    // First see if the user defined a function they want to be called when a
    // scope is popped/freed.
    //
	// If the user supplied the scope entries with a free function,then call it first
	//
    if	(SCOPE_TOP(email)->free != NULL)
	{
        SCOPE_TOP(email)->free(SCOPE_TOP(email));
	}

    // Now we decrement the scope's upper limit bound. We do not actually pop the scope as
    // we want to reuse scope entries if we do continuous push and pops. Most scopes don't
    // next too far so we don't want to keep freeing and allocating them
    //
    ctx->pbelle_sdpParser_emailStack_limit--;
    SCOPE_TOP(email) = (pbelle_sdpParser_email_SCOPE)(ctx->pbelle_sdpParser_emailStack->get(ctx->pbelle_sdpParser_emailStack, ctx->pbelle_sdpParser_emailStack_limit - 1));
}


/* ruleAttributeScopeFuncMacro(scope)
 */
/** Function for popping the top value from a pbelle_sdpParser_connectionStack
 */
void
pbelle_sdpParser_connectionPop(pbelle_sdpParser ctx)
{
    // First see if the user defined a function they want to be called when a
    // scope is popped/freed.
    //
	// If the user supplied the scope entries with a free function,then call it first
	//
    if	(SCOPE_TOP(connection)->free != NULL)
	{
        SCOPE_TOP(connection)->free(SCOPE_TOP(connection));
	}

    // Now we decrement the scope's upper limit bound. We do not actually pop the scope as
    // we want to reuse scope entries if we do continuous push and pops. Most scopes don't
    // next too far so we don't want to keep freeing and allocating them
    //
    ctx->pbelle_sdpParser_connectionStack_limit--;
    SCOPE_TOP(connection) = (pbelle_sdpParser_connection_SCOPE)(ctx->pbelle_sdpParser_connectionStack->get(ctx->pbelle_sdpParser_connectionStack, ctx->pbelle_sdpParser_connectionStack_limit - 1));
}


/* ruleAttributeScopeFuncMacro(scope)
 */
/** Function for popping the top value from a pbelle_sdpParser_bandwidthStack
 */
void
pbelle_sdpParser_bandwidthPop(pbelle_sdpParser ctx)
{
    // First see if the user defined a function they want to be called when a
    // scope is popped/freed.
    //
	// If the user supplied the scope entries with a free function,then call it first
	//
    if	(SCOPE_TOP(bandwidth)->free != NULL)
	{
        SCOPE_TOP(bandwidth)->free(SCOPE_TOP(bandwidth));
	}

    // Now we decrement the scope's upper limit bound. We do not actually pop the scope as
    // we want to reuse scope entries if we do continuous push and pops. Most scopes don't
    // next too far so we don't want to keep freeing and allocating them
    //
    ctx->pbelle_sdpParser_bandwidthStack_limit--;
    SCOPE_TOP(bandwidth) = (pbelle_sdpParser_bandwidth_SCOPE)(ctx->pbelle_sdpParser_bandwidthStack->get(ctx->pbelle_sdpParser_bandwidthStack, ctx->pbelle_sdpParser_bandwidthStack_limit - 1));
}


/* ruleAttributeScopeFuncMacro(scope)
 */
/** Function for popping the top value from a pbelle_sdpParser_attributeStack
 */
void
pbelle_sdpParser_attributePop(pbelle_sdpParser ctx)
{
    // First see if the user defined a function they want to be called when a
    // scope is popped/freed.
    //
	// If the user supplied the scope entries with a free function,then call it first
	//
    if	(SCOPE_TOP(attribute)->free != NULL)
	{
        SCOPE_TOP(attribute)->free(SCOPE_TOP(attribute));
	}

    // Now we decrement the scope's upper limit bound. We do not actually pop the scope as
    // we want to reuse scope entries if we do continuous push and pops. Most scopes don't
    // next too far so we don't want to keep freeing and allocating them
    //
    ctx->pbelle_sdpParser_attributeStack_limit--;
    SCOPE_TOP(attribute) = (pbelle_sdpParser_attribute_SCOPE)(ctx->pbelle_sdpParser_attributeStack->get(ctx->pbelle_sdpParser_attributeStack, ctx->pbelle_sdpParser_attributeStack_limit - 1));
}


/* ruleAttributeScopeFuncMacro(scope)
 */
/** Function for popping the top value from a pbelle_sdpParser_rtcp_xr_attributeStack
 */
void
pbelle_sdpParser_rtcp_xr_attributePop(pbelle_sdpParser ctx)
{
    // First see if the user defined a function they want to be called when a
    // scope is popped/freed.
    //
	// If the user supplied the scope entries with a free function,then call it first
	//
    if	(SCOPE_TOP(rtcp_xr_attribute)->free != NULL)
	{
        SCOPE_TOP(rtcp_xr_attribute)->free(SCOPE_TOP(rtcp_xr_attribute));
	}

    // Now we decrement the scope's upper limit bound. We do not actually pop the scope as
    // we want to reuse scope entries if we do continuous push and pops. Most scopes don't
    // next too far so we don't want to keep freeing and allocating them
    //
    ctx->pbelle_sdpParser_rtcp_xr_attributeStack_limit--;
    SCOPE_TOP(rtcp_xr_attribute) = (pbelle_sdpParser_rtcp_xr_attribute_SCOPE)(ctx->pbelle_sdpParser_rtcp_xr_attributeStack->get(ctx->pbelle_sdpParser_rtcp_xr_attributeStack, ctx->pbelle_sdpParser_rtcp_xr_attributeStack_limit - 1));
}


/* ruleAttributeScopeFuncMacro(scope)
 */
/** Function for popping the top value from a pbelle_sdpParser_rtcp_fb_attributeStack
 */
void
pbelle_sdpParser_rtcp_fb_attributePop(pbelle_sdpParser ctx)
{
    // First see if the user defined a function they want to be called when a
    // scope is popped/freed.
    //
	// If the user supplied the scope entries with a free function,then call it first
	//
    if	(SCOPE_TOP(rtcp_fb_attribute)->free != NULL)
	{
        SCOPE_TOP(rtcp_fb_attribute)->free(SCOPE_TOP(rtcp_fb_attribute));
	}

    // Now we decrement the scope's upper limit bound. We do not actually pop the scope as
    // we want to reuse scope entries if we do continuous push and pops. Most scopes don't
    // next too far so we don't want to keep freeing and allocating them
    //
    ctx->pbelle_sdpParser_rtcp_fb_attributeStack_limit--;
    SCOPE_TOP(rtcp_fb_attribute) = (pbelle_sdpParser_rtcp_fb_attribute_SCOPE)(ctx->pbelle_sdpParser_rtcp_fb_attributeStack->get(ctx->pbelle_sdpParser_rtcp_fb_attributeStack, ctx->pbelle_sdpParser_rtcp_fb_attributeStack_limit - 1));
}


/* ruleAttributeScopeFuncMacro(scope)
 */
/** Function for popping the top value from a pbelle_sdpParser_media_descriptionStack
 */
void
pbelle_sdpParser_media_descriptionPop(pbelle_sdpParser ctx)
{
    // First see if the user defined a function they want to be called when a
    // scope is popped/freed.
    //
	// If the user supplied the scope entries with a free function,then call it first
	//
    if	(SCOPE_TOP(media_description)->free != NULL)
	{
        SCOPE_TOP(media_description)->free(SCOPE_TOP(media_description));
	}

    // Now we decrement the scope's upper limit bound. We do not actually pop the scope as
    // we want to reuse scope entries if we do continuous push and pops. Most scopes don't
    // next too far so we don't want to keep freeing and allocating them
    //
    ctx->pbelle_sdpParser_media_descriptionStack_limit--;
    SCOPE_TOP(media_description) = (pbelle_sdpParser_media_description_SCOPE)(ctx->pbelle_sdpParser_media_descriptionStack->get(ctx->pbelle_sdpParser_media_descriptionStack, ctx->pbelle_sdpParser_media_descriptionStack_limit - 1));
}


/* ruleAttributeScopeFuncMacro(scope)
 */
/** Function for popping the top value from a pbelle_sdpParser_mediaStack
 */
void
pbelle_sdpParser_mediaPop(pbelle_sdpParser ctx)
{
    // First see if the user defined a function they want to be called when a
    // scope is popped/freed.
    //
	// If the user supplied the scope entries with a free function,then call it first
	//
    if	(SCOPE_TOP(media)->free != NULL)
	{
        SCOPE_TOP(media)->free(SCOPE_TOP(media));
	}

    // Now we decrement the scope's upper limit bound. We do not actually pop the scope as
    // we want to reuse scope entries if we do continuous push and pops. Most scopes don't
    // next too far so we don't want to keep freeing and allocating them
    //
    ctx->pbelle_sdpParser_mediaStack_limit--;
    SCOPE_TOP(media) = (pbelle_sdpParser_media_SCOPE)(ctx->pbelle_sdpParser_mediaStack->get(ctx->pbelle_sdpParser_mediaStack, ctx->pbelle_sdpParser_mediaStack_limit - 1));
}


/* ruleAttributeScopeFuncMacro(scope)
 */
/** Function for popping the top value from a pbelle_sdpParser_fmtStack
 */
void
pbelle_sdpParser_fmtPop(pbelle_sdpParser ctx)
{
    // First see if the user defined a function they want to be called when a
    // scope is popped/freed.
    //
	// If the user supplied the scope entries with a free function,then call it first
	//
    if	(SCOPE_TOP(fmt)->free != NULL)
	{
        SCOPE_TOP(fmt)->free(SCOPE_TOP(fmt));
	}

    // Now we decrement the scope's upper limit bound. We do not actually pop the scope as
    // we want to reuse scope entries if we do continuous push and pops. Most scopes don't
    // next too far so we don't want to keep freeing and allocating them
    //
    ctx->pbelle_sdpParser_fmtStack_limit--;
    SCOPE_TOP(fmt) = (pbelle_sdpParser_fmt_SCOPE)(ctx->pbelle_sdpParser_fmtStack->get(ctx->pbelle_sdpParser_fmtStack, ctx->pbelle_sdpParser_fmtStack_limit - 1));
}



// Forward declare the locally static matching functions we have generated.
//
static 
 belle_sdpParser_session_description_return
	session_description    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_version_return
	version    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_origin_return
	origin    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_session_name_return
	session_name    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_info_return
	info    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_info_value_return
	info_value    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_uri_field_return
	uri_field    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_email_return
	email    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_phone_field_return
	phone_field    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_connection_return
	connection    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_bandwidth_return
	bandwidth    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_time_field_return
	time_field    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_repeat_time_return
	repeat_time    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_zone_adjustments_return
	zone_adjustments    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_key_field_return
	key_field    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_key_value_return
	key_value    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_attribute_return
	attribute    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_attribute_content_return
	attribute_content    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_rtcp_xr_attribute_return
	rtcp_xr_attribute    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_rtcp_xr_attribute_value_return
	rtcp_xr_attribute_value    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_pkt_loss_rle_return
	pkt_loss_rle    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_pkt_dup_rle_return
	pkt_dup_rle    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_pkt_rcpt_times_return
	pkt_rcpt_times    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_rcvr_rtt_return
	rcvr_rtt    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_stat_summary_return
	stat_summary    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_voip_metrics_return
	voip_metrics    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_rtcp_xr_stat_summary_flag_return
	rtcp_xr_stat_summary_flag    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_rtcp_xr_max_size_return
	rtcp_xr_max_size    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_rtcp_fb_attribute_return
	rtcp_fb_attribute    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_rtcp_fb_pt_return
	rtcp_fb_pt    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_rtcp_fb_val_return
	rtcp_fb_val    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_rtcp_fb_ack_val_return
	rtcp_fb_ack_val    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_rtcp_fb_nack_val_return
	rtcp_fb_nack_val    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_rtcp_fb_trr_int_val_return
	rtcp_fb_trr_int_val    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_rtcp_fb_ccm_val_return
	rtcp_fb_ccm_val    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_rtcp_fb_id_val_return
	rtcp_fb_id_val    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_rtcp_fb_param_return
	rtcp_fb_param    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_rtcp_fb_ack_param_return
	rtcp_fb_ack_param    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_rtcp_fb_nack_param_return
	rtcp_fb_nack_param    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_rtcp_fb_pli_param_return
	rtcp_fb_pli_param    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_rtcp_fb_sli_param_return
	rtcp_fb_sli_param    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_rtcp_fb_rpsi_param_return
	rtcp_fb_rpsi_param    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_rtcp_fb_app_param_return
	rtcp_fb_app_param    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_rtcp_fb_ccm_param_return
	rtcp_fb_ccm_param    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_rtcp_fb_fir_param_return
	rtcp_fb_fir_param    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_rtcp_fb_tmmbr_param_return
	rtcp_fb_tmmbr_param    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_rtcp_fb_tmmbr_smaxpr_param_return
	rtcp_fb_tmmbr_smaxpr_param    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_rtcp_fb_tmmbr_smaxpr_return
	rtcp_fb_tmmbr_smaxpr    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_rtcp_fb_token_param_return
	rtcp_fb_token_param    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_media_description_return
	media_description    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_media_return
	media    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_media_value_return
	media_value    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_fmt_return
	fmt    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_proto_return
	proto    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_port_return
	port    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_attribute_name_return
	attribute_name    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_attribute_value_return
	attribute_value    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_rtcp_xr_attribute_name_return
	rtcp_xr_attribute_name    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_rtcp_xr_rcvr_rtt_mode_return
	rtcp_xr_rcvr_rtt_mode    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_rtcp_xr_stat_summary_flag_value_return
	rtcp_xr_stat_summary_flag_value    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_rtcp_fb_attribute_name_return
	rtcp_fb_attribute_name    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_sess_id_return
	sess_id    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_sess_version_return
	sess_version    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_connection_address_return
	connection_address    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_multicast_address_return
	multicast_address    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_ttl_return
	ttl    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_start_time_return
	start_time    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_stop_time_return
	stop_time    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_sdp_time_return
	sdp_time    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_repeat_interval_return
	repeat_interval    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_typed_time_return
	typed_time    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_fixed_len_time_unit_return
	fixed_len_time_unit    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_bwtype_return
	bwtype    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_bandwidth_value_return
	bandwidth_value    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_username_return
	username    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_email_address_return
	email_address    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_uri_return
	uri    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_phone_number_return
	phone_number    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_phone_return
	phone    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_nettype_return
	nettype    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_addrtype_return
	addrtype    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_addr_return
	addr    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_multicast_part_return
	multicast_part    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_fqdn_return
	fqdn    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_domainlabel_return
	domainlabel    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_toplabel_return
	toplabel    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_unicast_address_return
	unicast_address    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_ipv4_address_return
	ipv4_address    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_ipv6_address_return
	ipv6_address    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_hexpart_return
	hexpart    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_hexseq_return
	hexseq    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_hex4_return
	hex4    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_text_return
	text    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_byte_string_return
	byte_string    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_decimal_uchar_return
	decimal_uchar    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_integer_return
	integer    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_email_safe_return
	email_safe    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_token_return
	token    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_alpha_num_return
	alpha_num    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_hexdigit_return
	hexdigit    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_word_return
	word    (pbelle_sdpParser ctx);
static 
 belle_sdpParser_alpha_return
	alpha    (pbelle_sdpParser ctx);
static 
 ANTLR3_BOOLEAN
	synpred1_belle_sdp    (pbelle_sdpParser ctx);
static 
 ANTLR3_BOOLEAN
	synpred2_belle_sdp    (pbelle_sdpParser ctx);
static 
 ANTLR3_BOOLEAN
	synpred3_belle_sdp    (pbelle_sdpParser ctx);
static 
 ANTLR3_BOOLEAN
	synpred4_belle_sdp    (pbelle_sdpParser ctx);
static 
 ANTLR3_BOOLEAN
	synpred5_belle_sdp    (pbelle_sdpParser ctx);
static 
 ANTLR3_BOOLEAN
	synpred6_belle_sdp    (pbelle_sdpParser ctx);
static 
 ANTLR3_BOOLEAN
	synpred7_belle_sdp    (pbelle_sdpParser ctx);
static 
 ANTLR3_BOOLEAN
	synpred8_belle_sdp    (pbelle_sdpParser ctx);
static 
 ANTLR3_BOOLEAN
	synpred9_belle_sdp    (pbelle_sdpParser ctx);
static 
 ANTLR3_BOOLEAN
	synpred10_belle_sdp    (pbelle_sdpParser ctx);
static 
 ANTLR3_BOOLEAN
	synpred11_belle_sdp    (pbelle_sdpParser ctx);
static 
 ANTLR3_BOOLEAN
	synpred12_belle_sdp    (pbelle_sdpParser ctx);
static 
 ANTLR3_BOOLEAN
	synpred13_belle_sdp    (pbelle_sdpParser ctx);
static 
 ANTLR3_BOOLEAN
	synpred14_belle_sdp    (pbelle_sdpParser ctx);
static 
 ANTLR3_BOOLEAN
	synpred15_belle_sdp    (pbelle_sdpParser ctx);
static 
 ANTLR3_BOOLEAN
	synpred16_belle_sdp    (pbelle_sdpParser ctx);
static 
 ANTLR3_BOOLEAN
	synpred17_belle_sdp    (pbelle_sdpParser ctx);
static 
 ANTLR3_BOOLEAN
	synpred18_belle_sdp    (pbelle_sdpParser ctx);
static 
 ANTLR3_BOOLEAN
	synpred19_belle_sdp    (pbelle_sdpParser ctx);
static 
 ANTLR3_BOOLEAN
	synpred20_belle_sdp    (pbelle_sdpParser ctx);
static 
 ANTLR3_BOOLEAN
	synpred21_belle_sdp    (pbelle_sdpParser ctx);
static 
 ANTLR3_BOOLEAN
	synpred22_belle_sdp    (pbelle_sdpParser ctx);
static 
 ANTLR3_BOOLEAN
	synpred23_belle_sdp    (pbelle_sdpParser ctx);
static 
 ANTLR3_BOOLEAN
	synpred24_belle_sdp    (pbelle_sdpParser ctx);
static 
 ANTLR3_BOOLEAN
	synpred25_belle_sdp    (pbelle_sdpParser ctx);
static void	belle_sdpParserFree(pbelle_sdpParser ctx);
static void     belle_sdpParserReset (pbelle_sdpParser ctx);

/* For use in tree output where we are accumulating rule labels via label += ruleRef
 * we need a function that knows how to free a return scope when the list is destroyed.
 * We cannot just use ANTLR3_FREE because in debug tracking mode, this is a macro.
 */
static	void ANTLR3_CDECL freeScope(void * scope)
{
    ANTLR3_FREE(scope);
}

/** \brief Name of the grammar file that generated this code
 */
static const char fileName[] = "../grammars/belle_sdp.g";

/** \brief Return the name of the grammar file that generated this code.
 */
static const char * getGrammarFileName()
{
	return fileName;
}
/** \brief Create a new belle_sdpParser parser and return a context for it.
 *
 * \param[in] instream Pointer to an input stream interface.
 *
 * \return Pointer to new parser context upon success.
 */
ANTLR3_API pbelle_sdpParser
belle_sdpParserNew   (pANTLR3_COMMON_TOKEN_STREAM instream)
{
	// See if we can create a new parser with the standard constructor
	//
	return belle_sdpParserNewSSD(instream, NULL);
}

/** \brief Create a new belle_sdpParser parser and return a context for it.
 *
 * \param[in] instream Pointer to an input stream interface.
 *
 * \return Pointer to new parser context upon success.
 */
ANTLR3_API pbelle_sdpParser
belle_sdpParserNewSSD   (pANTLR3_COMMON_TOKEN_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state)
{
    pbelle_sdpParser ctx;	    /* Context structure we will build and return   */

    ctx	= (pbelle_sdpParser) ANTLR3_CALLOC(1, sizeof(belle_sdpParser));

    if	(ctx == NULL)
    {
		// Failed to allocate memory for parser context
		//
        return  NULL;
    }

    /* -------------------------------------------------------------------
     * Memory for basic structure is allocated, now to fill in
     * the base ANTLR3 structures. We initialize the function pointers
     * for the standard ANTLR3 parser function set, but upon return
     * from here, the programmer may set the pointers to provide custom
     * implementations of each function.
     *
     * We don't use the macros defined in belle_sdpParser.h here, in order that you can get a sense
     * of what goes where.
     */

    /* Create a base parser/recognizer, using the supplied token stream
     */
    ctx->pParser	    = antlr3ParserNewStream(ANTLR3_SIZE_HINT, instream->tstream, state);
    /* Install the implementation of our belle_sdpParser interface
     */
    ctx->session_description	= session_description;
    ctx->version	= version;
    ctx->origin	= origin;
    ctx->session_name	= session_name;
    ctx->info	= info;
    ctx->info_value	= info_value;
    ctx->uri_field	= uri_field;
    ctx->email	= email;
    ctx->phone_field	= phone_field;
    ctx->connection	= connection;
    ctx->bandwidth	= bandwidth;
    ctx->time_field	= time_field;
    ctx->repeat_time	= repeat_time;
    ctx->zone_adjustments	= zone_adjustments;
    ctx->key_field	= key_field;
    ctx->key_value	= key_value;
    ctx->attribute	= attribute;
    ctx->attribute_content	= attribute_content;
    ctx->rtcp_xr_attribute	= rtcp_xr_attribute;
    ctx->rtcp_xr_attribute_value	= rtcp_xr_attribute_value;
    ctx->pkt_loss_rle	= pkt_loss_rle;
    ctx->pkt_dup_rle	= pkt_dup_rle;
    ctx->pkt_rcpt_times	= pkt_rcpt_times;
    ctx->rcvr_rtt	= rcvr_rtt;
    ctx->stat_summary	= stat_summary;
    ctx->voip_metrics	= voip_metrics;
    ctx->rtcp_xr_stat_summary_flag	= rtcp_xr_stat_summary_flag;
    ctx->rtcp_xr_max_size	= rtcp_xr_max_size;
    ctx->rtcp_fb_attribute	= rtcp_fb_attribute;
    ctx->rtcp_fb_pt	= rtcp_fb_pt;
    ctx->rtcp_fb_val	= rtcp_fb_val;
    ctx->rtcp_fb_ack_val	= rtcp_fb_ack_val;
    ctx->rtcp_fb_nack_val	= rtcp_fb_nack_val;
    ctx->rtcp_fb_trr_int_val	= rtcp_fb_trr_int_val;
    ctx->rtcp_fb_ccm_val	= rtcp_fb_ccm_val;
    ctx->rtcp_fb_id_val	= rtcp_fb_id_val;
    ctx->rtcp_fb_param	= rtcp_fb_param;
    ctx->rtcp_fb_ack_param	= rtcp_fb_ack_param;
    ctx->rtcp_fb_nack_param	= rtcp_fb_nack_param;
    ctx->rtcp_fb_pli_param	= rtcp_fb_pli_param;
    ctx->rtcp_fb_sli_param	= rtcp_fb_sli_param;
    ctx->rtcp_fb_rpsi_param	= rtcp_fb_rpsi_param;
    ctx->rtcp_fb_app_param	= rtcp_fb_app_param;
    ctx->rtcp_fb_ccm_param	= rtcp_fb_ccm_param;
    ctx->rtcp_fb_fir_param	= rtcp_fb_fir_param;
    ctx->rtcp_fb_tmmbr_param	= rtcp_fb_tmmbr_param;
    ctx->rtcp_fb_tmmbr_smaxpr_param	= rtcp_fb_tmmbr_smaxpr_param;
    ctx->rtcp_fb_tmmbr_smaxpr	= rtcp_fb_tmmbr_smaxpr;
    ctx->rtcp_fb_token_param	= rtcp_fb_token_param;
    ctx->media_description	= media_description;
    ctx->media	= media;
    ctx->media_value	= media_value;
    ctx->fmt	= fmt;
    ctx->proto	= proto;
    ctx->port	= port;
    ctx->attribute_name	= attribute_name;
    ctx->attribute_value	= attribute_value;
    ctx->rtcp_xr_attribute_name	= rtcp_xr_attribute_name;
    ctx->rtcp_xr_rcvr_rtt_mode	= rtcp_xr_rcvr_rtt_mode;
    ctx->rtcp_xr_stat_summary_flag_value	= rtcp_xr_stat_summary_flag_value;
    ctx->rtcp_fb_attribute_name	= rtcp_fb_attribute_name;
    ctx->sess_id	= sess_id;
    ctx->sess_version	= sess_version;
    ctx->connection_address	= connection_address;
    ctx->multicast_address	= multicast_address;
    ctx->ttl	= ttl;
    ctx->start_time	= start_time;
    ctx->stop_time	= stop_time;
    ctx->sdp_time	= sdp_time;
    ctx->repeat_interval	= repeat_interval;
    ctx->typed_time	= typed_time;
    ctx->fixed_len_time_unit	= fixed_len_time_unit;
    ctx->bwtype	= bwtype;
    ctx->bandwidth_value	= bandwidth_value;
    ctx->username	= username;
    ctx->email_address	= email_address;
    ctx->uri	= uri;
    ctx->phone_number	= phone_number;
    ctx->phone	= phone;
    ctx->nettype	= nettype;
    ctx->addrtype	= addrtype;
    ctx->addr	= addr;
    ctx->multicast_part	= multicast_part;
    ctx->fqdn	= fqdn;
    ctx->domainlabel	= domainlabel;
    ctx->toplabel	= toplabel;
    ctx->unicast_address	= unicast_address;
    ctx->ipv4_address	= ipv4_address;
    ctx->ipv6_address	= ipv6_address;
    ctx->hexpart	= hexpart;
    ctx->hexseq	= hexseq;
    ctx->hex4	= hex4;
    ctx->text	= text;
    ctx->byte_string	= byte_string;
    ctx->decimal_uchar	= decimal_uchar;
    ctx->integer	= integer;
    ctx->email_safe	= email_safe;
    ctx->token	= token;
    ctx->alpha_num	= alpha_num;
    ctx->hexdigit	= hexdigit;
    ctx->word	= word;
    ctx->alpha	= alpha;
    ctx->synpred1_belle_sdp	= synpred1_belle_sdp;
    ctx->synpred2_belle_sdp	= synpred2_belle_sdp;
    ctx->synpred3_belle_sdp	= synpred3_belle_sdp;
    ctx->synpred4_belle_sdp	= synpred4_belle_sdp;
    ctx->synpred5_belle_sdp	= synpred5_belle_sdp;
    ctx->synpred6_belle_sdp	= synpred6_belle_sdp;
    ctx->synpred7_belle_sdp	= synpred7_belle_sdp;
    ctx->synpred8_belle_sdp	= synpred8_belle_sdp;
    ctx->synpred9_belle_sdp	= synpred9_belle_sdp;
    ctx->synpred10_belle_sdp	= synpred10_belle_sdp;
    ctx->synpred11_belle_sdp	= synpred11_belle_sdp;
    ctx->synpred12_belle_sdp	= synpred12_belle_sdp;
    ctx->synpred13_belle_sdp	= synpred13_belle_sdp;
    ctx->synpred14_belle_sdp	= synpred14_belle_sdp;
    ctx->synpred15_belle_sdp	= synpred15_belle_sdp;
    ctx->synpred16_belle_sdp	= synpred16_belle_sdp;
    ctx->synpred17_belle_sdp	= synpred17_belle_sdp;
    ctx->synpred18_belle_sdp	= synpred18_belle_sdp;
    ctx->synpred19_belle_sdp	= synpred19_belle_sdp;
    ctx->synpred20_belle_sdp	= synpred20_belle_sdp;
    ctx->synpred21_belle_sdp	= synpred21_belle_sdp;
    ctx->synpred22_belle_sdp	= synpred22_belle_sdp;
    ctx->synpred23_belle_sdp	= synpred23_belle_sdp;
    ctx->synpred24_belle_sdp	= synpred24_belle_sdp;
    ctx->synpred25_belle_sdp	= synpred25_belle_sdp;
    ctx->free			= belle_sdpParserFree;
    ctx->reset			= belle_sdpParserReset;
    ctx->getGrammarFileName	= getGrammarFileName;

    /* Install the scope pushing methods.
     */
    /* ruleAttributeScope(scope)
     */
    ctx->pbelle_sdpParser_session_descriptionPush     = pbelle_sdpParser_session_descriptionPush;
    ctx->pbelle_sdpParser_session_descriptionStack    = antlr3StackNew(0);
    ctx->pbelle_sdpParser_session_descriptionStack_limit    = 0;
    ctx->pbelle_sdpParser_session_descriptionTop      = NULL;


    /* ruleAttributeScope(scope)
     */
    ctx->pbelle_sdpParser_originPush     = pbelle_sdpParser_originPush;
    ctx->pbelle_sdpParser_originStack    = antlr3StackNew(0);
    ctx->pbelle_sdpParser_originStack_limit    = 0;
    ctx->pbelle_sdpParser_originTop      = NULL;


    /* ruleAttributeScope(scope)
     */
    ctx->pbelle_sdpParser_infoPush     = pbelle_sdpParser_infoPush;
    ctx->pbelle_sdpParser_infoStack    = antlr3StackNew(0);
    ctx->pbelle_sdpParser_infoStack_limit    = 0;
    ctx->pbelle_sdpParser_infoTop      = NULL;


    /* ruleAttributeScope(scope)
     */
    ctx->pbelle_sdpParser_emailPush     = pbelle_sdpParser_emailPush;
    ctx->pbelle_sdpParser_emailStack    = antlr3StackNew(0);
    ctx->pbelle_sdpParser_emailStack_limit    = 0;
    ctx->pbelle_sdpParser_emailTop      = NULL;


    /* ruleAttributeScope(scope)
     */
    ctx->pbelle_sdpParser_connectionPush     = pbelle_sdpParser_connectionPush;
    ctx->pbelle_sdpParser_connectionStack    = antlr3StackNew(0);
    ctx->pbelle_sdpParser_connectionStack_limit    = 0;
    ctx->pbelle_sdpParser_connectionTop      = NULL;


    /* ruleAttributeScope(scope)
     */
    ctx->pbelle_sdpParser_bandwidthPush     = pbelle_sdpParser_bandwidthPush;
    ctx->pbelle_sdpParser_bandwidthStack    = antlr3StackNew(0);
    ctx->pbelle_sdpParser_bandwidthStack_limit    = 0;
    ctx->pbelle_sdpParser_bandwidthTop      = NULL;


    /* ruleAttributeScope(scope)
     */
    ctx->pbelle_sdpParser_attributePush     = pbelle_sdpParser_attributePush;
    ctx->pbelle_sdpParser_attributeStack    = antlr3StackNew(0);
    ctx->pbelle_sdpParser_attributeStack_limit    = 0;
    ctx->pbelle_sdpParser_attributeTop      = NULL;


    /* ruleAttributeScope(scope)
     */
    ctx->pbelle_sdpParser_rtcp_xr_attributePush     = pbelle_sdpParser_rtcp_xr_attributePush;
    ctx->pbelle_sdpParser_rtcp_xr_attributeStack    = antlr3StackNew(0);
    ctx->pbelle_sdpParser_rtcp_xr_attributeStack_limit    = 0;
    ctx->pbelle_sdpParser_rtcp_xr_attributeTop      = NULL;


    /* ruleAttributeScope(scope)
     */
    ctx->pbelle_sdpParser_rtcp_fb_attributePush     = pbelle_sdpParser_rtcp_fb_attributePush;
    ctx->pbelle_sdpParser_rtcp_fb_attributeStack    = antlr3StackNew(0);
    ctx->pbelle_sdpParser_rtcp_fb_attributeStack_limit    = 0;
    ctx->pbelle_sdpParser_rtcp_fb_attributeTop      = NULL;


    /* ruleAttributeScope(scope)
     */
    ctx->pbelle_sdpParser_media_descriptionPush     = pbelle_sdpParser_media_descriptionPush;
    ctx->pbelle_sdpParser_media_descriptionStack    = antlr3StackNew(0);
    ctx->pbelle_sdpParser_media_descriptionStack_limit    = 0;
    ctx->pbelle_sdpParser_media_descriptionTop      = NULL;


    /* ruleAttributeScope(scope)
     */
    ctx->pbelle_sdpParser_mediaPush     = pbelle_sdpParser_mediaPush;
    ctx->pbelle_sdpParser_mediaStack    = antlr3StackNew(0);
    ctx->pbelle_sdpParser_mediaStack_limit    = 0;
    ctx->pbelle_sdpParser_mediaTop      = NULL;


    /* ruleAttributeScope(scope)
     */
    ctx->pbelle_sdpParser_fmtPush     = pbelle_sdpParser_fmtPush;
    ctx->pbelle_sdpParser_fmtStack    = antlr3StackNew(0);
    ctx->pbelle_sdpParser_fmtStack_limit    = 0;
    ctx->pbelle_sdpParser_fmtTop      = NULL;



ADAPTOR	= ANTLR3_TREE_ADAPTORNew(instream->tstream->tokenSource->strFactory);

ctx->vectors	= antlr3VectorFactoryNew(0);
    /* Install the token table
     */
    PSRSTATE->tokenNames   = belle_sdpParserTokenNames;


    /* Return the newly built parser to the caller
     */
    return  ctx;
}

static void
belle_sdpParserReset (pbelle_sdpParser ctx)
{
    RECOGNIZER->reset(RECOGNIZER);
}

/** Free the parser resources
 */
 static void
 belle_sdpParserFree(pbelle_sdpParser ctx)
 {
    /* Free any scope memory
     */
    /* ruleAttributeScope(scope)
     */
    ctx->pbelle_sdpParser_session_descriptionStack->free(ctx->pbelle_sdpParser_session_descriptionStack);


    /* ruleAttributeScope(scope)
     */
    ctx->pbelle_sdpParser_originStack->free(ctx->pbelle_sdpParser_originStack);


    /* ruleAttributeScope(scope)
     */
    ctx->pbelle_sdpParser_infoStack->free(ctx->pbelle_sdpParser_infoStack);


    /* ruleAttributeScope(scope)
     */
    ctx->pbelle_sdpParser_emailStack->free(ctx->pbelle_sdpParser_emailStack);


    /* ruleAttributeScope(scope)
     */
    ctx->pbelle_sdpParser_connectionStack->free(ctx->pbelle_sdpParser_connectionStack);


    /* ruleAttributeScope(scope)
     */
    ctx->pbelle_sdpParser_bandwidthStack->free(ctx->pbelle_sdpParser_bandwidthStack);


    /* ruleAttributeScope(scope)
     */
    ctx->pbelle_sdpParser_attributeStack->free(ctx->pbelle_sdpParser_attributeStack);


    /* ruleAttributeScope(scope)
     */
    ctx->pbelle_sdpParser_rtcp_xr_attributeStack->free(ctx->pbelle_sdpParser_rtcp_xr_attributeStack);


    /* ruleAttributeScope(scope)
     */
    ctx->pbelle_sdpParser_rtcp_fb_attributeStack->free(ctx->pbelle_sdpParser_rtcp_fb_attributeStack);


    /* ruleAttributeScope(scope)
     */
    ctx->pbelle_sdpParser_media_descriptionStack->free(ctx->pbelle_sdpParser_media_descriptionStack);


    /* ruleAttributeScope(scope)
     */
    ctx->pbelle_sdpParser_mediaStack->free(ctx->pbelle_sdpParser_mediaStack);


    /* ruleAttributeScope(scope)
     */
    ctx->pbelle_sdpParser_fmtStack->free(ctx->pbelle_sdpParser_fmtStack);



ctx->vectors->close(ctx->vectors);
/* We created the adaptor so we must free it
 */
ADAPTOR->free(ADAPTOR);
	// Free this parser
	//
    ctx->pParser->free(ctx->pParser);


    ANTLR3_FREE(ctx);

    /* Everything is released, so we can return
     */
    return;
 }

/** Return token names used by this 
parser

 *
 * The returned pointer is used as an index into the token names table (using the token
 * number as the index).
 *
 * \return Pointer to first char * in the table.
 */
static pANTLR3_UINT8    *getTokenNames()
{
        return belle_sdpParserTokenNames;
}


/* Declare the bitsets
 */
/** Bitset defining follow set for error recovery in rule state: FOLLOW_version_in_session_description98  */
static	ANTLR3_BITWORD FOLLOW_version_in_session_description98_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000080) };
static  ANTLR3_BITSET_LIST FOLLOW_version_in_session_description98	= { FOLLOW_version_in_session_description98_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CR_in_session_description100  */
static	ANTLR3_BITWORD FOLLOW_CR_in_session_description100_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000002000) };
static  ANTLR3_BITSET_LIST FOLLOW_CR_in_session_description100	= { FOLLOW_CR_in_session_description100_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_LF_in_session_description102  */
static	ANTLR3_BITWORD FOLLOW_LF_in_session_description102_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001240) };
static  ANTLR3_BITSET_LIST FOLLOW_LF_in_session_description102	= { FOLLOW_LF_in_session_description102_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_origin_in_session_description129  */
static	ANTLR3_BITWORD FOLLOW_origin_in_session_description129_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000080) };
static  ANTLR3_BITSET_LIST FOLLOW_origin_in_session_description129	= { FOLLOW_origin_in_session_description129_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CR_in_session_description132  */
static	ANTLR3_BITWORD FOLLOW_CR_in_session_description132_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000002000) };
static  ANTLR3_BITSET_LIST FOLLOW_CR_in_session_description132	= { FOLLOW_CR_in_session_description132_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_LF_in_session_description134  */
static	ANTLR3_BITWORD FOLLOW_LF_in_session_description134_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001240) };
static  ANTLR3_BITSET_LIST FOLLOW_LF_in_session_description134	= { FOLLOW_LF_in_session_description134_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_session_name_in_session_description161  */
static	ANTLR3_BITWORD FOLLOW_session_name_in_session_description161_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000080) };
static  ANTLR3_BITSET_LIST FOLLOW_session_name_in_session_description161	= { FOLLOW_session_name_in_session_description161_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CR_in_session_description163  */
static	ANTLR3_BITWORD FOLLOW_CR_in_session_description163_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000002000) };
static  ANTLR3_BITSET_LIST FOLLOW_CR_in_session_description163	= { FOLLOW_CR_in_session_description163_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_LF_in_session_description165  */
static	ANTLR3_BITWORD FOLLOW_LF_in_session_description165_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001240) };
static  ANTLR3_BITSET_LIST FOLLOW_LF_in_session_description165	= { FOLLOW_LF_in_session_description165_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_info_in_session_description193  */
static	ANTLR3_BITWORD FOLLOW_info_in_session_description193_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000080) };
static  ANTLR3_BITSET_LIST FOLLOW_info_in_session_description193	= { FOLLOW_info_in_session_description193_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CR_in_session_description195  */
static	ANTLR3_BITWORD FOLLOW_CR_in_session_description195_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000002000) };
static  ANTLR3_BITSET_LIST FOLLOW_CR_in_session_description195	= { FOLLOW_CR_in_session_description195_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_LF_in_session_description197  */
static	ANTLR3_BITWORD FOLLOW_LF_in_session_description197_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001240) };
static  ANTLR3_BITSET_LIST FOLLOW_LF_in_session_description197	= { FOLLOW_LF_in_session_description197_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_uri_field_in_session_description227  */
static	ANTLR3_BITWORD FOLLOW_uri_field_in_session_description227_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000080) };
static  ANTLR3_BITSET_LIST FOLLOW_uri_field_in_session_description227	= { FOLLOW_uri_field_in_session_description227_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CR_in_session_description229  */
static	ANTLR3_BITWORD FOLLOW_CR_in_session_description229_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000002000) };
static  ANTLR3_BITSET_LIST FOLLOW_CR_in_session_description229	= { FOLLOW_CR_in_session_description229_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_LF_in_session_description231  */
static	ANTLR3_BITWORD FOLLOW_LF_in_session_description231_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001240) };
static  ANTLR3_BITSET_LIST FOLLOW_LF_in_session_description231	= { FOLLOW_LF_in_session_description231_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_email_in_session_description261  */
static	ANTLR3_BITWORD FOLLOW_email_in_session_description261_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000080) };
static  ANTLR3_BITSET_LIST FOLLOW_email_in_session_description261	= { FOLLOW_email_in_session_description261_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CR_in_session_description263  */
static	ANTLR3_BITWORD FOLLOW_CR_in_session_description263_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000002000) };
static  ANTLR3_BITSET_LIST FOLLOW_CR_in_session_description263	= { FOLLOW_CR_in_session_description263_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_LF_in_session_description265  */
static	ANTLR3_BITWORD FOLLOW_LF_in_session_description265_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001240) };
static  ANTLR3_BITSET_LIST FOLLOW_LF_in_session_description265	= { FOLLOW_LF_in_session_description265_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_phone_field_in_session_description294  */
static	ANTLR3_BITWORD FOLLOW_phone_field_in_session_description294_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001240) };
static  ANTLR3_BITSET_LIST FOLLOW_phone_field_in_session_description294	= { FOLLOW_phone_field_in_session_description294_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_connection_in_session_description323  */
static	ANTLR3_BITWORD FOLLOW_connection_in_session_description323_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000080) };
static  ANTLR3_BITSET_LIST FOLLOW_connection_in_session_description323	= { FOLLOW_connection_in_session_description323_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CR_in_session_description327  */
static	ANTLR3_BITWORD FOLLOW_CR_in_session_description327_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000002000) };
static  ANTLR3_BITSET_LIST FOLLOW_CR_in_session_description327	= { FOLLOW_CR_in_session_description327_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_LF_in_session_description329  */
static	ANTLR3_BITWORD FOLLOW_LF_in_session_description329_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001240) };
static  ANTLR3_BITSET_LIST FOLLOW_LF_in_session_description329	= { FOLLOW_LF_in_session_description329_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_bandwidth_in_session_description359  */
static	ANTLR3_BITWORD FOLLOW_bandwidth_in_session_description359_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000080) };
static  ANTLR3_BITSET_LIST FOLLOW_bandwidth_in_session_description359	= { FOLLOW_bandwidth_in_session_description359_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CR_in_session_description363  */
static	ANTLR3_BITWORD FOLLOW_CR_in_session_description363_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000002000) };
static  ANTLR3_BITSET_LIST FOLLOW_CR_in_session_description363	= { FOLLOW_CR_in_session_description363_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_LF_in_session_description365  */
static	ANTLR3_BITWORD FOLLOW_LF_in_session_description365_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001240) };
static  ANTLR3_BITSET_LIST FOLLOW_LF_in_session_description365	= { FOLLOW_LF_in_session_description365_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_time_field_in_session_description394  */
static	ANTLR3_BITWORD FOLLOW_time_field_in_session_description394_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000080) };
static  ANTLR3_BITSET_LIST FOLLOW_time_field_in_session_description394	= { FOLLOW_time_field_in_session_description394_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CR_in_session_description396  */
static	ANTLR3_BITWORD FOLLOW_CR_in_session_description396_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000002000) };
static  ANTLR3_BITSET_LIST FOLLOW_CR_in_session_description396	= { FOLLOW_CR_in_session_description396_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_LF_in_session_description398  */
static	ANTLR3_BITWORD FOLLOW_LF_in_session_description398_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001242) };
static  ANTLR3_BITSET_LIST FOLLOW_LF_in_session_description398	= { FOLLOW_LF_in_session_description398_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_repeat_time_in_session_description426  */
static	ANTLR3_BITWORD FOLLOW_repeat_time_in_session_description426_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000080) };
static  ANTLR3_BITSET_LIST FOLLOW_repeat_time_in_session_description426	= { FOLLOW_repeat_time_in_session_description426_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CR_in_session_description428  */
static	ANTLR3_BITWORD FOLLOW_CR_in_session_description428_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000002000) };
static  ANTLR3_BITSET_LIST FOLLOW_CR_in_session_description428	= { FOLLOW_CR_in_session_description428_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_LF_in_session_description430  */
static	ANTLR3_BITWORD FOLLOW_LF_in_session_description430_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001242) };
static  ANTLR3_BITSET_LIST FOLLOW_LF_in_session_description430	= { FOLLOW_LF_in_session_description430_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_zone_adjustments_in_session_description460  */
static	ANTLR3_BITWORD FOLLOW_zone_adjustments_in_session_description460_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000080) };
static  ANTLR3_BITSET_LIST FOLLOW_zone_adjustments_in_session_description460	= { FOLLOW_zone_adjustments_in_session_description460_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CR_in_session_description462  */
static	ANTLR3_BITWORD FOLLOW_CR_in_session_description462_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000002000) };
static  ANTLR3_BITSET_LIST FOLLOW_CR_in_session_description462	= { FOLLOW_CR_in_session_description462_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_LF_in_session_description464  */
static	ANTLR3_BITWORD FOLLOW_LF_in_session_description464_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001242) };
static  ANTLR3_BITSET_LIST FOLLOW_LF_in_session_description464	= { FOLLOW_LF_in_session_description464_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_key_field_in_session_description494  */
static	ANTLR3_BITWORD FOLLOW_key_field_in_session_description494_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000080) };
static  ANTLR3_BITSET_LIST FOLLOW_key_field_in_session_description494	= { FOLLOW_key_field_in_session_description494_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CR_in_session_description496  */
static	ANTLR3_BITWORD FOLLOW_CR_in_session_description496_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000002000) };
static  ANTLR3_BITSET_LIST FOLLOW_CR_in_session_description496	= { FOLLOW_CR_in_session_description496_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_LF_in_session_description498  */
static	ANTLR3_BITWORD FOLLOW_LF_in_session_description498_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001242) };
static  ANTLR3_BITSET_LIST FOLLOW_LF_in_session_description498	= { FOLLOW_LF_in_session_description498_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_attribute_in_session_description528  */
static	ANTLR3_BITWORD FOLLOW_attribute_in_session_description528_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000080) };
static  ANTLR3_BITSET_LIST FOLLOW_attribute_in_session_description528	= { FOLLOW_attribute_in_session_description528_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CR_in_session_description532  */
static	ANTLR3_BITWORD FOLLOW_CR_in_session_description532_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000002000) };
static  ANTLR3_BITSET_LIST FOLLOW_CR_in_session_description532	= { FOLLOW_CR_in_session_description532_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_LF_in_session_description534  */
static	ANTLR3_BITWORD FOLLOW_LF_in_session_description534_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001242) };
static  ANTLR3_BITSET_LIST FOLLOW_LF_in_session_description534	= { FOLLOW_LF_in_session_description534_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_media_description_in_session_description564  */
static	ANTLR3_BITWORD FOLLOW_media_description_in_session_description564_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001242) };
static  ANTLR3_BITSET_LIST FOLLOW_media_description_in_session_description564	= { FOLLOW_media_description_in_session_description564_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_version590  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_version590_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000800) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_version590	= { FOLLOW_alpha_num_in_version590_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUAL_in_version592  */
static	ANTLR3_BITWORD FOLLOW_EQUAL_in_version592_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000200) };
static  ANTLR3_BITSET_LIST FOLLOW_EQUAL_in_version592	= { FOLLOW_EQUAL_in_version592_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DIGIT_in_version596  */
static	ANTLR3_BITWORD FOLLOW_DIGIT_in_version596_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000202) };
static  ANTLR3_BITSET_LIST FOLLOW_DIGIT_in_version596	= { FOLLOW_DIGIT_in_version596_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_origin654  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_origin654_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000800) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_origin654	= { FOLLOW_alpha_num_in_origin654_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUAL_in_origin656  */
static	ANTLR3_BITWORD FOLLOW_EQUAL_in_origin656_bits[]	= { ANTLR3_UINT64_LIT(0x0000000FFFF7FFF0) };
static  ANTLR3_BITSET_LIST FOLLOW_EQUAL_in_origin656	= { FOLLOW_EQUAL_in_origin656_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_username_in_origin658  */
static	ANTLR3_BITWORD FOLLOW_username_in_origin658_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000080000) };
static  ANTLR3_BITSET_LIST FOLLOW_username_in_origin658	= { FOLLOW_username_in_origin658_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SPACE_in_origin687  */
static	ANTLR3_BITWORD FOLLOW_SPACE_in_origin687_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000200) };
static  ANTLR3_BITSET_LIST FOLLOW_SPACE_in_origin687	= { FOLLOW_SPACE_in_origin687_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_sess_id_in_origin689  */
static	ANTLR3_BITWORD FOLLOW_sess_id_in_origin689_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000080000) };
static  ANTLR3_BITSET_LIST FOLLOW_sess_id_in_origin689	= { FOLLOW_sess_id_in_origin689_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SPACE_in_origin718  */
static	ANTLR3_BITWORD FOLLOW_SPACE_in_origin718_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000200) };
static  ANTLR3_BITSET_LIST FOLLOW_SPACE_in_origin718	= { FOLLOW_SPACE_in_origin718_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_sess_version_in_origin720  */
static	ANTLR3_BITWORD FOLLOW_sess_version_in_origin720_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000080000) };
static  ANTLR3_BITSET_LIST FOLLOW_sess_version_in_origin720	= { FOLLOW_sess_version_in_origin720_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SPACE_in_origin749  */
static	ANTLR3_BITWORD FOLLOW_SPACE_in_origin749_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001240) };
static  ANTLR3_BITSET_LIST FOLLOW_SPACE_in_origin749	= { FOLLOW_SPACE_in_origin749_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_nettype_in_origin751  */
static	ANTLR3_BITWORD FOLLOW_nettype_in_origin751_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000080000) };
static  ANTLR3_BITSET_LIST FOLLOW_nettype_in_origin751	= { FOLLOW_nettype_in_origin751_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SPACE_in_origin780  */
static	ANTLR3_BITWORD FOLLOW_SPACE_in_origin780_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001240) };
static  ANTLR3_BITSET_LIST FOLLOW_SPACE_in_origin780	= { FOLLOW_SPACE_in_origin780_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_addrtype_in_origin782  */
static	ANTLR3_BITWORD FOLLOW_addrtype_in_origin782_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000080000) };
static  ANTLR3_BITSET_LIST FOLLOW_addrtype_in_origin782	= { FOLLOW_addrtype_in_origin782_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SPACE_in_origin812  */
static	ANTLR3_BITWORD FOLLOW_SPACE_in_origin812_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001750) };
static  ANTLR3_BITSET_LIST FOLLOW_SPACE_in_origin812	= { FOLLOW_SPACE_in_origin812_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_addr_in_origin814  */
static	ANTLR3_BITWORD FOLLOW_addr_in_origin814_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_addr_in_origin814	= { FOLLOW_addr_in_origin814_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_session_name834  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_session_name834_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000800) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_session_name834	= { FOLLOW_alpha_num_in_session_name834_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUAL_in_session_name836  */
static	ANTLR3_BITWORD FOLLOW_EQUAL_in_session_name836_bits[]	= { ANTLR3_UINT64_LIT(0x0000000FFFFFDF70) };
static  ANTLR3_BITSET_LIST FOLLOW_EQUAL_in_session_name836	= { FOLLOW_EQUAL_in_session_name836_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_text_in_session_name838  */
static	ANTLR3_BITWORD FOLLOW_text_in_session_name838_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_text_in_session_name838	= { FOLLOW_text_in_session_name838_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_info865  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_info865_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000800) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_info865	= { FOLLOW_alpha_num_in_info865_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUAL_in_info867  */
static	ANTLR3_BITWORD FOLLOW_EQUAL_in_info867_bits[]	= { ANTLR3_UINT64_LIT(0x0000000FFFFFDF70) };
static  ANTLR3_BITSET_LIST FOLLOW_EQUAL_in_info867	= { FOLLOW_EQUAL_in_info867_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_info_value_in_info869  */
static	ANTLR3_BITWORD FOLLOW_info_value_in_info869_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_info_value_in_info869	= { FOLLOW_info_value_in_info869_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_uri_field932  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_uri_field932_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000800) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_uri_field932	= { FOLLOW_alpha_num_in_uri_field932_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUAL_in_uri_field934  */
static	ANTLR3_BITWORD FOLLOW_EQUAL_in_uri_field934_bits[]	= { ANTLR3_UINT64_LIT(0x0000000FFFFFDF70) };
static  ANTLR3_BITSET_LIST FOLLOW_EQUAL_in_uri_field934	= { FOLLOW_EQUAL_in_uri_field934_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_uri_in_uri_field936  */
static	ANTLR3_BITWORD FOLLOW_uri_in_uri_field936_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_uri_in_uri_field936	= { FOLLOW_uri_in_uri_field936_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_email968  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_email968_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000800) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_email968	= { FOLLOW_alpha_num_in_email968_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUAL_in_email970  */
static	ANTLR3_BITWORD FOLLOW_EQUAL_in_email970_bits[]	= { ANTLR3_UINT64_LIT(0x0000000FFFFFDF70) };
static  ANTLR3_BITSET_LIST FOLLOW_EQUAL_in_email970	= { FOLLOW_EQUAL_in_email970_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_email_address_in_email972  */
static	ANTLR3_BITWORD FOLLOW_email_address_in_email972_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_email_address_in_email972	= { FOLLOW_email_address_in_email972_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_phone_field989  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_phone_field989_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000800) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_phone_field989	= { FOLLOW_alpha_num_in_phone_field989_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUAL_in_phone_field991  */
static	ANTLR3_BITWORD FOLLOW_EQUAL_in_phone_field991_bits[]	= { ANTLR3_UINT64_LIT(0x0000000FFFFFDF70) };
static  ANTLR3_BITSET_LIST FOLLOW_EQUAL_in_phone_field991	= { FOLLOW_EQUAL_in_phone_field991_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_phone_number_in_phone_field993  */
static	ANTLR3_BITWORD FOLLOW_phone_number_in_phone_field993_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000080) };
static  ANTLR3_BITSET_LIST FOLLOW_phone_number_in_phone_field993	= { FOLLOW_phone_number_in_phone_field993_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CR_in_phone_field995  */
static	ANTLR3_BITWORD FOLLOW_CR_in_phone_field995_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000002000) };
static  ANTLR3_BITSET_LIST FOLLOW_CR_in_phone_field995	= { FOLLOW_CR_in_phone_field995_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_LF_in_phone_field997  */
static	ANTLR3_BITWORD FOLLOW_LF_in_phone_field997_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_LF_in_phone_field997	= { FOLLOW_LF_in_phone_field997_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_connection1022  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_connection1022_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000800) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_connection1022	= { FOLLOW_alpha_num_in_connection1022_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUAL_in_connection1024  */
static	ANTLR3_BITWORD FOLLOW_EQUAL_in_connection1024_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001240) };
static  ANTLR3_BITSET_LIST FOLLOW_EQUAL_in_connection1024	= { FOLLOW_EQUAL_in_connection1024_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_nettype_in_connection1026  */
static	ANTLR3_BITWORD FOLLOW_nettype_in_connection1026_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000080000) };
static  ANTLR3_BITSET_LIST FOLLOW_nettype_in_connection1026	= { FOLLOW_nettype_in_connection1026_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SPACE_in_connection1048  */
static	ANTLR3_BITWORD FOLLOW_SPACE_in_connection1048_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001240) };
static  ANTLR3_BITSET_LIST FOLLOW_SPACE_in_connection1048	= { FOLLOW_SPACE_in_connection1048_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_addrtype_in_connection1050  */
static	ANTLR3_BITWORD FOLLOW_addrtype_in_connection1050_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000080000) };
static  ANTLR3_BITSET_LIST FOLLOW_addrtype_in_connection1050	= { FOLLOW_addrtype_in_connection1050_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SPACE_in_connection1071  */
static	ANTLR3_BITWORD FOLLOW_SPACE_in_connection1071_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001750) };
static  ANTLR3_BITSET_LIST FOLLOW_SPACE_in_connection1071	= { FOLLOW_SPACE_in_connection1071_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_connection_address_in_connection1073  */
static	ANTLR3_BITWORD FOLLOW_connection_address_in_connection1073_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_connection_address_in_connection1073	= { FOLLOW_connection_address_in_connection1073_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_bandwidth1203  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_bandwidth1203_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000800) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_bandwidth1203	= { FOLLOW_alpha_num_in_bandwidth1203_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUAL_in_bandwidth1205  */
static	ANTLR3_BITWORD FOLLOW_EQUAL_in_bandwidth1205_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001240) };
static  ANTLR3_BITSET_LIST FOLLOW_EQUAL_in_bandwidth1205	= { FOLLOW_EQUAL_in_bandwidth1205_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_bwtype_in_bandwidth1207  */
static	ANTLR3_BITWORD FOLLOW_bwtype_in_bandwidth1207_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000010) };
static  ANTLR3_BITSET_LIST FOLLOW_bwtype_in_bandwidth1207	= { FOLLOW_bwtype_in_bandwidth1207_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_COLON_in_bandwidth1217  */
static	ANTLR3_BITWORD FOLLOW_COLON_in_bandwidth1217_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000200) };
static  ANTLR3_BITSET_LIST FOLLOW_COLON_in_bandwidth1217	= { FOLLOW_COLON_in_bandwidth1217_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_bandwidth_value_in_bandwidth1219  */
static	ANTLR3_BITWORD FOLLOW_bandwidth_value_in_bandwidth1219_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_bandwidth_value_in_bandwidth1219	= { FOLLOW_bandwidth_value_in_bandwidth1219_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_time_field1236  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_time_field1236_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000800) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_time_field1236	= { FOLLOW_alpha_num_in_time_field1236_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUAL_in_time_field1238  */
static	ANTLR3_BITWORD FOLLOW_EQUAL_in_time_field1238_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000200) };
static  ANTLR3_BITSET_LIST FOLLOW_EQUAL_in_time_field1238	= { FOLLOW_EQUAL_in_time_field1238_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_start_time_in_time_field1254  */
static	ANTLR3_BITWORD FOLLOW_start_time_in_time_field1254_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000080000) };
static  ANTLR3_BITSET_LIST FOLLOW_start_time_in_time_field1254	= { FOLLOW_start_time_in_time_field1254_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SPACE_in_time_field1270  */
static	ANTLR3_BITWORD FOLLOW_SPACE_in_time_field1270_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000200) };
static  ANTLR3_BITSET_LIST FOLLOW_SPACE_in_time_field1270	= { FOLLOW_SPACE_in_time_field1270_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_stop_time_in_time_field1286  */
static	ANTLR3_BITWORD FOLLOW_stop_time_in_time_field1286_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_stop_time_in_time_field1286	= { FOLLOW_stop_time_in_time_field1286_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_repeat_time1302  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_repeat_time1302_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000800) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_repeat_time1302	= { FOLLOW_alpha_num_in_repeat_time1302_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUAL_in_repeat_time1304  */
static	ANTLR3_BITWORD FOLLOW_EQUAL_in_repeat_time1304_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001240) };
static  ANTLR3_BITSET_LIST FOLLOW_EQUAL_in_repeat_time1304	= { FOLLOW_EQUAL_in_repeat_time1304_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_repeat_interval_in_repeat_time1306  */
static	ANTLR3_BITWORD FOLLOW_repeat_interval_in_repeat_time1306_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000080000) };
static  ANTLR3_BITSET_LIST FOLLOW_repeat_interval_in_repeat_time1306	= { FOLLOW_repeat_interval_in_repeat_time1306_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SPACE_in_repeat_time1309  */
static	ANTLR3_BITWORD FOLLOW_SPACE_in_repeat_time1309_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000081240) };
static  ANTLR3_BITSET_LIST FOLLOW_SPACE_in_repeat_time1309	= { FOLLOW_SPACE_in_repeat_time1309_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_typed_time_in_repeat_time1311  */
static	ANTLR3_BITWORD FOLLOW_typed_time_in_repeat_time1311_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000080002) };
static  ANTLR3_BITSET_LIST FOLLOW_typed_time_in_repeat_time1311	= { FOLLOW_typed_time_in_repeat_time1311_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_zone_adjustments1325  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_zone_adjustments1325_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000800) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_zone_adjustments1325	= { FOLLOW_alpha_num_in_zone_adjustments1325_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUAL_in_zone_adjustments1327  */
static	ANTLR3_BITWORD FOLLOW_EQUAL_in_zone_adjustments1327_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000200) };
static  ANTLR3_BITSET_LIST FOLLOW_EQUAL_in_zone_adjustments1327	= { FOLLOW_EQUAL_in_zone_adjustments1327_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_sdp_time_in_zone_adjustments1329  */
static	ANTLR3_BITWORD FOLLOW_sdp_time_in_zone_adjustments1329_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000080000) };
static  ANTLR3_BITSET_LIST FOLLOW_sdp_time_in_zone_adjustments1329	= { FOLLOW_sdp_time_in_zone_adjustments1329_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SPACE_in_zone_adjustments1331  */
static	ANTLR3_BITWORD FOLLOW_SPACE_in_zone_adjustments1331_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000081340) };
static  ANTLR3_BITSET_LIST FOLLOW_SPACE_in_zone_adjustments1331	= { FOLLOW_SPACE_in_zone_adjustments1331_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DASH_in_zone_adjustments1333  */
static	ANTLR3_BITWORD FOLLOW_DASH_in_zone_adjustments1333_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000081240) };
static  ANTLR3_BITSET_LIST FOLLOW_DASH_in_zone_adjustments1333	= { FOLLOW_DASH_in_zone_adjustments1333_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_typed_time_in_zone_adjustments1336  */
static	ANTLR3_BITWORD FOLLOW_typed_time_in_zone_adjustments1336_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000080002) };
static  ANTLR3_BITSET_LIST FOLLOW_typed_time_in_zone_adjustments1336	= { FOLLOW_typed_time_in_zone_adjustments1336_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SPACE_in_zone_adjustments1364  */
static	ANTLR3_BITWORD FOLLOW_SPACE_in_zone_adjustments1364_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000200) };
static  ANTLR3_BITSET_LIST FOLLOW_SPACE_in_zone_adjustments1364	= { FOLLOW_SPACE_in_zone_adjustments1364_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_sdp_time_in_zone_adjustments1366  */
static	ANTLR3_BITWORD FOLLOW_sdp_time_in_zone_adjustments1366_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000080000) };
static  ANTLR3_BITSET_LIST FOLLOW_sdp_time_in_zone_adjustments1366	= { FOLLOW_sdp_time_in_zone_adjustments1366_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SPACE_in_zone_adjustments1368  */
static	ANTLR3_BITWORD FOLLOW_SPACE_in_zone_adjustments1368_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000081340) };
static  ANTLR3_BITSET_LIST FOLLOW_SPACE_in_zone_adjustments1368	= { FOLLOW_SPACE_in_zone_adjustments1368_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DASH_in_zone_adjustments1370  */
static	ANTLR3_BITWORD FOLLOW_DASH_in_zone_adjustments1370_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000081240) };
static  ANTLR3_BITSET_LIST FOLLOW_DASH_in_zone_adjustments1370	= { FOLLOW_DASH_in_zone_adjustments1370_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_typed_time_in_zone_adjustments1373  */
static	ANTLR3_BITWORD FOLLOW_typed_time_in_zone_adjustments1373_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000080002) };
static  ANTLR3_BITSET_LIST FOLLOW_typed_time_in_zone_adjustments1373	= { FOLLOW_typed_time_in_zone_adjustments1373_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_key_field1393  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_key_field1393_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000800) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_key_field1393	= { FOLLOW_alpha_num_in_key_field1393_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUAL_in_key_field1395  */
static	ANTLR3_BITWORD FOLLOW_EQUAL_in_key_field1395_bits[]	= { ANTLR3_UINT64_LIT(0x0000000FFFFFDF70) };
static  ANTLR3_BITSET_LIST FOLLOW_EQUAL_in_key_field1395	= { FOLLOW_EQUAL_in_key_field1395_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_key_value_in_key_field1397  */
static	ANTLR3_BITWORD FOLLOW_key_value_in_key_field1397_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_key_value_in_key_field1397	= { FOLLOW_key_value_in_key_field1397_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_attribute1459  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_attribute1459_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000800) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_attribute1459	= { FOLLOW_alpha_num_in_attribute1459_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUAL_in_attribute1461  */
static	ANTLR3_BITWORD FOLLOW_EQUAL_in_attribute1461_bits[]	= { ANTLR3_UINT64_LIT(0x0000000FFFD01740) };
static  ANTLR3_BITSET_LIST FOLLOW_EQUAL_in_attribute1461	= { FOLLOW_EQUAL_in_attribute1461_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_attribute_content_in_attribute1463  */
static	ANTLR3_BITWORD FOLLOW_attribute_content_in_attribute1463_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_attribute_content_in_attribute1463	= { FOLLOW_attribute_content_in_attribute1463_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_attribute_name_in_attribute_content1487  */
static	ANTLR3_BITWORD FOLLOW_attribute_name_in_attribute_content1487_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000012) };
static  ANTLR3_BITSET_LIST FOLLOW_attribute_name_in_attribute_content1487	= { FOLLOW_attribute_name_in_attribute_content1487_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_COLON_in_attribute_content1490  */
static	ANTLR3_BITWORD FOLLOW_COLON_in_attribute_content1490_bits[]	= { ANTLR3_UINT64_LIT(0x0000000FFFFFDF70) };
static  ANTLR3_BITSET_LIST FOLLOW_COLON_in_attribute_content1490	= { FOLLOW_COLON_in_attribute_content1490_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_attribute_value_in_attribute_content1494  */
static	ANTLR3_BITWORD FOLLOW_attribute_value_in_attribute_content1494_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_attribute_value_in_attribute_content1494	= { FOLLOW_attribute_value_in_attribute_content1494_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_rtcp_xr_attribute1523  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_rtcp_xr_attribute1523_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000800) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_rtcp_xr_attribute1523	= { FOLLOW_alpha_num_in_rtcp_xr_attribute1523_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUAL_in_rtcp_xr_attribute1525  */
static	ANTLR3_BITWORD FOLLOW_EQUAL_in_rtcp_xr_attribute1525_bits[]	= { ANTLR3_UINT64_LIT(0x0000000FFFD01740) };
static  ANTLR3_BITSET_LIST FOLLOW_EQUAL_in_rtcp_xr_attribute1525	= { FOLLOW_EQUAL_in_rtcp_xr_attribute1525_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_attribute_name_in_rtcp_xr_attribute1529  */
static	ANTLR3_BITWORD FOLLOW_attribute_name_in_rtcp_xr_attribute1529_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000012) };
static  ANTLR3_BITSET_LIST FOLLOW_attribute_name_in_rtcp_xr_attribute1529	= { FOLLOW_attribute_name_in_rtcp_xr_attribute1529_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_COLON_in_rtcp_xr_attribute1534  */
static	ANTLR3_BITWORD FOLLOW_COLON_in_rtcp_xr_attribute1534_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001140) };
static  ANTLR3_BITSET_LIST FOLLOW_COLON_in_rtcp_xr_attribute1534	= { FOLLOW_COLON_in_rtcp_xr_attribute1534_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_xr_attribute_value_in_rtcp_xr_attribute1536  */
static	ANTLR3_BITWORD FOLLOW_rtcp_xr_attribute_value_in_rtcp_xr_attribute1536_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000080002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_xr_attribute_value_in_rtcp_xr_attribute1536	= { FOLLOW_rtcp_xr_attribute_value_in_rtcp_xr_attribute1536_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SPACE_in_rtcp_xr_attribute1539  */
static	ANTLR3_BITWORD FOLLOW_SPACE_in_rtcp_xr_attribute1539_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001140) };
static  ANTLR3_BITSET_LIST FOLLOW_SPACE_in_rtcp_xr_attribute1539	= { FOLLOW_SPACE_in_rtcp_xr_attribute1539_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_xr_attribute_value_in_rtcp_xr_attribute1541  */
static	ANTLR3_BITWORD FOLLOW_rtcp_xr_attribute_value_in_rtcp_xr_attribute1541_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000080002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_xr_attribute_value_in_rtcp_xr_attribute1541	= { FOLLOW_rtcp_xr_attribute_value_in_rtcp_xr_attribute1541_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_pkt_loss_rle_in_rtcp_xr_attribute_value1564  */
static	ANTLR3_BITWORD FOLLOW_pkt_loss_rle_in_rtcp_xr_attribute_value1564_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_pkt_loss_rle_in_rtcp_xr_attribute_value1564	= { FOLLOW_pkt_loss_rle_in_rtcp_xr_attribute_value1564_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_pkt_dup_rle_in_rtcp_xr_attribute_value1573  */
static	ANTLR3_BITWORD FOLLOW_pkt_dup_rle_in_rtcp_xr_attribute_value1573_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_pkt_dup_rle_in_rtcp_xr_attribute_value1573	= { FOLLOW_pkt_dup_rle_in_rtcp_xr_attribute_value1573_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_pkt_rcpt_times_in_rtcp_xr_attribute_value1582  */
static	ANTLR3_BITWORD FOLLOW_pkt_rcpt_times_in_rtcp_xr_attribute_value1582_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_pkt_rcpt_times_in_rtcp_xr_attribute_value1582	= { FOLLOW_pkt_rcpt_times_in_rtcp_xr_attribute_value1582_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rcvr_rtt_in_rtcp_xr_attribute_value1591  */
static	ANTLR3_BITWORD FOLLOW_rcvr_rtt_in_rtcp_xr_attribute_value1591_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rcvr_rtt_in_rtcp_xr_attribute_value1591	= { FOLLOW_rcvr_rtt_in_rtcp_xr_attribute_value1591_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_stat_summary_in_rtcp_xr_attribute_value1600  */
static	ANTLR3_BITWORD FOLLOW_stat_summary_in_rtcp_xr_attribute_value1600_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_stat_summary_in_rtcp_xr_attribute_value1600	= { FOLLOW_stat_summary_in_rtcp_xr_attribute_value1600_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_voip_metrics_in_rtcp_xr_attribute_value1609  */
static	ANTLR3_BITWORD FOLLOW_voip_metrics_in_rtcp_xr_attribute_value1609_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_voip_metrics_in_rtcp_xr_attribute_value1609	= { FOLLOW_voip_metrics_in_rtcp_xr_attribute_value1609_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_xr_attribute_name_in_pkt_loss_rle1620  */
static	ANTLR3_BITWORD FOLLOW_rtcp_xr_attribute_name_in_pkt_loss_rle1620_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000802) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_xr_attribute_name_in_pkt_loss_rle1620	= { FOLLOW_rtcp_xr_attribute_name_in_pkt_loss_rle1620_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUAL_in_pkt_loss_rle1625  */
static	ANTLR3_BITWORD FOLLOW_EQUAL_in_pkt_loss_rle1625_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000200) };
static  ANTLR3_BITSET_LIST FOLLOW_EQUAL_in_pkt_loss_rle1625	= { FOLLOW_EQUAL_in_pkt_loss_rle1625_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_xr_max_size_in_pkt_loss_rle1627  */
static	ANTLR3_BITWORD FOLLOW_rtcp_xr_max_size_in_pkt_loss_rle1627_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_xr_max_size_in_pkt_loss_rle1627	= { FOLLOW_rtcp_xr_max_size_in_pkt_loss_rle1627_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_xr_attribute_name_in_pkt_dup_rle1641  */
static	ANTLR3_BITWORD FOLLOW_rtcp_xr_attribute_name_in_pkt_dup_rle1641_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000802) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_xr_attribute_name_in_pkt_dup_rle1641	= { FOLLOW_rtcp_xr_attribute_name_in_pkt_dup_rle1641_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUAL_in_pkt_dup_rle1646  */
static	ANTLR3_BITWORD FOLLOW_EQUAL_in_pkt_dup_rle1646_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000200) };
static  ANTLR3_BITSET_LIST FOLLOW_EQUAL_in_pkt_dup_rle1646	= { FOLLOW_EQUAL_in_pkt_dup_rle1646_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_xr_max_size_in_pkt_dup_rle1648  */
static	ANTLR3_BITWORD FOLLOW_rtcp_xr_max_size_in_pkt_dup_rle1648_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_xr_max_size_in_pkt_dup_rle1648	= { FOLLOW_rtcp_xr_max_size_in_pkt_dup_rle1648_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_xr_attribute_name_in_pkt_rcpt_times1662  */
static	ANTLR3_BITWORD FOLLOW_rtcp_xr_attribute_name_in_pkt_rcpt_times1662_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000802) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_xr_attribute_name_in_pkt_rcpt_times1662	= { FOLLOW_rtcp_xr_attribute_name_in_pkt_rcpt_times1662_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUAL_in_pkt_rcpt_times1667  */
static	ANTLR3_BITWORD FOLLOW_EQUAL_in_pkt_rcpt_times1667_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000200) };
static  ANTLR3_BITSET_LIST FOLLOW_EQUAL_in_pkt_rcpt_times1667	= { FOLLOW_EQUAL_in_pkt_rcpt_times1667_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_xr_max_size_in_pkt_rcpt_times1669  */
static	ANTLR3_BITWORD FOLLOW_rtcp_xr_max_size_in_pkt_rcpt_times1669_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_xr_max_size_in_pkt_rcpt_times1669	= { FOLLOW_rtcp_xr_max_size_in_pkt_rcpt_times1669_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_xr_attribute_name_in_rcvr_rtt1683  */
static	ANTLR3_BITWORD FOLLOW_rtcp_xr_attribute_name_in_rcvr_rtt1683_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000800) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_xr_attribute_name_in_rcvr_rtt1683	= { FOLLOW_rtcp_xr_attribute_name_in_rcvr_rtt1683_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUAL_in_rcvr_rtt1687  */
static	ANTLR3_BITWORD FOLLOW_EQUAL_in_rcvr_rtt1687_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001140) };
static  ANTLR3_BITSET_LIST FOLLOW_EQUAL_in_rcvr_rtt1687	= { FOLLOW_EQUAL_in_rcvr_rtt1687_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_xr_rcvr_rtt_mode_in_rcvr_rtt1691  */
static	ANTLR3_BITWORD FOLLOW_rtcp_xr_rcvr_rtt_mode_in_rcvr_rtt1691_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000012) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_xr_rcvr_rtt_mode_in_rcvr_rtt1691	= { FOLLOW_rtcp_xr_rcvr_rtt_mode_in_rcvr_rtt1691_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_COLON_in_rcvr_rtt1694  */
static	ANTLR3_BITWORD FOLLOW_COLON_in_rcvr_rtt1694_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000200) };
static  ANTLR3_BITSET_LIST FOLLOW_COLON_in_rcvr_rtt1694	= { FOLLOW_COLON_in_rcvr_rtt1694_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_xr_max_size_in_rcvr_rtt1698  */
static	ANTLR3_BITWORD FOLLOW_rtcp_xr_max_size_in_rcvr_rtt1698_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_xr_max_size_in_rcvr_rtt1698	= { FOLLOW_rtcp_xr_max_size_in_rcvr_rtt1698_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_xr_attribute_name_in_stat_summary1713  */
static	ANTLR3_BITWORD FOLLOW_rtcp_xr_attribute_name_in_stat_summary1713_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000802) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_xr_attribute_name_in_stat_summary1713	= { FOLLOW_rtcp_xr_attribute_name_in_stat_summary1713_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUAL_in_stat_summary1720  */
static	ANTLR3_BITWORD FOLLOW_EQUAL_in_stat_summary1720_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001140) };
static  ANTLR3_BITSET_LIST FOLLOW_EQUAL_in_stat_summary1720	= { FOLLOW_EQUAL_in_stat_summary1720_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_xr_stat_summary_flag_in_stat_summary1722  */
static	ANTLR3_BITWORD FOLLOW_rtcp_xr_stat_summary_flag_in_stat_summary1722_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000022) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_xr_stat_summary_flag_in_stat_summary1722	= { FOLLOW_rtcp_xr_stat_summary_flag_in_stat_summary1722_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_COMMA_in_stat_summary1725  */
static	ANTLR3_BITWORD FOLLOW_COMMA_in_stat_summary1725_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001140) };
static  ANTLR3_BITSET_LIST FOLLOW_COMMA_in_stat_summary1725	= { FOLLOW_COMMA_in_stat_summary1725_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_xr_stat_summary_flag_in_stat_summary1727  */
static	ANTLR3_BITWORD FOLLOW_rtcp_xr_stat_summary_flag_in_stat_summary1727_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000022) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_xr_stat_summary_flag_in_stat_summary1727	= { FOLLOW_rtcp_xr_stat_summary_flag_in_stat_summary1727_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_xr_attribute_name_in_voip_metrics1742  */
static	ANTLR3_BITWORD FOLLOW_rtcp_xr_attribute_name_in_voip_metrics1742_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_xr_attribute_name_in_voip_metrics1742	= { FOLLOW_rtcp_xr_attribute_name_in_voip_metrics1742_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_xr_stat_summary_flag_value_in_rtcp_xr_stat_summary_flag1756  */
static	ANTLR3_BITWORD FOLLOW_rtcp_xr_stat_summary_flag_value_in_rtcp_xr_stat_summary_flag1756_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_xr_stat_summary_flag_value_in_rtcp_xr_stat_summary_flag1756	= { FOLLOW_rtcp_xr_stat_summary_flag_value_in_rtcp_xr_stat_summary_flag1756_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DIGIT_in_rtcp_xr_max_size1766  */
static	ANTLR3_BITWORD FOLLOW_DIGIT_in_rtcp_xr_max_size1766_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000202) };
static  ANTLR3_BITSET_LIST FOLLOW_DIGIT_in_rtcp_xr_max_size1766	= { FOLLOW_DIGIT_in_rtcp_xr_max_size1766_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_rtcp_fb_attribute1789  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_rtcp_fb_attribute1789_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000800) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_rtcp_fb_attribute1789	= { FOLLOW_alpha_num_in_rtcp_fb_attribute1789_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUAL_in_rtcp_fb_attribute1791  */
static	ANTLR3_BITWORD FOLLOW_EQUAL_in_rtcp_fb_attribute1791_bits[]	= { ANTLR3_UINT64_LIT(0x0000000FFFD01740) };
static  ANTLR3_BITSET_LIST FOLLOW_EQUAL_in_rtcp_fb_attribute1791	= { FOLLOW_EQUAL_in_rtcp_fb_attribute1791_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_attribute_name_in_rtcp_fb_attribute1795  */
static	ANTLR3_BITWORD FOLLOW_attribute_name_in_rtcp_fb_attribute1795_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000010) };
static  ANTLR3_BITSET_LIST FOLLOW_attribute_name_in_rtcp_fb_attribute1795	= { FOLLOW_attribute_name_in_rtcp_fb_attribute1795_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_COLON_in_rtcp_fb_attribute1799  */
static	ANTLR3_BITWORD FOLLOW_COLON_in_rtcp_fb_attribute1799_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000100200) };
static  ANTLR3_BITSET_LIST FOLLOW_COLON_in_rtcp_fb_attribute1799	= { FOLLOW_COLON_in_rtcp_fb_attribute1799_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_pt_in_rtcp_fb_attribute1801  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_pt_in_rtcp_fb_attribute1801_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000080000) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_pt_in_rtcp_fb_attribute1801	= { FOLLOW_rtcp_fb_pt_in_rtcp_fb_attribute1801_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SPACE_in_rtcp_fb_attribute1803  */
static	ANTLR3_BITWORD FOLLOW_SPACE_in_rtcp_fb_attribute1803_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001140) };
static  ANTLR3_BITSET_LIST FOLLOW_SPACE_in_rtcp_fb_attribute1803	= { FOLLOW_SPACE_in_rtcp_fb_attribute1803_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_val_in_rtcp_fb_attribute1805  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_val_in_rtcp_fb_attribute1805_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_val_in_rtcp_fb_attribute1805	= { FOLLOW_rtcp_fb_val_in_rtcp_fb_attribute1805_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_STAR_in_rtcp_fb_pt1818  */
static	ANTLR3_BITWORD FOLLOW_STAR_in_rtcp_fb_pt1818_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_STAR_in_rtcp_fb_pt1818	= { FOLLOW_STAR_in_rtcp_fb_pt1818_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_integer_in_rtcp_fb_pt1824  */
static	ANTLR3_BITWORD FOLLOW_integer_in_rtcp_fb_pt1824_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_integer_in_rtcp_fb_pt1824	= { FOLLOW_integer_in_rtcp_fb_pt1824_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_ack_val_in_rtcp_fb_val1839  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_ack_val_in_rtcp_fb_val1839_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_ack_val_in_rtcp_fb_val1839	= { FOLLOW_rtcp_fb_ack_val_in_rtcp_fb_val1839_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_nack_val_in_rtcp_fb_val1847  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_nack_val_in_rtcp_fb_val1847_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_nack_val_in_rtcp_fb_val1847	= { FOLLOW_rtcp_fb_nack_val_in_rtcp_fb_val1847_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_trr_int_val_in_rtcp_fb_val1855  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_trr_int_val_in_rtcp_fb_val1855_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_trr_int_val_in_rtcp_fb_val1855	= { FOLLOW_rtcp_fb_trr_int_val_in_rtcp_fb_val1855_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_ccm_val_in_rtcp_fb_val1863  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_ccm_val_in_rtcp_fb_val1863_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_ccm_val_in_rtcp_fb_val1863	= { FOLLOW_rtcp_fb_ccm_val_in_rtcp_fb_val1863_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_id_val_in_rtcp_fb_val1871  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_id_val_in_rtcp_fb_val1871_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_id_val_in_rtcp_fb_val1871	= { FOLLOW_rtcp_fb_id_val_in_rtcp_fb_val1871_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_ack_val1881  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_ack_val1881_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000080002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_ack_val1881	= { FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_ack_val1881_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SPACE_in_rtcp_fb_ack_val1886  */
static	ANTLR3_BITWORD FOLLOW_SPACE_in_rtcp_fb_ack_val1886_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001140) };
static  ANTLR3_BITSET_LIST FOLLOW_SPACE_in_rtcp_fb_ack_val1886	= { FOLLOW_SPACE_in_rtcp_fb_ack_val1886_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_ack_param_in_rtcp_fb_ack_val1888  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_ack_param_in_rtcp_fb_ack_val1888_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_ack_param_in_rtcp_fb_ack_val1888	= { FOLLOW_rtcp_fb_ack_param_in_rtcp_fb_ack_val1888_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_nack_val1902  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_nack_val1902_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000080002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_nack_val1902	= { FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_nack_val1902_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SPACE_in_rtcp_fb_nack_val1907  */
static	ANTLR3_BITWORD FOLLOW_SPACE_in_rtcp_fb_nack_val1907_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001140) };
static  ANTLR3_BITSET_LIST FOLLOW_SPACE_in_rtcp_fb_nack_val1907	= { FOLLOW_SPACE_in_rtcp_fb_nack_val1907_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_nack_param_in_rtcp_fb_nack_val1909  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_nack_param_in_rtcp_fb_nack_val1909_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_nack_param_in_rtcp_fb_nack_val1909	= { FOLLOW_rtcp_fb_nack_param_in_rtcp_fb_nack_val1909_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_trr_int_val1923  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_trr_int_val1923_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000080000) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_trr_int_val1923	= { FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_trr_int_val1923_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SPACE_in_rtcp_fb_trr_int_val1927  */
static	ANTLR3_BITWORD FOLLOW_SPACE_in_rtcp_fb_trr_int_val1927_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000200) };
static  ANTLR3_BITSET_LIST FOLLOW_SPACE_in_rtcp_fb_trr_int_val1927	= { FOLLOW_SPACE_in_rtcp_fb_trr_int_val1927_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_integer_in_rtcp_fb_trr_int_val1929  */
static	ANTLR3_BITWORD FOLLOW_integer_in_rtcp_fb_trr_int_val1929_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_integer_in_rtcp_fb_trr_int_val1929	= { FOLLOW_integer_in_rtcp_fb_trr_int_val1929_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_ccm_val1941  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_ccm_val1941_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000080002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_ccm_val1941	= { FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_ccm_val1941_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SPACE_in_rtcp_fb_ccm_val1946  */
static	ANTLR3_BITWORD FOLLOW_SPACE_in_rtcp_fb_ccm_val1946_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001140) };
static  ANTLR3_BITSET_LIST FOLLOW_SPACE_in_rtcp_fb_ccm_val1946	= { FOLLOW_SPACE_in_rtcp_fb_ccm_val1946_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_ccm_param_in_rtcp_fb_ccm_val1948  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_ccm_param_in_rtcp_fb_ccm_val1948_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_ccm_param_in_rtcp_fb_ccm_val1948	= { FOLLOW_rtcp_fb_ccm_param_in_rtcp_fb_ccm_val1948_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_id_val1960  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_id_val1960_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000080002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_id_val1960	= { FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_id_val1960_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SPACE_in_rtcp_fb_id_val1963  */
static	ANTLR3_BITWORD FOLLOW_SPACE_in_rtcp_fb_id_val1963_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001140) };
static  ANTLR3_BITSET_LIST FOLLOW_SPACE_in_rtcp_fb_id_val1963	= { FOLLOW_SPACE_in_rtcp_fb_id_val1963_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_param_in_rtcp_fb_id_val1965  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_param_in_rtcp_fb_id_val1965_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_param_in_rtcp_fb_id_val1965	= { FOLLOW_rtcp_fb_param_in_rtcp_fb_id_val1965_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_app_param_in_rtcp_fb_param1979  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_app_param_in_rtcp_fb_param1979_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_app_param_in_rtcp_fb_param1979	= { FOLLOW_rtcp_fb_app_param_in_rtcp_fb_param1979_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_token_param_in_rtcp_fb_param1987  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_token_param_in_rtcp_fb_param1987_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_token_param_in_rtcp_fb_param1987	= { FOLLOW_rtcp_fb_token_param_in_rtcp_fb_param1987_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_rpsi_param_in_rtcp_fb_ack_param1999  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_rpsi_param_in_rtcp_fb_ack_param1999_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_rpsi_param_in_rtcp_fb_ack_param1999	= { FOLLOW_rtcp_fb_rpsi_param_in_rtcp_fb_ack_param1999_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_app_param_in_rtcp_fb_ack_param2007  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_app_param_in_rtcp_fb_ack_param2007_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_app_param_in_rtcp_fb_ack_param2007	= { FOLLOW_rtcp_fb_app_param_in_rtcp_fb_ack_param2007_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_token_param_in_rtcp_fb_ack_param2015  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_token_param_in_rtcp_fb_ack_param2015_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_token_param_in_rtcp_fb_ack_param2015	= { FOLLOW_rtcp_fb_token_param_in_rtcp_fb_ack_param2015_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_pli_param_in_rtcp_fb_nack_param2027  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_pli_param_in_rtcp_fb_nack_param2027_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_pli_param_in_rtcp_fb_nack_param2027	= { FOLLOW_rtcp_fb_pli_param_in_rtcp_fb_nack_param2027_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_sli_param_in_rtcp_fb_nack_param2035  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_sli_param_in_rtcp_fb_nack_param2035_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_sli_param_in_rtcp_fb_nack_param2035	= { FOLLOW_rtcp_fb_sli_param_in_rtcp_fb_nack_param2035_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_rpsi_param_in_rtcp_fb_nack_param2043  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_rpsi_param_in_rtcp_fb_nack_param2043_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_rpsi_param_in_rtcp_fb_nack_param2043	= { FOLLOW_rtcp_fb_rpsi_param_in_rtcp_fb_nack_param2043_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_app_param_in_rtcp_fb_nack_param2051  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_app_param_in_rtcp_fb_nack_param2051_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_app_param_in_rtcp_fb_nack_param2051	= { FOLLOW_rtcp_fb_app_param_in_rtcp_fb_nack_param2051_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_token_param_in_rtcp_fb_nack_param2059  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_token_param_in_rtcp_fb_nack_param2059_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_token_param_in_rtcp_fb_nack_param2059	= { FOLLOW_rtcp_fb_token_param_in_rtcp_fb_nack_param2059_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_pli_param2069  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_pli_param2069_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_pli_param2069	= { FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_pli_param2069_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_sli_param2083  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_sli_param2083_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_sli_param2083	= { FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_sli_param2083_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_rpsi_param2097  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_rpsi_param2097_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_rpsi_param2097	= { FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_rpsi_param2097_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_app_param2111  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_app_param2111_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000080000) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_app_param2111	= { FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_app_param2111_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SPACE_in_rtcp_fb_app_param2116  */
static	ANTLR3_BITWORD FOLLOW_SPACE_in_rtcp_fb_app_param2116_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000008000) };
static  ANTLR3_BITSET_LIST FOLLOW_SPACE_in_rtcp_fb_app_param2116	= { FOLLOW_SPACE_in_rtcp_fb_app_param2116_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_byte_string_in_rtcp_fb_app_param2118  */
static	ANTLR3_BITWORD FOLLOW_byte_string_in_rtcp_fb_app_param2118_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_byte_string_in_rtcp_fb_app_param2118	= { FOLLOW_byte_string_in_rtcp_fb_app_param2118_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_fir_param_in_rtcp_fb_ccm_param2133  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_fir_param_in_rtcp_fb_ccm_param2133_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_fir_param_in_rtcp_fb_ccm_param2133	= { FOLLOW_rtcp_fb_fir_param_in_rtcp_fb_ccm_param2133_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_tmmbr_param_in_rtcp_fb_ccm_param2141  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_tmmbr_param_in_rtcp_fb_ccm_param2141_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_tmmbr_param_in_rtcp_fb_ccm_param2141	= { FOLLOW_rtcp_fb_tmmbr_param_in_rtcp_fb_ccm_param2141_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_token_param_in_rtcp_fb_ccm_param2149  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_token_param_in_rtcp_fb_ccm_param2149_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_token_param_in_rtcp_fb_ccm_param2149	= { FOLLOW_rtcp_fb_token_param_in_rtcp_fb_ccm_param2149_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_fir_param2159  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_fir_param2159_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_fir_param2159	= { FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_fir_param2159_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_tmmbr_param2173  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_tmmbr_param2173_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000080002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_tmmbr_param2173	= { FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_tmmbr_param2173_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SPACE_in_rtcp_fb_tmmbr_param2178  */
static	ANTLR3_BITWORD FOLLOW_SPACE_in_rtcp_fb_tmmbr_param2178_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001140) };
static  ANTLR3_BITSET_LIST FOLLOW_SPACE_in_rtcp_fb_tmmbr_param2178	= { FOLLOW_SPACE_in_rtcp_fb_tmmbr_param2178_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_tmmbr_smaxpr_param_in_rtcp_fb_tmmbr_param2180  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_tmmbr_smaxpr_param_in_rtcp_fb_tmmbr_param2180_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_tmmbr_smaxpr_param_in_rtcp_fb_tmmbr_param2180	= { FOLLOW_rtcp_fb_tmmbr_smaxpr_param_in_rtcp_fb_tmmbr_param2180_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_tmmbr_smaxpr_param2194  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_tmmbr_smaxpr_param2194_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000800) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_tmmbr_smaxpr_param2194	= { FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_tmmbr_smaxpr_param2194_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUAL_in_rtcp_fb_tmmbr_smaxpr_param2198  */
static	ANTLR3_BITWORD FOLLOW_EQUAL_in_rtcp_fb_tmmbr_smaxpr_param2198_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000200) };
static  ANTLR3_BITSET_LIST FOLLOW_EQUAL_in_rtcp_fb_tmmbr_smaxpr_param2198	= { FOLLOW_EQUAL_in_rtcp_fb_tmmbr_smaxpr_param2198_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_tmmbr_smaxpr_in_rtcp_fb_tmmbr_smaxpr_param2202  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_tmmbr_smaxpr_in_rtcp_fb_tmmbr_smaxpr_param2202_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_tmmbr_smaxpr_in_rtcp_fb_tmmbr_smaxpr_param2202	= { FOLLOW_rtcp_fb_tmmbr_smaxpr_in_rtcp_fb_tmmbr_smaxpr_param2202_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DIGIT_in_rtcp_fb_tmmbr_smaxpr2212  */
static	ANTLR3_BITWORD FOLLOW_DIGIT_in_rtcp_fb_tmmbr_smaxpr2212_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000202) };
static  ANTLR3_BITSET_LIST FOLLOW_DIGIT_in_rtcp_fb_tmmbr_smaxpr2212	= { FOLLOW_DIGIT_in_rtcp_fb_tmmbr_smaxpr2212_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_token_param2221  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_token_param2221_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000080002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_token_param2221	= { FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_token_param2221_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SPACE_in_rtcp_fb_token_param2224  */
static	ANTLR3_BITWORD FOLLOW_SPACE_in_rtcp_fb_token_param2224_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000008000) };
static  ANTLR3_BITSET_LIST FOLLOW_SPACE_in_rtcp_fb_token_param2224	= { FOLLOW_SPACE_in_rtcp_fb_token_param2224_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_byte_string_in_rtcp_fb_token_param2226  */
static	ANTLR3_BITWORD FOLLOW_byte_string_in_rtcp_fb_token_param2226_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_byte_string_in_rtcp_fb_token_param2226	= { FOLLOW_byte_string_in_rtcp_fb_token_param2226_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_media_in_media_description2269  */
static	ANTLR3_BITWORD FOLLOW_media_in_media_description2269_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000080) };
static  ANTLR3_BITSET_LIST FOLLOW_media_in_media_description2269	= { FOLLOW_media_in_media_description2269_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CR_in_media_description2271  */
static	ANTLR3_BITWORD FOLLOW_CR_in_media_description2271_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000002000) };
static  ANTLR3_BITSET_LIST FOLLOW_CR_in_media_description2271	= { FOLLOW_CR_in_media_description2271_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_LF_in_media_description2273  */
static	ANTLR3_BITWORD FOLLOW_LF_in_media_description2273_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001242) };
static  ANTLR3_BITSET_LIST FOLLOW_LF_in_media_description2273	= { FOLLOW_LF_in_media_description2273_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_info_in_media_description2299  */
static	ANTLR3_BITWORD FOLLOW_info_in_media_description2299_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000080) };
static  ANTLR3_BITSET_LIST FOLLOW_info_in_media_description2299	= { FOLLOW_info_in_media_description2299_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CR_in_media_description2303  */
static	ANTLR3_BITWORD FOLLOW_CR_in_media_description2303_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000002000) };
static  ANTLR3_BITSET_LIST FOLLOW_CR_in_media_description2303	= { FOLLOW_CR_in_media_description2303_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_LF_in_media_description2305  */
static	ANTLR3_BITWORD FOLLOW_LF_in_media_description2305_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001242) };
static  ANTLR3_BITSET_LIST FOLLOW_LF_in_media_description2305	= { FOLLOW_LF_in_media_description2305_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_connection_in_media_description2331  */
static	ANTLR3_BITWORD FOLLOW_connection_in_media_description2331_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000080) };
static  ANTLR3_BITSET_LIST FOLLOW_connection_in_media_description2331	= { FOLLOW_connection_in_media_description2331_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CR_in_media_description2335  */
static	ANTLR3_BITWORD FOLLOW_CR_in_media_description2335_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000002000) };
static  ANTLR3_BITSET_LIST FOLLOW_CR_in_media_description2335	= { FOLLOW_CR_in_media_description2335_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_LF_in_media_description2337  */
static	ANTLR3_BITWORD FOLLOW_LF_in_media_description2337_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001242) };
static  ANTLR3_BITSET_LIST FOLLOW_LF_in_media_description2337	= { FOLLOW_LF_in_media_description2337_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_bandwidth_in_media_description2363  */
static	ANTLR3_BITWORD FOLLOW_bandwidth_in_media_description2363_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000080) };
static  ANTLR3_BITSET_LIST FOLLOW_bandwidth_in_media_description2363	= { FOLLOW_bandwidth_in_media_description2363_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CR_in_media_description2367  */
static	ANTLR3_BITWORD FOLLOW_CR_in_media_description2367_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000002000) };
static  ANTLR3_BITSET_LIST FOLLOW_CR_in_media_description2367	= { FOLLOW_CR_in_media_description2367_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_LF_in_media_description2369  */
static	ANTLR3_BITWORD FOLLOW_LF_in_media_description2369_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001242) };
static  ANTLR3_BITSET_LIST FOLLOW_LF_in_media_description2369	= { FOLLOW_LF_in_media_description2369_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_key_field_in_media_description2395  */
static	ANTLR3_BITWORD FOLLOW_key_field_in_media_description2395_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000080) };
static  ANTLR3_BITSET_LIST FOLLOW_key_field_in_media_description2395	= { FOLLOW_key_field_in_media_description2395_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CR_in_media_description2397  */
static	ANTLR3_BITWORD FOLLOW_CR_in_media_description2397_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000002000) };
static  ANTLR3_BITSET_LIST FOLLOW_CR_in_media_description2397	= { FOLLOW_CR_in_media_description2397_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_LF_in_media_description2399  */
static	ANTLR3_BITWORD FOLLOW_LF_in_media_description2399_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001242) };
static  ANTLR3_BITSET_LIST FOLLOW_LF_in_media_description2399	= { FOLLOW_LF_in_media_description2399_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_attribute_in_media_description2425  */
static	ANTLR3_BITWORD FOLLOW_attribute_in_media_description2425_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000080) };
static  ANTLR3_BITSET_LIST FOLLOW_attribute_in_media_description2425	= { FOLLOW_attribute_in_media_description2425_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CR_in_media_description2429  */
static	ANTLR3_BITWORD FOLLOW_CR_in_media_description2429_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000002000) };
static  ANTLR3_BITSET_LIST FOLLOW_CR_in_media_description2429	= { FOLLOW_CR_in_media_description2429_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_LF_in_media_description2431  */
static	ANTLR3_BITWORD FOLLOW_LF_in_media_description2431_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001242) };
static  ANTLR3_BITSET_LIST FOLLOW_LF_in_media_description2431	= { FOLLOW_LF_in_media_description2431_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_media2469  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_media2469_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000800) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_media2469	= { FOLLOW_alpha_num_in_media2469_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUAL_in_media2471  */
static	ANTLR3_BITWORD FOLLOW_EQUAL_in_media2471_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001240) };
static  ANTLR3_BITSET_LIST FOLLOW_EQUAL_in_media2471	= { FOLLOW_EQUAL_in_media2471_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_media_value_in_media2483  */
static	ANTLR3_BITWORD FOLLOW_media_value_in_media2483_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000080000) };
static  ANTLR3_BITSET_LIST FOLLOW_media_value_in_media2483	= { FOLLOW_media_value_in_media2483_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SPACE_in_media2497  */
static	ANTLR3_BITWORD FOLLOW_SPACE_in_media2497_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000200) };
static  ANTLR3_BITSET_LIST FOLLOW_SPACE_in_media2497	= { FOLLOW_SPACE_in_media2497_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_port_in_media2499  */
static	ANTLR3_BITWORD FOLLOW_port_in_media2499_bits[]	= { ANTLR3_UINT64_LIT(0x00000000000C0000) };
static  ANTLR3_BITSET_LIST FOLLOW_port_in_media2499	= { FOLLOW_port_in_media2499_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SLASH_in_media2514  */
static	ANTLR3_BITWORD FOLLOW_SLASH_in_media2514_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000200) };
static  ANTLR3_BITSET_LIST FOLLOW_SLASH_in_media2514	= { FOLLOW_SLASH_in_media2514_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_integer_in_media2516  */
static	ANTLR3_BITWORD FOLLOW_integer_in_media2516_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000080000) };
static  ANTLR3_BITSET_LIST FOLLOW_integer_in_media2516	= { FOLLOW_integer_in_media2516_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SPACE_in_media2531  */
static	ANTLR3_BITWORD FOLLOW_SPACE_in_media2531_bits[]	= { ANTLR3_UINT64_LIT(0x0000000FFFFFDF70) };
static  ANTLR3_BITSET_LIST FOLLOW_SPACE_in_media2531	= { FOLLOW_SPACE_in_media2531_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_proto_in_media2533  */
static	ANTLR3_BITWORD FOLLOW_proto_in_media2533_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000080000) };
static  ANTLR3_BITSET_LIST FOLLOW_proto_in_media2533	= { FOLLOW_proto_in_media2533_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SPACE_in_media2548  */
static	ANTLR3_BITWORD FOLLOW_SPACE_in_media2548_bits[]	= { ANTLR3_UINT64_LIT(0x0000000FFFD01740) };
static  ANTLR3_BITSET_LIST FOLLOW_SPACE_in_media2548	= { FOLLOW_SPACE_in_media2548_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_fmt_in_media2550  */
static	ANTLR3_BITWORD FOLLOW_fmt_in_media2550_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000080002) };
static  ANTLR3_BITSET_LIST FOLLOW_fmt_in_media2550	= { FOLLOW_fmt_in_media2550_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_media_value2578  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_media_value2578_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001242) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_media_value2578	= { FOLLOW_alpha_num_in_media_value2578_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DIGIT_in_fmt2662  */
static	ANTLR3_BITWORD FOLLOW_DIGIT_in_fmt2662_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000202) };
static  ANTLR3_BITSET_LIST FOLLOW_DIGIT_in_fmt2662	= { FOLLOW_DIGIT_in_fmt2662_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_token_in_fmt2669  */
static	ANTLR3_BITWORD FOLLOW_token_in_fmt2669_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_token_in_fmt2669	= { FOLLOW_token_in_fmt2669_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DIGIT_in_port2880  */
static	ANTLR3_BITWORD FOLLOW_DIGIT_in_port2880_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000202) };
static  ANTLR3_BITSET_LIST FOLLOW_DIGIT_in_port2880	= { FOLLOW_DIGIT_in_port2880_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_token_in_attribute_name2932  */
static	ANTLR3_BITWORD FOLLOW_token_in_attribute_name2932_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_token_in_attribute_name2932	= { FOLLOW_token_in_attribute_name2932_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_word_in_rtcp_xr_attribute_name2963  */
static	ANTLR3_BITWORD FOLLOW_word_in_rtcp_xr_attribute_name2963_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_word_in_rtcp_xr_attribute_name2963	= { FOLLOW_word_in_rtcp_xr_attribute_name2963_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_word_in_rtcp_xr_rcvr_rtt_mode2970  */
static	ANTLR3_BITWORD FOLLOW_word_in_rtcp_xr_rcvr_rtt_mode2970_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_word_in_rtcp_xr_rcvr_rtt_mode2970	= { FOLLOW_word_in_rtcp_xr_rcvr_rtt_mode2970_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_word_in_rtcp_xr_stat_summary_flag_value2977  */
static	ANTLR3_BITWORD FOLLOW_word_in_rtcp_xr_stat_summary_flag_value2977_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_word_in_rtcp_xr_stat_summary_flag_value2977	= { FOLLOW_word_in_rtcp_xr_stat_summary_flag_value2977_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_word_in_rtcp_fb_attribute_name2984  */
static	ANTLR3_BITWORD FOLLOW_word_in_rtcp_fb_attribute_name2984_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_word_in_rtcp_fb_attribute_name2984	= { FOLLOW_word_in_rtcp_fb_attribute_name2984_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DIGIT_in_sess_id3003  */
static	ANTLR3_BITWORD FOLLOW_DIGIT_in_sess_id3003_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000202) };
static  ANTLR3_BITSET_LIST FOLLOW_DIGIT_in_sess_id3003	= { FOLLOW_DIGIT_in_sess_id3003_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DIGIT_in_sess_version3043  */
static	ANTLR3_BITWORD FOLLOW_DIGIT_in_sess_version3043_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000202) };
static  ANTLR3_BITSET_LIST FOLLOW_DIGIT_in_sess_version3043	= { FOLLOW_DIGIT_in_sess_version3043_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_addr_in_connection_address3097  */
static	ANTLR3_BITWORD FOLLOW_addr_in_connection_address3097_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000040002) };
static  ANTLR3_BITSET_LIST FOLLOW_addr_in_connection_address3097	= { FOLLOW_addr_in_connection_address3097_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_multicast_part_in_connection_address3101  */
static	ANTLR3_BITWORD FOLLOW_multicast_part_in_connection_address3101_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_multicast_part_in_connection_address3101	= { FOLLOW_multicast_part_in_connection_address3101_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_unicast_address_in_multicast_address3111  */
static	ANTLR3_BITWORD FOLLOW_unicast_address_in_multicast_address3111_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000040000) };
static  ANTLR3_BITSET_LIST FOLLOW_unicast_address_in_multicast_address3111	= { FOLLOW_unicast_address_in_multicast_address3111_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SLASH_in_multicast_address3113  */
static	ANTLR3_BITWORD FOLLOW_SLASH_in_multicast_address3113_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000200) };
static  ANTLR3_BITSET_LIST FOLLOW_SLASH_in_multicast_address3113	= { FOLLOW_SLASH_in_multicast_address3113_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_ttl_in_multicast_address3115  */
static	ANTLR3_BITWORD FOLLOW_ttl_in_multicast_address3115_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_ttl_in_multicast_address3115	= { FOLLOW_ttl_in_multicast_address3115_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_decimal_uchar_in_ttl3217  */
static	ANTLR3_BITWORD FOLLOW_decimal_uchar_in_ttl3217_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_decimal_uchar_in_ttl3217	= { FOLLOW_decimal_uchar_in_ttl3217_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DIGIT_in_start_time3234  */
static	ANTLR3_BITWORD FOLLOW_DIGIT_in_start_time3234_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000202) };
static  ANTLR3_BITSET_LIST FOLLOW_DIGIT_in_start_time3234	= { FOLLOW_DIGIT_in_start_time3234_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DIGIT_in_stop_time3254  */
static	ANTLR3_BITWORD FOLLOW_DIGIT_in_stop_time3254_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000202) };
static  ANTLR3_BITSET_LIST FOLLOW_DIGIT_in_stop_time3254	= { FOLLOW_DIGIT_in_stop_time3254_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DIGIT_in_sdp_time3280  */
static	ANTLR3_BITWORD FOLLOW_DIGIT_in_sdp_time3280_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000202) };
static  ANTLR3_BITSET_LIST FOLLOW_DIGIT_in_sdp_time3280	= { FOLLOW_DIGIT_in_sdp_time3280_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_typed_time_in_repeat_interval3314  */
static	ANTLR3_BITWORD FOLLOW_typed_time_in_repeat_interval3314_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_typed_time_in_repeat_interval3314	= { FOLLOW_typed_time_in_repeat_interval3314_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DIGIT_in_typed_time3330  */
static	ANTLR3_BITWORD FOLLOW_DIGIT_in_typed_time3330_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001242) };
static  ANTLR3_BITSET_LIST FOLLOW_DIGIT_in_typed_time3330	= { FOLLOW_DIGIT_in_typed_time3330_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_fixed_len_time_unit_in_typed_time3333  */
static	ANTLR3_BITWORD FOLLOW_fixed_len_time_unit_in_typed_time3333_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_fixed_len_time_unit_in_typed_time3333	= { FOLLOW_fixed_len_time_unit_in_typed_time3333_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_fixed_len_time_unit3343  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_fixed_len_time_unit3343_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_fixed_len_time_unit3343	= { FOLLOW_alpha_num_in_fixed_len_time_unit3343_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_fixed_len_time_unit3371  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_fixed_len_time_unit3371_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_fixed_len_time_unit3371	= { FOLLOW_alpha_num_in_fixed_len_time_unit3371_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_fixed_len_time_unit3399  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_fixed_len_time_unit3399_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_fixed_len_time_unit3399	= { FOLLOW_alpha_num_in_fixed_len_time_unit3399_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_fixed_len_time_unit3427  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_fixed_len_time_unit3427_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_fixed_len_time_unit3427	= { FOLLOW_alpha_num_in_fixed_len_time_unit3427_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_bwtype3447  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_bwtype3447_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001242) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_bwtype3447	= { FOLLOW_alpha_num_in_bwtype3447_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DIGIT_in_bandwidth_value3465  */
static	ANTLR3_BITWORD FOLLOW_DIGIT_in_bandwidth_value3465_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000202) };
static  ANTLR3_BITSET_LIST FOLLOW_DIGIT_in_bandwidth_value3465	= { FOLLOW_DIGIT_in_bandwidth_value3465_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_email_safe_in_username3484  */
static	ANTLR3_BITWORD FOLLOW_email_safe_in_username3484_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_email_safe_in_username3484	= { FOLLOW_email_safe_in_username3484_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_text_in_uri3593  */
static	ANTLR3_BITWORD FOLLOW_text_in_uri3593_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_text_in_uri3593	= { FOLLOW_text_in_uri3593_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_phone_in_phone_number3616  */
static	ANTLR3_BITWORD FOLLOW_phone_in_phone_number3616_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_phone_in_phone_number3616	= { FOLLOW_phone_in_phone_number3616_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_text_in_phone3638  */
static	ANTLR3_BITWORD FOLLOW_text_in_phone3638_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_text_in_phone3638	= { FOLLOW_text_in_phone3638_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_nettype3709  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_nettype3709_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001242) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_nettype3709	= { FOLLOW_alpha_num_in_nettype3709_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_addrtype3753  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_addrtype3753_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001242) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_addrtype3753	= { FOLLOW_alpha_num_in_addrtype3753_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_unicast_address_in_addr3805  */
static	ANTLR3_BITWORD FOLLOW_unicast_address_in_addr3805_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_unicast_address_in_addr3805	= { FOLLOW_unicast_address_in_addr3805_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SLASH_in_multicast_part3815  */
static	ANTLR3_BITWORD FOLLOW_SLASH_in_multicast_part3815_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000200) };
static  ANTLR3_BITSET_LIST FOLLOW_SLASH_in_multicast_part3815	= { FOLLOW_SLASH_in_multicast_part3815_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_integer_in_multicast_part3819  */
static	ANTLR3_BITWORD FOLLOW_integer_in_multicast_part3819_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000040002) };
static  ANTLR3_BITSET_LIST FOLLOW_integer_in_multicast_part3819	= { FOLLOW_integer_in_multicast_part3819_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_domainlabel_in_fqdn3843  */
static	ANTLR3_BITWORD FOLLOW_domainlabel_in_fqdn3843_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000400) };
static  ANTLR3_BITSET_LIST FOLLOW_domainlabel_in_fqdn3843	= { FOLLOW_domainlabel_in_fqdn3843_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DOT_in_fqdn3845  */
static	ANTLR3_BITWORD FOLLOW_DOT_in_fqdn3845_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001240) };
static  ANTLR3_BITSET_LIST FOLLOW_DOT_in_fqdn3845	= { FOLLOW_DOT_in_fqdn3845_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_toplabel_in_fqdn3850  */
static	ANTLR3_BITWORD FOLLOW_toplabel_in_fqdn3850_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000402) };
static  ANTLR3_BITSET_LIST FOLLOW_toplabel_in_fqdn3850	= { FOLLOW_toplabel_in_fqdn3850_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DOT_in_fqdn3852  */
static	ANTLR3_BITWORD FOLLOW_DOT_in_fqdn3852_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_DOT_in_fqdn3852	= { FOLLOW_DOT_in_fqdn3852_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_domainlabel3868  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_domainlabel3868_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_domainlabel3868	= { FOLLOW_alpha_num_in_domainlabel3868_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_domainlabel3873  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_domainlabel3873_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001340) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_domainlabel3873	= { FOLLOW_alpha_num_in_domainlabel3873_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_domainlabel3877  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_domainlabel3877_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001340) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_domainlabel3877	= { FOLLOW_alpha_num_in_domainlabel3877_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DASH_in_domainlabel3881  */
static	ANTLR3_BITWORD FOLLOW_DASH_in_domainlabel3881_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001340) };
static  ANTLR3_BITSET_LIST FOLLOW_DASH_in_domainlabel3881	= { FOLLOW_DASH_in_domainlabel3881_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_domainlabel3886  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_domainlabel3886_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_domainlabel3886	= { FOLLOW_alpha_num_in_domainlabel3886_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_in_toplabel3904  */
static	ANTLR3_BITWORD FOLLOW_alpha_in_toplabel3904_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_in_toplabel3904	= { FOLLOW_alpha_in_toplabel3904_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_in_toplabel3909  */
static	ANTLR3_BITWORD FOLLOW_alpha_in_toplabel3909_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001340) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_in_toplabel3909	= { FOLLOW_alpha_in_toplabel3909_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_toplabel3913  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_toplabel3913_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001340) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_toplabel3913	= { FOLLOW_alpha_num_in_toplabel3913_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DASH_in_toplabel3917  */
static	ANTLR3_BITWORD FOLLOW_DASH_in_toplabel3917_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001340) };
static  ANTLR3_BITSET_LIST FOLLOW_DASH_in_toplabel3917	= { FOLLOW_DASH_in_toplabel3917_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_toplabel3922  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_toplabel3922_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_toplabel3922	= { FOLLOW_alpha_num_in_toplabel3922_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_unicast_address3935  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_unicast_address3935_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001752) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_unicast_address3935	= { FOLLOW_alpha_num_in_unicast_address3935_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DOT_in_unicast_address3939  */
static	ANTLR3_BITWORD FOLLOW_DOT_in_unicast_address3939_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001752) };
static  ANTLR3_BITSET_LIST FOLLOW_DOT_in_unicast_address3939	= { FOLLOW_DOT_in_unicast_address3939_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_COLON_in_unicast_address3943  */
static	ANTLR3_BITWORD FOLLOW_COLON_in_unicast_address3943_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001752) };
static  ANTLR3_BITSET_LIST FOLLOW_COLON_in_unicast_address3943	= { FOLLOW_COLON_in_unicast_address3943_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DASH_in_unicast_address3946  */
static	ANTLR3_BITWORD FOLLOW_DASH_in_unicast_address3946_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001752) };
static  ANTLR3_BITSET_LIST FOLLOW_DASH_in_unicast_address3946	= { FOLLOW_DASH_in_unicast_address3946_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_decimal_uchar_in_ipv4_address3989  */
static	ANTLR3_BITWORD FOLLOW_decimal_uchar_in_ipv4_address3989_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000400) };
static  ANTLR3_BITSET_LIST FOLLOW_decimal_uchar_in_ipv4_address3989	= { FOLLOW_decimal_uchar_in_ipv4_address3989_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DOT_in_ipv4_address3991  */
static	ANTLR3_BITWORD FOLLOW_DOT_in_ipv4_address3991_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000200) };
static  ANTLR3_BITSET_LIST FOLLOW_DOT_in_ipv4_address3991	= { FOLLOW_DOT_in_ipv4_address3991_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_decimal_uchar_in_ipv4_address3993  */
static	ANTLR3_BITWORD FOLLOW_decimal_uchar_in_ipv4_address3993_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000400) };
static  ANTLR3_BITSET_LIST FOLLOW_decimal_uchar_in_ipv4_address3993	= { FOLLOW_decimal_uchar_in_ipv4_address3993_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DOT_in_ipv4_address3995  */
static	ANTLR3_BITWORD FOLLOW_DOT_in_ipv4_address3995_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000200) };
static  ANTLR3_BITSET_LIST FOLLOW_DOT_in_ipv4_address3995	= { FOLLOW_DOT_in_ipv4_address3995_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_decimal_uchar_in_ipv4_address3997  */
static	ANTLR3_BITWORD FOLLOW_decimal_uchar_in_ipv4_address3997_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000400) };
static  ANTLR3_BITSET_LIST FOLLOW_decimal_uchar_in_ipv4_address3997	= { FOLLOW_decimal_uchar_in_ipv4_address3997_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DOT_in_ipv4_address3999  */
static	ANTLR3_BITWORD FOLLOW_DOT_in_ipv4_address3999_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000200) };
static  ANTLR3_BITSET_LIST FOLLOW_DOT_in_ipv4_address3999	= { FOLLOW_DOT_in_ipv4_address3999_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_decimal_uchar_in_ipv4_address4001  */
static	ANTLR3_BITWORD FOLLOW_decimal_uchar_in_ipv4_address4001_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_decimal_uchar_in_ipv4_address4001	= { FOLLOW_decimal_uchar_in_ipv4_address4001_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_hexpart_in_ipv6_address4020  */
static	ANTLR3_BITWORD FOLLOW_hexpart_in_ipv6_address4020_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000012) };
static  ANTLR3_BITSET_LIST FOLLOW_hexpart_in_ipv6_address4020	= { FOLLOW_hexpart_in_ipv6_address4020_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_COLON_in_ipv6_address4024  */
static	ANTLR3_BITWORD FOLLOW_COLON_in_ipv6_address4024_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000200) };
static  ANTLR3_BITSET_LIST FOLLOW_COLON_in_ipv6_address4024	= { FOLLOW_COLON_in_ipv6_address4024_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_ipv4_address_in_ipv6_address4026  */
static	ANTLR3_BITWORD FOLLOW_ipv4_address_in_ipv6_address4026_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_ipv4_address_in_ipv6_address4026	= { FOLLOW_ipv4_address_in_ipv6_address4026_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_hexseq_in_hexpart4045  */
static	ANTLR3_BITWORD FOLLOW_hexseq_in_hexpart4045_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_hexseq_in_hexpart4045	= { FOLLOW_hexseq_in_hexpart4045_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_hexseq_in_hexpart4049  */
static	ANTLR3_BITWORD FOLLOW_hexseq_in_hexpart4049_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000010) };
static  ANTLR3_BITSET_LIST FOLLOW_hexseq_in_hexpart4049	= { FOLLOW_hexseq_in_hexpart4049_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_COLON_in_hexpart4051  */
static	ANTLR3_BITWORD FOLLOW_COLON_in_hexpart4051_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000010) };
static  ANTLR3_BITSET_LIST FOLLOW_COLON_in_hexpart4051	= { FOLLOW_COLON_in_hexpart4051_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_COLON_in_hexpart4053  */
static	ANTLR3_BITWORD FOLLOW_COLON_in_hexpart4053_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001202) };
static  ANTLR3_BITSET_LIST FOLLOW_COLON_in_hexpart4053	= { FOLLOW_COLON_in_hexpart4053_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_hexseq_in_hexpart4055  */
static	ANTLR3_BITWORD FOLLOW_hexseq_in_hexpart4055_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_hexseq_in_hexpart4055	= { FOLLOW_hexseq_in_hexpart4055_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_COLON_in_hexpart4060  */
static	ANTLR3_BITWORD FOLLOW_COLON_in_hexpart4060_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000010) };
static  ANTLR3_BITSET_LIST FOLLOW_COLON_in_hexpart4060	= { FOLLOW_COLON_in_hexpart4060_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_COLON_in_hexpart4062  */
static	ANTLR3_BITWORD FOLLOW_COLON_in_hexpart4062_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001202) };
static  ANTLR3_BITSET_LIST FOLLOW_COLON_in_hexpart4062	= { FOLLOW_COLON_in_hexpart4062_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_hexseq_in_hexpart4064  */
static	ANTLR3_BITWORD FOLLOW_hexseq_in_hexpart4064_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_hexseq_in_hexpart4064	= { FOLLOW_hexseq_in_hexpart4064_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_hex4_in_hexseq4082  */
static	ANTLR3_BITWORD FOLLOW_hex4_in_hexseq4082_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000012) };
static  ANTLR3_BITSET_LIST FOLLOW_hex4_in_hexseq4082	= { FOLLOW_hex4_in_hexseq4082_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_COLON_in_hexseq4086  */
static	ANTLR3_BITWORD FOLLOW_COLON_in_hexseq4086_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001200) };
static  ANTLR3_BITSET_LIST FOLLOW_COLON_in_hexseq4086	= { FOLLOW_COLON_in_hexseq4086_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_hex4_in_hexseq4088  */
static	ANTLR3_BITWORD FOLLOW_hex4_in_hexseq4088_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000012) };
static  ANTLR3_BITSET_LIST FOLLOW_hex4_in_hexseq4088	= { FOLLOW_hex4_in_hexseq4088_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_hexdigit_in_hex44109  */
static	ANTLR3_BITWORD FOLLOW_hexdigit_in_hex44109_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001202) };
static  ANTLR3_BITSET_LIST FOLLOW_hexdigit_in_hex44109	= { FOLLOW_hexdigit_in_hex44109_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_OCTET_in_byte_string4237  */
static	ANTLR3_BITWORD FOLLOW_OCTET_in_byte_string4237_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000008002) };
static  ANTLR3_BITSET_LIST FOLLOW_OCTET_in_byte_string4237	= { FOLLOW_OCTET_in_byte_string4237_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_integer_in_decimal_uchar4279  */
static	ANTLR3_BITWORD FOLLOW_integer_in_decimal_uchar4279_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_integer_in_decimal_uchar4279	= { FOLLOW_integer_in_decimal_uchar4279_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DIGIT_in_integer4298  */
static	ANTLR3_BITWORD FOLLOW_DIGIT_in_integer4298_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000202) };
static  ANTLR3_BITSET_LIST FOLLOW_DIGIT_in_integer4298	= { FOLLOW_DIGIT_in_integer4298_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_num_in_token4320  */
static	ANTLR3_BITWORD FOLLOW_alpha_num_in_token4320_bits[]	= { ANTLR3_UINT64_LIT(0x0000000FFFD01742) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_num_in_token4320	= { FOLLOW_alpha_num_in_token4320_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_22_in_token4324  */
static	ANTLR3_BITWORD FOLLOW_22_in_token4324_bits[]	= { ANTLR3_UINT64_LIT(0x0000000FFFD01742) };
static  ANTLR3_BITSET_LIST FOLLOW_22_in_token4324	= { FOLLOW_22_in_token4324_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_23_in_token4328  */
static	ANTLR3_BITWORD FOLLOW_23_in_token4328_bits[]	= { ANTLR3_UINT64_LIT(0x0000000FFFD01742) };
static  ANTLR3_BITSET_LIST FOLLOW_23_in_token4328	= { FOLLOW_23_in_token4328_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_24_in_token4332  */
static	ANTLR3_BITWORD FOLLOW_24_in_token4332_bits[]	= { ANTLR3_UINT64_LIT(0x0000000FFFD01742) };
static  ANTLR3_BITSET_LIST FOLLOW_24_in_token4332	= { FOLLOW_24_in_token4332_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_26_in_token4335  */
static	ANTLR3_BITWORD FOLLOW_26_in_token4335_bits[]	= { ANTLR3_UINT64_LIT(0x0000000FFFD01742) };
static  ANTLR3_BITSET_LIST FOLLOW_26_in_token4335	= { FOLLOW_26_in_token4335_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_25_in_token4338  */
static	ANTLR3_BITWORD FOLLOW_25_in_token4338_bits[]	= { ANTLR3_UINT64_LIT(0x0000000FFFD01742) };
static  ANTLR3_BITSET_LIST FOLLOW_25_in_token4338	= { FOLLOW_25_in_token4338_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_28_in_token4341  */
static	ANTLR3_BITWORD FOLLOW_28_in_token4341_bits[]	= { ANTLR3_UINT64_LIT(0x0000000FFFD01742) };
static  ANTLR3_BITSET_LIST FOLLOW_28_in_token4341	= { FOLLOW_28_in_token4341_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_STAR_in_token4345  */
static	ANTLR3_BITWORD FOLLOW_STAR_in_token4345_bits[]	= { ANTLR3_UINT64_LIT(0x0000000FFFD01742) };
static  ANTLR3_BITSET_LIST FOLLOW_STAR_in_token4345	= { FOLLOW_STAR_in_token4345_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_27_in_token4348  */
static	ANTLR3_BITWORD FOLLOW_27_in_token4348_bits[]	= { ANTLR3_UINT64_LIT(0x0000000FFFD01742) };
static  ANTLR3_BITSET_LIST FOLLOW_27_in_token4348	= { FOLLOW_27_in_token4348_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DASH_in_token4352  */
static	ANTLR3_BITWORD FOLLOW_DASH_in_token4352_bits[]	= { ANTLR3_UINT64_LIT(0x0000000FFFD01742) };
static  ANTLR3_BITSET_LIST FOLLOW_DASH_in_token4352	= { FOLLOW_DASH_in_token4352_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DOT_in_token4356  */
static	ANTLR3_BITWORD FOLLOW_DOT_in_token4356_bits[]	= { ANTLR3_UINT64_LIT(0x0000000FFFD01742) };
static  ANTLR3_BITSET_LIST FOLLOW_DOT_in_token4356	= { FOLLOW_DOT_in_token4356_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_29_in_token4360  */
static	ANTLR3_BITWORD FOLLOW_29_in_token4360_bits[]	= { ANTLR3_UINT64_LIT(0x0000000FFFD01742) };
static  ANTLR3_BITSET_LIST FOLLOW_29_in_token4360	= { FOLLOW_29_in_token4360_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_30_in_token4364  */
static	ANTLR3_BITWORD FOLLOW_30_in_token4364_bits[]	= { ANTLR3_UINT64_LIT(0x0000000FFFD01742) };
static  ANTLR3_BITSET_LIST FOLLOW_30_in_token4364	= { FOLLOW_30_in_token4364_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_31_in_token4368  */
static	ANTLR3_BITWORD FOLLOW_31_in_token4368_bits[]	= { ANTLR3_UINT64_LIT(0x0000000FFFD01742) };
static  ANTLR3_BITSET_LIST FOLLOW_31_in_token4368	= { FOLLOW_31_in_token4368_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_32_in_token4372  */
static	ANTLR3_BITWORD FOLLOW_32_in_token4372_bits[]	= { ANTLR3_UINT64_LIT(0x0000000FFFD01742) };
static  ANTLR3_BITSET_LIST FOLLOW_32_in_token4372	= { FOLLOW_32_in_token4372_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_33_in_token4376  */
static	ANTLR3_BITWORD FOLLOW_33_in_token4376_bits[]	= { ANTLR3_UINT64_LIT(0x0000000FFFD01742) };
static  ANTLR3_BITSET_LIST FOLLOW_33_in_token4376	= { FOLLOW_33_in_token4376_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_34_in_token4380  */
static	ANTLR3_BITWORD FOLLOW_34_in_token4380_bits[]	= { ANTLR3_UINT64_LIT(0x0000000FFFD01742) };
static  ANTLR3_BITSET_LIST FOLLOW_34_in_token4380	= { FOLLOW_34_in_token4380_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_35_in_token4384  */
static	ANTLR3_BITWORD FOLLOW_35_in_token4384_bits[]	= { ANTLR3_UINT64_LIT(0x0000000FFFD01742) };
static  ANTLR3_BITSET_LIST FOLLOW_35_in_token4384	= { FOLLOW_35_in_token4384_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_in_alpha_num4397  */
static	ANTLR3_BITWORD FOLLOW_alpha_in_alpha_num4397_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_in_alpha_num4397	= { FOLLOW_alpha_in_alpha_num4397_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DIGIT_in_alpha_num4401  */
static	ANTLR3_BITWORD FOLLOW_DIGIT_in_alpha_num4401_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_DIGIT_in_alpha_num4401	= { FOLLOW_DIGIT_in_alpha_num4401_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_alpha_in_word4423  */
static	ANTLR3_BITWORD FOLLOW_alpha_in_word4423_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001142) };
static  ANTLR3_BITSET_LIST FOLLOW_alpha_in_word4423	= { FOLLOW_alpha_in_word4423_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DASH_in_word4427  */
static	ANTLR3_BITWORD FOLLOW_DASH_in_word4427_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000001142) };
static  ANTLR3_BITSET_LIST FOLLOW_DASH_in_word4427	= { FOLLOW_DASH_in_word4427_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_pkt_loss_rle_in_synpred1_belle_sdp1560  */
static	ANTLR3_BITWORD FOLLOW_pkt_loss_rle_in_synpred1_belle_sdp1560_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_pkt_loss_rle_in_synpred1_belle_sdp1560	= { FOLLOW_pkt_loss_rle_in_synpred1_belle_sdp1560_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_pkt_dup_rle_in_synpred2_belle_sdp1569  */
static	ANTLR3_BITWORD FOLLOW_pkt_dup_rle_in_synpred2_belle_sdp1569_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_pkt_dup_rle_in_synpred2_belle_sdp1569	= { FOLLOW_pkt_dup_rle_in_synpred2_belle_sdp1569_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_pkt_rcpt_times_in_synpred3_belle_sdp1578  */
static	ANTLR3_BITWORD FOLLOW_pkt_rcpt_times_in_synpred3_belle_sdp1578_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_pkt_rcpt_times_in_synpred3_belle_sdp1578	= { FOLLOW_pkt_rcpt_times_in_synpred3_belle_sdp1578_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rcvr_rtt_in_synpred4_belle_sdp1587  */
static	ANTLR3_BITWORD FOLLOW_rcvr_rtt_in_synpred4_belle_sdp1587_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rcvr_rtt_in_synpred4_belle_sdp1587	= { FOLLOW_rcvr_rtt_in_synpred4_belle_sdp1587_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_stat_summary_in_synpred5_belle_sdp1596  */
static	ANTLR3_BITWORD FOLLOW_stat_summary_in_synpred5_belle_sdp1596_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_stat_summary_in_synpred5_belle_sdp1596	= { FOLLOW_stat_summary_in_synpred5_belle_sdp1596_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_voip_metrics_in_synpred6_belle_sdp1605  */
static	ANTLR3_BITWORD FOLLOW_voip_metrics_in_synpred6_belle_sdp1605_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_voip_metrics_in_synpred6_belle_sdp1605	= { FOLLOW_voip_metrics_in_synpred6_belle_sdp1605_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_ack_val_in_synpred7_belle_sdp1836  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_ack_val_in_synpred7_belle_sdp1836_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_ack_val_in_synpred7_belle_sdp1836	= { FOLLOW_rtcp_fb_ack_val_in_synpred7_belle_sdp1836_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_nack_val_in_synpred8_belle_sdp1844  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_nack_val_in_synpred8_belle_sdp1844_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_nack_val_in_synpred8_belle_sdp1844	= { FOLLOW_rtcp_fb_nack_val_in_synpred8_belle_sdp1844_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_trr_int_val_in_synpred9_belle_sdp1852  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_trr_int_val_in_synpred9_belle_sdp1852_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_trr_int_val_in_synpred9_belle_sdp1852	= { FOLLOW_rtcp_fb_trr_int_val_in_synpred9_belle_sdp1852_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_ccm_val_in_synpred10_belle_sdp1860  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_ccm_val_in_synpred10_belle_sdp1860_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_ccm_val_in_synpred10_belle_sdp1860	= { FOLLOW_rtcp_fb_ccm_val_in_synpred10_belle_sdp1860_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_id_val_in_synpred11_belle_sdp1868  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_id_val_in_synpred11_belle_sdp1868_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_id_val_in_synpred11_belle_sdp1868	= { FOLLOW_rtcp_fb_id_val_in_synpred11_belle_sdp1868_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_app_param_in_synpred12_belle_sdp1976  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_app_param_in_synpred12_belle_sdp1976_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_app_param_in_synpred12_belle_sdp1976	= { FOLLOW_rtcp_fb_app_param_in_synpred12_belle_sdp1976_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_token_param_in_synpred13_belle_sdp1984  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_token_param_in_synpred13_belle_sdp1984_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_token_param_in_synpred13_belle_sdp1984	= { FOLLOW_rtcp_fb_token_param_in_synpred13_belle_sdp1984_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_rpsi_param_in_synpred14_belle_sdp1996  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_rpsi_param_in_synpred14_belle_sdp1996_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_rpsi_param_in_synpred14_belle_sdp1996	= { FOLLOW_rtcp_fb_rpsi_param_in_synpred14_belle_sdp1996_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_app_param_in_synpred15_belle_sdp2004  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_app_param_in_synpred15_belle_sdp2004_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_app_param_in_synpred15_belle_sdp2004	= { FOLLOW_rtcp_fb_app_param_in_synpred15_belle_sdp2004_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_token_param_in_synpred16_belle_sdp2012  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_token_param_in_synpred16_belle_sdp2012_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_token_param_in_synpred16_belle_sdp2012	= { FOLLOW_rtcp_fb_token_param_in_synpred16_belle_sdp2012_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_pli_param_in_synpred17_belle_sdp2024  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_pli_param_in_synpred17_belle_sdp2024_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_pli_param_in_synpred17_belle_sdp2024	= { FOLLOW_rtcp_fb_pli_param_in_synpred17_belle_sdp2024_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_sli_param_in_synpred18_belle_sdp2032  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_sli_param_in_synpred18_belle_sdp2032_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_sli_param_in_synpred18_belle_sdp2032	= { FOLLOW_rtcp_fb_sli_param_in_synpred18_belle_sdp2032_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_rpsi_param_in_synpred19_belle_sdp2040  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_rpsi_param_in_synpred19_belle_sdp2040_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_rpsi_param_in_synpred19_belle_sdp2040	= { FOLLOW_rtcp_fb_rpsi_param_in_synpred19_belle_sdp2040_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_app_param_in_synpred20_belle_sdp2048  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_app_param_in_synpred20_belle_sdp2048_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_app_param_in_synpred20_belle_sdp2048	= { FOLLOW_rtcp_fb_app_param_in_synpred20_belle_sdp2048_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_token_param_in_synpred21_belle_sdp2056  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_token_param_in_synpred21_belle_sdp2056_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_token_param_in_synpred21_belle_sdp2056	= { FOLLOW_rtcp_fb_token_param_in_synpred21_belle_sdp2056_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_fir_param_in_synpred22_belle_sdp2130  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_fir_param_in_synpred22_belle_sdp2130_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_fir_param_in_synpred22_belle_sdp2130	= { FOLLOW_rtcp_fb_fir_param_in_synpred22_belle_sdp2130_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_tmmbr_param_in_synpred23_belle_sdp2138  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_tmmbr_param_in_synpred23_belle_sdp2138_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_tmmbr_param_in_synpred23_belle_sdp2138	= { FOLLOW_rtcp_fb_tmmbr_param_in_synpred23_belle_sdp2138_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rtcp_fb_token_param_in_synpred24_belle_sdp2146  */
static	ANTLR3_BITWORD FOLLOW_rtcp_fb_token_param_in_synpred24_belle_sdp2146_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rtcp_fb_token_param_in_synpred24_belle_sdp2146	= { FOLLOW_rtcp_fb_token_param_in_synpred24_belle_sdp2146_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DIGIT_in_synpred25_belle_sdp2657  */
static	ANTLR3_BITWORD FOLLOW_DIGIT_in_synpred25_belle_sdp2657_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000202) };
static  ANTLR3_BITSET_LIST FOLLOW_DIGIT_in_synpred25_belle_sdp2657	= { FOLLOW_DIGIT_in_synpred25_belle_sdp2657_bits, 1	};



/* =========================================================================
 * DFA tables for the parser
 */
/** Static dfa state tables for Cyclic dfa:
 *    108:26: ( info CR LF )?
 */
static const ANTLR3_INT32 dfa1_eot[33] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa1_eof[33] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa1_min[33] =
    {
	6, 11, 11, 4, 4, 13, 4, 4, 4, 4, 4, 0, 4, 4, 4, 4, -1, -1, 4, 4, 13, 13, 
	13, 4, 4, 4, 4, 4, 4, 0, 0, 0, 4
    };
static const ANTLR3_INT32 dfa1_max[33] =
    {
	12, 11, 11, 35, 35, 13, 35, 35, 35, 35, 35, 0, 35, 35, 35, 35, -1, -1, 
	35, 35, 13, 13, 13, 35, 35, 35, 35, 35, 35, 0, 0, 0, 35
    };
static const ANTLR3_INT32 dfa1_accept[33] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa1_special[33] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2, 1, 3, -1
    };

/** Used when there is no transition table entry for a particular state */
#define dfa1_T_empty	    NULL

static const ANTLR3_INT32 dfa1_T0[] =
    {
	7, 7, 7, 5, 7, 15, 7, 7, 7, -1, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa1_T1[] =
    {
	10, 7, 4, 5, 7, 9, 7, 7, 4, -1, 7, 7, 7, 7, 7, 8, 7, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa1_T2[] =
    {
	7, 7, 13, 5, 7, 14, 7, 7, 13, -1, 7, 7, 7, 7, 7, 19, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa1_T3[] =
    {
	-1
    };

static const ANTLR3_INT32 dfa1_T4[] =
    {
	7, 7, 13, 21, 7, 18, 7, 7, 13, -1, 7, 7, 7, 7, 7, 19, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa1_T5[] =
    {
	10, 7, 4, 5, 7, 6, 7, 7, 4, -1, 7, 7, 7, 7, 7, 12, 7, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa1_T6[] =
    {
	7, 7, 7, 20, 7, 15, 7, 7, 7, -1, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa1_T7[] =
    {
	7, 7, 13, 5, 7, 18, 7, 7, 13, -1, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa1_T8[] =
    {
	26, 7, 23, 22, 27, 24, 25, 7, 23, -1, 7, 7, 7, 7, 28, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa1_T9[] =
    {
	7, 7, 4, 5, 7, 6, 7, 7, 4, -1, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa1_T10[] =
    {
	31
    };

static const ANTLR3_INT32 dfa1_T11[] =
    {
	3
    };

static const ANTLR3_INT32 dfa1_T12[] =
    {
	11
    };

static const ANTLR3_INT32 dfa1_T13[] =
    {
	29
    };

static const ANTLR3_INT32 dfa1_T14[] =
    {
	7, 7, 7, 5, 7, 32, 7, 7, 7, -1, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa1_T15[] =
    {
	7, 7, 7, 22, 7, 32, 7, 7, 7, -1, 7, 7, 7, 7, 28, 7, 7, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa1_T16[] =
    {
	7, 7, 13, 5, 7, 14, 7, 7, 13, -1, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa1_T17[] =
    {
	30
    };

static const ANTLR3_INT32 dfa1_T18[] =
    {
	1, -1, -1, 2, -1, -1, 1
    };

static const ANTLR3_INT32 dfa1_T19[] =
    {
	7, 7, 7, 5, 7, 7, 7, 7, 7, -1, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7
    };


/* Transition tables are a table of sub tables, with some tables
 * reused for efficiency.
 */
static const ANTLR3_INT32 * const dfa1_transitions[] =
{
    dfa1_T18, dfa1_T11, dfa1_T11, dfa1_T9, dfa1_T1, dfa1_T12, dfa1_T5, dfa1_T19, 
    dfa1_T16, dfa1_T1, dfa1_T0, dfa1_T3, dfa1_T7, dfa1_T2, dfa1_T2, dfa1_T6, 
    NULL, NULL, dfa1_T4, dfa1_T8, dfa1_T13, dfa1_T17, dfa1_T10, dfa1_T8, 
    dfa1_T8, dfa1_T8, dfa1_T8, dfa1_T8, dfa1_T14, dfa1_T3, dfa1_T3, dfa1_T3, 
    dfa1_T15
};

static ANTLR3_INT32 dfa1_sst(pbelle_sdpParser ctx, pANTLR3_BASE_RECOGNIZER recognizer, pANTLR3_INT_STREAM is, pANTLR3_CYCLIC_DFA dfa, ANTLR3_INT32 s)
{
    ANTLR3_INT32    _s;

    _s	    = s;
    switch  (s)
    {
        case 0:

    	{
    	    ANTLR3_UINT32 LA1_11;

    	    ANTLR3_MARKER index1_11;


    		LA1_11 = LA(1);

    	     
    	        index1_11 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(i))) )
    	    {
    	        s = 16;
    	    }

    	    else if ( ((((IS_TOKEN(p)))||((IS_TOKEN(u)))||((IS_TOKEN(e))))) )
    	    {
    	        s = 17;
    	    }

    		 
    			SEEK(index1_11);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;

        case 1:

    	{
    	    ANTLR3_UINT32 LA1_30;

    	    ANTLR3_MARKER index1_30;


    		LA1_30 = LA(1);

    	     
    	        index1_30 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(i))) )
    	    {
    	        s = 16;
    	    }

    	    else if ( ((((IS_TOKEN(p)))||((IS_TOKEN(u)))||((IS_TOKEN(e)))||((IS_TOKEN(t))))) )
    	    {
    	        s = 17;
    	    }

    		 
    			SEEK(index1_30);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;

        case 2:

    	{
    	    ANTLR3_UINT32 LA1_29;

    	    ANTLR3_MARKER index1_29;


    		LA1_29 = LA(1);

    	     
    	        index1_29 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(i))) )
    	    {
    	        s = 16;
    	    }

    	    else if ( ((((IS_TOKEN(p)))||((IS_TOKEN(b)))||((IS_TOKEN(u)))||((IS_TOKEN(e))))) )
    	    {
    	        s = 17;
    	    }

    		 
    			SEEK(index1_29);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;

        case 3:

    	{
    	    ANTLR3_UINT32 LA1_31;

    	    ANTLR3_MARKER index1_31;


    		LA1_31 = LA(1);

    	     
    	        index1_31 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(i))) )
    	    {
    	        s = 16;
    	    }

    	    else if ( ((((IS_TOKEN(p)))||((IS_TOKEN(c)))||((IS_TOKEN(u)))||((IS_TOKEN(e))))) )
    	    {
    	        s = 17;
    	    }

    		 
    			SEEK(index1_31);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;
    }
    if (BACKTRACKING > 0)
    {
	FAILEDFLAG = ANTLR3_TRUE;
	return	-1;
    }

    CONSTRUCTEX();
    EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
    EXCEPTION->message      = (void *)"108:26: ( info CR LF )?";
    EXCEPTION->decisionNum  = 1;
    EXCEPTION->state        = _s;
    return -1;
}


/* Declare tracking structure for Cyclic DFA 1
 */
static
ANTLR3_CYCLIC_DFA cdfa1
    =	{
	    1,		    /* Decision number of this dfa	    */
	    /* Which decision this represents:   */
	    (const pANTLR3_UCHAR)"108:26: ( info CR LF )?",
	    (CDFA_SPECIAL_FUNC) dfa1_sst,
	    antlr3dfaspecialTransition,		/* DFA specialTransition is currently just a default function in the runtime */
	    antlr3dfapredict,			/* DFA simulator function is in the runtime */
	    dfa1_eot,	    /* EOT table			    */
	    dfa1_eof,	    /* EOF table			    */
	    dfa1_min,	    /* Minimum tokens for each state    */
	    dfa1_max,	    /* Maximum tokens for each state    */
	    dfa1_accept,	/* Accept table			    */
	    dfa1_special,	/* Special transition states	    */
	    dfa1_transitions	/* Table of transition tables	    */

	};
/* End of Cyclic DFA 1
 * ---------------------
 *//** Static dfa state tables for Cyclic dfa:
 *    109:26: ( uri_field CR LF )?
 */
static const ANTLR3_INT32 dfa2_eot[33] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa2_eof[33] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa2_min[33] =
    {
	6, 11, 11, 4, 4, 13, 4, 4, 4, 4, 4, 0, 4, 4, 4, 4, -1, -1, 4, 4, 13, 13, 
	13, 4, 4, 4, 4, 4, 4, 0, 0, 0, 4
    };
static const ANTLR3_INT32 dfa2_max[33] =
    {
	12, 11, 11, 35, 35, 13, 35, 35, 35, 35, 35, 0, 35, 35, 35, 35, -1, -1, 
	35, 35, 13, 13, 13, 35, 35, 35, 35, 35, 35, 0, 0, 0, 35
    };
static const ANTLR3_INT32 dfa2_accept[33] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa2_special[33] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 3, 1, -1
    };

/** Used when there is no transition table entry for a particular state */
#define dfa2_T_empty	    NULL

static const ANTLR3_INT32 dfa2_T0[] =
    {
	7, 7, 4, 5, 7, 6, 7, 7, 4, -1, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa2_T1[] =
    {
	-1
    };

static const ANTLR3_INT32 dfa2_T2[] =
    {
	7, 7, 7, 5, 7, 15, 7, 7, 7, -1, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa2_T3[] =
    {
	10, 7, 4, 5, 7, 9, 7, 7, 4, -1, 7, 7, 7, 7, 7, 8, 7, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa2_T4[] =
    {
	31
    };

static const ANTLR3_INT32 dfa2_T5[] =
    {
	7, 7, 13, 5, 7, 14, 7, 7, 13, -1, 7, 7, 7, 7, 7, 19, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa2_T6[] =
    {
	7, 7, 13, 21, 7, 18, 7, 7, 13, -1, 7, 7, 7, 7, 7, 19, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa2_T7[] =
    {
	11
    };

static const ANTLR3_INT32 dfa2_T8[] =
    {
	10, 7, 4, 5, 7, 6, 7, 7, 4, -1, 7, 7, 7, 7, 7, 12, 7, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa2_T9[] =
    {
	7, 7, 7, 20, 7, 15, 7, 7, 7, -1, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa2_T10[] =
    {
	7, 7, 13, 5, 7, 18, 7, 7, 13, -1, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa2_T11[] =
    {
	29
    };

static const ANTLR3_INT32 dfa2_T12[] =
    {
	26, 7, 23, 22, 27, 24, 25, 7, 23, -1, 7, 7, 7, 7, 28, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa2_T13[] =
    {
	3
    };

static const ANTLR3_INT32 dfa2_T14[] =
    {
	30
    };

static const ANTLR3_INT32 dfa2_T15[] =
    {
	1, -1, -1, 2, -1, -1, 1
    };

static const ANTLR3_INT32 dfa2_T16[] =
    {
	7, 7, 7, 5, 7, 32, 7, 7, 7, -1, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa2_T17[] =
    {
	7, 7, 7, 22, 7, 32, 7, 7, 7, -1, 7, 7, 7, 7, 28, 7, 7, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa2_T18[] =
    {
	7, 7, 13, 5, 7, 14, 7, 7, 13, -1, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa2_T19[] =
    {
	7, 7, 7, 5, 7, 7, 7, 7, 7, -1, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7
    };


/* Transition tables are a table of sub tables, with some tables
 * reused for efficiency.
 */
static const ANTLR3_INT32 * const dfa2_transitions[] =
{
    dfa2_T15, dfa2_T13, dfa2_T13, dfa2_T0, dfa2_T3, dfa2_T7, dfa2_T8, dfa2_T19, 
    dfa2_T18, dfa2_T3, dfa2_T2, dfa2_T1, dfa2_T10, dfa2_T5, dfa2_T5, dfa2_T9, 
    NULL, NULL, dfa2_T6, dfa2_T12, dfa2_T11, dfa2_T14, dfa2_T4, dfa2_T12, 
    dfa2_T12, dfa2_T12, dfa2_T12, dfa2_T12, dfa2_T16, dfa2_T1, dfa2_T1, 
    dfa2_T1, dfa2_T17
};

static ANTLR3_INT32 dfa2_sst(pbelle_sdpParser ctx, pANTLR3_BASE_RECOGNIZER recognizer, pANTLR3_INT_STREAM is, pANTLR3_CYCLIC_DFA dfa, ANTLR3_INT32 s)
{
    ANTLR3_INT32    _s;

    _s	    = s;
    switch  (s)
    {
        case 0:

    	{
    	    ANTLR3_UINT32 LA2_29;

    	    ANTLR3_MARKER index2_29;


    		LA2_29 = LA(1);

    	     
    	        index2_29 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(u))) )
    	    {
    	        s = 16;
    	    }

    	    else if ( ((((IS_TOKEN(p)))||((IS_TOKEN(b)))||((IS_TOKEN(e))))) )
    	    {
    	        s = 17;
    	    }

    		 
    			SEEK(index2_29);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;

        case 1:

    	{
    	    ANTLR3_UINT32 LA2_31;

    	    ANTLR3_MARKER index2_31;


    		LA2_31 = LA(1);

    	     
    	        index2_31 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(u))) )
    	    {
    	        s = 16;
    	    }

    	    else if ( ((((IS_TOKEN(p)))||((IS_TOKEN(c)))||((IS_TOKEN(e))))) )
    	    {
    	        s = 17;
    	    }

    		 
    			SEEK(index2_31);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;

        case 2:

    	{
    	    ANTLR3_UINT32 LA2_11;

    	    ANTLR3_MARKER index2_11;


    		LA2_11 = LA(1);

    	     
    	        index2_11 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(u))) )
    	    {
    	        s = 16;
    	    }

    	    else if ( ((((IS_TOKEN(p)))||((IS_TOKEN(e))))) )
    	    {
    	        s = 17;
    	    }

    		 
    			SEEK(index2_11);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;

        case 3:

    	{
    	    ANTLR3_UINT32 LA2_30;

    	    ANTLR3_MARKER index2_30;


    		LA2_30 = LA(1);

    	     
    	        index2_30 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(u))) )
    	    {
    	        s = 16;
    	    }

    	    else if ( ((((IS_TOKEN(p)))||((IS_TOKEN(e)))||((IS_TOKEN(t))))) )
    	    {
    	        s = 17;
    	    }

    		 
    			SEEK(index2_30);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;
    }
    if (BACKTRACKING > 0)
    {
	FAILEDFLAG = ANTLR3_TRUE;
	return	-1;
    }

    CONSTRUCTEX();
    EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
    EXCEPTION->message      = (void *)"109:26: ( uri_field CR LF )?";
    EXCEPTION->decisionNum  = 2;
    EXCEPTION->state        = _s;
    return -1;
}


/* Declare tracking structure for Cyclic DFA 2
 */
static
ANTLR3_CYCLIC_DFA cdfa2
    =	{
	    2,		    /* Decision number of this dfa	    */
	    /* Which decision this represents:   */
	    (const pANTLR3_UCHAR)"109:26: ( uri_field CR LF )?",
	    (CDFA_SPECIAL_FUNC) dfa2_sst,
	    antlr3dfaspecialTransition,		/* DFA specialTransition is currently just a default function in the runtime */
	    antlr3dfapredict,			/* DFA simulator function is in the runtime */
	    dfa2_eot,	    /* EOT table			    */
	    dfa2_eof,	    /* EOF table			    */
	    dfa2_min,	    /* Minimum tokens for each state    */
	    dfa2_max,	    /* Maximum tokens for each state    */
	    dfa2_accept,	/* Accept table			    */
	    dfa2_special,	/* Special transition states	    */
	    dfa2_transitions	/* Table of transition tables	    */

	};
/* End of Cyclic DFA 2
 * ---------------------
 *//** Static dfa state tables for Cyclic dfa:
 *    ()* loopback of 110:26: ( email CR LF )*
 */
static const ANTLR3_INT32 dfa3_eot[33] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa3_eof[33] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa3_min[33] =
    {
	6, 11, 11, 4, 4, 13, 4, 4, 4, 4, 4, 0, 4, 4, 4, 4, -1, -1, 4, 4, 13, 13, 
	13, 4, 4, 4, 4, 4, 4, 0, 0, 0, 4
    };
static const ANTLR3_INT32 dfa3_max[33] =
    {
	12, 11, 11, 35, 35, 13, 35, 35, 35, 35, 35, 0, 35, 35, 35, 35, -1, -1, 
	35, 35, 13, 13, 13, 35, 35, 35, 35, 35, 35, 0, 0, 0, 35
    };
static const ANTLR3_INT32 dfa3_accept[33] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa3_special[33] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2, 1, 3, -1
    };

/** Used when there is no transition table entry for a particular state */
#define dfa3_T_empty	    NULL

static const ANTLR3_INT32 dfa3_T0[] =
    {
	26, 7, 23, 22, 27, 24, 25, 7, 23, -1, 7, 7, 7, 7, 28, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa3_T1[] =
    {
	7, 7, 7, 5, 7, 7, 7, 7, 7, -1, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa3_T2[] =
    {
	7, 7, 7, 5, 7, 15, 7, 7, 7, -1, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa3_T3[] =
    {
	-1
    };

static const ANTLR3_INT32 dfa3_T4[] =
    {
	10, 7, 4, 5, 7, 9, 7, 7, 4, -1, 7, 7, 7, 7, 7, 8, 7, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa3_T5[] =
    {
	7, 7, 13, 5, 7, 14, 7, 7, 13, -1, 7, 7, 7, 7, 7, 19, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa3_T6[] =
    {
	7, 7, 13, 21, 7, 18, 7, 7, 13, -1, 7, 7, 7, 7, 7, 19, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa3_T7[] =
    {
	10, 7, 4, 5, 7, 6, 7, 7, 4, -1, 7, 7, 7, 7, 7, 12, 7, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa3_T8[] =
    {
	7, 7, 7, 20, 7, 15, 7, 7, 7, -1, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa3_T9[] =
    {
	7, 7, 13, 5, 7, 18, 7, 7, 13, -1, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa3_T10[] =
    {
	7, 7, 4, 5, 7, 6, 7, 7, 4, -1, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa3_T11[] =
    {
	31
    };

static const ANTLR3_INT32 dfa3_T12[] =
    {
	11
    };

static const ANTLR3_INT32 dfa3_T13[] =
    {
	29
    };

static const ANTLR3_INT32 dfa3_T14[] =
    {
	3
    };

static const ANTLR3_INT32 dfa3_T15[] =
    {
	1, -1, -1, 2, -1, -1, 1
    };

static const ANTLR3_INT32 dfa3_T16[] =
    {
	7, 7, 7, 5, 7, 32, 7, 7, 7, -1, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa3_T17[] =
    {
	30
    };

static const ANTLR3_INT32 dfa3_T18[] =
    {
	7, 7, 7, 22, 7, 32, 7, 7, 7, -1, 7, 7, 7, 7, 28, 7, 7, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa3_T19[] =
    {
	7, 7, 13, 5, 7, 14, 7, 7, 13, -1, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7
    };


/* Transition tables are a table of sub tables, with some tables
 * reused for efficiency.
 */
static const ANTLR3_INT32 * const dfa3_transitions[] =
{
    dfa3_T15, dfa3_T14, dfa3_T14, dfa3_T10, dfa3_T4, dfa3_T12, dfa3_T7, 
    dfa3_T1, dfa3_T19, dfa3_T4, dfa3_T2, dfa3_T3, dfa3_T9, dfa3_T5, dfa3_T5, 
    dfa3_T8, NULL, NULL, dfa3_T6, dfa3_T0, dfa3_T13, dfa3_T17, dfa3_T11, 
    dfa3_T0, dfa3_T0, dfa3_T0, dfa3_T0, dfa3_T0, dfa3_T16, dfa3_T3, dfa3_T3, 
    dfa3_T3, dfa3_T18
};

static ANTLR3_INT32 dfa3_sst(pbelle_sdpParser ctx, pANTLR3_BASE_RECOGNIZER recognizer, pANTLR3_INT_STREAM is, pANTLR3_CYCLIC_DFA dfa, ANTLR3_INT32 s)
{
    ANTLR3_INT32    _s;

    _s	    = s;
    switch  (s)
    {
        case 0:

    	{
    	    ANTLR3_UINT32 LA3_11;

    	    ANTLR3_MARKER index3_11;


    		LA3_11 = LA(1);

    	     
    	        index3_11 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(e))) )
    	    {
    	        s = 16;
    	    }

    	    else if ( ((IS_TOKEN(p))) )
    	    {
    	        s = 17;
    	    }

    		 
    			SEEK(index3_11);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;

        case 1:

    	{
    	    ANTLR3_UINT32 LA3_30;

    	    ANTLR3_MARKER index3_30;


    		LA3_30 = LA(1);

    	     
    	        index3_30 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(e))) )
    	    {
    	        s = 16;
    	    }

    	    else if ( ((((IS_TOKEN(p)))||((IS_TOKEN(t))))) )
    	    {
    	        s = 17;
    	    }

    		 
    			SEEK(index3_30);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;

        case 2:

    	{
    	    ANTLR3_UINT32 LA3_29;

    	    ANTLR3_MARKER index3_29;


    		LA3_29 = LA(1);

    	     
    	        index3_29 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(e))) )
    	    {
    	        s = 16;
    	    }

    	    else if ( ((((IS_TOKEN(p)))||((IS_TOKEN(b))))) )
    	    {
    	        s = 17;
    	    }

    		 
    			SEEK(index3_29);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;

        case 3:

    	{
    	    ANTLR3_UINT32 LA3_31;

    	    ANTLR3_MARKER index3_31;


    		LA3_31 = LA(1);

    	     
    	        index3_31 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(e))) )
    	    {
    	        s = 16;
    	    }

    	    else if ( ((((IS_TOKEN(p)))||((IS_TOKEN(c))))) )
    	    {
    	        s = 17;
    	    }

    		 
    			SEEK(index3_31);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;
    }
    if (BACKTRACKING > 0)
    {
	FAILEDFLAG = ANTLR3_TRUE;
	return	-1;
    }

    CONSTRUCTEX();
    EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
    EXCEPTION->message      = (void *)"()* loopback of 110:26: ( email CR LF )*";
    EXCEPTION->decisionNum  = 3;
    EXCEPTION->state        = _s;
    return -1;
}


/* Declare tracking structure for Cyclic DFA 3
 */
static
ANTLR3_CYCLIC_DFA cdfa3
    =	{
	    3,		    /* Decision number of this dfa	    */
	    /* Which decision this represents:   */
	    (const pANTLR3_UCHAR)"()* loopback of 110:26: ( email CR LF )*",
	    (CDFA_SPECIAL_FUNC) dfa3_sst,
	    antlr3dfaspecialTransition,		/* DFA specialTransition is currently just a default function in the runtime */
	    antlr3dfapredict,			/* DFA simulator function is in the runtime */
	    dfa3_eot,	    /* EOT table			    */
	    dfa3_eof,	    /* EOF table			    */
	    dfa3_min,	    /* Minimum tokens for each state    */
	    dfa3_max,	    /* Maximum tokens for each state    */
	    dfa3_accept,	/* Accept table			    */
	    dfa3_special,	/* Special transition states	    */
	    dfa3_transitions	/* Table of transition tables	    */

	};
/* End of Cyclic DFA 3
 * ---------------------
 *//** Static dfa state tables for Cyclic dfa:
 *    ()* loopback of 111:26: ( phone_field )*
 */
static const ANTLR3_INT32 dfa4_eot[1007] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa4_eof[1007] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, 29, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 29, -1, -1, -1, -1, 
	-1, 29, -1, -1, -1, -1, -1, 29, -1, -1, -1, -1, -1, -1, -1, -1, 29, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 29, 29, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, 29, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 29, -1, -1, -1, 
	-1, -1, -1, 29, -1, -1, -1, -1, -1, -1, -1, -1, 29, 29, -1, -1, -1, -1, 
	29, -1, 29, -1, -1, -1, -1, -1, -1, 29, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 29, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, 29, -1, 29, -1, -1, -1, -1, -1, -1, -1, 
	29, -1, -1, -1, -1, -1, -1, 29, -1, -1, 29, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 29, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 29, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 29, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, 29, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 29, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 29, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, 29, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, 29, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 29, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 29, -1, -1, 
	-1, -1, 29, 29, -1, -1, -1, -1, -1, -1, -1, -1, -1, 29, 29, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, 29, -1, -1, -1, -1, -1, -1, -1, -1, 29, 
	29, -1, -1, -1, 29, -1, 29, -1, 29, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, 29, -1, -1, 29, 29, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, 29, -1, -1, -1, -1, -1, -1, -1, 29, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 29, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 29, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, 29, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, 29, 29, -1, -1, -1, 29, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 29, 
	29, 29, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 29, -1, -1, -1, -1, 29, 
	-1, -1, 29, -1, 29, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 29, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 29, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 29, -1, -1, 29
    };
static const ANTLR3_INT32 dfa4_min[1007] =
    {
	6, 11, 11, 4, 4, 4, -1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 13, 13, 4, 4, 4, 4, 
	4, 4, 13, 0, 6, 4, 0, -1, 11, 11, 4, 4, 4, 4, 4, 13, 4, 4, 4, 4, 4, 4, 
	4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 13, 4, 4, 4, 4, 4, 4, 13, 4, 4, 4, 
	6, 4, 4, 13, 4, 4, 6, 4, 4, 4, 4, 4, 6, 11, 11, 13, 4, 4, 4, 4, 4, 6, 4, 
	4, 4, 4, 13, 13, 4, 4, 4, 4, 0, 4, 4, 13, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
	4, 4, 4, 4, 4, 4, 6, 6, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
	4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
	4, 4, 4, 4, 4, 13, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 11, 11, 4, 13, 4, 4, 4, 
	4, 4, 4, 4, 4, 4, 13, 4, 4, 13, 6, 4, 4, 4, 4, 4, 4, 6, 4, 4, 13, 4, 4, 
	4, 13, 4, 6, 6, 4, 13, 4, 4, 6, 4, 6, 4, 11, 11, 11, 11, 4, 6, 4, 4, 4, 
	4, 4, 4, 4, 4, 4, 11, 11, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
	4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 13, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
	4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
	4, 4, 4, 4, 4, 4, 13, 13, 13, 4, 4, 4, 4, 13, 4, 4, 4, 6, 4, 4, 4, 13, 
	4, 4, 4, 13, 4, 4, 4, 4, 4, 4, 6, 0, 6, 4, 4, 4, 4, 4, 4, 13, 6, 4, 4, 
	4, 4, 11, 11, 6, 4, 4, 6, 4, 4, 4, 11, 11, 11, 11, 4, 4, 4, 4, 4, 4, 13, 
	4, 13, 4, 4, 4, 4, 6, 13, 4, 4, 4, 11, 11, 13, 4, 4, 4, 4, 13, 4, 4, 4, 
	4, 13, 4, 6, 4, 13, 4, 4, 4, 4, 4, 4, 4, 0, 4, 4, 4, 4, 4, 4, 4, 4, 6, 
	4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 13, 4, 
	6, 4, 4, 4, 13, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 4, 4, 4, 4, 4, 4, 
	4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
	4, 4, 4, 4, 4, 4, 4, 4, 13, 4, 4, 4, 4, 4, 0, 4, 11, 11, 4, 6, 4, 4, 4, 
	4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 13, 
	4, 4, 4, 4, 4, 4, 6, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
	4, 4, 4, 13, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
	4, 6, 4, 4, 4, 4, 13, 4, 4, 4, 13, 4, 4, 4, 4, 4, 6, 4, 4, 4, 4, 4, 4, 
	4, 4, 13, 4, 13, 4, 4, 6, 4, 4, 4, 11, 11, 4, 13, 4, 4, 4, 4, 4, 4, 4, 
	13, 4, 4, 6, 13, 4, 4, 4, 6, 6, 4, 4, 4, 4, 4, 13, 4, 13, 4, 6, 6, 13, 
	11, 11, 4, 4, 4, 4, 13, 4, 4, 4, 6, 4, 4, 4, 4, 4, 4, 4, 13, 6, 6, 13, 
	13, 4, 6, 4, 6, 4, 6, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 13, 4, 4, 4, 4, 4, 
	4, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 13, 4, 4, 
	4, 4, 4, 4, 4, 13, 4, 4, 4, 13, 4, 4, 6, 11, 11, 6, 6, 4, 4, 11, 11, 4, 
	4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
	4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 4, 4, 13, 4, 4, 4, 4, 6, 
	4, 4, 4, 4, 4, 13, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 4, 6, 4, 4, 
	4, 11, 11, 13, 4, 4, 4, 4, 13, 4, 4, 4, 13, 4, 4, 4, 6, 4, 4, 13, 4, 4, 
	4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 4, 4, 
	4, 4, 11, 11, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
	4, 4, 4, 4, 0, 4, 4, 4, 4, 6, 6, 13, 4, 4, 6, 13, 4, 13, 11, 11, 4, 4, 
	4, 4, 4, 4, 4, 13, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 13, 6, 6, 6, 4, 13, 4, 
	13, 4, 4, 4, 4, 4, 4, 6, 4, 4, 4, 4, 6, 4, 4, 6, 4, 6, 4, 13, 4, 4, 4, 
	4, 4, 4, 4, 4, 6, 4, 13, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
	4, 6, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 13, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
	4, 4, 4, 4, 4, 13, 4, 4, 4, 6, 4, 4, 6
    };
static const ANTLR3_INT32 dfa4_max[1007] =
    {
	12, 11, 11, 35, 35, 35, -1, 35, 35, 35, 35, 35, 35, 35, 35, 35, 13, 13, 
	35, 35, 35, 35, 35, 35, 13, 0, 12, 35, 0, -1, 11, 11, 35, 35, 35, 35, 35, 
	13, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
	35, 13, 35, 35, 35, 35, 35, 35, 13, 35, 35, 35, 12, 35, 35, 13, 35, 35, 
	12, 35, 35, 35, 35, 35, 12, 11, 11, 13, 35, 35, 35, 35, 35, 12, 35, 35, 
	35, 35, 13, 13, 35, 35, 35, 35, 0, 35, 35, 13, 35, 35, 35, 35, 35, 35, 
	35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 12, 12, 35, 35, 35, 35, 35, 35, 
	35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
	35, 12, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
	35, 35, 35, 13, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 11, 11, 35, 13, 
	35, 35, 35, 35, 35, 35, 35, 35, 35, 13, 35, 35, 13, 12, 35, 35, 35, 35, 
	35, 35, 12, 35, 35, 13, 35, 35, 35, 13, 35, 12, 12, 35, 13, 35, 35, 12, 
	35, 12, 35, 11, 11, 11, 11, 35, 12, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
	11, 11, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
	35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 13, 35, 35, 35, 35, 
	35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
	35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 13, 
	13, 13, 35, 35, 35, 35, 13, 35, 35, 35, 12, 35, 35, 35, 13, 35, 35, 35, 
	13, 35, 35, 35, 35, 35, 35, 12, 0, 12, 35, 35, 35, 35, 35, 35, 13, 12, 
	35, 35, 35, 35, 11, 11, 12, 35, 35, 12, 35, 35, 35, 11, 11, 11, 11, 35, 
	35, 35, 35, 35, 35, 13, 35, 13, 35, 35, 35, 35, 12, 13, 35, 35, 35, 11, 
	11, 13, 35, 35, 35, 35, 13, 35, 35, 35, 35, 13, 35, 12, 35, 13, 35, 35, 
	35, 35, 35, 35, 35, 0, 35, 35, 35, 35, 35, 35, 35, 35, 12, 35, 35, 35, 
	35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
	35, 13, 35, 12, 35, 35, 35, 13, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
	35, 35, 0, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
	35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
	35, 35, 35, 35, 35, 13, 35, 35, 35, 35, 35, 0, 35, 11, 11, 35, 12, 35, 
	35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
	35, 35, 35, 35, 35, 35, 35, 13, 35, 35, 35, 35, 35, 35, 12, 35, 35, 35, 
	35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 13, 
	35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
	35, 35, 35, 12, 35, 35, 35, 35, 13, 35, 35, 35, 13, 35, 35, 35, 35, 35, 
	12, 35, 35, 35, 35, 35, 35, 35, 35, 13, 35, 13, 35, 35, 12, 35, 35, 35, 
	11, 11, 35, 13, 35, 35, 35, 35, 35, 35, 35, 13, 35, 35, 12, 13, 35, 35, 
	35, 12, 12, 35, 35, 35, 35, 35, 13, 35, 13, 35, 12, 12, 13, 11, 11, 35, 
	35, 35, 35, 13, 35, 35, 35, 12, 35, 35, 35, 35, 35, 35, 35, 13, 12, 12, 
	13, 13, 35, 12, 35, 12, 35, 12, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
	13, 35, 35, 35, 35, 35, 35, 0, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
	35, 35, 35, 35, 35, 35, 35, 35, 35, 13, 35, 35, 35, 35, 35, 35, 35, 13, 
	35, 35, 35, 13, 35, 35, 12, 11, 11, 12, 12, 35, 35, 11, 11, 35, 35, 35, 
	35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
	35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
	35, 12, 35, 35, 13, 35, 35, 35, 35, 12, 35, 35, 35, 35, 35, 13, 35, 35, 
	35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 0, 35, 12, 35, 35, 35, 11, 
	11, 13, 35, 35, 35, 35, 13, 35, 35, 35, 13, 35, 35, 35, 12, 35, 35, 13, 
	35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
	35, 35, 35, 35, 35, 12, 35, 35, 35, 35, 11, 11, 35, 35, 35, 35, 35, 35, 
	35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 0, 
	35, 35, 35, 35, 12, 12, 13, 35, 35, 12, 13, 35, 13, 11, 11, 35, 35, 35, 
	35, 35, 35, 35, 13, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 13, 12, 12, 
	12, 35, 13, 35, 13, 35, 35, 35, 35, 35, 35, 12, 35, 35, 35, 35, 12, 35, 
	35, 12, 35, 12, 35, 13, 35, 35, 35, 35, 35, 35, 35, 35, 12, 35, 13, 35, 
	35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 12, 35, 
	35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 13, 35, 35, 35, 35, 35, 35, 
	35, 35, 35, 35, 35, 35, 35, 35, 13, 35, 35, 35, 12, 35, 35, 12
    };
static const ANTLR3_INT32 dfa4_accept[1007] =
    {
	-1, -1, -1, -1, -1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa4_special[1007] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, 3, -1, -1, 8, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
    };

/** Used when there is no transition table entry for a particular state */
#define dfa4_T_empty	    NULL

static const ANTLR3_INT32 dfa4_T0[] =
    {
	781, 6, 782, 779, 703, 783, 704, 6, 782, -1, 6, 6, 6, 6, 6, 6, 701, 6, 
	695, 696, 697, 699, 698, 702, 700, 705, 706, 707, 708, 709, 710, 711
    };

static const ANTLR3_INT32 dfa4_T1[] =
    {
	54, 54, 191, 193, 157, 192, 158, 54, 191, -1, 54, 54, 54, 54, 54, 167, 
	155, 54, 149, 150, 151, 153, 152, 156, 154, 159, 160, 161, 162, 163, 164, 
	165
    };

static const ANTLR3_INT32 dfa4_T2[] =
    {
	433, 433, 611, 434, 433, 610, 433, 433, 611, -1, 433, 433, 433, 433, 648, 
	649, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 
	433, 433
    };

static const ANTLR3_INT32 dfa4_T3[] =
    {
	627
    };

static const ANTLR3_INT32 dfa4_T4[] =
    {
	728, -1, -1, 729, -1, -1, 728
    };

static const ANTLR3_INT32 dfa4_T5[] =
    {
	113, 54, 111, 102, 114, 110, 112, 54, 111, -1, 54, 54, 54, 54, 115, 117, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T6[] =
    {
	407, 285, 405, 394, 408, 404, 406, 285, 405, -1, 285, 285, 285, 285, 409, 
	410, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T7[] =
    {
	810, -1, -1, 811, -1, -1, 810
    };

static const ANTLR3_INT32 dfa4_T8[] =
    {
	796, 796, 796, 558, 796, 853, 796, 796, 796, -1, 796, 796, 796, 796, 796, 
	827, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 
	796, 796
    };

static const ANTLR3_INT32 dfa4_T9[] =
    {
	887
    };

static const ANTLR3_INT32 dfa4_T10[] =
    {
	234, 234, 234, 6, 234, 234, 234, 234, 234, -1, 234, 234, 234, 234, 234, 
	228, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 
	234, 234
    };

static const ANTLR3_INT32 dfa4_T11[] =
    {
	559, 559, 559, 558, 559, 559, 559, 559, 559, -1, 559, 559, 559, 559, 559, 
	559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T12[] =
    {
	433, 433, 414, 434, 424, 415, 425, 433, 414, -1, 433, 433, 433, 433, 433, 
	433, 422, 433, 416, 417, 418, 420, 419, 423, 421, 426, 427, 428, 429, 430, 
	431, 432
    };

static const ANTLR3_INT32 dfa4_T13[] =
    {
	358, -1, -1, 359, -1, -1, 358
    };

static const ANTLR3_INT32 dfa4_T14[] =
    {
	179, 6, 124, 180, 134, 125, 135, 6, 124, -1, 6, 6, 6, 6, 6, 183, 132, 6, 
	126, 127, 128, 130, 129, 133, 131, 136, 137, 138, 139, 140, 141, 142
    };

static const ANTLR3_INT32 dfa4_T15[] =
    {
	584, 433, 911, 585, 464, 931, 465, 433, 911, -1, 433, 433, 433, 433, 433, 
	913, 462, 433, 456, 457, 458, 460, 459, 463, 461, 466, 467, 468, 469, 470, 
	471, 472
    };

static const ANTLR3_INT32 dfa4_T16[] =
    {
	285, 285, 599, 366, 285, 598, 285, 285, 599, -1, 285, 285, 285, 285, 285, 
	365, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T17[] =
    {
	57, 54, 59, 56, 45, 60, 46, 54, 59, -1, 54, 54, 54, 54, 54, 58, 43, 54, 
	36, 38, 39, 41, 40, 44, 42, 47, 48, 49, 50, 51, 52, 53
    };

static const ANTLR3_INT32 dfa4_T18[] =
    {
	793, 796, 826, 828, 794, 829, 792, 796, 826, -1, 796, 796, 796, 796, 795, 
	827, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 
	796, 796
    };

static const ANTLR3_INT32 dfa4_T19[] =
    {
	285, 285, 528, 341, 526, 527, 285, 285, 528, -1, 285, 285, 285, 285, 285, 
	340, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T20[] =
    {
	559, 559, 559, 558, 559, 805, 559, 559, 559, -1, 559, 559, 559, 559, 559, 
	559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T21[] =
    {
	559, 559, 559, 558, 559, 805, 559, 559, 559, -1, 559, 559, 559, 559, 559, 
	856, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T22[] =
    {
	54, 54, 86, 70, 54, 87, 54, 54, 86, -1, 54, 54, 54, 54, 54, 85, 54, 54, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T23[] =
    {
	234, 234, 234, 6, 234, 261, 234, 234, 234, -1, 234, 234, 234, 234, 234, 
	228, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 
	234, 234
    };

static const ANTLR3_INT32 dfa4_T24[] =
    {
	689, 433, 686, 685, 690, 687, 688, 433, 686, -1, 433, 433, 433, 433, 691, 
	433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 
	433, 433
    };

static const ANTLR3_INT32 dfa4_T25[] =
    {
	559, 559, 559, 558, 559, 1005, 559, 559, 559, -1, 559, 559, 559, 559, 559, 
	559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T26[] =
    {
	318, 285, 319, 313, 275, 320, 276, 285, 319, -1, 285, 285, 285, 285, 285, 
	285, 273, 285, 267, 268, 269, 271, 270, 274, 272, 277, 278, 279, 280, 281, 
	282, 283
    };

static const ANTLR3_INT32 dfa4_T27[] =
    {
	591, 305, 473, 589, 483, 474, 484, 305, 473, -1, 305, 305, 305, 305, 305, 
	328, 481, 305, 475, 476, 477, 479, 478, 482, 480, 485, 486, 487, 488, 489, 
	490, 491
    };

static const ANTLR3_INT32 dfa4_T28[] =
    {
	646, -1, -1, 647, -1, -1, 646
    };

static const ANTLR3_INT32 dfa4_T29[] =
    {
	54, 54, 54, 93, 54, 54, 54, 54, 54, -1, 54, 54, 54, 54, 54, 92, 54, 54, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T30[] =
    {
	615, 559, 946, 616, 548, 947, 549, 559, 946, -1, 559, 559, 559, 559, 559, 
	948, 546, 559, 540, 541, 542, 544, 543, 547, 545, 550, 551, 552, 553, 554, 
	555, 556
    };

static const ANTLR3_INT32 dfa4_T31[] =
    {
	411
    };

static const ANTLR3_INT32 dfa4_T32[] =
    {
	179, 6, 124, 180, 134, 181, 135, 6, 124, -1, 6, 6, 6, 6, 6, 182, 132, 6, 
	126, 127, 128, 130, 129, 133, 131, 136, 137, 138, 139, 140, 141, 142
    };

static const ANTLR3_INT32 dfa4_T33[] =
    {
	285, 285, 361, 266, 285, 371, 285, 285, 361, -1, 285, 285, 285, 285, 285, 
	389, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T34[] =
    {
	54, 54, 191, 193, 157, 195, 158, 54, 191, -1, 54, 54, 54, 54, 54, 167, 
	155, 54, 149, 150, 151, 153, 152, 156, 154, 159, 160, 161, 162, 163, 164, 
	165
    };

static const ANTLR3_INT32 dfa4_T35[] =
    {
	559, 559, 559, 558, 559, 854, 559, 559, 559, -1, 559, 559, 559, 559, 559, 
	559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T36[] =
    {
	402
    };

static const ANTLR3_INT32 dfa4_T37[] =
    {
	433, 433, 757, 434, 766, 756, 767, 433, 757, -1, 433, 433, 433, 433, 433, 
	433, 764, 433, 758, 759, 760, 762, 761, 765, 763, 768, 769, 770, 771, 772, 
	773, 774
    };

static const ANTLR3_INT32 dfa4_T38[] =
    {
	54, 54, 207, 93, 189, 263, 158, 54, 207, -1, 54, 54, 54, 54, 54, 92, 155, 
	54, 149, 150, 151, 153, 152, 156, 154, 159, 160, 161, 162, 163, 164, 165
    };

static const ANTLR3_INT32 dfa4_T39[] =
    {
	433, 433, 454, 434, 464, 455, 465, 433, 454, -1, 433, 433, 433, 433, 433, 
	433, 462, 433, 456, 457, 458, 460, 459, 463, 461, 466, 467, 468, 469, 470, 
	471, 472
    };

static const ANTLR3_INT32 dfa4_T40[] =
    {
	621, 559, 622, 616, 548, 623, 549, 559, 622, -1, 559, 559, 559, 559, 559, 
	559, 546, 559, 540, 541, 542, 544, 543, 547, 545, 550, 551, 552, 553, 554, 
	555, 556
    };

static const ANTLR3_INT32 dfa4_T41[] =
    {
	54, 54, 191, 190, 157, 192, 158, 54, 191, -1, 54, 54, 54, 54, 54, 103, 
	155, 54, 149, 150, 151, 153, 152, 156, 154, 159, 160, 161, 162, 163, 164, 
	165
    };

static const ANTLR3_INT32 dfa4_T42[] =
    {
	54, 54, 191, 193, 157, 219, 158, 54, 191, -1, 54, 54, 54, 54, 54, 237, 
	155, 54, 149, 150, 151, 153, 152, 156, 154, 159, 160, 161, 162, 163, 164, 
	165
    };

static const ANTLR3_INT32 dfa4_T43[] =
    {
	591, 305, 473, 589, 483, 590, 484, 305, 473, -1, 305, 305, 305, 305, 305, 
	327, 481, 305, 475, 476, 477, 479, 478, 482, 480, 485, 486, 487, 488, 489, 
	490, 491
    };

static const ANTLR3_INT32 dfa4_T44[] =
    {
	920
    };

static const ANTLR3_INT32 dfa4_T45[] =
    {
	684, 684, 684, 953, 684, 972, 684, 684, 684, -1, 684, 684, 684, 684, 958, 
	678, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 
	684, 684
    };

static const ANTLR3_INT32 dfa4_T46[] =
    {
	734, -1, -1, 735, -1, -1, 734
    };

static const ANTLR3_INT32 dfa4_T47[] =
    {
	401, 401, 401, 492, 401, 523, 401, 401, 401, -1, 401, 401, 401, 401, 400, 
	494, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 
	401, 401
    };

static const ANTLR3_INT32 dfa4_T48[] =
    {
	684, 684, 684, 434, 684, 684, 684, 684, 684, -1, 684, 684, 684, 684, 684, 
	678, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 
	684, 684
    };

static const ANTLR3_INT32 dfa4_T49[] =
    {
	886, 886, 886, 817, 886, 885, 886, 886, 886, -1, 886, 886, 886, 886, 886, 
	886, 886, 886, 886, 886, 886, 886, 886, 886, 886, 886, 886, 886, 886, 886, 
	886, 886
    };

static const ANTLR3_INT32 dfa4_T50[] =
    {
	6, 6, 6, 6, 6, 27, 6, 6, 6, -1, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 
	6, 6, 6, 6, 6, 6, 6, 6, 6
    };

static const ANTLR3_INT32 dfa4_T51[] =
    {
	608, 608, 608, 645, 608, 607, 608, 608, 608, -1, 608, 608, 608, 608, 608, 
	608, 608, 608, 608, 608, 608, 608, 608, 608, 608, 608, 608, 608, 608, 608, 
	608, 608
    };

static const ANTLR3_INT32 dfa4_T52[] =
    {
	580
    };

static const ANTLR3_INT32 dfa4_T53[] =
    {
	559, 559, 722, 724, 559, 721, 559, 559, 722, -1, 559, 559, 559, 559, 559, 
	723, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T54[] =
    {
	54, 54, 86, 37, 54, 87, 54, 54, 86, -1, 54, 54, 54, 54, 54, 116, 54, 54, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T55[] =
    {
	987, 796, 985, 984, 988, 983, 986, 796, 985, -1, 796, 796, 796, 796, 989, 
	789, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 
	796, 796
    };

static const ANTLR3_INT32 dfa4_T56[] =
    {
	435
    };

static const ANTLR3_INT32 dfa4_T57[] =
    {
	644
    };

static const ANTLR3_INT32 dfa4_T58[] =
    {
	235, -1, -1, 236, -1, -1, 235
    };

static const ANTLR3_INT32 dfa4_T59[] =
    {
	433, 433, 933, 652, 433, 934, 433, 433, 933, -1, 433, 433, 433, 433, 648, 
	943, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 
	433, 433
    };

static const ANTLR3_INT32 dfa4_T60[] =
    {
	635, 635, 635, 589, 635, 635, 635, 635, 635, -1, 635, 635, 635, 635, 635, 
	635, 635, 635, 635, 635, 635, 635, 635, 635, 635, 635, 635, 635, 635, 635, 
	635, 635
    };

static const ANTLR3_INT32 dfa4_T61[] =
    {
	238
    };

static const ANTLR3_INT32 dfa4_T62[] =
    {
	559, 559, 967, 624, 559, 966, 559, 559, 967, -1, 559, 559, 559, 559, 715, 
	976, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T63[] =
    {
	220, -1, -1, 221, -1, -1, 220
    };

static const ANTLR3_INT32 dfa4_T64[] =
    {
	559, 559, 626, 624, 559, 625, 559, 559, 626, -1, 559, 559, 559, 559, 559, 
	557, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T65[] =
    {
	559, 559, 891, 895, 843, 894, 844, 559, 891, -1, 559, 559, 559, 559, 559, 
	827, 841, 559, 835, 836, 837, 839, 838, 842, 840, 845, 846, 847, 848, 849, 
	850, 851
    };

static const ANTLR3_INT32 dfa4_T66[] =
    {
	987, 796, 985, 984, 988, 996, 986, 796, 985, -1, 796, 796, 796, 796, 989, 
	855, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 
	796, 796
    };

static const ANTLR3_INT32 dfa4_T67[] =
    {
	559, 559, 559, 558, 559, 787, 559, 559, 559, -1, 559, 559, 559, 559, 559, 
	832, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T68[] =
    {
	818, 6, 819, 817, 746, 820, 747, 6, 819, -1, 6, 6, 6, 6, 6, 6, 744, 6, 
	738, 739, 740, 742, 741, 745, 743, 748, 749, 750, 751, 752, 753, 754
    };

static const ANTLR3_INT32 dfa4_T69[] =
    {
	305, 305, 562, 628, 571, 629, 572, 305, 562, -1, 305, 305, 305, 305, 305, 
	439, 569, 305, 563, 564, 565, 567, 566, 570, 568, 573, 574, 575, 576, 577, 
	578, 579
    };

static const ANTLR3_INT32 dfa4_T70[] =
    {
	529, 433, 414, 530, 424, 531, 425, 433, 414, -1, 433, 433, 433, 433, 433, 
	532, 422, 433, 416, 417, 418, 420, 419, 423, 421, 426, 427, 428, 429, 430, 
	431, 432
    };

static const ANTLR3_INT32 dfa4_T71[] =
    {
	793, 796, 791, 790, 794, 788, 792, 796, 791, -1, 796, 796, 796, 796, 795, 
	789, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 
	796, 796
    };

static const ANTLR3_INT32 dfa4_T72[] =
    {
	433, 433, 433, 953, 433, 973, 433, 433, 433, -1, 433, 433, 433, 433, 964, 
	433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 
	433, 433
    };

static const ANTLR3_INT32 dfa4_T73[] =
    {
	730
    };

static const ANTLR3_INT32 dfa4_T74[] =
    {
	655, 655, 655, 616, 655, 654, 655, 655, 655, -1, 655, 655, 655, 655, 655, 
	655, 655, 655, 655, 655, 655, 655, 655, 655, 655, 655, 655, 655, 655, 655, 
	655, 655
    };

static const ANTLR3_INT32 dfa4_T75[] =
    {
	559, 559, 626, 624, 559, 726, 559, 559, 626, -1, 559, 559, 559, 559, 559, 
	557, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T76[] =
    {
	285, 285, 285, 492, 285, 525, 285, 285, 285, -1, 285, 285, 285, 285, 409, 
	285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T77[] =
    {
	529, 433, 883, 530, 424, 884, 425, 433, 883, -1, 433, 433, 433, 433, 433, 
	915, 422, 433, 416, 417, 418, 420, 419, 423, 421, 426, 427, 428, 429, 430, 
	431, 432
    };

static const ANTLR3_INT32 dfa4_T78[] =
    {
	559, 559, 559, 624, 559, 559, 559, 559, 559, -1, 559, 559, 559, 559, 559, 
	557, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T79[] =
    {
	210
    };

static const ANTLR3_INT32 dfa4_T80[] =
    {
	285, 285, 603, 641, 514, 602, 515, 285, 603, -1, 285, 285, 285, 285, 285, 
	642, 512, 285, 506, 507, 508, 510, 509, 513, 511, 516, 517, 518, 519, 520, 
	521, 522
    };

static const ANTLR3_INT32 dfa4_T81[] =
    {
	352
    };

static const ANTLR3_INT32 dfa4_T82[] =
    {
	54, 54, 191, 208, 157, 192, 158, 54, 191, -1, 54, 54, 54, 54, 54, 209, 
	155, 54, 149, 150, 151, 153, 152, 156, 154, 159, 160, 161, 162, 163, 164, 
	165
    };

static const ANTLR3_INT32 dfa4_T83[] =
    {
	218
    };

static const ANTLR3_INT32 dfa4_T84[] =
    {
	613, -1, -1, 614, -1, -1, 613
    };

static const ANTLR3_INT32 dfa4_T85[] =
    {
	793, 796, 791, 790, 794, 803, 792, 796, 791, -1, 796, 796, 796, 796, 795, 
	789, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 
	796, 796
    };

static const ANTLR3_INT32 dfa4_T86[] =
    {
	433, 433, 433, 434, 433, 676, 433, 433, 433, -1, 433, 433, 433, 433, 433, 
	433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 
	433, 433
    };

static const ANTLR3_INT32 dfa4_T87[] =
    {
	1006
    };

static const ANTLR3_INT32 dfa4_T88[] =
    {
	3
    };

static const ANTLR3_INT32 dfa4_T89[] =
    {
	615, 559, 538, 616, 548, 539, 549, 559, 538, -1, 559, 559, 559, 559, 559, 
	620, 546, 559, 540, 541, 542, 544, 543, 547, 545, 550, 551, 552, 553, 554, 
	555, 556
    };

static const ANTLR3_INT32 dfa4_T90[] =
    {
	993, 559, 991, 984, 994, 990, 992, 559, 991, -1, 559, 559, 559, 559, 995, 
	557, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T91[] =
    {
	54, 54, 906, 37, 872, 927, 873, 54, 906, -1, 54, 54, 54, 54, 54, 54, 870, 
	54, 864, 865, 866, 868, 867, 871, 869, 874, 875, 876, 877, 878, 879, 880
    };

static const ANTLR3_INT32 dfa4_T92[] =
    {
	882
    };

static const ANTLR3_INT32 dfa4_T93[] =
    {
	344, 344, 344, 313, 344, 344, 344, 344, 344, -1, 344, 344, 344, 344, 344, 
	344, 344, 344, 344, 344, 344, 344, 344, 344, 344, 344, 344, 344, 344, 344, 
	344, 344
    };

static const ANTLR3_INT32 dfa4_T94[] =
    {
	6, 6, 6, 6, 6, 13, 6, 6, 6, -1, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 
	6, 6, 6, 6, 6, 6, 6, 6, 6
    };

static const ANTLR3_INT32 dfa4_T95[] =
    {
	665
    };

static const ANTLR3_INT32 dfa4_T96[] =
    {
	398, 401, 493, 492, 399, 495, 397, 401, 493, -1, 401, 401, 401, 401, 400, 
	494, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 
	401, 401
    };

static const ANTLR3_INT32 dfa4_T97[] =
    {
	608, 608, 608, 530, 608, 608, 608, 608, 608, -1, 608, 608, 608, 608, 608, 
	608, 608, 608, 608, 608, 608, 608, 608, 608, 608, 608, 608, 608, 608, 608, 
	608, 608
    };

static const ANTLR3_INT32 dfa4_T98[] =
    {
	586, 433, 587, 585, 464, 588, 465, 433, 587, -1, 433, 433, 433, 433, 433, 
	433, 462, 433, 456, 457, 458, 460, 459, 463, 461, 466, 467, 468, 469, 470, 
	471, 472
    };

static const ANTLR3_INT32 dfa4_T99[] =
    {
	935
    };

static const ANTLR3_INT32 dfa4_T100[] =
    {
	806
    };

static const ANTLR3_INT32 dfa4_T101[] =
    {
	54, 54, 54, 70, 54, 54, 54, 54, 54, -1, 54, 54, 54, 54, 54, 71, 54, 54, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T102[] =
    {
	6, 6, 6, 6, 6, 226, 6, 6, 6, -1, 6, 6, 6, 6, 6, 241, 6, 6, 6, 6, 6, 6, 
	6, 6, 6, 6, 6, 6, 6, 6, 6, 6
    };

static const ANTLR3_INT32 dfa4_T103[] =
    {
	6, 6, 243, 308, 252, 309, 253, 6, 243, -1, 6, 6, 6, 6, 6, 228, 250, 6, 
	244, 245, 246, 248, 247, 251, 249, 254, 255, 256, 257, 258, 259, 260
    };

static const ANTLR3_INT32 dfa4_T104[] =
    {
	631, 631, 631, 667, 631, 630, 631, 631, 631, -1, 631, 631, 631, 631, 631, 
	631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 
	631, 631
    };

static const ANTLR3_INT32 dfa4_T105[] =
    {
	54, 54, 188, 70, 189, 187, 158, 54, 188, -1, 54, 54, 54, 54, 54, 71, 155, 
	54, 149, 150, 151, 153, 152, 156, 154, 159, 160, 161, 162, 163, 164, 165
    };

static const ANTLR3_INT32 dfa4_T106[] =
    {
	993, 559, 991, 984, 994, 997, 992, 559, 991, -1, 559, 559, 559, 559, 995, 
	808, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T107[] =
    {
	929, 929, 929, 942, 929, 928, 929, 929, 929, -1, 929, 929, 929, 929, 929, 
	929, 929, 929, 929, 929, 929, 929, 929, 929, 929, 929, 929, 929, 929, 929, 
	929, 929
    };

static const ANTLR3_INT32 dfa4_T108[] =
    {
	529, 433, 883, 530, 424, 914, 425, 433, 883, -1, 433, 433, 433, 433, 433, 
	913, 422, 433, 416, 417, 418, 420, 419, 423, 421, 426, 427, 428, 429, 430, 
	431, 432
    };

static const ANTLR3_INT32 dfa4_T109[] =
    {
	222, -1, -1, 223, -1, -1, 222
    };

static const ANTLR3_INT32 dfa4_T110[] =
    {
	285, 285, 361, 321, 285, 371, 285, 285, 361, -1, 285, 285, 285, 285, 285, 
	376, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T111[] =
    {
	800, 559, 830, 828, 801, 831, 799, 559, 830, -1, 559, 559, 559, 559, 802, 
	559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T112[] =
    {
	930
    };

static const ANTLR3_INT32 dfa4_T113[] =
    {
	54, 54, 91, 93, 54, 90, 54, 54, 91, -1, 54, 54, 54, 54, 54, 92, 54, 54, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T114[] =
    {
	285, 285, 323, 321, 285, 322, 285, 285, 323, -1, 285, 285, 285, 285, 285, 
	284, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T115[] =
    {
	184, 6, 185, 180, 134, 186, 135, 6, 185, -1, 6, 6, 6, 6, 6, 6, 132, 6, 
	126, 127, 128, 130, 129, 133, 131, 136, 137, 138, 139, 140, 141, 142
    };

static const ANTLR3_INT32 dfa4_T116[] =
    {
	285, 285, 361, 266, 285, 362, 285, 285, 361, -1, 285, 285, 285, 285, 285, 
	285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T117[] =
    {
	559, 559, 714, 812, 559, 732, 559, 559, 714, -1, 559, 559, 559, 559, 715, 
	785, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T118[] =
    {
	285, 285, 323, 321, 285, 372, 285, 285, 323, -1, 285, 285, 285, 285, 285, 
	410, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T119[] =
    {
	559, 559, 975, 664, 559, 978, 559, 559, 975, -1, 559, 559, 559, 559, 559, 
	980, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T120[] =
    {
	684, 684, 684, 434, 684, 972, 684, 684, 684, -1, 684, 684, 684, 684, 684, 
	678, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 
	684, 684
    };

static const ANTLR3_INT32 dfa4_T121[] =
    {
	559, 559, 662, 720, 559, 660, 559, 559, 662, -1, 559, 559, 559, 559, 715, 
	719, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T122[] =
    {
	285, 285, 361, 266, 285, 360, 285, 285, 361, -1, 285, 285, 285, 285, 285, 
	285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T123[] =
    {
	105, 108, 144, 166, 106, 145, 104, 108, 144, -1, 108, 108, 108, 108, 107, 
	167, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 
	108, 108
    };

static const ANTLR3_INT32 dfa4_T124[] =
    {
	54, 54, 59, 37, 45, 212, 46, 54, 59, -1, 54, 54, 54, 54, 54, 54, 43, 54, 
	36, 38, 39, 41, 40, 44, 42, 47, 48, 49, 50, 51, 52, 53
    };

static const ANTLR3_INT32 dfa4_T125[] =
    {
	615, 559, 617, 616, 548, 636, 549, 559, 617, -1, 559, 559, 559, 559, 559, 
	669, 546, 559, 540, 541, 542, 544, 543, 547, 545, 550, 551, 552, 553, 554, 
	555, 556
    };

static const ANTLR3_INT32 dfa4_T126[] =
    {
	559, 559, 559, 724, 559, 559, 559, 559, 559, -1, 559, 559, 559, 559, 559, 
	723, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T127[] =
    {
	-1
    };

static const ANTLR3_INT32 dfa4_T128[] =
    {
	305, 305, 286, 306, 296, 287, 297, 305, 286, -1, 305, 305, 305, 305, 305, 
	305, 294, 305, 288, 289, 290, 292, 291, 295, 293, 298, 299, 300, 301, 302, 
	303, 304
    };

static const ANTLR3_INT32 dfa4_T129[] =
    {
	407, 285, 496, 492, 408, 497, 406, 285, 496, -1, 285, 285, 285, 285, 409, 
	285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T130[] =
    {
	54, 54, 86, 63, 54, 87, 54, 54, 86, -1, 54, 54, 54, 54, 54, 96, 54, 54, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T131[] =
    {
	559, 559, 891, 895, 843, 890, 844, 559, 891, -1, 559, 559, 559, 559, 559, 
	827, 841, 559, 835, 836, 837, 839, 838, 842, 840, 845, 846, 847, 848, 849, 
	850, 851
    };

static const ANTLR3_INT32 dfa4_T132[] =
    {
	347, -1, -1, 348, -1, -1, 347
    };

static const ANTLR3_INT32 dfa4_T133[] =
    {
	684, 684, 684, 434, 684, 775, 684, 684, 684, -1, 684, 684, 684, 684, 684, 
	678, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 
	684, 684
    };

static const ANTLR3_INT32 dfa4_T134[] =
    {
	54, 54, 86, 37, 54, 240, 54, 54, 86, -1, 54, 54, 54, 54, 54, 54, 54, 54, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T135[] =
    {
	584, 433, 911, 585, 464, 912, 465, 433, 911, -1, 433, 433, 433, 433, 433, 
	915, 462, 433, 456, 457, 458, 460, 459, 463, 461, 466, 467, 468, 469, 470, 
	471, 472
    };

static const ANTLR3_INT32 dfa4_T136[] =
    {
	433, 433, 433, 434, 433, 433, 433, 433, 433, -1, 433, 433, 433, 433, 433, 
	433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 
	433, 433
    };

static const ANTLR3_INT32 dfa4_T137[] =
    {
	559, 559, 925, 724, 900, 970, 844, 559, 925, -1, 559, 559, 559, 559, 559, 
	723, 841, 559, 835, 836, 837, 839, 838, 842, 840, 845, 846, 847, 848, 849, 
	850, 851
    };

static const ANTLR3_INT32 dfa4_T138[] =
    {
	177, -1, -1, 178, -1, -1, 177
    };

static const ANTLR3_INT32 dfa4_T139[] =
    {
	54, 54, 197, 93, 175, 196, 54, 54, 197, -1, 54, 54, 54, 54, 54, 92, 54, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T140[] =
    {
	30, -1, -1, 31, -1, -1, 30
    };

static const ANTLR3_INT32 dfa4_T141[] =
    {
	559, 559, 891, 895, 843, 941, 844, 559, 891, -1, 559, 559, 559, 559, 559, 
	950, 841, 559, 835, 836, 837, 839, 838, 842, 840, 845, 846, 847, 848, 849, 
	850, 851
    };

static const ANTLR3_INT32 dfa4_T142[] =
    {
	559, 559, 891, 893, 843, 894, 844, 559, 891, -1, 559, 559, 559, 559, 559, 
	789, 841, 559, 835, 836, 837, 839, 838, 842, 840, 845, 846, 847, 848, 849, 
	850, 851
    };

static const ANTLR3_INT32 dfa4_T143[] =
    {
	54, 54, 174, 70, 54, 173, 54, 54, 174, -1, 54, 54, 54, 54, 54, 71, 54, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T144[] =
    {
	615, 559, 617, 616, 548, 618, 549, 559, 617, -1, 559, 559, 559, 559, 559, 
	657, 546, 559, 540, 541, 542, 544, 543, 547, 545, 550, 551, 552, 553, 554, 
	555, 556
    };

static const ANTLR3_INT32 dfa4_T145[] =
    {
	681, 684, 677, 685, 682, 679, 680, 684, 677, -1, 684, 684, 684, 684, 683, 
	678, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 
	684, 684
    };

static const ANTLR3_INT32 dfa4_T146[] =
    {
	54, 54, 86, 37, 54, 97, 54, 54, 86, -1, 54, 54, 54, 54, 54, 54, 54, 54, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T147[] =
    {
	559, 559, 936, 558, 548, 937, 549, 559, 936, -1, 559, 559, 559, 559, 559, 
	557, 546, 559, 540, 541, 542, 544, 543, 547, 545, 550, 551, 552, 553, 554, 
	555, 556
    };

static const ANTLR3_INT32 dfa4_T148[] =
    {
	433, 433, 433, 434, 433, 973, 433, 433, 433, -1, 433, 433, 433, 433, 433, 
	433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 
	433, 433
    };

static const ANTLR3_INT32 dfa4_T149[] =
    {
	285, 285, 339, 341, 337, 338, 285, 285, 339, -1, 285, 285, 285, 285, 285, 
	340, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T150[] =
    {
	329, 305, 330, 325, 296, 331, 297, 305, 330, -1, 305, 305, 305, 305, 305, 
	305, 294, 305, 288, 289, 290, 292, 291, 295, 293, 298, 299, 300, 301, 302, 
	303, 304
    };

static const ANTLR3_INT32 dfa4_T151[] =
    {
	113, 54, 170, 166, 114, 171, 112, 54, 170, -1, 54, 54, 54, 54, 115, 54, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T152[] =
    {
	584, 433, 454, 585, 464, 583, 465, 433, 454, -1, 433, 433, 433, 433, 433, 
	532, 462, 433, 456, 457, 458, 460, 459, 463, 461, 466, 467, 468, 469, 470, 
	471, 472
    };

static const ANTLR3_INT32 dfa4_T153[] =
    {
	54, 54, 191, 204, 157, 192, 158, 54, 191, -1, 54, 54, 54, 54, 54, 205, 
	155, 54, 149, 150, 151, 153, 152, 156, 154, 159, 160, 161, 162, 163, 164, 
	165
    };

static const ANTLR3_INT32 dfa4_T154[] =
    {
	559, 559, 975, 558, 559, 978, 559, 559, 975, -1, 559, 559, 559, 559, 559, 
	982, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T155[] =
    {
	595
    };

static const ANTLR3_INT32 dfa4_T156[] =
    {
	305, 305, 473, 306, 483, 474, 484, 305, 473, -1, 305, 305, 305, 305, 305, 
	305, 481, 305, 475, 476, 477, 479, 478, 482, 480, 485, 486, 487, 488, 489, 
	490, 491
    };

static const ANTLR3_INT32 dfa4_T157[] =
    {
	54, 54, 86, 37, 54, 97, 54, 54, 86, -1, 54, 54, 54, 54, 84, 123, 54, 54, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T158[] =
    {
	643
    };

static const ANTLR3_INT32 dfa4_T159[] =
    {
	305, 305, 354, 306, 305, 384, 305, 305, 354, -1, 305, 305, 305, 305, 305, 
	383, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 
	305, 305
    };

static const ANTLR3_INT32 dfa4_T160[] =
    {
	285, 285, 361, 266, 285, 360, 285, 285, 361, -1, 285, 285, 285, 285, 369, 
	388, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T161[] =
    {
	6, 6, 243, 308, 252, 242, 253, 6, 243, -1, 6, 6, 6, 6, 6, 228, 250, 6, 
	244, 245, 246, 248, 247, 251, 249, 254, 255, 256, 257, 258, 259, 260
    };

static const ANTLR3_INT32 dfa4_T162[] =
    {
	670
    };

static const ANTLR3_INT32 dfa4_T163[] =
    {
	800, 559, 798, 790, 801, 797, 799, 559, 798, -1, 559, 559, 559, 559, 802, 
	557, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T164[] =
    {
	433, 433, 433, 434, 433, 777, 433, 433, 433, -1, 433, 433, 433, 433, 433, 
	433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 
	433, 433
    };

static const ANTLR3_INT32 dfa4_T165[] =
    {
	904, 54, 906, 905, 872, 907, 873, 54, 906, -1, 54, 54, 54, 54, 54, 78, 
	870, 54, 864, 865, 866, 868, 867, 871, 869, 874, 875, 876, 877, 878, 879, 
	880
    };

static const ANTLR3_INT32 dfa4_T166[] =
    {
	398, 401, 493, 394, 399, 495, 397, 401, 493, -1, 401, 401, 401, 401, 400, 
	396, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 
	401, 401
    };

static const ANTLR3_INT32 dfa4_T167[] =
    {
	534, 433, 535, 530, 424, 536, 425, 433, 535, -1, 433, 433, 433, 433, 433, 
	433, 422, 433, 416, 417, 418, 420, 419, 423, 421, 426, 427, 428, 429, 430, 
	431, 432
    };

static const ANTLR3_INT32 dfa4_T168[] =
    {
	615, 559, 617, 616, 548, 618, 549, 559, 617, -1, 559, 559, 559, 559, 559, 
	619, 546, 559, 540, 541, 542, 544, 543, 547, 545, 550, 551, 552, 553, 554, 
	555, 556
    };

static const ANTLR3_INT32 dfa4_T169[] =
    {
	387
    };

static const ANTLR3_INT32 dfa4_T170[] =
    {
	80, -1, -1, 81, -1, -1, 80
    };

static const ANTLR3_INT32 dfa4_T171[] =
    {
	800, 559, 798, 790, 801, 807, 799, 559, 798, -1, 559, 559, 559, 559, 802, 
	557, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T172[] =
    {
	635, 635, 635, 589, 635, 634, 635, 635, 635, -1, 635, 635, 635, 635, 635, 
	635, 635, 635, 635, 635, 635, 635, 635, 635, 635, 635, 635, 635, 635, 635, 
	635, 635
    };

static const ANTLR3_INT32 dfa4_T173[] =
    {
	356, -1, -1, 357, -1, -1, 356
    };

static const ANTLR3_INT32 dfa4_T174[] =
    {
	54, 54, 69, 70, 72, 68, 54, 54, 69, -1, 54, 54, 54, 54, 54, 71, 54, 54, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T175[] =
    {
	446, 446, 446, 440, 446, 581, 446, 446, 446, -1, 446, 446, 446, 446, 445, 
	439, 446, 446, 446, 446, 446, 446, 446, 446, 446, 446, 446, 446, 446, 446, 
	446, 446
    };

static const ANTLR3_INT32 dfa4_T176[] =
    {
	216
    };

static const ANTLR3_INT32 dfa4_T177[] =
    {
	674
    };

static const ANTLR3_INT32 dfa4_T178[] =
    {
	1003
    };

static const ANTLR3_INT32 dfa4_T179[] =
    {
	98
    };

static const ANTLR3_INT32 dfa4_T180[] =
    {
	285, 285, 346, 321, 285, 345, 285, 285, 346, -1, 285, 285, 285, 285, 285, 
	284, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T181[] =
    {
	653
    };

static const ANTLR3_INT32 dfa4_T182[] =
    {
	559, 559, 891, 923, 843, 894, 844, 559, 891, -1, 559, 559, 559, 559, 559, 
	924, 841, 559, 835, 836, 837, 839, 838, 842, 840, 845, 846, 847, 848, 849, 
	850, 851
    };

static const ANTLR3_INT32 dfa4_T183[] =
    {
	342
    };

static const ANTLR3_INT32 dfa4_T184[] =
    {
	6, 6, 11, 6, 6, 14, 6, 6, 11, -1, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 
	6, 6, 6, 6, 6, 6, 6, 6, 6
    };

static const ANTLR3_INT32 dfa4_T185[] =
    {
	285, 285, 285, 366, 285, 285, 285, 285, 285, -1, 285, 285, 285, 285, 285, 
	365, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T186[] =
    {
	6, 6, 11, 6, 6, 12, 6, 6, 11, -1, 6, 6, 6, 6, 6, 15, 6, 6, 6, 6, 6, 6, 
	6, 6, 6, 6, 6, 6, 6, 6, 6, 6
    };

static const ANTLR3_INT32 dfa4_T187[] =
    {
	1, -1, -1, 2, -1, -1, 1
    };

static const ANTLR3_INT32 dfa4_T188[] =
    {
	727
    };

static const ANTLR3_INT32 dfa4_T189[] =
    {
	54, 54, 197, 93, 54, 196, 54, 54, 197, -1, 54, 54, 54, 54, 54, 92, 54, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T190[] =
    {
	105, 108, 144, 102, 106, 145, 104, 108, 144, -1, 108, 108, 108, 108, 107, 
	103, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 
	108, 108
    };

static const ANTLR3_INT32 dfa4_T191[] =
    {
	559, 559, 899, 664, 900, 898, 844, 559, 899, -1, 559, 559, 559, 559, 559, 
	663, 841, 559, 835, 836, 837, 839, 838, 842, 840, 845, 846, 847, 848, 849, 
	850, 851
    };

static const ANTLR3_INT32 dfa4_T192[] =
    {
	559, 559, 559, 664, 559, 559, 559, 559, 559, -1, 559, 559, 559, 559, 559, 
	663, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T193[] =
    {
	386
    };

static const ANTLR3_INT32 dfa4_T194[] =
    {
	6, 6, 11, 6, 6, 12, 6, 6, 11, -1, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 
	6, 6, 6, 6, 6, 6, 6, 6, 6
    };

static const ANTLR3_INT32 dfa4_T195[] =
    {
	433, 433, 757, 821, 766, 822, 767, 433, 757, -1, 433, 433, 433, 433, 433, 
	678, 764, 433, 758, 759, 760, 762, 761, 765, 763, 768, 769, 770, 771, 772, 
	773, 774
    };

static const ANTLR3_INT32 dfa4_T196[] =
    {
	951
    };

static const ANTLR3_INT32 dfa4_T197[] =
    {
	433, 433, 433, 434, 433, 676, 433, 433, 433, -1, 433, 433, 433, 433, 433, 
	755, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 
	433, 433
    };

static const ANTLR3_INT32 dfa4_T198[] =
    {
	54, 54, 174, 70, 175, 173, 54, 54, 174, -1, 54, 54, 54, 54, 54, 71, 54, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T199[] =
    {
	407, 285, 496, 394, 408, 497, 406, 285, 496, -1, 285, 285, 285, 285, 409, 
	284, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T200[] =
    {
	285, 285, 597, 266, 514, 596, 515, 285, 597, -1, 285, 285, 285, 285, 285, 
	285, 512, 285, 506, 507, 508, 510, 509, 513, 511, 516, 517, 518, 519, 520, 
	521, 522
    };

static const ANTLR3_INT32 dfa4_T201[] =
    {
	239
    };

static const ANTLR3_INT32 dfa4_T202[] =
    {
	881
    };

static const ANTLR3_INT32 dfa4_T203[] =
    {
	908, 54, 909, 905, 872, 910, 873, 54, 909, -1, 54, 54, 54, 54, 54, 54, 
	870, 54, 864, 865, 866, 868, 867, 871, 869, 874, 875, 876, 877, 878, 879, 
	880
    };

static const ANTLR3_INT32 dfa4_T204[] =
    {
	54, 54, 77, 63, 54, 76, 54, 54, 77, -1, 54, 54, 54, 54, 54, 35, 54, 54, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T205[] =
    {
	608, 608, 608, 530, 608, 607, 608, 608, 608, -1, 608, 608, 608, 608, 608, 
	608, 608, 608, 608, 608, 608, 608, 608, 608, 608, 608, 608, 608, 608, 608, 
	608, 608
    };

static const ANTLR3_INT32 dfa4_T206[] =
    {
	198
    };

static const ANTLR3_INT32 dfa4_T207[] =
    {
	305, 305, 305, 440, 305, 582, 305, 305, 305, -1, 305, 305, 305, 305, 452, 
	305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 
	305, 305
    };

static const ANTLR3_INT32 dfa4_T208[] =
    {
	285, 285, 597, 266, 514, 671, 515, 285, 597, -1, 285, 285, 285, 285, 285, 
	285, 512, 285, 506, 507, 508, 510, 509, 513, 511, 516, 517, 518, 519, 520, 
	521, 522
    };

static const ANTLR3_INT32 dfa4_T209[] =
    {
	401, 401, 401, 266, 401, 401, 401, 401, 401, -1, 401, 401, 401, 401, 401, 
	494, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 
	401, 401
    };

static const ANTLR3_INT32 dfa4_T210[] =
    {
	675
    };

static const ANTLR3_INT32 dfa4_T211[] =
    {
	6, 6, 4, 6, 6, 5, 6, 6, 4, -1, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 
	6, 6, 6, 6, 6, 6, 6, 6
    };

static const ANTLR3_INT32 dfa4_T212[] =
    {
	888
    };

static const ANTLR3_INT32 dfa4_T213[] =
    {
	344, 344, 344, 374, 344, 343, 344, 344, 344, -1, 344, 344, 344, 344, 344, 
	344, 344, 344, 344, 344, 344, 344, 344, 344, 344, 344, 344, 344, 344, 344, 
	344, 344
    };

static const ANTLR3_INT32 dfa4_T214[] =
    {
	332
    };

static const ANTLR3_INT32 dfa4_T215[] =
    {
	987, 796, 998, 999, 988, 1000, 986, 796, 998, -1, 796, 796, 796, 796, 989, 
	827, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 
	796, 796
    };

static const ANTLR3_INT32 dfa4_T216[] =
    {
	351, 351, 351, 325, 351, 351, 351, 351, 351, -1, 351, 351, 351, 351, 351, 
	351, 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, 
	351, 351
    };

static const ANTLR3_INT32 dfa4_T217[] =
    {
	262
    };

static const ANTLR3_INT32 dfa4_T218[] =
    {
	377
    };

static const ANTLR3_INT32 dfa4_T219[] =
    {
	443, 446, 438, 440, 444, 441, 442, 446, 438, -1, 446, 446, 446, 446, 445, 
	439, 446, 446, 446, 446, 446, 446, 446, 446, 446, 446, 446, 446, 446, 446, 
	446, 446
    };

static const ANTLR3_INT32 dfa4_T220[] =
    {
	378, -1, -1, 379, -1, -1, 378
    };

static const ANTLR3_INT32 dfa4_T221[] =
    {
	113, 54, 170, 102, 114, 171, 112, 54, 170, -1, 54, 54, 54, 54, 115, 35, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T222[] =
    {
	32
    };

static const ANTLR3_INT32 dfa4_T223[] =
    {
	28
    };

static const ANTLR3_INT32 dfa4_T224[] =
    {
	886, 886, 886, 916, 886, 885, 886, 886, 886, -1, 886, 886, 886, 886, 886, 
	886, 886, 886, 886, 886, 886, 886, 886, 886, 886, 886, 886, 886, 886, 886, 
	886, 886
    };

static const ANTLR3_INT32 dfa4_T225[] =
    {
	559, 559, 975, 624, 559, 978, 559, 559, 975, -1, 559, 559, 559, 559, 559, 
	977, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T226[] =
    {
	632
    };

static const ANTLR3_INT32 dfa4_T227[] =
    {
	285, 285, 638, 639, 514, 637, 515, 285, 638, -1, 285, 285, 285, 285, 285, 
	640, 512, 285, 506, 507, 508, 510, 509, 513, 511, 516, 517, 518, 519, 520, 
	521, 522
    };

static const ANTLR3_INT32 dfa4_T228[] =
    {
	25
    };

static const ANTLR3_INT32 dfa4_T229[] =
    {
	75, 75, 75, 56, 75, 75, 75, 75, 75, -1, 75, 75, 75, 75, 75, 75, 75, 75, 
	75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75
    };

static const ANTLR3_INT32 dfa4_T230[] =
    {
	285, 285, 505, 604, 514, 504, 515, 285, 505, -1, 285, 285, 285, 285, 285, 
	396, 512, 285, 506, 507, 508, 510, 509, 513, 511, 516, 517, 518, 519, 520, 
	521, 522
    };

static const ANTLR3_INT32 dfa4_T231[] =
    {
	592, 305, 593, 589, 483, 594, 484, 305, 593, -1, 305, 305, 305, 305, 305, 
	305, 481, 305, 475, 476, 477, 479, 478, 482, 480, 485, 486, 487, 488, 489, 
	490, 491
    };

static const ANTLR3_INT32 dfa4_T232[] =
    {
	26
    };

static const ANTLR3_INT32 dfa4_T233[] =
    {
	814
    };

static const ANTLR3_INT32 dfa4_T234[] =
    {
	903
    };

static const ANTLR3_INT32 dfa4_T235[] =
    {
	314, 285, 310, 313, 275, 315, 276, 285, 310, -1, 285, 285, 285, 285, 285, 
	335, 273, 285, 267, 268, 269, 271, 270, 274, 272, 277, 278, 279, 280, 281, 
	282, 283
    };

static const ANTLR3_INT32 dfa4_T236[] =
    {
	559, 559, 902, 724, 859, 901, 559, 559, 902, -1, 559, 559, 559, 559, 559, 
	723, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T237[] =
    {
	285, 285, 505, 604, 514, 673, 515, 285, 505, -1, 285, 285, 285, 285, 285, 
	502, 512, 285, 506, 507, 508, 510, 509, 513, 511, 516, 517, 518, 519, 520, 
	521, 522
    };

static const ANTLR3_INT32 dfa4_T238[] =
    {
	559, 559, 861, 664, 559, 860, 559, 559, 861, -1, 559, 559, 559, 559, 559, 
	663, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T239[] =
    {
	67
    };

static const ANTLR3_INT32 dfa4_T240[] =
    {
	305, 305, 354, 306, 305, 355, 305, 305, 354, -1, 305, 305, 305, 305, 305, 
	305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 
	305, 305
    };

static const ANTLR3_INT32 dfa4_T241[] =
    {
	201
    };

static const ANTLR3_INT32 dfa4_T242[] =
    {
	559, 559, 975, 558, 559, 974, 559, 559, 975, -1, 559, 559, 559, 559, 559, 
	559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T243[] =
    {
	433, 433, 611, 652, 433, 612, 433, 433, 611, -1, 433, 433, 433, 433, 648, 
	649, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 
	433, 433
    };

static const ANTLR3_INT32 dfa4_T244[] =
    {
	824, 824, 824, 779, 824, 824, 824, 824, 824, -1, 824, 824, 824, 824, 824, 
	824, 824, 824, 824, 824, 824, 824, 824, 824, 824, 824, 824, 824, 824, 824, 
	824, 824
    };

static const ANTLR3_INT32 dfa4_T245[] =
    {
	6, 6, 736, 6, 746, 737, 747, 6, 736, -1, 6, 6, 6, 6, 6, 6, 744, 6, 738, 
	739, 740, 742, 741, 745, 743, 748, 749, 750, 751, 752, 753, 754
    };

static const ANTLR3_INT32 dfa4_T246[] =
    {
	285, 285, 285, 266, 285, 403, 285, 285, 285, -1, 285, 285, 285, 285, 285, 
	285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T247[] =
    {
	600
    };

static const ANTLR3_INT32 dfa4_T248[] =
    {
	559, 559, 659, 624, 559, 658, 559, 559, 659, -1, 559, 559, 559, 559, 715, 
	716, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T249[] =
    {
	231, 234, 227, 6, 232, 229, 230, 234, 227, -1, 234, 234, 234, 234, 233, 
	228, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 
	234, 234
    };

static const ANTLR3_INT32 dfa4_T250[] =
    {
	305, 305, 354, 306, 305, 353, 305, 305, 354, -1, 305, 305, 305, 305, 305, 
	305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 
	305, 305
    };

static const ANTLR3_INT32 dfa4_T251[] =
    {
	793, 796, 791, 790, 794, 803, 792, 796, 791, -1, 796, 796, 796, 796, 795, 
	855, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 
	796, 796
    };

static const ANTLR3_INT32 dfa4_T252[] =
    {
	529, 433, 414, 530, 424, 415, 425, 433, 414, -1, 433, 433, 433, 433, 433, 
	533, 422, 433, 416, 417, 418, 420, 419, 423, 421, 426, 427, 428, 429, 430, 
	431, 432
    };

static const ANTLR3_INT32 dfa4_T253[] =
    {
	904, 54, 862, 905, 872, 863, 873, 54, 862, -1, 54, 54, 54, 54, 54, 55, 
	870, 54, 864, 865, 866, 868, 867, 871, 869, 874, 875, 876, 877, 878, 879, 
	880
    };

static const ANTLR3_INT32 dfa4_T254[] =
    {
	993, 559, 1001, 999, 994, 1002, 992, 559, 1001, -1, 559, 559, 559, 559, 
	995, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559, 559
    };

static const ANTLR3_INT32 dfa4_T255[] =
    {
	503
    };

static const ANTLR3_INT32 dfa4_T256[] =
    {
	809
    };

static const ANTLR3_INT32 dfa4_T257[] =
    {
	559, 559, 891, 921, 843, 894, 844, 559, 891, -1, 559, 559, 559, 559, 559, 
	922, 841, 559, 835, 836, 837, 839, 838, 842, 840, 845, 846, 847, 848, 849, 
	850, 851
    };

static const ANTLR3_INT32 dfa4_T258[] =
    {
	450, 305, 447, 440, 451, 448, 449, 305, 447, -1, 305, 305, 305, 305, 452, 
	305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 
	305, 305
    };

static const ANTLR3_INT32 dfa4_T259[] =
    {
	105, 108, 101, 102, 106, 121, 104, 108, 101, -1, 108, 108, 108, 108, 107, 
	103, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 
	108, 108
    };

static const ANTLR3_INT32 dfa4_T260[] =
    {
	285, 285, 505, 321, 514, 504, 515, 285, 505, -1, 285, 285, 285, 285, 285, 
	284, 512, 285, 506, 507, 508, 510, 509, 513, 511, 516, 517, 518, 519, 520, 
	521, 522
    };

static const ANTLR3_INT32 dfa4_T261[] =
    {
	672
    };

static const ANTLR3_INT32 dfa4_T262[] =
    {
	559, 559, 975, 558, 559, 974, 559, 559, 975, -1, 559, 559, 559, 559, 715, 
	981, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T263[] =
    {
	75, 75, 75, 94, 75, 74, 75, 75, 75, -1, 75, 75, 75, 75, 75, 75, 75, 75, 
	75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75
    };

static const ANTLR3_INT32 dfa4_T264[] =
    {
	433, 433, 757, 821, 766, 756, 767, 433, 757, -1, 433, 433, 433, 433, 433, 
	678, 764, 433, 758, 759, 760, 762, 761, 765, 763, 768, 769, 770, 771, 772, 
	773, 774
    };

static const ANTLR3_INT32 dfa4_T265[] =
    {
	6, 6, 6, 6, 6, 203, 6, 6, 6, -1, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 
	6, 6, 6, 6, 6, 6, 6, 6, 6
    };

static const ANTLR3_INT32 dfa4_T266[] =
    {
	54, 54, 188, 204, 157, 187, 158, 54, 188, -1, 54, 54, 54, 54, 54, 205, 
	155, 54, 149, 150, 151, 153, 152, 156, 154, 159, 160, 161, 162, 163, 164, 
	165
    };

static const ANTLR3_INT32 dfa4_T267[] =
    {
	105, 108, 101, 102, 106, 100, 104, 108, 101, -1, 108, 108, 108, 108, 107, 
	103, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 
	108, 108
    };

static const ANTLR3_INT32 dfa4_T268[] =
    {
	285, 285, 505, 321, 514, 673, 515, 285, 505, -1, 285, 285, 285, 285, 285, 
	284, 512, 285, 506, 507, 508, 510, 509, 513, 511, 516, 517, 518, 519, 520, 
	521, 522
    };

static const ANTLR3_INT32 dfa4_T269[] =
    {
	559, 559, 714, 664, 559, 718, 559, 559, 714, -1, 559, 559, 559, 559, 559, 
	725, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T270[] =
    {
	559, 559, 969, 664, 661, 968, 559, 559, 969, -1, 559, 559, 559, 559, 559, 
	663, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T271[] =
    {
	285, 285, 638, 639, 514, 813, 515, 285, 638, -1, 285, 285, 285, 285, 285, 
	640, 512, 285, 506, 507, 508, 510, 509, 513, 511, 516, 517, 518, 519, 520, 
	521, 522
    };

static const ANTLR3_INT32 dfa4_T272[] =
    {
	824, 824, 824, 889, 824, 823, 824, 824, 824, -1, 824, 824, 824, 824, 824, 
	824, 824, 824, 824, 824, 824, 824, 824, 824, 824, 824, 824, 824, 824, 824, 
	824, 824
    };

static const ANTLR3_INT32 dfa4_T273[] =
    {
	6, 6, 6, 6, 6, 202, 6, 6, 6, -1, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 
	6, 6, 6, 6, 6, 6, 6, 6, 6
    };

static const ANTLR3_INT32 dfa4_T274[] =
    {
	929, 929, 929, 905, 929, 929, 929, 929, 929, -1, 929, 929, 929, 929, 929, 
	929, 929, 929, 929, 929, 929, 929, 929, 929, 929, 929, 929, 929, 929, 929, 
	929, 929
    };

static const ANTLR3_INT32 dfa4_T275[] =
    {
	6, 6, 124, 6, 134, 125, 135, 6, 124, -1, 6, 6, 6, 6, 6, 6, 132, 6, 126, 
	127, 128, 130, 129, 133, 131, 136, 137, 138, 139, 140, 141, 142
    };

static const ANTLR3_INT32 dfa4_T276[] =
    {
	6, 6, 693, 6, 703, 694, 704, 6, 693, -1, 6, 6, 6, 6, 6, 6, 701, 6, 695, 
	696, 697, 699, 698, 702, 700, 705, 706, 707, 708, 709, 710, 711
    };

static const ANTLR3_INT32 dfa4_T277[] =
    {
	800, 559, 798, 790, 801, 807, 799, 559, 798, -1, 559, 559, 559, 559, 802, 
	808, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T278[] =
    {
	784
    };

static const ANTLR3_INT32 dfa4_T279[] =
    {
	904, 54, 906, 905, 872, 927, 873, 54, 906, -1, 54, 54, 54, 54, 54, 224, 
	870, 54, 864, 865, 866, 868, 867, 871, 869, 874, 875, 876, 877, 878, 879, 
	880
    };

static const ANTLR3_INT32 dfa4_T280[] =
    {
	75, 75, 75, 56, 75, 74, 75, 75, 75, -1, 75, 75, 75, 75, 75, 75, 75, 75, 
	75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75
    };

static const ANTLR3_INT32 dfa4_T281[] =
    {
	433, 433, 933, 434, 433, 945, 433, 433, 933, -1, 433, 433, 433, 433, 433, 
	944, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 
	433, 433
    };

static const ANTLR3_INT32 dfa4_T282[] =
    {
	804
    };

static const ANTLR3_INT32 dfa4_T283[] =
    {
	6, 6, 6, 6, 6, 202, 6, 6, 6, -1, 6, 6, 6, 6, 214, 215, 6, 6, 6, 6, 6, 6, 
	6, 6, 6, 6, 6, 6, 6, 6, 6, 6
    };

static const ANTLR3_INT32 dfa4_T284[] =
    {
	305, 305, 354, 306, 305, 353, 305, 305, 354, -1, 305, 305, 305, 305, 381, 
	382, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 
	305, 305
    };

static const ANTLR3_INT32 dfa4_T285[] =
    {
	54, 54, 62, 63, 54, 61, 54, 54, 62, -1, 54, 54, 54, 54, 54, 35, 54, 54, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T286[] =
    {
	9, 6, 4, 6, 6, 8, 6, 6, 4, -1, 6, 6, 6, 6, 6, 7, 6, 6, 6, 6, 6, 6, 6, 6, 
	6, 6, 6, 6, 6, 6, 6, 6
    };

static const ANTLR3_INT32 dfa4_T287[] =
    {
	559, 559, 902, 724, 559, 901, 559, 559, 902, -1, 559, 559, 559, 559, 559, 
	723, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T288[] =
    {
	987, 796, 998, 984, 988, 1000, 986, 796, 998, -1, 796, 796, 796, 796, 989, 
	789, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 
	796, 796
    };

static const ANTLR3_INT32 dfa4_T289[] =
    {
	21, 6, 18, 24, 22, 19, 20, 6, 18, -1, 6, 6, 6, 6, 23, 6, 6, 6, 6, 6, 6, 
	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6
    };

static const ANTLR3_INT32 dfa4_T290[] =
    {
	816, 6, 736, 817, 746, 815, 747, 6, 736, -1, 6, 6, 6, 6, 6, 182, 744, 6, 
	738, 739, 740, 742, 741, 745, 743, 748, 749, 750, 751, 752, 753, 754
    };

static const ANTLR3_INT32 dfa4_T291[] =
    {
	401, 401, 401, 266, 401, 523, 401, 401, 401, -1, 401, 401, 401, 401, 401, 
	494, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 
	401, 401
    };

static const ANTLR3_INT32 dfa4_T292[] =
    {
	559, 559, 861, 664, 859, 860, 559, 559, 861, -1, 559, 559, 559, 559, 559, 
	663, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T293[] =
    {
	54, 54, 62, 63, 54, 89, 54, 54, 62, -1, 54, 54, 54, 54, 54, 117, 54, 54, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T294[] =
    {
	285, 285, 285, 266, 285, 285, 285, 285, 285, -1, 285, 285, 285, 285, 285, 
	285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T295[] =
    {
	559, 559, 538, 558, 548, 539, 549, 559, 538, -1, 559, 559, 559, 559, 559, 
	557, 546, 559, 540, 541, 542, 544, 543, 547, 545, 550, 551, 552, 553, 554, 
	555, 556
    };

static const ANTLR3_INT32 dfa4_T296[] =
    {
	824, 824, 824, 779, 824, 823, 824, 824, 824, -1, 824, 824, 824, 824, 824, 
	824, 824, 824, 824, 824, 824, 824, 824, 824, 824, 824, 824, 824, 824, 824, 
	824, 824
    };

static const ANTLR3_INT32 dfa4_T297[] =
    {
	559, 559, 967, 624, 559, 966, 559, 559, 967, -1, 559, 559, 559, 559, 559, 
	557, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T298[] =
    {
	584, 433, 454, 585, 464, 455, 465, 433, 454, -1, 433, 433, 433, 433, 433, 
	533, 462, 433, 456, 457, 458, 460, 459, 463, 461, 466, 467, 468, 469, 470, 
	471, 472
    };

static const ANTLR3_INT32 dfa4_T299[] =
    {
	776
    };

static const ANTLR3_INT32 dfa4_T300[] =
    {
	285, 285, 285, 266, 285, 391, 285, 285, 285, -1, 285, 285, 285, 285, 285, 
	285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T301[] =
    {
	285, 285, 285, 266, 285, 391, 285, 285, 285, -1, 285, 285, 285, 285, 285, 
	499, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T302[] =
    {
	453
    };

static const ANTLR3_INT32 dfa4_T303[] =
    {
	559, 559, 714, 558, 559, 718, 559, 559, 714, -1, 559, 559, 559, 559, 559, 
	786, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T304[] =
    {
	919
    };

static const ANTLR3_INT32 dfa4_T305[] =
    {
	317
    };

static const ANTLR3_INT32 dfa4_T306[] =
    {
	993, 559, 1001, 984, 994, 1002, 992, 559, 1001, -1, 559, 559, 559, 559, 
	995, 557, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559, 559
    };

static const ANTLR3_INT32 dfa4_T307[] =
    {
	285, 285, 285, 266, 285, 525, 285, 285, 285, -1, 285, 285, 285, 285, 285, 
	285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T308[] =
    {
	305, 305, 562, 306, 571, 561, 572, 305, 562, -1, 305, 305, 305, 305, 305, 
	305, 569, 305, 563, 564, 565, 567, 566, 570, 568, 573, 574, 575, 576, 577, 
	578, 579
    };

static const ANTLR3_INT32 dfa4_T309[] =
    {
	194
    };

static const ANTLR3_INT32 dfa4_T310[] =
    {
	9, 6, 4, 6, 6, 5, 6, 6, 4, -1, 6, 6, 6, 6, 6, 10, 6, 6, 6, 6, 6, 6, 6, 
	6, 6, 6, 6, 6, 6, 6, 6, 6
    };

static const ANTLR3_INT32 dfa4_T311[] =
    {
	796, 796, 796, 828, 796, 853, 796, 796, 796, -1, 796, 796, 796, 796, 795, 
	827, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 
	796, 796
    };

static const ANTLR3_INT32 dfa4_T312[] =
    {
	333
    };

static const ANTLR3_INT32 dfa4_T313[] =
    {
	609
    };

static const ANTLR3_INT32 dfa4_T314[] =
    {
	225
    };

static const ANTLR3_INT32 dfa4_T315[] =
    {
	79
    };

static const ANTLR3_INT32 dfa4_T316[] =
    {
	119
    };

static const ANTLR3_INT32 dfa4_T317[] =
    {
	446, 446, 446, 306, 446, 446, 446, 446, 446, -1, 446, 446, 446, 446, 446, 
	439, 446, 446, 446, 446, 446, 446, 446, 446, 446, 446, 446, 446, 446, 446, 
	446, 446
    };

static const ANTLR3_INT32 dfa4_T318[] =
    {
	351, 351, 351, 380, 351, 350, 351, 351, 351, -1, 351, 351, 351, 351, 351, 
	351, 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, 
	351, 351
    };

static const ANTLR3_INT32 dfa4_T319[] =
    {
	73
    };

static const ANTLR3_INT32 dfa4_T320[] =
    {
	631, 631, 631, 585, 631, 631, 631, 631, 631, -1, 631, 631, 631, 631, 631, 
	631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 
	631, 631
    };

static const ANTLR3_INT32 dfa4_T321[] =
    {
	113, 54, 111, 102, 114, 122, 112, 54, 111, -1, 54, 54, 54, 54, 115, 35, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T322[] =
    {
	285, 285, 364, 366, 285, 363, 285, 285, 364, -1, 285, 285, 285, 285, 285, 
	365, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T323[] =
    {
	956, 684, 952, 953, 957, 954, 955, 684, 952, -1, 684, 684, 684, 684, 958, 
	678, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 
	684, 684
    };

static const ANTLR3_INT32 dfa4_T324[] =
    {
	113, 54, 111, 102, 114, 110, 112, 54, 111, -1, 54, 54, 54, 54, 115, 35, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T325[] =
    {
	57, 54, 59, 56, 45, 60, 46, 54, 59, -1, 54, 54, 54, 54, 54, 78, 43, 54, 
	36, 38, 39, 41, 40, 44, 42, 47, 48, 49, 50, 51, 52, 53
    };

static const ANTLR3_INT32 dfa4_T326[] =
    {
	285, 285, 285, 266, 285, 403, 285, 285, 285, -1, 285, 285, 285, 285, 285, 
	524, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T327[] =
    {
	285, 285, 597, 606, 514, 605, 515, 285, 597, -1, 285, 285, 285, 285, 285, 
	494, 512, 285, 506, 507, 508, 510, 509, 513, 511, 516, 517, 518, 519, 520, 
	521, 522
    };

static const ANTLR3_INT32 dfa4_T328[] =
    {
	559, 559, 559, 828, 559, 854, 559, 559, 559, -1, 559, 559, 559, 559, 802, 
	559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T329[] =
    {
	200, 200, 200, 180, 200, 200, 200, 200, 200, -1, 200, 200, 200, 200, 200, 
	200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 
	200, 200
    };

static const ANTLR3_INT32 dfa4_T330[] =
    {
	433, 433, 933, 434, 433, 934, 433, 433, 933, -1, 433, 433, 433, 433, 433, 
	433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 
	433, 433
    };

static const ANTLR3_INT32 dfa4_T331[] =
    {
	559, 559, 899, 921, 843, 898, 844, 559, 899, -1, 559, 559, 559, 559, 559, 
	922, 841, 559, 835, 836, 837, 839, 838, 842, 840, 845, 846, 847, 848, 849, 
	850, 851
    };

static const ANTLR3_INT32 dfa4_T332[] =
    {
	398, 401, 395, 394, 399, 412, 397, 401, 395, -1, 401, 401, 401, 401, 400, 
	396, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 
	401, 401
    };

static const ANTLR3_INT32 dfa4_T333[] =
    {
	987, 796, 985, 984, 988, 996, 986, 796, 985, -1, 796, 796, 796, 796, 989, 
	789, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 
	796, 796
    };

static const ANTLR3_INT32 dfa4_T334[] =
    {
	324, 305, 286, 325, 296, 326, 297, 305, 286, -1, 305, 305, 305, 305, 305, 
	327, 294, 305, 288, 289, 290, 292, 291, 295, 293, 298, 299, 300, 301, 302, 
	303, 304
    };

static const ANTLR3_INT32 dfa4_T335[] =
    {
	344, 344, 344, 313, 344, 343, 344, 344, 344, -1, 344, 344, 344, 344, 344, 
	344, 344, 344, 344, 344, 344, 344, 344, 344, 344, 344, 344, 344, 344, 344, 
	344, 344
    };

static const ANTLR3_INT32 dfa4_T336[] =
    {
	285, 285, 323, 321, 285, 372, 285, 285, 323, -1, 285, 285, 285, 285, 285, 
	284, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T337[] =
    {
	285, 285, 285, 321, 285, 285, 285, 285, 285, -1, 285, 285, 285, 285, 285, 
	284, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T338[] =
    {
	433, 433, 933, 434, 433, 932, 433, 433, 933, -1, 433, 433, 433, 433, 433, 
	433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 
	433, 433
    };

static const ANTLR3_INT32 dfa4_T339[] =
    {
	778, 6, 693, 779, 703, 780, 704, 6, 693, -1, 6, 6, 6, 6, 6, 182, 701, 6, 
	695, 696, 697, 699, 698, 702, 700, 705, 706, 707, 708, 709, 710, 711
    };

static const ANTLR3_INT32 dfa4_T340[] =
    {
	615, 559, 946, 616, 548, 947, 549, 559, 946, -1, 559, 559, 559, 559, 559, 
	965, 546, 559, 540, 541, 542, 544, 543, 547, 545, 550, 551, 552, 553, 554, 
	555, 556
    };

static const ANTLR3_INT32 dfa4_T341[] =
    {
	655, 655, 655, 616, 655, 655, 655, 655, 655, -1, 655, 655, 655, 655, 655, 
	655, 655, 655, 655, 655, 655, 655, 655, 655, 655, 655, 655, 655, 655, 655, 
	655, 655
    };

static const ANTLR3_INT32 dfa4_T342[] =
    {
	398, 401, 395, 394, 399, 393, 397, 401, 395, -1, 401, 401, 401, 401, 400, 
	396, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 
	401, 401
    };

static const ANTLR3_INT32 dfa4_T343[] =
    {
	305, 305, 305, 306, 305, 437, 305, 305, 305, -1, 305, 305, 305, 305, 305, 
	305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 
	305, 305
    };

static const ANTLR3_INT32 dfa4_T344[] =
    {
	314, 285, 265, 313, 275, 264, 276, 285, 265, -1, 285, 285, 285, 285, 285, 
	312, 273, 285, 267, 268, 269, 271, 270, 274, 272, 277, 278, 279, 280, 281, 
	282, 283
    };

static const ANTLR3_INT32 dfa4_T345[] =
    {
	54, 54, 191, 37, 157, 195, 158, 54, 191, -1, 54, 54, 54, 54, 54, 54, 155, 
	54, 149, 150, 151, 153, 152, 156, 154, 159, 160, 161, 162, 163, 164, 165
    };

static const ANTLR3_INT32 dfa4_T346[] =
    {
	500, -1, -1, 501, -1, -1, 500
    };

static const ANTLR3_INT32 dfa4_T347[] =
    {
	962, 433, 959, 953, 963, 960, 961, 433, 959, -1, 433, 433, 433, 433, 964, 
	433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 
	433, 433
    };

static const ANTLR3_INT32 dfa4_T348[] =
    {
	559, 559, 714, 624, 559, 718, 559, 559, 714, -1, 559, 559, 559, 559, 559, 
	717, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T349[] =
    {
	433, 433, 933, 434, 433, 932, 433, 433, 933, -1, 433, 433, 433, 433, 648, 
	943, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 
	433, 433
    };

static const ANTLR3_INT32 dfa4_T350[] =
    {
	904, 54, 906, 905, 872, 907, 873, 54, 906, -1, 54, 54, 54, 54, 54, 58, 
	870, 54, 864, 865, 866, 868, 867, 871, 869, 874, 875, 876, 877, 878, 879, 
	880
    };

static const ANTLR3_INT32 dfa4_T351[] =
    {
	108, 108, 108, 166, 108, 168, 108, 108, 108, -1, 108, 108, 108, 108, 107, 
	167, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 
	108, 108
    };

static const ANTLR3_INT32 dfa4_T352[] =
    {
	200, 200, 200, 213, 200, 199, 200, 200, 200, -1, 200, 200, 200, 200, 200, 
	200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 
	200, 200
    };

static const ANTLR3_INT32 dfa4_T353[] =
    {
	635, 635, 635, 668, 635, 634, 635, 635, 635, -1, 635, 635, 635, 635, 635, 
	635, 635, 635, 635, 635, 635, 635, 635, 635, 635, 635, 635, 635, 635, 635, 
	635, 635
    };

static const ANTLR3_INT32 dfa4_T354[] =
    {
	54, 54, 191, 37, 157, 219, 158, 54, 191, -1, 54, 54, 54, 54, 54, 54, 155, 
	54, 149, 150, 151, 153, 152, 156, 154, 159, 160, 161, 162, 163, 164, 165
    };

static const ANTLR3_INT32 dfa4_T355[] =
    {
	896, -1, -1, 897, -1, -1, 896
    };

static const ANTLR3_INT32 dfa4_T356[] =
    {
	108, 108, 108, 37, 108, 108, 108, 108, 108, -1, 108, 108, 108, 108, 108, 
	167, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 
	108, 108
    };

static const ANTLR3_INT32 dfa4_T357[] =
    {
	559, 559, 714, 558, 559, 732, 559, 559, 714, -1, 559, 559, 559, 559, 559, 
	559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T358[] =
    {
	731
    };

static const ANTLR3_INT32 dfa4_T359[] =
    {
	559, 559, 626, 624, 559, 726, 559, 559, 626, -1, 559, 559, 559, 559, 559, 
	808, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T360[] =
    {
	64, 54, 65, 56, 45, 66, 46, 54, 65, -1, 54, 54, 54, 54, 54, 54, 43, 54, 
	36, 38, 39, 41, 40, 44, 42, 47, 48, 49, 50, 51, 52, 53
    };

static const ANTLR3_INT32 dfa4_T361[] =
    {
	559, 559, 714, 558, 559, 713, 559, 559, 714, -1, 559, 559, 559, 559, 559, 
	559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T362[] =
    {
	886, 886, 886, 817, 886, 886, 886, 886, 886, -1, 886, 886, 886, 886, 886, 
	886, 886, 886, 886, 886, 886, 886, 886, 886, 886, 886, 886, 886, 886, 886, 
	886, 886
    };

static const ANTLR3_INT32 dfa4_T363[] =
    {
	54, 54, 86, 307, 54, 240, 54, 54, 86, -1, 54, 54, 54, 54, 84, 123, 54, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T364[] =
    {
	285, 285, 361, 390, 285, 362, 285, 285, 361, -1, 285, 285, 285, 285, 369, 
	388, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T365[] =
    {
	892
    };

static const ANTLR3_INT32 dfa4_T366[] =
    {
	918
    };

static const ANTLR3_INT32 dfa4_T367[] =
    {
	54, 54, 69, 82, 54, 68, 54, 54, 69, -1, 54, 54, 54, 54, 84, 83, 54, 54, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T368[] =
    {
	54, 54, 148, 190, 157, 147, 158, 54, 148, -1, 54, 54, 54, 54, 54, 103, 
	155, 54, 149, 150, 151, 153, 152, 156, 154, 159, 160, 161, 162, 163, 164, 
	165
    };

static const ANTLR3_INT32 dfa4_T369[] =
    {
	314, 285, 310, 313, 275, 311, 276, 285, 310, -1, 285, 285, 285, 285, 285, 
	336, 273, 285, 267, 268, 269, 271, 270, 274, 272, 277, 278, 279, 280, 281, 
	282, 283
    };

static const ANTLR3_INT32 dfa4_T370[] =
    {
	498
    };

static const ANTLR3_INT32 dfa4_T371[] =
    {
	54, 54, 207, 208, 157, 206, 158, 54, 207, -1, 54, 54, 54, 54, 54, 209, 
	155, 54, 149, 150, 151, 153, 152, 156, 154, 159, 160, 161, 162, 163, 164, 
	165
    };

static const ANTLR3_INT32 dfa4_T372[] =
    {
	285, 285, 339, 368, 285, 338, 285, 285, 339, -1, 285, 285, 285, 285, 369, 
	367, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T373[] =
    {
	940
    };

static const ANTLR3_INT32 dfa4_T374[] =
    {
	349
    };

static const ANTLR3_INT32 dfa4_T375[] =
    {
	200, 200, 200, 180, 200, 199, 200, 200, 200, -1, 200, 200, 200, 200, 200, 
	200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 
	200, 200
    };

static const ANTLR3_INT32 dfa4_T376[] =
    {
	816, 6, 736, 817, 746, 737, 747, 6, 736, -1, 6, 6, 6, 6, 6, 183, 744, 6, 
	738, 739, 740, 742, 741, 745, 743, 748, 749, 750, 751, 752, 753, 754
    };

static const ANTLR3_INT32 dfa4_T377[] =
    {
	392
    };

static const ANTLR3_INT32 dfa4_T378[] =
    {
	285, 285, 265, 266, 275, 264, 276, 285, 265, -1, 285, 285, 285, 285, 285, 
	284, 273, 285, 267, 268, 269, 271, 270, 274, 272, 277, 278, 279, 280, 281, 
	282, 283
    };

static const ANTLR3_INT32 dfa4_T379[] =
    {
	54, 54, 54, 166, 54, 172, 54, 54, 54, -1, 54, 54, 54, 54, 115, 54, 54, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T380[] =
    {
	57, 54, 34, 56, 45, 33, 46, 54, 34, -1, 54, 54, 54, 54, 54, 55, 43, 54, 
	36, 38, 39, 41, 40, 44, 42, 47, 48, 49, 50, 51, 52, 53
    };

static const ANTLR3_INT32 dfa4_T381[] =
    {
	285, 285, 597, 606, 514, 596, 515, 285, 597, -1, 285, 285, 285, 285, 285, 
	494, 512, 285, 506, 507, 508, 510, 509, 513, 511, 516, 517, 518, 519, 520, 
	521, 522
    };

static const ANTLR3_INT32 dfa4_T382[] =
    {
	54, 54, 148, 190, 157, 217, 158, 54, 148, -1, 54, 54, 54, 54, 54, 143, 
	155, 54, 149, 150, 151, 153, 152, 156, 154, 159, 160, 161, 162, 163, 164, 
	165
    };

static const ANTLR3_INT32 dfa4_T383[] =
    {
	446, 446, 446, 306, 446, 581, 446, 446, 446, -1, 446, 446, 446, 446, 446, 
	439, 446, 446, 446, 446, 446, 446, 446, 446, 446, 446, 446, 446, 446, 446, 
	446, 446
    };

static const ANTLR3_INT32 dfa4_T384[] =
    {
	146
    };

static const ANTLR3_INT32 dfa4_T385[] =
    {
	559, 559, 617, 558, 548, 636, 549, 559, 617, -1, 559, 559, 559, 559, 559, 
	559, 546, 559, 540, 541, 542, 544, 543, 547, 545, 550, 551, 552, 553, 554, 
	555, 556
    };

static const ANTLR3_INT32 dfa4_T386[] =
    {
	305, 305, 305, 306, 305, 305, 305, 305, 305, -1, 305, 305, 305, 305, 305, 
	305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 
	305, 305
    };

static const ANTLR3_INT32 dfa4_T387[] =
    {
	54, 54, 54, 37, 54, 109, 54, 54, 54, -1, 54, 54, 54, 54, 54, 54, 54, 54, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T388[] =
    {
	285, 285, 638, 366, 601, 813, 515, 285, 638, -1, 285, 285, 285, 285, 285, 
	365, 512, 285, 506, 507, 508, 510, 509, 513, 511, 516, 517, 518, 519, 520, 
	521, 522
    };

static const ANTLR3_INT32 dfa4_T389[] =
    {
	433, 433, 883, 434, 424, 884, 425, 433, 883, -1, 433, 433, 433, 433, 433, 
	433, 422, 433, 416, 417, 418, 420, 419, 423, 421, 426, 427, 428, 429, 430, 
	431, 432
    };

static const ANTLR3_INT32 dfa4_T390[] =
    {
	285, 285, 597, 606, 514, 671, 515, 285, 597, -1, 285, 285, 285, 285, 285, 
	733, 512, 285, 506, 507, 508, 510, 509, 513, 511, 516, 517, 518, 519, 520, 
	521, 522
    };

static const ANTLR3_INT32 dfa4_T391[] =
    {
	285, 285, 597, 604, 514, 605, 515, 285, 597, -1, 285, 285, 285, 285, 285, 
	396, 512, 285, 506, 507, 508, 510, 509, 513, 511, 516, 517, 518, 519, 520, 
	521, 522
    };

static const ANTLR3_INT32 dfa4_T392[] =
    {
	559, 559, 662, 664, 661, 660, 559, 559, 662, -1, 559, 559, 559, 559, 559, 
	663, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T393[] =
    {
	88
    };

static const ANTLR3_INT32 dfa4_T394[] =
    {
	656
    };

static const ANTLR3_INT32 dfa4_T395[] =
    {
	120
    };

static const ANTLR3_INT32 dfa4_T396[] =
    {
	6, 6, 6, 16, 6, 13, 6, 6, 6, -1, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 
	6, 6, 6, 6, 6, 6, 6, 6, 6
    };

static const ANTLR3_INT32 dfa4_T397[] =
    {
	433, 433, 611, 434, 433, 651, 433, 433, 611, -1, 433, 433, 433, 433, 433, 
	650, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 
	433, 433
    };

static const ANTLR3_INT32 dfa4_T398[] =
    {
	559, 559, 714, 558, 559, 713, 559, 559, 714, -1, 559, 559, 559, 559, 715, 
	785, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T399[] =
    {
	54, 54, 148, 63, 157, 147, 158, 54, 148, -1, 54, 54, 54, 54, 54, 35, 155, 
	54, 149, 150, 151, 153, 152, 156, 154, 159, 160, 161, 162, 163, 164, 165
    };

static const ANTLR3_INT32 dfa4_T400[] =
    {
	54, 54, 148, 63, 157, 217, 158, 54, 148, -1, 54, 54, 54, 54, 54, 35, 155, 
	54, 149, 150, 151, 153, 152, 156, 154, 159, 160, 161, 162, 163, 164, 165
    };

static const ANTLR3_INT32 dfa4_T401[] =
    {
	793, 796, 826, 790, 794, 829, 792, 796, 826, -1, 796, 796, 796, 796, 795, 
	789, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 
	796, 796
    };

static const ANTLR3_INT32 dfa4_T402[] =
    {
	57, 54, 59, 56, 45, 212, 46, 54, 59, -1, 54, 54, 54, 54, 54, 224, 43, 54, 
	36, 38, 39, 41, 40, 44, 42, 47, 48, 49, 50, 51, 52, 53
    };

static const ANTLR3_INT32 dfa4_T403[] =
    {
	407, 285, 405, 394, 408, 413, 406, 285, 405, -1, 285, 285, 285, 285, 409, 
	284, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T404[] =
    {
	305, 305, 305, 306, 305, 582, 305, 305, 305, -1, 305, 305, 305, 305, 305, 
	305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 
	305, 305
    };

static const ANTLR3_INT32 dfa4_T405[] =
    {
	631, 631, 631, 585, 631, 630, 631, 631, 631, -1, 631, 631, 631, 631, 631, 
	631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 
	631, 631
    };

static const ANTLR3_INT32 dfa4_T406[] =
    {
	334
    };

static const ANTLR3_INT32 dfa4_T407[] =
    {
	993, 559, 991, 984, 994, 997, 992, 559, 991, -1, 559, 559, 559, 559, 995, 
	557, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T408[] =
    {
	54, 54, 207, 208, 157, 263, 158, 54, 207, -1, 54, 54, 54, 54, 54, 209, 
	155, 54, 149, 150, 151, 153, 152, 156, 154, 159, 160, 161, 162, 163, 164, 
	165
    };

static const ANTLR3_INT32 dfa4_T409[] =
    {
	684, 684, 684, 685, 684, 775, 684, 684, 684, -1, 684, 684, 684, 684, 683, 
	678, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, 
	684, 684
    };

static const ANTLR3_INT32 dfa4_T410[] =
    {
	314, 285, 310, 313, 275, 315, 276, 285, 310, -1, 285, 285, 285, 285, 285, 
	316, 273, 285, 267, 268, 269, 271, 270, 274, 272, 277, 278, 279, 280, 281, 
	282, 283
    };

static const ANTLR3_INT32 dfa4_T411[] =
    {
	559, 559, 659, 624, 559, 658, 559, 559, 659, -1, 559, 559, 559, 559, 559, 
	557, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T412[] =
    {
	433, 433, 911, 434, 464, 912, 465, 433, 911, -1, 433, 433, 433, 433, 433, 
	433, 462, 433, 456, 457, 458, 460, 459, 463, 461, 466, 467, 468, 469, 470, 
	471, 472
    };

static const ANTLR3_INT32 dfa4_T413[] =
    {
	108, 108, 108, 37, 108, 168, 108, 108, 108, -1, 108, 108, 108, 108, 108, 
	167, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 
	108, 108
    };

static const ANTLR3_INT32 dfa4_T414[] =
    {
	407, 285, 405, 394, 408, 404, 406, 285, 405, -1, 285, 285, 285, 285, 409, 
	284, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T415[] =
    {
	778, 6, 693, 779, 703, 694, 704, 6, 693, -1, 6, 6, 6, 6, 6, 183, 701, 6, 
	695, 696, 697, 699, 698, 702, 700, 705, 706, 707, 708, 709, 710, 711
    };

static const ANTLR3_INT32 dfa4_T416[] =
    {
	537
    };

static const ANTLR3_INT32 dfa4_T417[] =
    {
	6, 6, 11, 17, 6, 14, 6, 6, 11, -1, 6, 6, 6, 6, 6, 15, 6, 6, 6, 6, 6, 6, 
	6, 6, 6, 6, 6, 6, 6, 6, 6, 6
    };

static const ANTLR3_INT32 dfa4_T418[] =
    {
	857, -1, -1, 858, -1, -1, 857
    };

static const ANTLR3_INT32 dfa4_T419[] =
    {
	825
    };

static const ANTLR3_INT32 dfa4_T420[] =
    {
	285, 285, 597, 639, 514, 605, 515, 285, 597, -1, 285, 285, 285, 285, 285, 
	640, 512, 285, 506, 507, 508, 510, 509, 513, 511, 516, 517, 518, 519, 520, 
	521, 522
    };

static const ANTLR3_INT32 dfa4_T421[] =
    {
	800, 559, 830, 790, 801, 831, 799, 559, 830, -1, 559, 559, 559, 559, 802, 
	557, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T422[] =
    {
	559, 559, 891, 558, 843, 890, 844, 559, 891, -1, 559, 559, 559, 559, 559, 
	559, 841, 559, 835, 836, 837, 839, 838, 842, 840, 845, 846, 847, 848, 849, 
	850, 851
    };

static const ANTLR3_INT32 dfa4_T423[] =
    {
	54, 54, 54, 37, 54, 54, 54, 54, 54, -1, 54, 54, 54, 54, 54, 54, 54, 54, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T424[] =
    {
	285, 285, 285, 341, 285, 285, 285, 285, 285, -1, 285, 285, 285, 285, 285, 
	340, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T425[] =
    {
	796, 796, 796, 999, 796, 1004, 796, 796, 796, -1, 796, 796, 796, 796, 989, 
	827, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 
	796, 796
    };

static const ANTLR3_INT32 dfa4_T426[] =
    {
	615, 559, 936, 616, 548, 937, 549, 559, 936, -1, 559, 559, 559, 559, 559, 
	949, 546, 559, 540, 541, 542, 544, 543, 547, 545, 550, 551, 552, 553, 554, 
	555, 556
    };

static const ANTLR3_INT32 dfa4_T427[] =
    {
	305, 305, 305, 306, 305, 437, 305, 305, 305, -1, 305, 305, 305, 305, 305, 
	560, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 
	305, 305
    };

static const ANTLR3_INT32 dfa4_T428[] =
    {
	433, 433, 433, 685, 433, 777, 433, 433, 433, -1, 433, 433, 433, 433, 691, 
	433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 
	433, 433
    };

static const ANTLR3_INT32 dfa4_T429[] =
    {
	285, 285, 603, 341, 601, 602, 515, 285, 603, -1, 285, 285, 285, 285, 285, 
	340, 512, 285, 506, 507, 508, 510, 509, 513, 511, 516, 517, 518, 519, 520, 
	521, 522
    };

static const ANTLR3_INT32 dfa4_T430[] =
    {
	559, 559, 891, 558, 843, 941, 844, 559, 891, -1, 559, 559, 559, 559, 559, 
	559, 841, 559, 835, 836, 837, 839, 838, 842, 840, 845, 846, 847, 848, 849, 
	850, 851
    };

static const ANTLR3_INT32 dfa4_T431[] =
    {
	54, 54, 54, 37, 54, 118, 54, 54, 54, -1, 54, 54, 54, 54, 54, 54, 54, 54, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T432[] =
    {
	54, 54, 54, 37, 54, 118, 54, 54, 54, -1, 54, 54, 54, 54, 54, 176, 54, 54, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T433[] =
    {
	796, 796, 796, 558, 796, 796, 796, 796, 796, -1, 796, 796, 796, 796, 796, 
	827, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 
	796, 796
    };

static const ANTLR3_INT32 dfa4_T434[] =
    {
	929, 929, 929, 905, 929, 928, 929, 929, 929, -1, 929, 929, 929, 929, 929, 
	929, 929, 929, 929, 929, 929, 929, 929, 929, 929, 929, 929, 929, 929, 929, 
	929, 929
    };

static const ANTLR3_INT32 dfa4_T435[] =
    {
	54, 54, 54, 37, 54, 172, 54, 54, 54, -1, 54, 54, 54, 54, 54, 54, 54, 54, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T436[] =
    {
	655, 655, 655, 712, 655, 654, 655, 655, 655, -1, 655, 655, 655, 655, 655, 
	655, 655, 655, 655, 655, 655, 655, 655, 655, 655, 655, 655, 655, 655, 655, 
	655, 655
    };

static const ANTLR3_INT32 dfa4_T437[] =
    {
	351, 351, 351, 325, 351, 350, 351, 351, 351, -1, 351, 351, 351, 351, 351, 
	351, 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, 
	351, 351
    };

static const ANTLR3_INT32 dfa4_T438[] =
    {
	436
    };

static const ANTLR3_INT32 dfa4_T439[] =
    {
	852
    };

static const ANTLR3_INT32 dfa4_T440[] =
    {
	6, 6, 243, 6, 252, 242, 253, 6, 243, -1, 6, 6, 6, 6, 6, 6, 250, 6, 244, 
	245, 246, 248, 247, 251, 249, 254, 255, 256, 257, 258, 259, 260
    };

static const ANTLR3_INT32 dfa4_T441[] =
    {
	938
    };

static const ANTLR3_INT32 dfa4_T442[] =
    {
	559, 559, 925, 923, 843, 926, 844, 559, 925, -1, 559, 559, 559, 559, 559, 
	924, 841, 559, 835, 836, 837, 839, 838, 842, 840, 845, 846, 847, 848, 849, 
	850, 851
    };

static const ANTLR3_INT32 dfa4_T443[] =
    {
	559, 559, 969, 720, 559, 968, 559, 559, 969, -1, 559, 559, 559, 559, 715, 
	979, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T444[] =
    {
	559, 559, 834, 893, 843, 833, 844, 559, 834, -1, 559, 559, 559, 559, 559, 
	789, 841, 559, 835, 836, 837, 839, 838, 842, 840, 845, 846, 847, 848, 849, 
	850, 851
    };

static const ANTLR3_INT32 dfa4_T445[] =
    {
	373
    };

static const ANTLR3_INT32 dfa4_T446[] =
    {
	234, 234, 234, 6, 234, 261, 234, 234, 234, -1, 234, 234, 234, 234, 233, 
	228, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 
	234, 234
    };

static const ANTLR3_INT32 dfa4_T447[] =
    {
	559, 559, 559, 999, 559, 1005, 559, 559, 559, -1, 559, 559, 559, 559, 995, 
	559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T448[] =
    {
	433, 433, 611, 434, 433, 612, 433, 433, 611, -1, 433, 433, 433, 433, 433, 
	433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 
	433, 433
    };

static const ANTLR3_INT32 dfa4_T449[] =
    {
	559, 559, 834, 893, 843, 939, 844, 559, 834, -1, 559, 559, 559, 559, 559, 
	855, 841, 559, 835, 836, 837, 839, 838, 842, 840, 845, 846, 847, 848, 849, 
	850, 851
    };

static const ANTLR3_INT32 dfa4_T450[] =
    {
	559, 559, 559, 558, 559, 787, 559, 559, 559, -1, 559, 559, 559, 559, 559, 
	559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 
	559, 559
    };

static const ANTLR3_INT32 dfa4_T451[] =
    {
	285, 285, 599, 366, 526, 598, 285, 285, 599, -1, 285, 285, 285, 285, 285, 
	365, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T452[] =
    {
	99
    };

static const ANTLR3_INT32 dfa4_T453[] =
    {
	285, 285, 528, 341, 285, 527, 285, 285, 528, -1, 285, 285, 285, 285, 285, 
	340, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T454[] =
    {
	433, 433, 611, 434, 433, 610, 433, 433, 611, -1, 433, 433, 433, 433, 433, 
	433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 
	433, 433
    };

static const ANTLR3_INT32 dfa4_T455[] =
    {
	666
    };

static const ANTLR3_INT32 dfa4_T456[] =
    {
	6, 6, 6, 6, 6, 203, 6, 6, 6, -1, 6, 6, 6, 6, 214, 215, 6, 6, 6, 6, 6, 6, 
	6, 6, 6, 6, 6, 6, 6, 6, 6, 6
    };

static const ANTLR3_INT32 dfa4_T457[] =
    {
	54, 54, 862, 37, 872, 863, 873, 54, 862, -1, 54, 54, 54, 54, 54, 35, 870, 
	54, 864, 865, 866, 868, 867, 871, 869, 874, 875, 876, 877, 878, 879, 880
    };

static const ANTLR3_INT32 dfa4_T458[] =
    {
	305, 305, 354, 385, 305, 355, 305, 305, 354, -1, 305, 305, 305, 305, 381, 
	382, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 
	305, 305
    };

static const ANTLR3_INT32 dfa4_T459[] =
    {
	54, 54, 77, 63, 54, 76, 54, 54, 77, -1, 54, 54, 54, 54, 84, 95, 54, 54, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T460[] =
    {
	559, 559, 834, 624, 843, 833, 844, 559, 834, -1, 559, 559, 559, 559, 559, 
	557, 841, 559, 835, 836, 837, 839, 838, 842, 840, 845, 846, 847, 848, 849, 
	850, 851
    };

static const ANTLR3_INT32 dfa4_T461[] =
    {
	285, 285, 346, 321, 285, 345, 285, 285, 346, -1, 285, 285, 285, 285, 369, 
	375, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T462[] =
    {
	54, 54, 54, 37, 54, 109, 54, 54, 54, -1, 54, 54, 54, 54, 54, 169, 54, 54, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T463[] =
    {
	398, 401, 395, 394, 399, 393, 397, 401, 395, -1, 401, 401, 401, 401, 400, 
	502, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 
	401, 401
    };

static const ANTLR3_INT32 dfa4_T464[] =
    {
	105, 108, 101, 102, 106, 100, 104, 108, 101, -1, 108, 108, 108, 108, 107, 
	143, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 
	108, 108
    };

static const ANTLR3_INT32 dfa4_T465[] =
    {
	324, 305, 286, 325, 296, 287, 297, 305, 286, -1, 305, 305, 305, 305, 305, 
	328, 294, 305, 288, 289, 290, 292, 291, 295, 293, 298, 299, 300, 301, 302, 
	303, 304
    };

static const ANTLR3_INT32 dfa4_T466[] =
    {
	285, 285, 310, 266, 275, 311, 276, 285, 310, -1, 285, 285, 285, 285, 285, 
	285, 273, 285, 267, 268, 269, 271, 270, 274, 272, 277, 278, 279, 280, 281, 
	282, 283
    };

static const ANTLR3_INT32 dfa4_T467[] =
    {
	285, 285, 597, 641, 514, 605, 515, 285, 597, -1, 285, 285, 285, 285, 285, 
	642, 512, 285, 506, 507, 508, 510, 509, 513, 511, 516, 517, 518, 519, 520, 
	521, 522
    };

static const ANTLR3_INT32 dfa4_T468[] =
    {
	559, 559, 834, 624, 843, 939, 844, 559, 834, -1, 559, 559, 559, 559, 559, 
	557, 841, 559, 835, 836, 837, 839, 838, 842, 840, 845, 846, 847, 848, 849, 
	850, 851
    };

static const ANTLR3_INT32 dfa4_T469[] =
    {
	54, 54, 62, 63, 54, 89, 54, 54, 62, -1, 54, 54, 54, 54, 54, 35, 54, 54, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T470[] =
    {
	633
    };

static const ANTLR3_INT32 dfa4_T471[] =
    {
	305, 305, 562, 628, 571, 561, 572, 305, 562, -1, 305, 305, 305, 305, 305, 
	439, 569, 305, 563, 564, 565, 567, 566, 570, 568, 573, 574, 575, 576, 577, 
	578, 579
    };

static const ANTLR3_INT32 dfa4_T472[] =
    {
	6, 6, 6, 24, 6, 27, 6, 6, 6, -1, 6, 6, 6, 6, 23, 6, 6, 6, 6, 6, 6, 6, 6, 
	6, 6, 6, 6, 6, 6, 6, 6, 6
    };

static const ANTLR3_INT32 dfa4_T473[] =
    {
	54, 54, 54, 63, 54, 54, 54, 54, 54, -1, 54, 54, 54, 54, 54, 35, 54, 54, 
	54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54
    };

static const ANTLR3_INT32 dfa4_T474[] =
    {
	559, 559, 925, 923, 843, 970, 844, 559, 925, -1, 559, 559, 559, 559, 559, 
	924, 841, 559, 835, 836, 837, 839, 838, 842, 840, 845, 846, 847, 848, 849, 
	850, 851
    };

static const ANTLR3_INT32 dfa4_T475[] =
    {
	971
    };

static const ANTLR3_INT32 dfa4_T476[] =
    {
	211
    };

static const ANTLR3_INT32 dfa4_T477[] =
    {
	6, 6, 6, 6, 6, 226, 6, 6, 6, -1, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 
	6, 6, 6, 6, 6, 6, 6, 6, 6
    };

static const ANTLR3_INT32 dfa4_T478[] =
    {
	796, 796, 796, 558, 796, 1004, 796, 796, 796, -1, 796, 796, 796, 796, 796, 
	827, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, 
	796, 796
    };

static const ANTLR3_INT32 dfa4_T479[] =
    {
	692
    };

static const ANTLR3_INT32 dfa4_T480[] =
    {
	285, 285, 361, 341, 285, 371, 285, 285, 361, -1, 285, 285, 285, 285, 285, 
	370, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, 
	285, 285
    };

static const ANTLR3_INT32 dfa4_T481[] =
    {
	917
    };

static const ANTLR3_INT32 dfa4_T482[] =
    {
	54, 54, 34, 37, 45, 33, 46, 54, 34, -1, 54, 54, 54, 54, 54, 35, 43, 54, 
	36, 38, 39, 41, 40, 44, 42, 47, 48, 49, 50, 51, 52, 53
    };


/* Transition tables are a table of sub tables, with some tables
 * reused for efficiency.
 */
static const ANTLR3_INT32 * const dfa4_transitions[] =
{
    dfa4_T187, dfa4_T88, dfa4_T88, dfa4_T211, dfa4_T286, dfa4_T310, NULL, 
    dfa4_T194, dfa4_T286, dfa4_T94, dfa4_T184, dfa4_T186, dfa4_T186, dfa4_T396, 
    dfa4_T417, dfa4_T289, dfa4_T228, dfa4_T232, dfa4_T289, dfa4_T289, dfa4_T289, 
    dfa4_T289, dfa4_T289, dfa4_T50, dfa4_T223, dfa4_T127, dfa4_T140, dfa4_T472, 
    dfa4_T127, NULL, dfa4_T222, dfa4_T222, dfa4_T482, dfa4_T380, dfa4_T17, 
    dfa4_T285, dfa4_T360, dfa4_T239, dfa4_T360, dfa4_T360, dfa4_T360, dfa4_T360, 
    dfa4_T360, dfa4_T360, dfa4_T360, dfa4_T360, dfa4_T360, dfa4_T360, dfa4_T360, 
    dfa4_T360, dfa4_T360, dfa4_T360, dfa4_T360, dfa4_T360, dfa4_T423, dfa4_T174, 
    dfa4_T319, dfa4_T280, dfa4_T204, dfa4_T325, dfa4_T325, dfa4_T285, dfa4_T473, 
    dfa4_T315, dfa4_T229, dfa4_T360, dfa4_T360, dfa4_T170, dfa4_T367, dfa4_T22, 
    dfa4_T393, dfa4_T469, dfa4_T113, dfa4_T170, dfa4_T263, dfa4_T229, dfa4_T459, 
    dfa4_T130, dfa4_T146, dfa4_T140, dfa4_T179, dfa4_T179, dfa4_T452, dfa4_T267, 
    dfa4_T387, dfa4_T324, dfa4_T54, dfa4_T54, dfa4_T140, dfa4_T293, dfa4_T113, 
    dfa4_T29, dfa4_T431, dfa4_T316, dfa4_T395, dfa4_T259, dfa4_T321, dfa4_T157, 
    dfa4_T275, dfa4_T127, dfa4_T464, dfa4_T190, dfa4_T384, dfa4_T399, dfa4_T123, 
    dfa4_T123, dfa4_T123, dfa4_T413, dfa4_T356, dfa4_T462, dfa4_T5, dfa4_T221, 
    dfa4_T151, dfa4_T151, dfa4_T151, dfa4_T435, dfa4_T151, dfa4_T198, dfa4_T432, 
    dfa4_T138, dfa4_T170, dfa4_T259, dfa4_T321, dfa4_T123, dfa4_T32, dfa4_T14, 
    dfa4_T115, dfa4_T115, dfa4_T115, dfa4_T115, dfa4_T115, dfa4_T115, dfa4_T115, 
    dfa4_T115, dfa4_T115, dfa4_T115, dfa4_T115, dfa4_T115, dfa4_T115, dfa4_T115, 
    dfa4_T115, dfa4_T115, dfa4_T115, dfa4_T105, dfa4_T123, dfa4_T123, dfa4_T140, 
    dfa4_T368, dfa4_T41, dfa4_T1, dfa4_T1, dfa4_T1, dfa4_T1, dfa4_T1, dfa4_T1, 
    dfa4_T1, dfa4_T1, dfa4_T1, dfa4_T1, dfa4_T1, dfa4_T1, dfa4_T1, dfa4_T1, 
    dfa4_T1, dfa4_T1, dfa4_T1, dfa4_T309, dfa4_T345, dfa4_T351, dfa4_T356, 
    dfa4_T151, dfa4_T151, dfa4_T379, dfa4_T143, dfa4_T101, dfa4_T189, dfa4_T139, 
    dfa4_T206, dfa4_T206, dfa4_T375, dfa4_T241, dfa4_T32, dfa4_T273, dfa4_T265, 
    dfa4_T329, dfa4_T115, dfa4_T115, dfa4_T266, dfa4_T153, dfa4_T371, dfa4_T79, 
    dfa4_T1, dfa4_T1, dfa4_T476, dfa4_T170, dfa4_T34, dfa4_T189, dfa4_T29, 
    dfa4_T124, dfa4_T352, dfa4_T329, dfa4_T170, dfa4_T283, dfa4_T456, dfa4_T176, 
    dfa4_T400, dfa4_T371, dfa4_T82, dfa4_T83, dfa4_T354, dfa4_T63, dfa4_T109, 
    dfa4_T402, dfa4_T314, dfa4_T477, dfa4_T249, dfa4_T63, dfa4_T382, dfa4_T58, 
    dfa4_T42, dfa4_T61, dfa4_T61, dfa4_T201, dfa4_T201, dfa4_T134, dfa4_T170, 
    dfa4_T102, dfa4_T249, dfa4_T440, dfa4_T249, dfa4_T249, dfa4_T249, dfa4_T249, 
    dfa4_T23, dfa4_T10, dfa4_T217, dfa4_T217, dfa4_T38, dfa4_T378, dfa4_T128, 
    dfa4_T363, dfa4_T10, dfa4_T161, dfa4_T103, dfa4_T103, dfa4_T103, dfa4_T103, 
    dfa4_T103, dfa4_T103, dfa4_T103, dfa4_T103, dfa4_T103, dfa4_T103, dfa4_T103, 
    dfa4_T103, dfa4_T103, dfa4_T103, dfa4_T103, dfa4_T103, dfa4_T103, dfa4_T103, 
    dfa4_T446, dfa4_T466, dfa4_T408, dfa4_T344, dfa4_T410, dfa4_T305, dfa4_T26, 
    dfa4_T26, dfa4_T26, dfa4_T26, dfa4_T26, dfa4_T26, dfa4_T26, dfa4_T26, 
    dfa4_T26, dfa4_T26, dfa4_T26, dfa4_T26, dfa4_T26, dfa4_T26, dfa4_T26, 
    dfa4_T26, dfa4_T26, dfa4_T114, dfa4_T294, dfa4_T334, dfa4_T465, dfa4_T150, 
    dfa4_T150, dfa4_T150, dfa4_T150, dfa4_T150, dfa4_T150, dfa4_T150, dfa4_T150, 
    dfa4_T150, dfa4_T150, dfa4_T150, dfa4_T150, dfa4_T150, dfa4_T150, dfa4_T150, 
    dfa4_T150, dfa4_T150, dfa4_T386, dfa4_T214, dfa4_T312, dfa4_T406, dfa4_T103, 
    dfa4_T235, dfa4_T369, dfa4_T149, dfa4_T183, dfa4_T335, dfa4_T235, dfa4_T180, 
    dfa4_T132, dfa4_T93, dfa4_T26, dfa4_T26, dfa4_T374, dfa4_T114, dfa4_T337, 
    dfa4_T437, dfa4_T81, dfa4_T334, dfa4_T250, dfa4_T240, dfa4_T216, dfa4_T150, 
    dfa4_T150, dfa4_T173, dfa4_T127, dfa4_T13, dfa4_T122, dfa4_T116, dfa4_T322, 
    dfa4_T372, dfa4_T480, dfa4_T336, dfa4_T445, dfa4_T132, dfa4_T213, dfa4_T93, 
    dfa4_T461, dfa4_T110, dfa4_T218, dfa4_T218, dfa4_T220, dfa4_T318, dfa4_T216, 
    dfa4_T132, dfa4_T284, dfa4_T159, dfa4_T458, dfa4_T193, dfa4_T193, dfa4_T169, 
    dfa4_T169, dfa4_T160, dfa4_T33, dfa4_T364, dfa4_T322, dfa4_T185, dfa4_T300, 
    dfa4_T377, dfa4_T342, dfa4_T36, dfa4_T246, dfa4_T414, dfa4_T33, dfa4_T118, 
    dfa4_T220, dfa4_T31, dfa4_T332, dfa4_T403, dfa4_T12, dfa4_T56, dfa4_T56, 
    dfa4_T438, dfa4_T343, dfa4_T219, dfa4_T258, dfa4_T159, dfa4_T302, dfa4_T39, 
    dfa4_T156, dfa4_T96, dfa4_T129, dfa4_T370, dfa4_T301, dfa4_T346, dfa4_T463, 
    dfa4_T255, dfa4_T166, dfa4_T260, dfa4_T96, dfa4_T96, dfa4_T96, dfa4_T291, 
    dfa4_T209, dfa4_T127, dfa4_T326, dfa4_T6, dfa4_T199, dfa4_T129, dfa4_T129, 
    dfa4_T129, dfa4_T307, dfa4_T19, dfa4_T132, dfa4_T332, dfa4_T403, dfa4_T70, 
    dfa4_T252, dfa4_T167, dfa4_T167, dfa4_T167, dfa4_T167, dfa4_T167, dfa4_T167, 
    dfa4_T167, dfa4_T167, dfa4_T167, dfa4_T167, dfa4_T167, dfa4_T167, dfa4_T167, 
    dfa4_T167, dfa4_T167, dfa4_T167, dfa4_T167, dfa4_T136, dfa4_T416, dfa4_T295, 
    dfa4_T132, dfa4_T427, dfa4_T219, dfa4_T308, dfa4_T52, dfa4_T219, dfa4_T219, 
    dfa4_T219, dfa4_T219, dfa4_T383, dfa4_T317, dfa4_T258, dfa4_T258, dfa4_T258, 
    dfa4_T258, dfa4_T258, dfa4_T404, dfa4_T127, dfa4_T152, dfa4_T298, dfa4_T98, 
    dfa4_T98, dfa4_T98, dfa4_T98, dfa4_T98, dfa4_T98, dfa4_T98, dfa4_T98, 
    dfa4_T98, dfa4_T98, dfa4_T98, dfa4_T98, dfa4_T98, dfa4_T98, dfa4_T98, 
    dfa4_T98, dfa4_T98, dfa4_T43, dfa4_T27, dfa4_T231, dfa4_T231, dfa4_T231, 
    dfa4_T231, dfa4_T231, dfa4_T231, dfa4_T231, dfa4_T231, dfa4_T231, dfa4_T231, 
    dfa4_T231, dfa4_T231, dfa4_T231, dfa4_T231, dfa4_T231, dfa4_T231, dfa4_T231, 
    dfa4_T155, dfa4_T96, dfa4_T200, dfa4_T96, dfa4_T129, dfa4_T129, dfa4_T127, 
    dfa4_T451, dfa4_T247, dfa4_T247, dfa4_T429, dfa4_T220, dfa4_T230, dfa4_T391, 
    dfa4_T327, dfa4_T327, dfa4_T327, dfa4_T327, dfa4_T327, dfa4_T327, dfa4_T327, 
    dfa4_T327, dfa4_T327, dfa4_T327, dfa4_T327, dfa4_T327, dfa4_T327, dfa4_T327, 
    dfa4_T327, dfa4_T327, dfa4_T327, dfa4_T47, dfa4_T209, dfa4_T76, dfa4_T16, 
    dfa4_T453, dfa4_T424, dfa4_T205, dfa4_T313, dfa4_T70, dfa4_T454, dfa4_T448, 
    dfa4_T97, dfa4_T167, dfa4_T167, dfa4_T84, dfa4_T168, dfa4_T89, dfa4_T40, 
    dfa4_T40, dfa4_T40, dfa4_T40, dfa4_T40, dfa4_T40, dfa4_T40, dfa4_T40, 
    dfa4_T40, dfa4_T40, dfa4_T40, dfa4_T40, dfa4_T40, dfa4_T40, dfa4_T40, 
    dfa4_T40, dfa4_T40, dfa4_T64, dfa4_T3, dfa4_T11, dfa4_T317, dfa4_T471, 
    dfa4_T69, dfa4_T69, dfa4_T69, dfa4_T69, dfa4_T69, dfa4_T69, dfa4_T69, 
    dfa4_T69, dfa4_T69, dfa4_T69, dfa4_T69, dfa4_T69, dfa4_T69, dfa4_T69, 
    dfa4_T69, dfa4_T69, dfa4_T69, dfa4_T69, dfa4_T173, dfa4_T175, dfa4_T207, 
    dfa4_T152, dfa4_T405, dfa4_T226, dfa4_T320, dfa4_T98, dfa4_T98, dfa4_T470, 
    dfa4_T43, dfa4_T172, dfa4_T60, dfa4_T231, dfa4_T231, dfa4_T132, dfa4_T381, 
    dfa4_T327, dfa4_T16, dfa4_T185, dfa4_T385, dfa4_T227, dfa4_T80, dfa4_T467, 
    dfa4_T158, dfa4_T327, dfa4_T57, dfa4_T51, dfa4_T97, dfa4_T28, dfa4_T2, 
    dfa4_T397, dfa4_T243, dfa4_T181, dfa4_T181, dfa4_T74, dfa4_T394, dfa4_T144, 
    dfa4_T144, dfa4_T411, dfa4_T392, dfa4_T341, dfa4_T40, dfa4_T40, dfa4_T95, 
    dfa4_T64, dfa4_T78, dfa4_T28, dfa4_T455, dfa4_T69, dfa4_T104, dfa4_T320, 
    dfa4_T84, dfa4_T173, dfa4_T353, dfa4_T60, dfa4_T125, dfa4_T227, dfa4_T420, 
    dfa4_T162, dfa4_T208, dfa4_T261, dfa4_T268, dfa4_T63, dfa4_T109, dfa4_T177, 
    dfa4_T210, dfa4_T210, dfa4_T86, dfa4_T145, dfa4_T24, dfa4_T397, dfa4_T479, 
    dfa4_T276, dfa4_T436, dfa4_T341, dfa4_T28, dfa4_T361, dfa4_T248, dfa4_T348, 
    dfa4_T121, dfa4_T53, dfa4_T269, dfa4_T75, dfa4_T188, dfa4_T4, dfa4_T13, 
    dfa4_T73, dfa4_T358, dfa4_T357, dfa4_T58, dfa4_T390, dfa4_T63, dfa4_T237, 
    dfa4_T46, dfa4_T245, dfa4_T197, dfa4_T145, dfa4_T37, dfa4_T145, dfa4_T145, 
    dfa4_T145, dfa4_T145, dfa4_T133, dfa4_T48, dfa4_T299, dfa4_T24, dfa4_T24, 
    dfa4_T24, dfa4_T24, dfa4_T24, dfa4_T164, dfa4_T127, dfa4_T339, dfa4_T415, 
    dfa4_T0, dfa4_T0, dfa4_T0, dfa4_T0, dfa4_T0, dfa4_T0, dfa4_T0, dfa4_T0, 
    dfa4_T0, dfa4_T0, dfa4_T0, dfa4_T0, dfa4_T0, dfa4_T0, dfa4_T0, dfa4_T0, 
    dfa4_T0, dfa4_T278, dfa4_T398, dfa4_T303, dfa4_T450, dfa4_T71, dfa4_T163, 
    dfa4_T303, dfa4_T85, dfa4_T282, dfa4_T53, dfa4_T126, dfa4_T20, dfa4_T100, 
    dfa4_T171, dfa4_T359, dfa4_T4, dfa4_T256, dfa4_T256, dfa4_T7, dfa4_T173, 
    dfa4_T117, dfa4_T388, dfa4_T233, dfa4_T233, dfa4_T290, dfa4_T376, dfa4_T68, 
    dfa4_T68, dfa4_T68, dfa4_T68, dfa4_T68, dfa4_T68, dfa4_T68, dfa4_T68, 
    dfa4_T68, dfa4_T68, dfa4_T68, dfa4_T68, dfa4_T68, dfa4_T68, dfa4_T68, 
    dfa4_T68, dfa4_T68, dfa4_T48, dfa4_T264, dfa4_T195, dfa4_T195, dfa4_T195, 
    dfa4_T195, dfa4_T195, dfa4_T195, dfa4_T195, dfa4_T195, dfa4_T195, dfa4_T195, 
    dfa4_T195, dfa4_T195, dfa4_T195, dfa4_T195, dfa4_T195, dfa4_T195, dfa4_T195, 
    dfa4_T195, dfa4_T409, dfa4_T7, dfa4_T428, dfa4_T296, dfa4_T419, dfa4_T339, 
    dfa4_T244, dfa4_T0, dfa4_T0, dfa4_T46, dfa4_T18, dfa4_T111, dfa4_T67, 
    dfa4_T71, dfa4_T460, dfa4_T439, dfa4_T401, dfa4_T18, dfa4_T18, dfa4_T18, 
    dfa4_T8, dfa4_T433, dfa4_T163, dfa4_T421, dfa4_T111, dfa4_T111, dfa4_T111, 
    dfa4_T35, dfa4_T251, dfa4_T127, dfa4_T21, dfa4_T418, dfa4_T277, dfa4_T292, 
    dfa4_T457, dfa4_T202, dfa4_T202, dfa4_T92, dfa4_T271, dfa4_T389, dfa4_T290, 
    dfa4_T49, dfa4_T9, dfa4_T362, dfa4_T68, dfa4_T68, dfa4_T212, dfa4_T195, 
    dfa4_T272, dfa4_T244, dfa4_T84, dfa4_T18, dfa4_T422, dfa4_T365, dfa4_T18, 
    dfa4_T111, dfa4_T111, dfa4_T433, dfa4_T444, dfa4_T142, dfa4_T65, dfa4_T65, 
    dfa4_T65, dfa4_T65, dfa4_T65, dfa4_T65, dfa4_T65, dfa4_T65, dfa4_T65, 
    dfa4_T65, dfa4_T65, dfa4_T65, dfa4_T65, dfa4_T65, dfa4_T65, dfa4_T65, 
    dfa4_T65, dfa4_T355, dfa4_T311, dfa4_T328, dfa4_T191, dfa4_T236, dfa4_T234, 
    dfa4_T234, dfa4_T287, dfa4_T238, dfa4_T192, dfa4_T350, dfa4_T253, dfa4_T203, 
    dfa4_T203, dfa4_T203, dfa4_T203, dfa4_T203, dfa4_T203, dfa4_T203, dfa4_T203, 
    dfa4_T203, dfa4_T203, dfa4_T203, dfa4_T203, dfa4_T203, dfa4_T203, dfa4_T203, 
    dfa4_T203, dfa4_T203, dfa4_T412, dfa4_T127, dfa4_T108, dfa4_T77, dfa4_T224, 
    dfa4_T362, dfa4_T28, dfa4_T13, dfa4_T481, dfa4_T131, dfa4_T65, dfa4_T46, 
    dfa4_T366, dfa4_T65, dfa4_T304, dfa4_T44, dfa4_T44, dfa4_T331, dfa4_T257, 
    dfa4_T442, dfa4_T287, dfa4_T126, dfa4_T91, dfa4_T434, dfa4_T112, dfa4_T165, 
    dfa4_T165, dfa4_T274, dfa4_T203, dfa4_T203, dfa4_T15, dfa4_T135, dfa4_T338, 
    dfa4_T108, dfa4_T330, dfa4_T99, dfa4_T84, dfa4_T63, dfa4_T109, dfa4_T147, 
    dfa4_T441, dfa4_T468, dfa4_T373, dfa4_T430, dfa4_T182, dfa4_T442, dfa4_T279, 
    dfa4_T107, dfa4_T274, dfa4_T28, dfa4_T15, dfa4_T349, dfa4_T281, dfa4_T59, 
    dfa4_T28, dfa4_T30, dfa4_T426, dfa4_T63, dfa4_T449, dfa4_T58, dfa4_T141, 
    dfa4_T196, dfa4_T323, dfa4_T347, dfa4_T281, dfa4_T340, dfa4_T340, dfa4_T297, 
    dfa4_T270, dfa4_T137, dfa4_T28, dfa4_T323, dfa4_T475, dfa4_T323, dfa4_T323, 
    dfa4_T323, dfa4_T323, dfa4_T120, dfa4_T347, dfa4_T347, dfa4_T347, dfa4_T347, 
    dfa4_T347, dfa4_T148, dfa4_T242, dfa4_T62, dfa4_T225, dfa4_T443, dfa4_T119, 
    dfa4_T474, dfa4_T84, dfa4_T45, dfa4_T72, dfa4_T262, dfa4_T154, dfa4_T55, 
    dfa4_T90, dfa4_T154, dfa4_T333, dfa4_T407, dfa4_T215, dfa4_T254, dfa4_T55, 
    dfa4_T178, dfa4_T288, dfa4_T215, dfa4_T215, dfa4_T215, dfa4_T478, dfa4_T90, 
    dfa4_T306, dfa4_T254, dfa4_T254, dfa4_T254, dfa4_T25, dfa4_T66, dfa4_T106, 
    dfa4_T215, dfa4_T87, dfa4_T215, dfa4_T254, dfa4_T254, dfa4_T4, dfa4_T425, 
    dfa4_T447, dfa4_T28
};

static ANTLR3_INT32 dfa4_sst(pbelle_sdpParser ctx, pANTLR3_BASE_RECOGNIZER recognizer, pANTLR3_INT_STREAM is, pANTLR3_CYCLIC_DFA dfa, ANTLR3_INT32 s)
{
    ANTLR3_INT32    _s;

    _s	    = s;
    switch  (s)
    {
        case 0:

    	{
    	    ANTLR3_UINT32 LA4_498;

    	    ANTLR3_MARKER index4_498;


    		LA4_498 = LA(1);

    	     
    	        index4_498 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(p))) )
    	    {
    	        s = 6;
    	    }

    	    else if ( ((IS_TOKEN(t))) )
    	    {
    	        s = 29;
    	    }

    		 
    			SEEK(index4_498);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;

        case 1:

    	{
    	    ANTLR3_UINT32 LA4_402;

    	    ANTLR3_MARKER index4_402;


    		LA4_402 = LA(1);

    	     
    	        index4_402 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(p))) )
    	    {
    	        s = 6;
    	    }

    	    else if ( ((IS_TOKEN(t))) )
    	    {
    	        s = 29;
    	    }

    		 
    			SEEK(index4_402);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;

        case 2:

    	{
    	    ANTLR3_UINT32 LA4_882;

    	    ANTLR3_MARKER index4_882;


    		LA4_882 = LA(1);

    	     
    	        index4_882 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(p))) )
    	    {
    	        s = 6;
    	    }

    	    else if ( ((IS_TOKEN(t))) )
    	    {
    	        s = 29;
    	    }

    		 
    			SEEK(index4_882);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;

        case 3:

    	{
    	    ANTLR3_UINT32 LA4_25;

    	    ANTLR3_MARKER index4_25;


    		LA4_25 = LA(1);

    	     
    	        index4_25 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(p))) )
    	    {
    	        s = 6;
    	    }

    	    else if ( ((IS_TOKEN(b))) )
    	    {
    	        s = 29;
    	    }

    		 
    			SEEK(index4_25);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;

        case 4:

    	{
    	    ANTLR3_UINT32 LA4_453;

    	    ANTLR3_MARKER index4_453;


    		LA4_453 = LA(1);

    	     
    	        index4_453 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(p))) )
    	    {
    	        s = 6;
    	    }

    	    else if ( ((IS_TOKEN(t))) )
    	    {
    	        s = 29;
    	    }

    		 
    			SEEK(index4_453);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;

        case 5:

    	{
    	    ANTLR3_UINT32 LA4_804;

    	    ANTLR3_MARKER index4_804;


    		LA4_804 = LA(1);

    	     
    	        index4_804 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(p))) )
    	    {
    	        s = 6;
    	    }

    	    else if ( ((IS_TOKEN(t))) )
    	    {
    	        s = 29;
    	    }

    		 
    			SEEK(index4_804);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;

        case 6:

    	{
    	    ANTLR3_UINT32 LA4_692;

    	    ANTLR3_MARKER index4_692;


    		LA4_692 = LA(1);

    	     
    	        index4_692 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(p))) )
    	    {
    	        s = 6;
    	    }

    	    else if ( ((IS_TOKEN(t))) )
    	    {
    	        s = 29;
    	    }

    		 
    			SEEK(index4_692);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;

        case 7:

    	{
    	    ANTLR3_UINT32 LA4_333;

    	    ANTLR3_MARKER index4_333;


    		LA4_333 = LA(1);

    	     
    	        index4_333 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(p))) )
    	    {
    	        s = 6;
    	    }

    	    else if ( ((IS_TOKEN(t))) )
    	    {
    	        s = 29;
    	    }

    		 
    			SEEK(index4_333);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;

        case 8:

    	{
    	    ANTLR3_UINT32 LA4_28;

    	    ANTLR3_MARKER index4_28;


    		LA4_28 = LA(1);

    	     
    	        index4_28 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(p))) )
    	    {
    	        s = 6;
    	    }

    	    else if ( ((IS_TOKEN(c))) )
    	    {
    	        s = 29;
    	    }

    		 
    			SEEK(index4_28);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;

        case 9:

    	{
    	    ANTLR3_UINT32 LA4_99;

    	    ANTLR3_MARKER index4_99;


    		LA4_99 = LA(1);

    	     
    	        index4_99 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(p))) )
    	    {
    	        s = 6;
    	    }

    	    else if ( ((IS_TOKEN(t))) )
    	    {
    	        s = 29;
    	    }

    		 
    			SEEK(index4_99);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;
    }
    if (BACKTRACKING > 0)
    {
	FAILEDFLAG = ANTLR3_TRUE;
	return	-1;
    }

    CONSTRUCTEX();
    EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
    EXCEPTION->message      = (void *)"()* loopback of 111:26: ( phone_field )*";
    EXCEPTION->decisionNum  = 4;
    EXCEPTION->state        = _s;
    return -1;
}


/* Declare tracking structure for Cyclic DFA 4
 */
static
ANTLR3_CYCLIC_DFA cdfa4
    =	{
	    4,		    /* Decision number of this dfa	    */
	    /* Which decision this represents:   */
	    (const pANTLR3_UCHAR)"()* loopback of 111:26: ( phone_field )*",
	    (CDFA_SPECIAL_FUNC) dfa4_sst,
	    antlr3dfaspecialTransition,		/* DFA specialTransition is currently just a default function in the runtime */
	    antlr3dfapredict,			/* DFA simulator function is in the runtime */
	    dfa4_eot,	    /* EOT table			    */
	    dfa4_eof,	    /* EOF table			    */
	    dfa4_min,	    /* Minimum tokens for each state    */
	    dfa4_max,	    /* Maximum tokens for each state    */
	    dfa4_accept,	/* Accept table			    */
	    dfa4_special,	/* Special transition states	    */
	    dfa4_transitions	/* Table of transition tables	    */

	};
/* End of Cyclic DFA 4
 * ---------------------
 *//** Static dfa state tables for Cyclic dfa:
 *    112:26: ( connection CR LF )?
 */
static const ANTLR3_INT32 dfa5_eot[11] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa5_eof[11] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa5_min[11] =
    {
	6, 11, 11, 6, 4, 4, -1, 4, -1, 6, 6
    };
static const ANTLR3_INT32 dfa5_max[11] =
    {
	12, 11, 11, 12, 19, 19, -1, 19, -1, 12, 19
    };
static const ANTLR3_INT32 dfa5_accept[11] =
    {
	-1, -1, -1, -1, -1, -1, 1, -1, 2, -1, -1
    };
static const ANTLR3_INT32 dfa5_special[11] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
    };

/** Used when there is no transition table entry for a particular state */
#define dfa5_T_empty	    NULL

static const ANTLR3_INT32 dfa5_T0[] =
    {
	1, -1, -1, 2, -1, -1, 1
    };

static const ANTLR3_INT32 dfa5_T1[] =
    {
	3
    };

static const ANTLR3_INT32 dfa5_T2[] =
    {
	8, -1, 4, -1, -1, 7, -1, -1, 4, -1, -1, -1, -1, -1, -1, 6
    };

static const ANTLR3_INT32 dfa5_T3[] =
    {
	4, -1, -1, 5, -1, -1, 4
    };

static const ANTLR3_INT32 dfa5_T4[] =
    {
	6, -1, -1, 10, -1, -1, 6
    };

static const ANTLR3_INT32 dfa5_T5[] =
    {
	6, 8, -1, 10, -1, -1, 6, -1, -1, -1, -1, -1, -1, 6
    };

static const ANTLR3_INT32 dfa5_T6[] =
    {
	8, -1, 4, -1, -1, 5, -1, -1, 4, -1, -1, -1, -1, -1, -1, 9
    };


/* Transition tables are a table of sub tables, with some tables
 * reused for efficiency.
 */
static const ANTLR3_INT32 * const dfa5_transitions[] =
{
    dfa5_T0, dfa5_T1, dfa5_T1, dfa5_T3, dfa5_T2, dfa5_T6, NULL, dfa5_T2, 
    NULL, dfa5_T4, dfa5_T5
};


/* Declare tracking structure for Cyclic DFA 5
 */
static
ANTLR3_CYCLIC_DFA cdfa5
    =	{
	    5,		    /* Decision number of this dfa	    */
	    /* Which decision this represents:   */
	    (const pANTLR3_UCHAR)"112:26: ( connection CR LF )?",
	    (CDFA_SPECIAL_FUNC) antlr3dfaspecialStateTransition,	/* Default special state transition function	*/

	    antlr3dfaspecialTransition,		/* DFA specialTransition is currently just a default function in the runtime */
	    antlr3dfapredict,			/* DFA simulator function is in the runtime */
	    dfa5_eot,	    /* EOT table			    */
	    dfa5_eof,	    /* EOF table			    */
	    dfa5_min,	    /* Minimum tokens for each state    */
	    dfa5_max,	    /* Maximum tokens for each state    */
	    dfa5_accept,	/* Accept table			    */
	    dfa5_special,	/* Special transition states	    */
	    dfa5_transitions	/* Table of transition tables	    */

	};
/* End of Cyclic DFA 5
 * ---------------------
 *//** Static dfa state tables for Cyclic dfa:
 *    ()* loopback of 113:26: ( bandwidth CR LF )*
 */
static const ANTLR3_INT32 dfa6_eot[7] =
    {
	-1, -1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa6_eof[7] =
    {
	-1, -1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa6_min[7] =
    {
	6, 11, 11, 6, 4, -1, -1
    };
static const ANTLR3_INT32 dfa6_max[7] =
    {
	12, 11, 11, 12, 19, -1, -1
    };
static const ANTLR3_INT32 dfa6_accept[7] =
    {
	-1, -1, -1, -1, -1, 1, 2
    };
static const ANTLR3_INT32 dfa6_special[7] =
    {
	-1, -1, -1, -1, -1, -1, -1
    };

/** Used when there is no transition table entry for a particular state */
#define dfa6_T_empty	    NULL

static const ANTLR3_INT32 dfa6_T0[] =
    {
	3
    };

static const ANTLR3_INT32 dfa6_T1[] =
    {
	1, -1, -1, 2, -1, -1, 1
    };

static const ANTLR3_INT32 dfa6_T2[] =
    {
	5, -1, -1, 4, -1, -1, 5
    };

static const ANTLR3_INT32 dfa6_T3[] =
    {
	5, -1, 5, -1, -1, 4, -1, -1, 5, -1, -1, -1, -1, -1, -1, 6
    };


/* Transition tables are a table of sub tables, with some tables
 * reused for efficiency.
 */
static const ANTLR3_INT32 * const dfa6_transitions[] =
{
    dfa6_T1, dfa6_T0, dfa6_T0, dfa6_T2, dfa6_T3, NULL, NULL
};


/* Declare tracking structure for Cyclic DFA 6
 */
static
ANTLR3_CYCLIC_DFA cdfa6
    =	{
	    6,		    /* Decision number of this dfa	    */
	    /* Which decision this represents:   */
	    (const pANTLR3_UCHAR)"()* loopback of 113:26: ( bandwidth CR LF )*",
	    (CDFA_SPECIAL_FUNC) antlr3dfaspecialStateTransition,	/* Default special state transition function	*/

	    antlr3dfaspecialTransition,		/* DFA specialTransition is currently just a default function in the runtime */
	    antlr3dfapredict,			/* DFA simulator function is in the runtime */
	    dfa6_eot,	    /* EOT table			    */
	    dfa6_eof,	    /* EOF table			    */
	    dfa6_min,	    /* Minimum tokens for each state    */
	    dfa6_max,	    /* Maximum tokens for each state    */
	    dfa6_accept,	/* Accept table			    */
	    dfa6_special,	/* Special transition states	    */
	    dfa6_transitions	/* Table of transition tables	    */

	};
/* End of Cyclic DFA 6
 * ---------------------
 *//** Static dfa state tables for Cyclic dfa:
 *    ()* loopback of 115:26: ( repeat_time CR LF )*
 */
static const ANTLR3_INT32 dfa7_eot[42] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa7_eof[42] =
    {
	3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa7_min[42] =
    {
	6, 11, 11, -1, 4, 4, 4, 4, 4, 4, 13, 4, 4, 4, 4, 4, 13, 4, 0, 4, 4, 0, 
	4, -1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 13, 13, 4, 0, 0, 4
    };
static const ANTLR3_INT32 dfa7_max[42] =
    {
	12, 11, 11, -1, 35, 35, 35, 35, 35, 35, 13, 35, 35, 35, 35, 35, 13, 35, 
	0, 35, 35, 0, 35, -1, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 13, 
	13, 35, 0, 0, 35
    };
static const ANTLR3_INT32 dfa7_accept[42] =
    {
	-1, -1, -1, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa7_special[42] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	0, -1, -1, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, 1, 3, -1
    };

/** Used when there is no transition table entry for a particular state */
#define dfa7_T_empty	    NULL

static const ANTLR3_INT32 dfa7_T0[] =
    {
	18
    };

static const ANTLR3_INT32 dfa7_T1[] =
    {
	3, 3, 12, 10, 3, 11, 3, 3, 12, -1, 3, 3, 3, 3, 3, 7, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa7_T2[] =
    {
	3, 3, 25, 10, 3, 28, 3, 3, 25, -1, 3, 3, 3, 3, 3, 26, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa7_T3[] =
    {
	4
    };

static const ANTLR3_INT32 dfa7_T4[] =
    {
	3, 3, 3, 16, 3, 3, 3, 3, 3, -1, 3, 3, 3, 3, 3, 15, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa7_T5[] =
    {
	3, 3, 3, 37, 3, 3, 3, 3, 3, -1, 3, 3, 3, 3, 3, 38, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa7_T6[] =
    {
	1, -1, -1, 2, -1, -1, 1
    };

static const ANTLR3_INT32 dfa7_T7[] =
    {
	3, 3, 31, 36, 3, 41, 3, 3, 31, -1, 3, 3, 3, 3, 3, 29, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa7_T8[] =
    {
	3, 3, 6, 3, 3, 5, 3, 3, 6, -1, 3, 3, 3, 3, 3, 7, 3, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa7_T9[] =
    {
	3, 3, 3, 10, 3, 3, 3, 3, 3, -1, 3, 3, 3, 3, 3, 7, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa7_T10[] =
    {
	40
    };

static const ANTLR3_INT32 dfa7_T11[] =
    {
	3, 3, 12, 10, 3, 20, 3, 3, 12, -1, 3, 3, 3, 3, 3, 27, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa7_T12[] =
    {
	3, 3, 35, 16, 3, 34, 3, 3, 35, -1, 3, 3, 3, 3, 3, 15, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa7_T13[] =
    {
	3, 3, 35, 37, 3, 34, 3, 3, 35, -1, 3, 3, 3, 3, 3, 38, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa7_T14[] =
    {
	3, 3, 6, 3, 3, 5, 3, 3, 6, -1, 3, 3, 3, 3, 3, 8, 3, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa7_T15[] =
    {
	3, 3, 31, 10, 3, 30, 3, 3, 31, -1, 3, 3, 3, 3, 3, 7, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa7_T16[] =
    {
	3, 3, 3, 3, 3, 3, 3, 3, 3, -1, 3, 3, 3, 3, 3, 9, 3, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa7_T17[] =
    {
	3, 3, 33, 16, 3, 32, 3, 3, 33, -1, 3, 3, 3, 3, 3, 15, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa7_T18[] =
    {
	3, 3, 14, 16, 3, 13, 3, 3, 14, -1, 3, 3, 3, 3, 3, 15, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa7_T19[] =
    {
	21
    };

static const ANTLR3_INT32 dfa7_T20[] =
    {
	3, 3, 3, 10, 3, 3, 3, 3, 3, -1, 3, 3, 3, 3, 3, 26, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa7_T21[] =
    {
	3, 3, 12, 10, 3, 20, 3, 3, 12, -1, 3, 3, 3, 3, 3, 7, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa7_T22[] =
    {
	3, 3, 25, 10, 3, 24, 3, 3, 25, -1, 3, 3, 3, 3, 3, 26, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa7_T23[] =
    {
	3, 3, 12, 10, 3, 17, 3, 3, 12, -1, 3, 3, 3, 3, 3, 7, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa7_T24[] =
    {
	3, 3, 25, 10, 3, 24, 3, 3, 25, -1, 3, 3, 3, 3, 3, 29, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa7_T25[] =
    {
	3, 3, 31, 36, 3, 30, 3, 3, 31, -1, 3, 3, 3, 3, 3, 26, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa7_T26[] =
    {
	3, 3, 3, 36, 3, 3, 3, 3, 3, -1, 3, 3, 3, 3, 3, 26, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa7_T27[] =
    {
	-1
    };

static const ANTLR3_INT32 dfa7_T28[] =
    {
	39
    };

static const ANTLR3_INT32 dfa7_T29[] =
    {
	3, 3, 12, 10, 3, 17, 3, 3, 12, -1, 3, 3, 3, 3, 3, 22, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa7_T30[] =
    {
	3, 3, 14, 16, 3, 13, 3, 3, 14, -1, 3, 3, 3, 3, 3, 19, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa7_T31[] =
    {
	3, 3, 31, 10, 3, 41, 3, 3, 31, -1, 3, 3, 3, 3, 3, 7, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3
    };


/* Transition tables are a table of sub tables, with some tables
 * reused for efficiency.
 */
static const ANTLR3_INT32 * const dfa7_transitions[] =
{
    dfa7_T6, dfa7_T3, dfa7_T3, NULL, dfa7_T8, dfa7_T14, dfa7_T16, dfa7_T1, 
    dfa7_T18, dfa7_T23, dfa7_T0, dfa7_T1, dfa7_T9, dfa7_T30, dfa7_T4, dfa7_T21, 
    dfa7_T19, dfa7_T29, dfa7_T27, dfa7_T22, dfa7_T11, dfa7_T27, dfa7_T2, 
    NULL, dfa7_T24, dfa7_T20, dfa7_T15, dfa7_T17, dfa7_T2, dfa7_T12, dfa7_T25, 
    dfa7_T26, dfa7_T17, dfa7_T4, dfa7_T13, dfa7_T5, dfa7_T28, dfa7_T10, 
    dfa7_T31, dfa7_T27, dfa7_T27, dfa7_T7
};

static ANTLR3_INT32 dfa7_sst(pbelle_sdpParser ctx, pANTLR3_BASE_RECOGNIZER recognizer, pANTLR3_INT_STREAM is, pANTLR3_CYCLIC_DFA dfa, ANTLR3_INT32 s)
{
    ANTLR3_INT32    _s;

    _s	    = s;
    switch  (s)
    {
        case 0:

    	{
    	    ANTLR3_UINT32 LA7_18;

    	    ANTLR3_MARKER index7_18;


    		LA7_18 = LA(1);

    	     
    	        index7_18 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(r))) )
    	    {
    	        s = 23;
    	    }

    	    else if ( ((IS_TOKEN(k))) )
    	    {
    	        s = 3;
    	    }

    		 
    			SEEK(index7_18);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;

        case 1:

    	{
    	    ANTLR3_UINT32 LA7_39;

    	    ANTLR3_MARKER index7_39;


    		LA7_39 = LA(1);

    	     
    	        index7_39 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(r))) )
    	    {
    	        s = 23;
    	    }

    	    else if ( ((((IS_TOKEN(k)))||((IS_TOKEN(m))))) )
    	    {
    	        s = 3;
    	    }

    		 
    			SEEK(index7_39);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;

        case 2:

    	{
    	    ANTLR3_UINT32 LA7_21;

    	    ANTLR3_MARKER index7_21;


    		LA7_21 = LA(1);

    	     
    	        index7_21 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(r))) )
    	    {
    	        s = 23;
    	    }

    	    else if ( ((((IS_TOKEN(k)))||((IS_TOKEN(z))))) )
    	    {
    	        s = 3;
    	    }

    		 
    			SEEK(index7_21);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;

        case 3:

    	{
    	    ANTLR3_UINT32 LA7_40;

    	    ANTLR3_MARKER index7_40;


    		LA7_40 = LA(1);

    	     
    	        index7_40 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(r))) )
    	    {
    	        s = 23;
    	    }

    	    else if ( ((((IS_TOKEN(k)))||((IS_TOKEN(z)))||((IS_TOKEN(m))))) )
    	    {
    	        s = 3;
    	    }

    		 
    			SEEK(index7_40);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;
    }
    if (BACKTRACKING > 0)
    {
	FAILEDFLAG = ANTLR3_TRUE;
	return	-1;
    }

    CONSTRUCTEX();
    EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
    EXCEPTION->message      = (void *)"()* loopback of 115:26: ( repeat_time CR LF )*";
    EXCEPTION->decisionNum  = 7;
    EXCEPTION->state        = _s;
    return -1;
}


/* Declare tracking structure for Cyclic DFA 7
 */
static
ANTLR3_CYCLIC_DFA cdfa7
    =	{
	    7,		    /* Decision number of this dfa	    */
	    /* Which decision this represents:   */
	    (const pANTLR3_UCHAR)"()* loopback of 115:26: ( repeat_time CR LF )*",
	    (CDFA_SPECIAL_FUNC) dfa7_sst,
	    antlr3dfaspecialTransition,		/* DFA specialTransition is currently just a default function in the runtime */
	    antlr3dfapredict,			/* DFA simulator function is in the runtime */
	    dfa7_eot,	    /* EOT table			    */
	    dfa7_eof,	    /* EOF table			    */
	    dfa7_min,	    /* Minimum tokens for each state    */
	    dfa7_max,	    /* Maximum tokens for each state    */
	    dfa7_accept,	/* Accept table			    */
	    dfa7_special,	/* Special transition states	    */
	    dfa7_transitions	/* Table of transition tables	    */

	};
/* End of Cyclic DFA 7
 * ---------------------
 *//** Static dfa state tables for Cyclic dfa:
 *    116:26: ( zone_adjustments CR LF )?
 */
static const ANTLR3_INT32 dfa8_eot[31] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa8_eof[31] =
    {
	3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa8_min[31] =
    {
	6, 11, 11, -1, 4, 4, 4, 4, 4, 4, 4, 13, 4, 4, 4, 0, 4, 4, -1, 4, 4, 4, 
	4, 4, 4, 4, 4, 13, 4, 0, 4
    };
static const ANTLR3_INT32 dfa8_max[31] =
    {
	12, 11, 11, -1, 35, 35, 35, 35, 35, 35, 35, 13, 35, 35, 35, 0, 35, 35, 
	-1, 35, 35, 35, 35, 35, 35, 35, 35, 13, 35, 0, 35
    };
static const ANTLR3_INT32 dfa8_accept[31] =
    {
	-1, -1, -1, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa8_special[31] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1
    };

/** Used when there is no transition table entry for a particular state */
#define dfa8_T_empty	    NULL

static const ANTLR3_INT32 dfa8_T0[] =
    {
	-1
    };

static const ANTLR3_INT32 dfa8_T1[] =
    {
	3, 3, 3, 27, 3, 3, 3, 3, 3, -1, 3, 3, 3, 3, 3, 28, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa8_T2[] =
    {
	4
    };

static const ANTLR3_INT32 dfa8_T3[] =
    {
	3, 3, 25, 27, 3, 26, 3, 3, 25, -1, 3, 3, 3, 3, 3, 28, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa8_T4[] =
    {
	1, -1, -1, 2, -1, -1, 1
    };

static const ANTLR3_INT32 dfa8_T5[] =
    {
	3, 3, 25, 27, 3, 24, 3, 3, 25, -1, 3, 3, 3, 3, 3, 28, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa8_T6[] =
    {
	3, 3, 3, 3, 3, 30, 3, 3, 3, -1, 3, 3, 3, 3, 3, 19, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa8_T7[] =
    {
	15
    };

static const ANTLR3_INT32 dfa8_T8[] =
    {
	3, 3, 9, 11, 7, 8, 3, 3, 9, -1, 3, 3, 3, 3, 3, 10, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa8_T9[] =
    {
	3, 3, 22, 11, 3, 21, 3, 3, 22, -1, 3, 3, 3, 3, 3, 10, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa8_T10[] =
    {
	3, 3, 3, 3, 3, 14, 3, 3, 3, -1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa8_T11[] =
    {
	3, 3, 3, 3, 3, 16, 3, 3, 3, -1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa8_T12[] =
    {
	3, 3, 3, 3, 3, 14, 3, 3, 3, -1, 3, 3, 3, 3, 3, 17, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa8_T13[] =
    {
	3, 3, 9, 11, 3, 12, 3, 3, 9, -1, 3, 3, 3, 3, 3, 10, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa8_T14[] =
    {
	3, 3, 3, 3, 3, 16, 3, 3, 3, -1, 3, 3, 3, 3, 3, 19, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa8_T15[] =
    {
	3, 3, 22, 11, 20, 21, 3, 3, 22, -1, 3, 3, 3, 3, 3, 10, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa8_T16[] =
    {
	3, 3, 9, 11, 3, 8, 3, 3, 9, -1, 3, 3, 3, 3, 3, 13, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa8_T17[] =
    {
	3, 3, 3, 3, 3, 30, 3, 3, 3, -1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa8_T18[] =
    {
	3, 3, 3, 11, 3, 3, 3, 3, 3, -1, 3, 3, 3, 3, 3, 10, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa8_T19[] =
    {
	3, 3, 3, 3, 3, 5, 3, 3, 3, -1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa8_T20[] =
    {
	3, 3, 3, 3, 3, 5, 3, 3, 3, -1, 3, 3, 3, 3, 3, 6, 3, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa8_T21[] =
    {
	3, 3, 25, 11, 23, 24, 3, 3, 25, -1, 3, 3, 3, 3, 3, 10, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa8_T22[] =
    {
	29
    };


/* Transition tables are a table of sub tables, with some tables
 * reused for efficiency.
 */
static const ANTLR3_INT32 * const dfa8_transitions[] =
{
    dfa8_T4, dfa8_T2, dfa8_T2, NULL, dfa8_T19, dfa8_T20, dfa8_T8, dfa8_T13, 
    dfa8_T16, dfa8_T18, dfa8_T10, dfa8_T7, dfa8_T13, dfa8_T11, dfa8_T12, 
    dfa8_T0, dfa8_T14, dfa8_T15, NULL, dfa8_T21, dfa8_T9, dfa8_T9, dfa8_T18, 
    dfa8_T3, dfa8_T5, dfa8_T1, dfa8_T3, dfa8_T22, dfa8_T17, dfa8_T0, dfa8_T6
};

static ANTLR3_INT32 dfa8_sst(pbelle_sdpParser ctx, pANTLR3_BASE_RECOGNIZER recognizer, pANTLR3_INT_STREAM is, pANTLR3_CYCLIC_DFA dfa, ANTLR3_INT32 s)
{
    ANTLR3_INT32    _s;

    _s	    = s;
    switch  (s)
    {
        case 0:

    	{
    	    ANTLR3_UINT32 LA8_15;

    	    ANTLR3_MARKER index8_15;


    		LA8_15 = LA(1);

    	     
    	        index8_15 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(z))) )
    	    {
    	        s = 18;
    	    }

    	    else if ( ((IS_TOKEN(k))) )
    	    {
    	        s = 3;
    	    }

    		 
    			SEEK(index8_15);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;

        case 1:

    	{
    	    ANTLR3_UINT32 LA8_29;

    	    ANTLR3_MARKER index8_29;


    		LA8_29 = LA(1);

    	     
    	        index8_29 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(z))) )
    	    {
    	        s = 18;
    	    }

    	    else if ( ((((IS_TOKEN(k)))||((IS_TOKEN(m))))) )
    	    {
    	        s = 3;
    	    }

    		 
    			SEEK(index8_29);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;
    }
    if (BACKTRACKING > 0)
    {
	FAILEDFLAG = ANTLR3_TRUE;
	return	-1;
    }

    CONSTRUCTEX();
    EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
    EXCEPTION->message      = (void *)"116:26: ( zone_adjustments CR LF )?";
    EXCEPTION->decisionNum  = 8;
    EXCEPTION->state        = _s;
    return -1;
}


/* Declare tracking structure for Cyclic DFA 8
 */
static
ANTLR3_CYCLIC_DFA cdfa8
    =	{
	    8,		    /* Decision number of this dfa	    */
	    /* Which decision this represents:   */
	    (const pANTLR3_UCHAR)"116:26: ( zone_adjustments CR LF )?",
	    (CDFA_SPECIAL_FUNC) dfa8_sst,
	    antlr3dfaspecialTransition,		/* DFA specialTransition is currently just a default function in the runtime */
	    antlr3dfapredict,			/* DFA simulator function is in the runtime */
	    dfa8_eot,	    /* EOT table			    */
	    dfa8_eof,	    /* EOF table			    */
	    dfa8_min,	    /* Minimum tokens for each state    */
	    dfa8_max,	    /* Maximum tokens for each state    */
	    dfa8_accept,	/* Accept table			    */
	    dfa8_special,	/* Special transition states	    */
	    dfa8_transitions	/* Table of transition tables	    */

	};
/* End of Cyclic DFA 8
 * ---------------------
 *//** Static dfa state tables for Cyclic dfa:
 *    117:26: ( key_field CR LF )?
 */
static const ANTLR3_INT32 dfa9_eot[60] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa9_eof[60] =
    {
	3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa9_min[60] =
    {
	6, 11, 11, -1, 4, 4, -1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
	4, 4, 13, 4, 4, 4, 4, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
	4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 13, 4, 0
    };
static const ANTLR3_INT32 dfa9_max[60] =
    {
	12, 11, 11, -1, 35, 35, -1, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
	35, 35, 35, 35, 35, 35, 35, 13, 35, 35, 35, 35, 0, 35, 35, 35, 35, 35, 
	35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
	35, 35, 35, 13, 35, 0
    };
static const ANTLR3_INT32 dfa9_accept[60] =
    {
	-1, -1, -1, 2, -1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa9_special[60] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, 0
    };

/** Used when there is no transition table entry for a particular state */
#define dfa9_T_empty	    NULL

static const ANTLR3_INT32 dfa9_T0[] =
    {
	6, 6, 39, 57, 48, 58, 49, 6, 39, -1, 6, 6, 6, 6, 6, 37, 46, 6, 40, 41, 
	42, 44, 43, 47, 45, 50, 51, 52, 53, 54, 55, 56
    };

static const ANTLR3_INT32 dfa9_T1[] =
    {
	6, 6, 6, 6, 6, 35, 6, 6, 6, -1, 6, 6, 6, 6, 6, 34, 6, 6, 6, 6, 6, 6, 6, 
	6, 6, 6, 6, 6, 6, 6, 6, 6
    };

static const ANTLR3_INT32 dfa9_T2[] =
    {
	31, 31, 31, 25, 31, 31, 31, 31, 31, -1, 31, 31, 31, 31, 31, 31, 31, 31, 
	31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31
    };

static const ANTLR3_INT32 dfa9_T3[] =
    {
	26, 6, 28, 25, 16, 29, 17, 6, 28, -1, 6, 6, 6, 6, 6, 6, 14, 6, 8, 9, 10, 
	12, 11, 15, 13, 18, 19, 20, 21, 22, 23, 24
    };

static const ANTLR3_INT32 dfa9_T4[] =
    {
	26, 6, 5, 25, 16, 7, 17, 6, 5, -1, 6, 6, 6, 6, 6, 27, 14, 6, 8, 9, 10, 
	12, 11, 15, 13, 18, 19, 20, 21, 22, 23, 24
    };

static const ANTLR3_INT32 dfa9_T5[] =
    {
	6, 6, 6, 6, 6, 32, 6, 6, 6, -1, 6, 6, 6, 6, 33, 34, 6, 6, 6, 6, 6, 6, 6, 
	6, 6, 6, 6, 6, 6, 6, 6, 6
    };

static const ANTLR3_INT32 dfa9_T6[] =
    {
	36, 36, 36, 6, 36, 36, 36, 36, 36, -1, 36, 36, 36, 36, 36, 37, 36, 36, 
	36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36
    };

static const ANTLR3_INT32 dfa9_T7[] =
    {
	4
    };

static const ANTLR3_INT32 dfa9_T8[] =
    {
	6, 6, 39, 6, 48, 38, 49, 6, 39, -1, 6, 6, 6, 6, 6, 6, 46, 6, 40, 41, 42, 
	44, 43, 47, 45, 50, 51, 52, 53, 54, 55, 56
    };

static const ANTLR3_INT32 dfa9_T9[] =
    {
	6, 6, 6, 6, 6, 32, 6, 6, 6, -1, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 
	6, 6, 6, 6, 6, 6, 6, 6, 6
    };

static const ANTLR3_INT32 dfa9_T10[] =
    {
	1, -1, -1, 2, -1, -1, 1
    };

static const ANTLR3_INT32 dfa9_T11[] =
    {
	-1
    };

static const ANTLR3_INT32 dfa9_T12[] =
    {
	6, 6, 5, 6, 16, 7, 17, 6, 5, -1, 6, 6, 6, 6, 6, 6, 14, 6, 8, 9, 10, 12, 
	11, 15, 13, 18, 19, 20, 21, 22, 23, 24
    };

static const ANTLR3_INT32 dfa9_T13[] =
    {
	59
    };

static const ANTLR3_INT32 dfa9_T14[] =
    {
	30
    };

static const ANTLR3_INT32 dfa9_T15[] =
    {
	6, 6, 39, 57, 48, 38, 49, 6, 39, -1, 6, 6, 6, 6, 6, 37, 46, 6, 40, 41, 
	42, 44, 43, 47, 45, 50, 51, 52, 53, 54, 55, 56
    };

static const ANTLR3_INT32 dfa9_T16[] =
    {
	6, 6, 6, 6, 6, 35, 6, 6, 6, -1, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 
	6, 6, 6, 6, 6, 6, 6, 6, 6
    };


/* Transition tables are a table of sub tables, with some tables
 * reused for efficiency.
 */
static const ANTLR3_INT32 * const dfa9_transitions[] =
{
    dfa9_T10, dfa9_T7, dfa9_T7, NULL, dfa9_T12, dfa9_T4, NULL, dfa9_T4, 
    dfa9_T3, dfa9_T3, dfa9_T3, dfa9_T3, dfa9_T3, dfa9_T3, dfa9_T3, dfa9_T3, 
    dfa9_T3, dfa9_T3, dfa9_T3, dfa9_T3, dfa9_T3, dfa9_T3, dfa9_T3, dfa9_T3, 
    dfa9_T3, dfa9_T14, dfa9_T2, dfa9_T9, dfa9_T3, dfa9_T3, dfa9_T11, dfa9_T2, 
    dfa9_T5, dfa9_T16, dfa9_T6, dfa9_T1, dfa9_T6, dfa9_T8, dfa9_T15, dfa9_T0, 
    dfa9_T0, dfa9_T0, dfa9_T0, dfa9_T0, dfa9_T0, dfa9_T0, dfa9_T0, dfa9_T0, 
    dfa9_T0, dfa9_T0, dfa9_T0, dfa9_T0, dfa9_T0, dfa9_T0, dfa9_T0, dfa9_T0, 
    dfa9_T0, dfa9_T13, dfa9_T0, dfa9_T11
};

static ANTLR3_INT32 dfa9_sst(pbelle_sdpParser ctx, pANTLR3_BASE_RECOGNIZER recognizer, pANTLR3_INT_STREAM is, pANTLR3_CYCLIC_DFA dfa, ANTLR3_INT32 s)
{
    ANTLR3_INT32    _s;

    _s	    = s;
    switch  (s)
    {
        case 0:

    	{
    	    ANTLR3_UINT32 LA9_59;

    	    ANTLR3_MARKER index9_59;


    		LA9_59 = LA(1);

    	     
    	        index9_59 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(k))) )
    	    {
    	        s = 6;
    	    }

    	    else if ( ((IS_TOKEN(m))) )
    	    {
    	        s = 3;
    	    }

    		 
    			SEEK(index9_59);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;

        case 1:

    	{
    	    ANTLR3_UINT32 LA9_30;

    	    ANTLR3_MARKER index9_30;


    		LA9_30 = LA(1);

    	     
    	        index9_30 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(k))) )
    	    {
    	        s = 6;
    	    }

    	    else if ( ((IS_TOKEN(a))) )
    	    {
    	        s = 3;
    	    }

    		 
    			SEEK(index9_30);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;
    }
    if (BACKTRACKING > 0)
    {
	FAILEDFLAG = ANTLR3_TRUE;
	return	-1;
    }

    CONSTRUCTEX();
    EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
    EXCEPTION->message      = (void *)"117:26: ( key_field CR LF )?";
    EXCEPTION->decisionNum  = 9;
    EXCEPTION->state        = _s;
    return -1;
}


/* Declare tracking structure for Cyclic DFA 9
 */
static
ANTLR3_CYCLIC_DFA cdfa9
    =	{
	    9,		    /* Decision number of this dfa	    */
	    /* Which decision this represents:   */
	    (const pANTLR3_UCHAR)"117:26: ( key_field CR LF )?",
	    (CDFA_SPECIAL_FUNC) dfa9_sst,
	    antlr3dfaspecialTransition,		/* DFA specialTransition is currently just a default function in the runtime */
	    antlr3dfapredict,			/* DFA simulator function is in the runtime */
	    dfa9_eot,	    /* EOT table			    */
	    dfa9_eof,	    /* EOF table			    */
	    dfa9_min,	    /* Minimum tokens for each state    */
	    dfa9_max,	    /* Maximum tokens for each state    */
	    dfa9_accept,	/* Accept table			    */
	    dfa9_special,	/* Special transition states	    */
	    dfa9_transitions	/* Table of transition tables	    */

	};
/* End of Cyclic DFA 9
 * ---------------------
 *//** Static dfa state tables for Cyclic dfa:
 *    ()* loopback of 118:26: ( attribute CR LF )*
 */
static const ANTLR3_INT32 dfa10_eot[8] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa10_eof[8] =
    {
	3, -1, -1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa10_min[8] =
    {
	6, 11, 11, -1, 6, 4, 4, -1
    };
static const ANTLR3_INT32 dfa10_max[8] =
    {
	12, 11, 11, -1, 35, 35, 35, -1
    };
static const ANTLR3_INT32 dfa10_accept[8] =
    {
	-1, -1, -1, 2, -1, -1, -1, 1
    };
static const ANTLR3_INT32 dfa10_special[8] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1
    };

/** Used when there is no transition table entry for a particular state */
#define dfa10_T_empty	    NULL

static const ANTLR3_INT32 dfa10_T0[] =
    {
	4
    };

static const ANTLR3_INT32 dfa10_T1[] =
    {
	5, -1, 7, 6, 7, -1, 5, -1, -1, -1, -1, -1, -1, -1, 7, -1, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa10_T2[] =
    {
	7, -1, 5, 7, 7, 6, 7, -1, 5, -1, -1, -1, -1, -1, -1, 3, 7, -1, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa10_T3[] =
    {
	1, -1, -1, 2, -1, -1, 1
    };


/* Transition tables are a table of sub tables, with some tables
 * reused for efficiency.
 */
static const ANTLR3_INT32 * const dfa10_transitions[] =
{
    dfa10_T3, dfa10_T0, dfa10_T0, NULL, dfa10_T1, dfa10_T2, dfa10_T2, NULL
};


/* Declare tracking structure for Cyclic DFA 10
 */
static
ANTLR3_CYCLIC_DFA cdfa10
    =	{
	    10,		    /* Decision number of this dfa	    */
	    /* Which decision this represents:   */
	    (const pANTLR3_UCHAR)"()* loopback of 118:26: ( attribute CR LF )*",
	    (CDFA_SPECIAL_FUNC) antlr3dfaspecialStateTransition,	/* Default special state transition function	*/

	    antlr3dfaspecialTransition,		/* DFA specialTransition is currently just a default function in the runtime */
	    antlr3dfapredict,			/* DFA simulator function is in the runtime */
	    dfa10_eot,	    /* EOT table			    */
	    dfa10_eof,	    /* EOF table			    */
	    dfa10_min,	    /* Minimum tokens for each state    */
	    dfa10_max,	    /* Maximum tokens for each state    */
	    dfa10_accept,	/* Accept table			    */
	    dfa10_special,	/* Special transition states	    */
	    dfa10_transitions	/* Table of transition tables	    */

	};
/* End of Cyclic DFA 10
 * ---------------------
 *//** Static dfa state tables for Cyclic dfa:
 *    342:1: rtcp_fb_param : ( ( rtcp_fb_app_param )=> rtcp_fb_app_param | ( rtcp_fb_token_param )=> rtcp_fb_token_param );
 */
static const ANTLR3_INT32 dfa36_eot[6] =
    {
	-1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa36_eof[6] =
    {
	-1, 4, 4, -1, -1, -1
    };
static const ANTLR3_INT32 dfa36_min[6] =
    {
	6, 6, 6, 0, -1, -1
    };
static const ANTLR3_INT32 dfa36_max[6] =
    {
	12, 19, 19, 0, -1, -1
    };
static const ANTLR3_INT32 dfa36_accept[6] =
    {
	-1, -1, -1, -1, 2, 1
    };
static const ANTLR3_INT32 dfa36_special[6] =
    {
	-1, 0, 1, 2, -1, -1
    };

/** Used when there is no transition table entry for a particular state */
#define dfa36_T_empty	    NULL

static const ANTLR3_INT32 dfa36_T0[] =
    {
	1, -1, 2, -1, -1, -1, 1
    };

static const ANTLR3_INT32 dfa36_T1[] =
    {
	1, -1, 2, -1, -1, -1, 1, -1, -1, -1, -1, -1, -1, 3
    };

static const ANTLR3_INT32 dfa36_T2[] =
    {
	-1
    };


/* Transition tables are a table of sub tables, with some tables
 * reused for efficiency.
 */
static const ANTLR3_INT32 * const dfa36_transitions[] =
{
    dfa36_T0, dfa36_T1, dfa36_T1, dfa36_T2, NULL, NULL
};

static ANTLR3_INT32 dfa36_sst(pbelle_sdpParser ctx, pANTLR3_BASE_RECOGNIZER recognizer, pANTLR3_INT_STREAM is, pANTLR3_CYCLIC_DFA dfa, ANTLR3_INT32 s)
{
    ANTLR3_INT32    _s;

    _s	    = s;
    switch  (s)
    {
        case 0:

    	{
    	    ANTLR3_UINT32 LA36_1;

    	    ANTLR3_MARKER index36_1;


    		LA36_1 = LA(1);

    	     
    	        index36_1 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( (LA36_1 == SPACE) )
    	    {
    	        s = 3;
    	    }

    	    else if ( (LA36_1 == COMMON_CHAR || LA36_1 == HEX_CHAR) )
    	    {
    	        s = 1;
    	    }

    	    else if ( (LA36_1 == DASH) )
    	    {
    	        s = 2;
    	    }

    	    else if ( (synpred13_belle_sdp(ctx)) && (LA36_1 == EOF) )
    	    {
    	        s = 4;
    	    }

    		 
    			SEEK(index36_1);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;

        case 1:

    	{
    	    ANTLR3_UINT32 LA36_2;

    	    ANTLR3_MARKER index36_2;


    		LA36_2 = LA(1);

    	     
    	        index36_2 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( (LA36_2 == SPACE) )
    	    {
    	        s = 3;
    	    }

    	    else if ( (LA36_2 == COMMON_CHAR || LA36_2 == HEX_CHAR) )
    	    {
    	        s = 1;
    	    }

    	    else if ( (LA36_2 == DASH) )
    	    {
    	        s = 2;
    	    }

    	    else if ( (synpred13_belle_sdp(ctx)) && (LA36_2 == EOF) )
    	    {
    	        s = 4;
    	    }

    		 
    			SEEK(index36_2);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;

        case 2:

    	{
    	    ANTLR3_UINT32 LA36_3;

    	    ANTLR3_MARKER index36_3;


    		LA36_3 = LA(1);

    	     
    	        index36_3 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( (( (( ((IS_TOKEN(app))) && ((IS_TOKEN(app))) )) && (synpred12_belle_sdp(ctx)) )) )
    	    {
    	        s = 5;
    	    }

    	    else if ( (synpred13_belle_sdp(ctx)) )
    	    {
    	        s = 4;
    	    }

    		 
    			SEEK(index36_3);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;
    }
    if (BACKTRACKING > 0)
    {
	FAILEDFLAG = ANTLR3_TRUE;
	return	-1;
    }

    CONSTRUCTEX();
    EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
    EXCEPTION->message      = (void *)"342:1: rtcp_fb_param : ( ( rtcp_fb_app_param )=> rtcp_fb_app_param | ( rtcp_fb_token_param )=> rtcp_fb_token_param );";
    EXCEPTION->decisionNum  = 36;
    EXCEPTION->state        = _s;
    return -1;
}


/* Declare tracking structure for Cyclic DFA 36
 */
static
ANTLR3_CYCLIC_DFA cdfa36
    =	{
	    36,		    /* Decision number of this dfa	    */
	    /* Which decision this represents:   */
	    (const pANTLR3_UCHAR)"342:1: rtcp_fb_param : ( ( rtcp_fb_app_param )=> rtcp_fb_app_param | ( rtcp_fb_token_param )=> rtcp_fb_token_param );",
	    (CDFA_SPECIAL_FUNC) dfa36_sst,
	    antlr3dfaspecialTransition,		/* DFA specialTransition is currently just a default function in the runtime */
	    antlr3dfapredict,			/* DFA simulator function is in the runtime */
	    dfa36_eot,	    /* EOT table			    */
	    dfa36_eof,	    /* EOF table			    */
	    dfa36_min,	    /* Minimum tokens for each state    */
	    dfa36_max,	    /* Maximum tokens for each state    */
	    dfa36_accept,	/* Accept table			    */
	    dfa36_special,	/* Special transition states	    */
	    dfa36_transitions	/* Table of transition tables	    */

	};
/* End of Cyclic DFA 36
 * ---------------------
 *//** Static dfa state tables for Cyclic dfa:
 *    407:21: ( info CR LF )?
 */
static const ANTLR3_INT32 dfa43_eot[87] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa43_eof[87] =
    {
	3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa43_min[87] =
    {
	6, 11, 11, -1, 4, 4, 13, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
	4, 4, 4, 13, 4, 4, 0, 4, 4, 4, 0, 4, 4, 4, 4, -1, 4, 4, 4, 4, 13, 13, 4, 
	4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 
	4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 13, 4, 0
    };
static const ANTLR3_INT32 dfa43_max[87] =
    {
	12, 11, 11, -1, 35, 35, 13, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
	35, 35, 35, 35, 35, 35, 35, 35, 13, 35, 35, 0, 35, 35, 35, 0, 35, 35, 35, 
	35, -1, 35, 35, 35, 35, 13, 13, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
	35, 35, 35, 35, 35, 0, 0, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
	35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 13, 35, 0
    };
static const ANTLR3_INT32 dfa43_accept[87] =
    {
	-1, -1, -1, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa43_special[87] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, -1, 3, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, 4, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1
    };

/** Used when there is no transition table entry for a particular state */
#define dfa43_T_empty	    NULL

static const ANTLR3_INT32 dfa43_T0[] =
    {
	25, 25, 65, 84, 74, 85, 75, 25, 65, -1, 25, 25, 25, 25, 25, 58, 72, 25, 
	66, 67, 68, 70, 69, 73, 71, 76, 77, 78, 79, 80, 81, 82
    };

static const ANTLR3_INT32 dfa43_T1[] =
    {
	86
    };

static const ANTLR3_INT32 dfa43_T2[] =
    {
	25, 25, 65, 6, 74, 64, 75, 25, 65, -1, 25, 25, 25, 25, 25, 25, 72, 25, 
	66, 67, 68, 70, 69, 73, 71, 76, 77, 78, 79, 80, 81, 82
    };

static const ANTLR3_INT32 dfa43_T3[] =
    {
	54, 57, 51, 44, 55, 52, 53, 57, 51, -1, 57, 57, 57, 57, 56, 58, 57, 57, 
	57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57
    };

static const ANTLR3_INT32 dfa43_T4[] =
    {
	30, 25, 31, 26, 16, 32, 17, 25, 31, -1, 25, 25, 25, 25, 25, 25, 14, 25, 
	8, 9, 10, 12, 11, 15, 13, 18, 19, 20, 21, 22, 23, 24
    };

static const ANTLR3_INT32 dfa43_T5[] =
    {
	25, 25, 34, 6, 25, 40, 25, 25, 34, -1, 25, 25, 25, 25, 25, 39, 25, 25, 
	25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25
    };

static const ANTLR3_INT32 dfa43_T6[] =
    {
	48, 25, 45, 44, 49, 46, 47, 25, 45, -1, 25, 25, 25, 25, 50, 25, 25, 25, 
	25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25
    };

static const ANTLR3_INT32 dfa43_T7[] =
    {
	29
    };

static const ANTLR3_INT32 dfa43_T8[] =
    {
	1, -1, -1, 2, -1, -1, 1
    };

static const ANTLR3_INT32 dfa43_T9[] =
    {
	37, 37, 37, 26, 37, 36, 37, 37, 37, -1, 37, 37, 37, 37, 37, 37, 37, 37, 
	37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37
    };

static const ANTLR3_INT32 dfa43_T10[] =
    {
	61
    };

static const ANTLR3_INT32 dfa43_T11[] =
    {
	25, 25, 25, 6, 25, 62, 25, 25, 25, -1, 25, 25, 25, 25, 25, 25, 25, 25, 
	25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25
    };

static const ANTLR3_INT32 dfa43_T12[] =
    {
	4
    };

static const ANTLR3_INT32 dfa43_T13[] =
    {
	25, 25, 65, 84, 74, 64, 75, 25, 65, -1, 25, 25, 25, 25, 25, 58, 72, 25, 
	66, 67, 68, 70, 69, 73, 71, 76, 77, 78, 79, 80, 81, 82
    };

static const ANTLR3_INT32 dfa43_T14[] =
    {
	-1
    };

static const ANTLR3_INT32 dfa43_T15[] =
    {
	57, 57, 57, 6, 57, 57, 57, 57, 57, -1, 57, 57, 57, 57, 57, 58, 57, 57, 
	57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57
    };

static const ANTLR3_INT32 dfa43_T16[] =
    {
	37, 37, 37, 26, 37, 37, 37, 37, 37, -1, 37, 37, 37, 37, 37, 37, 37, 37, 
	37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37
    };

static const ANTLR3_INT32 dfa43_T17[] =
    {
	57, 57, 57, 6, 57, 63, 57, 57, 57, -1, 57, 57, 57, 57, 57, 58, 57, 57, 
	57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57
    };

static const ANTLR3_INT32 dfa43_T18[] =
    {
	25, 25, 25, 6, 25, 59, 25, 25, 25, -1, 25, 25, 25, 25, 25, 25, 25, 25, 
	25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25
    };

static const ANTLR3_INT32 dfa43_T19[] =
    {
	25, 25, 25, 44, 25, 62, 25, 25, 25, -1, 25, 25, 25, 25, 50, 25, 25, 25, 
	25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25
    };

static const ANTLR3_INT32 dfa43_T20[] =
    {
	33
    };

static const ANTLR3_INT32 dfa43_T21[] =
    {
	25, 25, 25, 6, 25, 59, 25, 25, 25, -1, 25, 25, 25, 25, 25, 83, 25, 25, 
	25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25
    };

static const ANTLR3_INT32 dfa43_T22[] =
    {
	57, 57, 57, 44, 57, 63, 57, 57, 57, -1, 57, 57, 57, 57, 56, 58, 57, 57, 
	57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57
    };

static const ANTLR3_INT32 dfa43_T23[] =
    {
	28, 25, 5, 26, 16, 7, 17, 25, 5, -1, 25, 25, 25, 25, 25, 27, 14, 25, 8, 
	9, 10, 12, 11, 15, 13, 18, 19, 20, 21, 22, 23, 24
    };

static const ANTLR3_INT32 dfa43_T24[] =
    {
	25, 25, 34, 6, 25, 35, 25, 25, 34, -1, 25, 25, 25, 25, 25, 25, 25, 25, 
	25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25
    };

static const ANTLR3_INT32 dfa43_T25[] =
    {
	60
    };

static const ANTLR3_INT32 dfa43_T26[] =
    {
	37, 37, 37, 43, 37, 36, 37, 37, 37, -1, 37, 37, 37, 37, 37, 37, 37, 37, 
	37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37
    };

static const ANTLR3_INT32 dfa43_T27[] =
    {
	25, 25, 5, 6, 16, 7, 17, 25, 5, -1, 25, 25, 25, 25, 25, 25, 14, 25, 8, 
	9, 10, 12, 11, 15, 13, 18, 19, 20, 21, 22, 23, 24
    };

static const ANTLR3_INT32 dfa43_T28[] =
    {
	25, 25, 25, 6, 25, 25, 25, 25, 25, -1, 25, 25, 25, 25, 25, 25, 25, 25, 
	25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25
    };

static const ANTLR3_INT32 dfa43_T29[] =
    {
	25, 25, 34, 6, 25, 35, 25, 25, 34, -1, 25, 25, 25, 25, 42, 41, 25, 25, 
	25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25
    };


/* Transition tables are a table of sub tables, with some tables
 * reused for efficiency.
 */
static const ANTLR3_INT32 * const dfa43_transitions[] =
{
    dfa43_T8, dfa43_T12, dfa43_T12, NULL, dfa43_T27, dfa43_T23, dfa43_T7, 
    dfa43_T23, dfa43_T4, dfa43_T4, dfa43_T4, dfa43_T4, dfa43_T4, dfa43_T4, 
    dfa43_T4, dfa43_T4, dfa43_T4, dfa43_T4, dfa43_T4, dfa43_T4, dfa43_T4, 
    dfa43_T4, dfa43_T4, dfa43_T4, dfa43_T4, dfa43_T28, dfa43_T20, dfa43_T24, 
    dfa43_T9, dfa43_T14, dfa43_T16, dfa43_T4, dfa43_T4, dfa43_T14, dfa43_T5, 
    dfa43_T29, dfa43_T26, dfa43_T16, NULL, dfa43_T6, dfa43_T5, dfa43_T3, 
    dfa43_T18, dfa43_T25, dfa43_T10, dfa43_T6, dfa43_T6, dfa43_T6, dfa43_T6, 
    dfa43_T6, dfa43_T11, dfa43_T3, dfa43_T3, dfa43_T3, dfa43_T3, dfa43_T3, 
    dfa43_T17, dfa43_T15, dfa43_T2, dfa43_T21, dfa43_T14, dfa43_T14, dfa43_T19, 
    dfa43_T22, dfa43_T13, dfa43_T0, dfa43_T0, dfa43_T0, dfa43_T0, dfa43_T0, 
    dfa43_T0, dfa43_T0, dfa43_T0, dfa43_T0, dfa43_T0, dfa43_T0, dfa43_T0, 
    dfa43_T0, dfa43_T0, dfa43_T0, dfa43_T0, dfa43_T0, dfa43_T0, dfa43_T15, 
    dfa43_T1, dfa43_T0, dfa43_T14
};

static ANTLR3_INT32 dfa43_sst(pbelle_sdpParser ctx, pANTLR3_BASE_RECOGNIZER recognizer, pANTLR3_INT_STREAM is, pANTLR3_CYCLIC_DFA dfa, ANTLR3_INT32 s)
{
    ANTLR3_INT32    _s;

    _s	    = s;
    switch  (s)
    {
        case 0:

    	{
    	    ANTLR3_UINT32 LA43_29;

    	    ANTLR3_MARKER index43_29;


    		LA43_29 = LA(1);

    	     
    	        index43_29 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(i))) )
    	    {
    	        s = 38;
    	    }

    	    else if ( ((IS_TOKEN(k))) )
    	    {
    	        s = 3;
    	    }

    		 
    			SEEK(index43_29);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;

        case 1:

    	{
    	    ANTLR3_UINT32 LA43_86;

    	    ANTLR3_MARKER index43_86;


    		LA43_86 = LA(1);

    	     
    	        index43_86 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(i))) )
    	    {
    	        s = 38;
    	    }

    	    else if ( (ANTLR3_TRUE) )
    	    {
    	        s = 3;
    	    }

    		 
    			SEEK(index43_86);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;

        case 2:

    	{
    	    ANTLR3_UINT32 LA43_61;

    	    ANTLR3_MARKER index43_61;


    		LA43_61 = LA(1);

    	     
    	        index43_61 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(i))) )
    	    {
    	        s = 38;
    	    }

    	    else if ( ((((IS_TOKEN(k)))||((IS_TOKEN(c))))) )
    	    {
    	        s = 3;
    	    }

    		 
    			SEEK(index43_61);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;

        case 3:

    	{
    	    ANTLR3_UINT32 LA43_33;

    	    ANTLR3_MARKER index43_33;


    		LA43_33 = LA(1);

    	     
    	        index43_33 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(i))) )
    	    {
    	        s = 38;
    	    }

    	    else if ( ((((IS_TOKEN(k)))||((IS_TOKEN(a))))) )
    	    {
    	        s = 3;
    	    }

    		 
    			SEEK(index43_33);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;

        case 4:

    	{
    	    ANTLR3_UINT32 LA43_60;

    	    ANTLR3_MARKER index43_60;


    		LA43_60 = LA(1);

    	     
    	        index43_60 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(i))) )
    	    {
    	        s = 38;
    	    }

    	    else if ( ((((IS_TOKEN(k)))||((IS_TOKEN(a)))||((IS_TOKEN(b))))) )
    	    {
    	        s = 3;
    	    }

    		 
    			SEEK(index43_60);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;
    }
    if (BACKTRACKING > 0)
    {
	FAILEDFLAG = ANTLR3_TRUE;
	return	-1;
    }

    CONSTRUCTEX();
    EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
    EXCEPTION->message      = (void *)"407:21: ( info CR LF )?";
    EXCEPTION->decisionNum  = 43;
    EXCEPTION->state        = _s;
    return -1;
}


/* Declare tracking structure for Cyclic DFA 43
 */
static
ANTLR3_CYCLIC_DFA cdfa43
    =	{
	    43,		    /* Decision number of this dfa	    */
	    /* Which decision this represents:   */
	    (const pANTLR3_UCHAR)"407:21: ( info CR LF )?",
	    (CDFA_SPECIAL_FUNC) dfa43_sst,
	    antlr3dfaspecialTransition,		/* DFA specialTransition is currently just a default function in the runtime */
	    antlr3dfapredict,			/* DFA simulator function is in the runtime */
	    dfa43_eot,	    /* EOT table			    */
	    dfa43_eof,	    /* EOF table			    */
	    dfa43_min,	    /* Minimum tokens for each state    */
	    dfa43_max,	    /* Maximum tokens for each state    */
	    dfa43_accept,	/* Accept table			    */
	    dfa43_special,	/* Special transition states	    */
	    dfa43_transitions	/* Table of transition tables	    */

	};
/* End of Cyclic DFA 43
 * ---------------------
 *//** Static dfa state tables for Cyclic dfa:
 *    408:22: ( connection CR LF )?
 */
static const ANTLR3_INT32 dfa44_eot[30] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa44_eof[30] =
    {
	3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa44_min[30] =
    {
	6, 11, 11, -1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 13, 4, 4, 4, 
	4, 4, 4, 4, 0, 4, -1
    };
static const ANTLR3_INT32 dfa44_max[30] =
    {
	12, 11, 11, -1, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
	35, 13, 35, 35, 35, 35, 35, 35, 35, 0, 35, -1
    };
static const ANTLR3_INT32 dfa44_accept[30] =
    {
	-1, -1, -1, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1
    };
static const ANTLR3_INT32 dfa44_special[30] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1
    };

/** Used when there is no transition table entry for a particular state */
#define dfa44_T_empty	    NULL

static const ANTLR3_INT32 dfa44_T0[] =
    {
	16, 3, 13, 19, 17, 14, 15, 3, 13, -1, 3, 3, 3, 3, 18, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa44_T1[] =
    {
	23, 3, 20, 19, 24, 21, 22, 3, 20, -1, 3, 3, 3, 3, 25, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa44_T2[] =
    {
	3, 3, 3, 3, 3, 26, 3, 3, 3, -1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa44_T3[] =
    {
	4
    };

static const ANTLR3_INT32 dfa44_T4[] =
    {
	3, 3, 3, 19, 3, 26, 3, 3, 3, -1, 3, 3, 3, 3, 18, 3, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa44_T5[] =
    {
	3, 3, 8, 3, 3, 11, 3, 3, 8, -1, 3, 3, 3, 3, 3, 10, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa44_T6[] =
    {
	-1
    };

static const ANTLR3_INT32 dfa44_T7[] =
    {
	3, 3, 3, 3, 3, 28, 3, 3, 3, -1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa44_T8[] =
    {
	27
    };

static const ANTLR3_INT32 dfa44_T9[] =
    {
	3, 3, 8, 3, 3, 9, 3, 3, 8, -1, 3, 3, 3, 3, 3, 12, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa44_T10[] =
    {
	3, 3, 3, 19, 3, 28, 3, 3, 3, -1, 3, 3, 3, 3, 25, 3, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa44_T11[] =
    {
	3, 3, 5, 3, 3, 6, 3, 3, 5, -1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa44_T12[] =
    {
	3, 3, 5, 3, 3, 6, 3, 3, 5, -1, 3, 3, 3, 3, 3, 7, 3, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa44_T13[] =
    {
	3, 3, 8, 3, 3, 9, 3, 3, 8, -1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa44_T14[] =
    {
	1, -1, -1, 2, -1, -1, 1
    };


/* Transition tables are a table of sub tables, with some tables
 * reused for efficiency.
 */
static const ANTLR3_INT32 * const dfa44_transitions[] =
{
    dfa44_T14, dfa44_T3, dfa44_T3, NULL, dfa44_T11, dfa44_T12, dfa44_T12, 
    dfa44_T13, dfa44_T5, dfa44_T9, dfa44_T0, dfa44_T5, dfa44_T1, dfa44_T0, 
    dfa44_T0, dfa44_T0, dfa44_T0, dfa44_T0, dfa44_T2, dfa44_T8, dfa44_T1, 
    dfa44_T1, dfa44_T1, dfa44_T1, dfa44_T1, dfa44_T7, dfa44_T4, dfa44_T6, 
    dfa44_T10, NULL
};

static ANTLR3_INT32 dfa44_sst(pbelle_sdpParser ctx, pANTLR3_BASE_RECOGNIZER recognizer, pANTLR3_INT_STREAM is, pANTLR3_CYCLIC_DFA dfa, ANTLR3_INT32 s)
{
    ANTLR3_INT32    _s;

    _s	    = s;
    switch  (s)
    {
        case 0:

    	{
    	    ANTLR3_UINT32 LA44_27;

    	    ANTLR3_MARKER index44_27;


    		LA44_27 = LA(1);

    	     
    	        index44_27 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(c))) )
    	    {
    	        s = 29;
    	    }

    	    else if ( ((IS_TOKEN(k))) )
    	    {
    	        s = 3;
    	    }

    		 
    			SEEK(index44_27);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;
    }
    if (BACKTRACKING > 0)
    {
	FAILEDFLAG = ANTLR3_TRUE;
	return	-1;
    }

    CONSTRUCTEX();
    EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
    EXCEPTION->message      = (void *)"408:22: ( connection CR LF )?";
    EXCEPTION->decisionNum  = 44;
    EXCEPTION->state        = _s;
    return -1;
}


/* Declare tracking structure for Cyclic DFA 44
 */
static
ANTLR3_CYCLIC_DFA cdfa44
    =	{
	    44,		    /* Decision number of this dfa	    */
	    /* Which decision this represents:   */
	    (const pANTLR3_UCHAR)"408:22: ( connection CR LF )?",
	    (CDFA_SPECIAL_FUNC) dfa44_sst,
	    antlr3dfaspecialTransition,		/* DFA specialTransition is currently just a default function in the runtime */
	    antlr3dfapredict,			/* DFA simulator function is in the runtime */
	    dfa44_eot,	    /* EOT table			    */
	    dfa44_eof,	    /* EOF table			    */
	    dfa44_min,	    /* Minimum tokens for each state    */
	    dfa44_max,	    /* Maximum tokens for each state    */
	    dfa44_accept,	/* Accept table			    */
	    dfa44_special,	/* Special transition states	    */
	    dfa44_transitions	/* Table of transition tables	    */

	};
/* End of Cyclic DFA 44
 * ---------------------
 *//** Static dfa state tables for Cyclic dfa:
 *    ()* loopback of 409:22: ( bandwidth CR LF )*
 */
static const ANTLR3_INT32 dfa45_eot[12] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa45_eof[12] =
    {
	3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa45_min[12] =
    {
	6, 11, 11, -1, 4, 4, 4, 4, 4, 13, 0, -1
    };
static const ANTLR3_INT32 dfa45_max[12] =
    {
	12, 11, 11, -1, 35, 35, 35, 35, 35, 13, 0, -1
    };
static const ANTLR3_INT32 dfa45_accept[12] =
    {
	-1, -1, -1, 2, -1, -1, -1, -1, -1, -1, -1, 1
    };
static const ANTLR3_INT32 dfa45_special[12] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1
    };

/** Used when there is no transition table entry for a particular state */
#define dfa45_T_empty	    NULL

static const ANTLR3_INT32 dfa45_T0[] =
    {
	4
    };

static const ANTLR3_INT32 dfa45_T1[] =
    {
	1, -1, -1, 2, -1, -1, 1
    };

static const ANTLR3_INT32 dfa45_T2[] =
    {
	7, 3, 5, 3, 3, 6, 3, 3, 5, -1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa45_T3[] =
    {
	3, 3, 3, 9, 3, 8, 3, 3, 3, -1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa45_T4[] =
    {
	3, 3, 5, 3, 3, 6, 3, 3, 5, -1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3
    };

static const ANTLR3_INT32 dfa45_T5[] =
    {
	10
    };

static const ANTLR3_INT32 dfa45_T6[] =
    {
	-1
    };

static const ANTLR3_INT32 dfa45_T7[] =
    {
	3, 3, 3, 3, 3, 8, 3, 3, 3, -1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 
	3, 3, 3, 3, 3, 3, 3, 3
    };


/* Transition tables are a table of sub tables, with some tables
 * reused for efficiency.
 */
static const ANTLR3_INT32 * const dfa45_transitions[] =
{
    dfa45_T1, dfa45_T0, dfa45_T0, NULL, dfa45_T4, dfa45_T2, dfa45_T2, dfa45_T7, 
    dfa45_T3, dfa45_T5, dfa45_T6, NULL
};

static ANTLR3_INT32 dfa45_sst(pbelle_sdpParser ctx, pANTLR3_BASE_RECOGNIZER recognizer, pANTLR3_INT_STREAM is, pANTLR3_CYCLIC_DFA dfa, ANTLR3_INT32 s)
{
    ANTLR3_INT32    _s;

    _s	    = s;
    switch  (s)
    {
        case 0:

    	{
    	    ANTLR3_UINT32 LA45_10;

    	    ANTLR3_MARKER index45_10;


    		LA45_10 = LA(1);

    	     
    	        index45_10 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(b))) )
    	    {
    	        s = 11;
    	    }

    	    else if ( ((((IS_TOKEN(k)))||((IS_TOKEN(a))))) )
    	    {
    	        s = 3;
    	    }

    		 
    			SEEK(index45_10);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;
    }
    if (BACKTRACKING > 0)
    {
	FAILEDFLAG = ANTLR3_TRUE;
	return	-1;
    }

    CONSTRUCTEX();
    EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
    EXCEPTION->message      = (void *)"()* loopback of 409:22: ( bandwidth CR LF )*";
    EXCEPTION->decisionNum  = 45;
    EXCEPTION->state        = _s;
    return -1;
}


/* Declare tracking structure for Cyclic DFA 45
 */
static
ANTLR3_CYCLIC_DFA cdfa45
    =	{
	    45,		    /* Decision number of this dfa	    */
	    /* Which decision this represents:   */
	    (const pANTLR3_UCHAR)"()* loopback of 409:22: ( bandwidth CR LF )*",
	    (CDFA_SPECIAL_FUNC) dfa45_sst,
	    antlr3dfaspecialTransition,		/* DFA specialTransition is currently just a default function in the runtime */
	    antlr3dfapredict,			/* DFA simulator function is in the runtime */
	    dfa45_eot,	    /* EOT table			    */
	    dfa45_eof,	    /* EOF table			    */
	    dfa45_min,	    /* Minimum tokens for each state    */
	    dfa45_max,	    /* Maximum tokens for each state    */
	    dfa45_accept,	/* Accept table			    */
	    dfa45_special,	/* Special transition states	    */
	    dfa45_transitions	/* Table of transition tables	    */

	};
/* End of Cyclic DFA 45
 * ---------------------
 *//** Static dfa state tables for Cyclic dfa:
 *    410:22: ( key_field CR LF )?
 */
static const ANTLR3_INT32 dfa46_eot[60] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa46_eof[60] =
    {
	3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa46_min[60] =
    {
	6, 11, 11, -1, 4, 4, -1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
	4, 4, 13, 4, 4, 4, 4, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
	4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 13, 4, 0
    };
static const ANTLR3_INT32 dfa46_max[60] =
    {
	12, 11, 11, -1, 35, 35, -1, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
	35, 35, 35, 35, 35, 35, 35, 13, 35, 35, 35, 35, 0, 35, 35, 35, 35, 35, 
	35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
	35, 35, 35, 13, 35, 0
    };
static const ANTLR3_INT32 dfa46_accept[60] =
    {
	-1, -1, -1, 2, -1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa46_special[60] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
	-1, -1, -1, -1, -1, 0
    };

/** Used when there is no transition table entry for a particular state */
#define dfa46_T_empty	    NULL

static const ANTLR3_INT32 dfa46_T0[] =
    {
	6, 6, 6, 6, 6, 32, 6, 6, 6, -1, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 
	6, 6, 6, 6, 6, 6, 6, 6, 6
    };

static const ANTLR3_INT32 dfa46_T1[] =
    {
	26, 6, 28, 25, 16, 29, 17, 6, 28, -1, 6, 6, 6, 6, 6, 6, 14, 6, 8, 9, 10, 
	12, 11, 15, 13, 18, 19, 20, 21, 22, 23, 24
    };

static const ANTLR3_INT32 dfa46_T2[] =
    {
	6, 6, 5, 6, 16, 7, 17, 6, 5, -1, 6, 6, 6, 6, 6, 6, 14, 6, 8, 9, 10, 12, 
	11, 15, 13, 18, 19, 20, 21, 22, 23, 24
    };

static const ANTLR3_INT32 dfa46_T3[] =
    {
	59
    };

static const ANTLR3_INT32 dfa46_T4[] =
    {
	1, -1, -1, 2, -1, -1, 1
    };

static const ANTLR3_INT32 dfa46_T5[] =
    {
	-1
    };

static const ANTLR3_INT32 dfa46_T6[] =
    {
	6, 6, 39, 57, 48, 38, 49, 6, 39, -1, 6, 6, 6, 6, 6, 37, 46, 6, 40, 41, 
	42, 44, 43, 47, 45, 50, 51, 52, 53, 54, 55, 56
    };

static const ANTLR3_INT32 dfa46_T7[] =
    {
	6, 6, 39, 57, 48, 58, 49, 6, 39, -1, 6, 6, 6, 6, 6, 37, 46, 6, 40, 41, 
	42, 44, 43, 47, 45, 50, 51, 52, 53, 54, 55, 56
    };

static const ANTLR3_INT32 dfa46_T8[] =
    {
	36, 36, 36, 6, 36, 36, 36, 36, 36, -1, 36, 36, 36, 36, 36, 37, 36, 36, 
	36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36
    };

static const ANTLR3_INT32 dfa46_T9[] =
    {
	31, 31, 31, 25, 31, 31, 31, 31, 31, -1, 31, 31, 31, 31, 31, 31, 31, 31, 
	31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31
    };

static const ANTLR3_INT32 dfa46_T10[] =
    {
	6, 6, 6, 6, 6, 35, 6, 6, 6, -1, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 
	6, 6, 6, 6, 6, 6, 6, 6, 6
    };

static const ANTLR3_INT32 dfa46_T11[] =
    {
	26, 6, 5, 25, 16, 7, 17, 6, 5, -1, 6, 6, 6, 6, 6, 27, 14, 6, 8, 9, 10, 
	12, 11, 15, 13, 18, 19, 20, 21, 22, 23, 24
    };

static const ANTLR3_INT32 dfa46_T12[] =
    {
	6, 6, 6, 6, 6, 35, 6, 6, 6, -1, 6, 6, 6, 6, 6, 34, 6, 6, 6, 6, 6, 6, 6, 
	6, 6, 6, 6, 6, 6, 6, 6, 6
    };

static const ANTLR3_INT32 dfa46_T13[] =
    {
	4
    };

static const ANTLR3_INT32 dfa46_T14[] =
    {
	30
    };

static const ANTLR3_INT32 dfa46_T15[] =
    {
	6, 6, 6, 6, 6, 32, 6, 6, 6, -1, 6, 6, 6, 6, 33, 34, 6, 6, 6, 6, 6, 6, 6, 
	6, 6, 6, 6, 6, 6, 6, 6, 6
    };

static const ANTLR3_INT32 dfa46_T16[] =
    {
	6, 6, 39, 6, 48, 38, 49, 6, 39, -1, 6, 6, 6, 6, 6, 6, 46, 6, 40, 41, 42, 
	44, 43, 47, 45, 50, 51, 52, 53, 54, 55, 56
    };


/* Transition tables are a table of sub tables, with some tables
 * reused for efficiency.
 */
static const ANTLR3_INT32 * const dfa46_transitions[] =
{
    dfa46_T4, dfa46_T13, dfa46_T13, NULL, dfa46_T2, dfa46_T11, NULL, dfa46_T11, 
    dfa46_T1, dfa46_T1, dfa46_T1, dfa46_T1, dfa46_T1, dfa46_T1, dfa46_T1, 
    dfa46_T1, dfa46_T1, dfa46_T1, dfa46_T1, dfa46_T1, dfa46_T1, dfa46_T1, 
    dfa46_T1, dfa46_T1, dfa46_T1, dfa46_T14, dfa46_T9, dfa46_T0, dfa46_T1, 
    dfa46_T1, dfa46_T5, dfa46_T9, dfa46_T15, dfa46_T10, dfa46_T8, dfa46_T12, 
    dfa46_T8, dfa46_T16, dfa46_T6, dfa46_T7, dfa46_T7, dfa46_T7, dfa46_T7, 
    dfa46_T7, dfa46_T7, dfa46_T7, dfa46_T7, dfa46_T7, dfa46_T7, dfa46_T7, 
    dfa46_T7, dfa46_T7, dfa46_T7, dfa46_T7, dfa46_T7, dfa46_T7, dfa46_T7, 
    dfa46_T3, dfa46_T7, dfa46_T5
};

static ANTLR3_INT32 dfa46_sst(pbelle_sdpParser ctx, pANTLR3_BASE_RECOGNIZER recognizer, pANTLR3_INT_STREAM is, pANTLR3_CYCLIC_DFA dfa, ANTLR3_INT32 s)
{
    ANTLR3_INT32    _s;

    _s	    = s;
    switch  (s)
    {
        case 0:

    	{
    	    ANTLR3_UINT32 LA46_59;

    	    ANTLR3_MARKER index46_59;


    		LA46_59 = LA(1);

    	     
    	        index46_59 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(k))) )
    	    {
    	        s = 6;
    	    }

    	    else if ( (ANTLR3_TRUE) )
    	    {
    	        s = 3;
    	    }

    		 
    			SEEK(index46_59);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;

        case 1:

    	{
    	    ANTLR3_UINT32 LA46_30;

    	    ANTLR3_MARKER index46_30;


    		LA46_30 = LA(1);

    	     
    	        index46_30 = INDEX();

    	        REWINDLAST();

    	    s = -1;
    	    if ( ((IS_TOKEN(k))) )
    	    {
    	        s = 6;
    	    }

    	    else if ( ((IS_TOKEN(a))) )
    	    {
    	        s = 3;
    	    }

    		 
    			SEEK(index46_30);

    	    if ( s>=0 )
    	    {
    		return s;
    	    }
    	}
    	break;
    }
    if (BACKTRACKING > 0)
    {
	FAILEDFLAG = ANTLR3_TRUE;
	return	-1;
    }

    CONSTRUCTEX();
    EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
    EXCEPTION->message      = (void *)"410:22: ( key_field CR LF )?";
    EXCEPTION->decisionNum  = 46;
    EXCEPTION->state        = _s;
    return -1;
}


/* Declare tracking structure for Cyclic DFA 46
 */
static
ANTLR3_CYCLIC_DFA cdfa46
    =	{
	    46,		    /* Decision number of this dfa	    */
	    /* Which decision this represents:   */
	    (const pANTLR3_UCHAR)"410:22: ( key_field CR LF )?",
	    (CDFA_SPECIAL_FUNC) dfa46_sst,
	    antlr3dfaspecialTransition,		/* DFA specialTransition is currently just a default function in the runtime */
	    antlr3dfapredict,			/* DFA simulator function is in the runtime */
	    dfa46_eot,	    /* EOT table			    */
	    dfa46_eof,	    /* EOF table			    */
	    dfa46_min,	    /* Minimum tokens for each state    */
	    dfa46_max,	    /* Maximum tokens for each state    */
	    dfa46_accept,	/* Accept table			    */
	    dfa46_special,	/* Special transition states	    */
	    dfa46_transitions	/* Table of transition tables	    */

	};
/* End of Cyclic DFA 46
 * ---------------------
 *//** Static dfa state tables for Cyclic dfa:
 *    ()* loopback of 411:22: ( attribute CR LF )*
 */
static const ANTLR3_INT32 dfa47_eot[8] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa47_eof[8] =
    {
	1, -1, -1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa47_min[8] =
    {
	6, -1, 11, 11, 6, 4, 4, -1
    };
static const ANTLR3_INT32 dfa47_max[8] =
    {
	12, -1, 11, 11, 35, 35, 35, -1
    };
static const ANTLR3_INT32 dfa47_accept[8] =
    {
	-1, 2, -1, -1, -1, -1, -1, 1
    };
static const ANTLR3_INT32 dfa47_special[8] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1
    };

/** Used when there is no transition table entry for a particular state */
#define dfa47_T_empty	    NULL

static const ANTLR3_INT32 dfa47_T0[] =
    {
	2, -1, -1, 3, -1, -1, 2
    };

static const ANTLR3_INT32 dfa47_T1[] =
    {
	4
    };

static const ANTLR3_INT32 dfa47_T2[] =
    {
	7, -1, 5, 7, 7, 6, 7, -1, 5, -1, -1, -1, -1, -1, -1, 1, 7, -1, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7
    };

static const ANTLR3_INT32 dfa47_T3[] =
    {
	5, -1, 7, 6, 7, -1, 5, -1, -1, -1, -1, -1, -1, -1, 7, -1, 7, 7, 7, 7, 7, 
	7, 7, 7, 7, 7, 7, 7, 7, 7
    };


/* Transition tables are a table of sub tables, with some tables
 * reused for efficiency.
 */
static const ANTLR3_INT32 * const dfa47_transitions[] =
{
    dfa47_T0, NULL, dfa47_T1, dfa47_T1, dfa47_T3, dfa47_T2, dfa47_T2, NULL
};


/* Declare tracking structure for Cyclic DFA 47
 */
static
ANTLR3_CYCLIC_DFA cdfa47
    =	{
	    47,		    /* Decision number of this dfa	    */
	    /* Which decision this represents:   */
	    (const pANTLR3_UCHAR)"()* loopback of 411:22: ( attribute CR LF )*",
	    (CDFA_SPECIAL_FUNC) antlr3dfaspecialStateTransition,	/* Default special state transition function	*/

	    antlr3dfaspecialTransition,		/* DFA specialTransition is currently just a default function in the runtime */
	    antlr3dfapredict,			/* DFA simulator function is in the runtime */
	    dfa47_eot,	    /* EOT table			    */
	    dfa47_eof,	    /* EOF table			    */
	    dfa47_min,	    /* Minimum tokens for each state    */
	    dfa47_max,	    /* Maximum tokens for each state    */
	    dfa47_accept,	/* Accept table			    */
	    dfa47_special,	/* Special transition states	    */
	    dfa47_transitions	/* Table of transition tables	    */

	};
/* End of Cyclic DFA 47
 * ---------------------
 *//** Static dfa state tables for Cyclic dfa:
 *    ()* loopback of 537:17: ( domainlabel DOT )*
 */
static const ANTLR3_INT32 dfa71_eot[8] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa71_eof[8] =
    {
	-1, 4, -1, 4, -1, 4, 4, -1
    };
static const ANTLR3_INT32 dfa71_min[8] =
    {
	6, 6, -1, 6, -1, 6, 6, 6
    };
static const ANTLR3_INT32 dfa71_max[8] =
    {
	12, 12, -1, 12, -1, 12, 12, 12
    };
static const ANTLR3_INT32 dfa71_accept[8] =
    {
	-1, -1, 1, -1, 2, -1, -1, -1
    };
static const ANTLR3_INT32 dfa71_special[8] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1
    };

/** Used when there is no transition table entry for a particular state */
#define dfa71_T_empty	    NULL

static const ANTLR3_INT32 dfa71_T0[] =
    {
	5, -1, 7, 6, 3, -1, 5
    };

static const ANTLR3_INT32 dfa71_T1[] =
    {
	2, -1, -1, 2, -1, -1, 2
    };

static const ANTLR3_INT32 dfa71_T2[] =
    {
	5, -1, 7, 6, -1, -1, 5
    };

static const ANTLR3_INT32 dfa71_T3[] =
    {
	1, -1, -1, 2, -1, -1, 1
    };


/* Transition tables are a table of sub tables, with some tables
 * reused for efficiency.
 */
static const ANTLR3_INT32 * const dfa71_transitions[] =
{
    dfa71_T3, dfa71_T0, NULL, dfa71_T1, NULL, dfa71_T0, dfa71_T0, dfa71_T2
};


/* Declare tracking structure for Cyclic DFA 71
 */
static
ANTLR3_CYCLIC_DFA cdfa71
    =	{
	    71,		    /* Decision number of this dfa	    */
	    /* Which decision this represents:   */
	    (const pANTLR3_UCHAR)"()* loopback of 537:17: ( domainlabel DOT )*",
	    (CDFA_SPECIAL_FUNC) antlr3dfaspecialStateTransition,	/* Default special state transition function	*/

	    antlr3dfaspecialTransition,		/* DFA specialTransition is currently just a default function in the runtime */
	    antlr3dfapredict,			/* DFA simulator function is in the runtime */
	    dfa71_eot,	    /* EOT table			    */
	    dfa71_eof,	    /* EOF table			    */
	    dfa71_min,	    /* Minimum tokens for each state    */
	    dfa71_max,	    /* Maximum tokens for each state    */
	    dfa71_accept,	/* Accept table			    */
	    dfa71_special,	/* Special transition states	    */
	    dfa71_transitions	/* Table of transition tables	    */

	};
/* End of Cyclic DFA 71
 * ---------------------
 *//** Static dfa state tables for Cyclic dfa:
 *    552:1: hexpart : ( hexseq | hexseq COLON COLON ( hexseq )? | COLON COLON ( hexseq )? );
 */
static const ANTLR3_INT32 dfa81_eot[8] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa81_eof[8] =
    {
	-1, 4, -1, -1, -1, -1, 4, 4
    };
static const ANTLR3_INT32 dfa81_min[8] =
    {
	4, 4, -1, 4, -1, -1, 4, 4
    };
static const ANTLR3_INT32 dfa81_max[8] =
    {
	12, 12, -1, 12, -1, -1, 12, 12
    };
static const ANTLR3_INT32 dfa81_accept[8] =
    {
	-1, -1, 3, -1, 1, 2, -1, -1
    };
static const ANTLR3_INT32 dfa81_special[8] =
    {
	-1, -1, -1, -1, -1, -1, -1, -1
    };

/** Used when there is no transition table entry for a particular state */
#define dfa81_T_empty	    NULL

static const ANTLR3_INT32 dfa81_T0[] =
    {
	3, -1, -1, -1, -1, 1, -1, -1, 1
    };

static const ANTLR3_INT32 dfa81_T1[] =
    {
	3, -1, -1, -1, -1, 6, 4, -1, 7
    };

static const ANTLR3_INT32 dfa81_T2[] =
    {
	3, -1, -1, -1, -1, 7, -1, -1, 7
    };

static const ANTLR3_INT32 dfa81_T3[] =
    {
	5, -1, -1, -1, -1, 6, -1, -1, 7
    };

static const ANTLR3_INT32 dfa81_T4[] =
    {
	2, -1, -1, -1, -1, 1, -1, -1, 1
    };


/* Transition tables are a table of sub tables, with some tables
 * reused for efficiency.
 */
static const ANTLR3_INT32 * const dfa81_transitions[] =
{
    dfa81_T4, dfa81_T0, NULL, dfa81_T3, NULL, NULL, dfa81_T1, dfa81_T2
};


/* Declare tracking structure for Cyclic DFA 81
 */
static
ANTLR3_CYCLIC_DFA cdfa81
    =	{
	    81,		    /* Decision number of this dfa	    */
	    /* Which decision this represents:   */
	    (const pANTLR3_UCHAR)"552:1: hexpart : ( hexseq | hexseq COLON COLON ( hexseq )? | COLON COLON ( hexseq )? );",
	    (CDFA_SPECIAL_FUNC) antlr3dfaspecialStateTransition,	/* Default special state transition function	*/

	    antlr3dfaspecialTransition,		/* DFA specialTransition is currently just a default function in the runtime */
	    antlr3dfapredict,			/* DFA simulator function is in the runtime */
	    dfa81_eot,	    /* EOT table			    */
	    dfa81_eof,	    /* EOF table			    */
	    dfa81_min,	    /* Minimum tokens for each state    */
	    dfa81_max,	    /* Maximum tokens for each state    */
	    dfa81_accept,	/* Accept table			    */
	    dfa81_special,	/* Special transition states	    */
	    dfa81_transitions	/* Table of transition tables	    */

	};
/* End of Cyclic DFA 81
 * ---------------------
 *//** Static dfa state tables for Cyclic dfa:
 *    ()* loopback of 553:24: ( COLON hex4 )*
 */
static const ANTLR3_INT32 dfa82_eot[5] =
    {
	-1, -1, -1, -1, -1
    };
static const ANTLR3_INT32 dfa82_eof[5] =
    {
	2, -1, -1, 4, -1
    };
static const ANTLR3_INT32 dfa82_min[5] =
    {
	4, 4, -1, 4, -1
    };
static const ANTLR3_INT32 dfa82_max[5] =
    {
	4, 12, -1, 12, -1
    };
static const ANTLR3_INT32 dfa82_accept[5] =
    {
	-1, -1, 2, -1, 1
    };
static const ANTLR3_INT32 dfa82_special[5] =
    {
	-1, -1, -1, -1, -1
    };

/** Used when there is no transition table entry for a particular state */
#define dfa82_T_empty	    NULL

static const ANTLR3_INT32 dfa82_T0[] =
    {
	4, -1, -1, -1, -1, 3, 2, -1, 4
    };

static const ANTLR3_INT32 dfa82_T1[] =
    {
	1
    };

static const ANTLR3_INT32 dfa82_T2[] =
    {
	2, -1, -1, -1, -1, 3, -1, -1, 4
    };


/* Transition tables are a table of sub tables, with some tables
 * reused for efficiency.
 */
static const ANTLR3_INT32 * const dfa82_transitions[] =
{
    dfa82_T1, dfa82_T2, NULL, dfa82_T0, NULL
};


/* Declare tracking structure for Cyclic DFA 82
 */
static
ANTLR3_CYCLIC_DFA cdfa82
    =	{
	    82,		    /* Decision number of this dfa	    */
	    /* Which decision this represents:   */
	    (const pANTLR3_UCHAR)"()* loopback of 553:24: ( COLON hex4 )*",
	    (CDFA_SPECIAL_FUNC) antlr3dfaspecialStateTransition,	/* Default special state transition function	*/

	    antlr3dfaspecialTransition,		/* DFA specialTransition is currently just a default function in the runtime */
	    antlr3dfapredict,			/* DFA simulator function is in the runtime */
	    dfa82_eot,	    /* EOT table			    */
	    dfa82_eof,	    /* EOF table			    */
	    dfa82_min,	    /* Minimum tokens for each state    */
	    dfa82_max,	    /* Maximum tokens for each state    */
	    dfa82_accept,	/* Accept table			    */
	    dfa82_special,	/* Special transition states	    */
	    dfa82_transitions	/* Table of transition tables	    */

	};
/* End of Cyclic DFA 82
 * ---------------------
 */ 
/* =========================================================================
 * End of DFA tables for the parser
 */

/* ==============================================
 * Parsing rules
 */
/**
 * $ANTLR start session_description
 * ../grammars/belle_sdp.g:102:1: session_description returns [belle_sdp_session_description_t* ret] : version CR LF origin CR LF session_name CR LF ( info CR LF )? ( uri_field CR LF )? ( email CR LF )* ( phone_field )* ( connection CR LF )? ( bandwidth CR LF )* time_field CR LF ( repeat_time CR LF )* ( zone_adjustments CR LF )? ( key_field CR LF )? ( attribute CR LF )* ( media_description )* ;
 */
static belle_sdpParser_session_description_return
session_description(pbelle_sdpParser ctx)
{
    belle_sdpParser_session_description_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    CR2;
    pANTLR3_COMMON_TOKEN    LF3;
    pANTLR3_COMMON_TOKEN    CR5;
    pANTLR3_COMMON_TOKEN    LF6;
    pANTLR3_COMMON_TOKEN    CR8;
    pANTLR3_COMMON_TOKEN    LF9;
    pANTLR3_COMMON_TOKEN    CR11;
    pANTLR3_COMMON_TOKEN    LF12;
    pANTLR3_COMMON_TOKEN    CR14;
    pANTLR3_COMMON_TOKEN    LF15;
    pANTLR3_COMMON_TOKEN    CR17;
    pANTLR3_COMMON_TOKEN    LF18;
    pANTLR3_COMMON_TOKEN    CR21;
    pANTLR3_COMMON_TOKEN    LF22;
    pANTLR3_COMMON_TOKEN    CR24;
    pANTLR3_COMMON_TOKEN    LF25;
    pANTLR3_COMMON_TOKEN    CR27;
    pANTLR3_COMMON_TOKEN    LF28;
    pANTLR3_COMMON_TOKEN    CR30;
    pANTLR3_COMMON_TOKEN    LF31;
    pANTLR3_COMMON_TOKEN    CR33;
    pANTLR3_COMMON_TOKEN    LF34;
    pANTLR3_COMMON_TOKEN    CR36;
    pANTLR3_COMMON_TOKEN    LF37;
    pANTLR3_COMMON_TOKEN    CR39;
    pANTLR3_COMMON_TOKEN    LF40;
    belle_sdpParser_version_return version1;
    #undef	RETURN_TYPE_version1
    #define	RETURN_TYPE_version1 belle_sdpParser_version_return

    belle_sdpParser_origin_return origin4;
    #undef	RETURN_TYPE_origin4
    #define	RETURN_TYPE_origin4 belle_sdpParser_origin_return

    belle_sdpParser_session_name_return session_name7;
    #undef	RETURN_TYPE_session_name7
    #define	RETURN_TYPE_session_name7 belle_sdpParser_session_name_return

    belle_sdpParser_info_return info10;
    #undef	RETURN_TYPE_info10
    #define	RETURN_TYPE_info10 belle_sdpParser_info_return

    belle_sdpParser_uri_field_return uri_field13;
    #undef	RETURN_TYPE_uri_field13
    #define	RETURN_TYPE_uri_field13 belle_sdpParser_uri_field_return

    belle_sdpParser_email_return email16;
    #undef	RETURN_TYPE_email16
    #define	RETURN_TYPE_email16 belle_sdpParser_email_return

    belle_sdpParser_phone_field_return phone_field19;
    #undef	RETURN_TYPE_phone_field19
    #define	RETURN_TYPE_phone_field19 belle_sdpParser_phone_field_return

    belle_sdpParser_connection_return connection20;
    #undef	RETURN_TYPE_connection20
    #define	RETURN_TYPE_connection20 belle_sdpParser_connection_return

    belle_sdpParser_bandwidth_return bandwidth23;
    #undef	RETURN_TYPE_bandwidth23
    #define	RETURN_TYPE_bandwidth23 belle_sdpParser_bandwidth_return

    belle_sdpParser_time_field_return time_field26;
    #undef	RETURN_TYPE_time_field26
    #define	RETURN_TYPE_time_field26 belle_sdpParser_time_field_return

    belle_sdpParser_repeat_time_return repeat_time29;
    #undef	RETURN_TYPE_repeat_time29
    #define	RETURN_TYPE_repeat_time29 belle_sdpParser_repeat_time_return

    belle_sdpParser_zone_adjustments_return zone_adjustments32;
    #undef	RETURN_TYPE_zone_adjustments32
    #define	RETURN_TYPE_zone_adjustments32 belle_sdpParser_zone_adjustments_return

    belle_sdpParser_key_field_return key_field35;
    #undef	RETURN_TYPE_key_field35
    #define	RETURN_TYPE_key_field35 belle_sdpParser_key_field_return

    belle_sdpParser_attribute_return attribute38;
    #undef	RETURN_TYPE_attribute38
    #define	RETURN_TYPE_attribute38 belle_sdpParser_attribute_return

    belle_sdpParser_media_description_return media_description41;
    #undef	RETURN_TYPE_media_description41
    #define	RETURN_TYPE_media_description41 belle_sdpParser_media_description_return

    pANTLR3_BASE_TREE CR2_tree;
    pANTLR3_BASE_TREE LF3_tree;
    pANTLR3_BASE_TREE CR5_tree;
    pANTLR3_BASE_TREE LF6_tree;
    pANTLR3_BASE_TREE CR8_tree;
    pANTLR3_BASE_TREE LF9_tree;
    pANTLR3_BASE_TREE CR11_tree;
    pANTLR3_BASE_TREE LF12_tree;
    pANTLR3_BASE_TREE CR14_tree;
    pANTLR3_BASE_TREE LF15_tree;
    pANTLR3_BASE_TREE CR17_tree;
    pANTLR3_BASE_TREE LF18_tree;
    pANTLR3_BASE_TREE CR21_tree;
    pANTLR3_BASE_TREE LF22_tree;
    pANTLR3_BASE_TREE CR24_tree;
    pANTLR3_BASE_TREE LF25_tree;
    pANTLR3_BASE_TREE CR27_tree;
    pANTLR3_BASE_TREE LF28_tree;
    pANTLR3_BASE_TREE CR30_tree;
    pANTLR3_BASE_TREE LF31_tree;
    pANTLR3_BASE_TREE CR33_tree;
    pANTLR3_BASE_TREE LF34_tree;
    pANTLR3_BASE_TREE CR36_tree;
    pANTLR3_BASE_TREE LF37_tree;
    pANTLR3_BASE_TREE CR39_tree;
    pANTLR3_BASE_TREE LF40_tree;

    /* Initialize rule variables
     */
    ctx->pbelle_sdpParser_session_descriptionTop = pbelle_sdpParser_session_descriptionPush(ctx);
    root_0 = NULL;

    (SCOPE_TOP(session_description))->current= belle_sdp_session_description_new(); 
    retval.ret=(SCOPE_TOP(session_description))->current;
     
    CR2       = NULL;
    LF3       = NULL;
    CR5       = NULL;
    LF6       = NULL;
    CR8       = NULL;
    LF9       = NULL;
    CR11       = NULL;
    LF12       = NULL;
    CR14       = NULL;
    LF15       = NULL;
    CR17       = NULL;
    LF18       = NULL;
    CR21       = NULL;
    LF22       = NULL;
    CR24       = NULL;
    LF25       = NULL;
    CR27       = NULL;
    LF28       = NULL;
    CR30       = NULL;
    LF31       = NULL;
    CR33       = NULL;
    LF34       = NULL;
    CR36       = NULL;
    LF37       = NULL;
    CR39       = NULL;
    LF40       = NULL;
    version1.tree = NULL;

    origin4.tree = NULL;

    session_name7.tree = NULL;

    info10.tree = NULL;

    uri_field13.tree = NULL;

    email16.tree = NULL;

    phone_field19.tree = NULL;

    connection20.tree = NULL;

    bandwidth23.tree = NULL;

    time_field26.tree = NULL;

    repeat_time29.tree = NULL;

    zone_adjustments32.tree = NULL;

    key_field35.tree = NULL;

    attribute38.tree = NULL;

    media_description41.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    CR2_tree   = NULL;
    LF3_tree   = NULL;
    CR5_tree   = NULL;
    LF6_tree   = NULL;
    CR8_tree   = NULL;
    LF9_tree   = NULL;
    CR11_tree   = NULL;
    LF12_tree   = NULL;
    CR14_tree   = NULL;
    LF15_tree   = NULL;
    CR17_tree   = NULL;
    LF18_tree   = NULL;
    CR21_tree   = NULL;
    LF22_tree   = NULL;
    CR24_tree   = NULL;
    LF25_tree   = NULL;
    CR27_tree   = NULL;
    LF28_tree   = NULL;
    CR30_tree   = NULL;
    LF31_tree   = NULL;
    CR33_tree   = NULL;
    LF34_tree   = NULL;
    CR36_tree   = NULL;
    LF37_tree   = NULL;
    CR39_tree   = NULL;
    LF40_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:105:21: ( version CR LF origin CR LF session_name CR LF ( info CR LF )? ( uri_field CR LF )? ( email CR LF )* ( phone_field )* ( connection CR LF )? ( bandwidth CR LF )* time_field CR LF ( repeat_time CR LF )* ( zone_adjustments CR LF )? ( key_field CR LF )? ( attribute CR LF )* ( media_description )* )
        // ../grammars/belle_sdp.g:105:26: version CR LF origin CR LF session_name CR LF ( info CR LF )? ( uri_field CR LF )? ( email CR LF )* ( phone_field )* ( connection CR LF )? ( bandwidth CR LF )* time_field CR LF ( repeat_time CR LF )* ( zone_adjustments CR LF )? ( key_field CR LF )? ( attribute CR LF )* ( media_description )*
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            FOLLOWPUSH(FOLLOW_version_in_session_description98);
            version1=version(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulesession_descriptionEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_session_descriptionPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, version1.tree);

            CR2 = (pANTLR3_COMMON_TOKEN) MATCHT(CR, &FOLLOW_CR_in_session_description100);
            if  (HASEXCEPTION())
            {
                goto rulesession_descriptionEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_session_descriptionPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) {
            CR2_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, CR2));
            ADAPTOR->addChild(ADAPTOR, root_0, CR2_tree);
            }

            LF3 = (pANTLR3_COMMON_TOKEN) MATCHT(LF, &FOLLOW_LF_in_session_description102);
            if  (HASEXCEPTION())
            {
                goto rulesession_descriptionEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_session_descriptionPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) {
            LF3_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, LF3));
            ADAPTOR->addChild(ADAPTOR, root_0, LF3_tree);
            }

            FOLLOWPUSH(FOLLOW_origin_in_session_description129);
            origin4=origin(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulesession_descriptionEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_session_descriptionPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, origin4.tree);

            if ( BACKTRACKING==0 )
            {
                belle_sdp_session_description_set_origin((SCOPE_TOP(session_description))->current,
                origin4.ret
                );
            }


            CR5 = (pANTLR3_COMMON_TOKEN) MATCHT(CR, &FOLLOW_CR_in_session_description132);
            if  (HASEXCEPTION())
            {
                goto rulesession_descriptionEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_session_descriptionPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) {
            CR5_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, CR5));
            ADAPTOR->addChild(ADAPTOR, root_0, CR5_tree);
            }

            LF6 = (pANTLR3_COMMON_TOKEN) MATCHT(LF, &FOLLOW_LF_in_session_description134);
            if  (HASEXCEPTION())
            {
                goto rulesession_descriptionEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_session_descriptionPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) {
            LF6_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, LF6));
            ADAPTOR->addChild(ADAPTOR, root_0, LF6_tree);
            }

            FOLLOWPUSH(FOLLOW_session_name_in_session_description161);
            session_name7=session_name(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulesession_descriptionEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_session_descriptionPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, session_name7.tree);

            CR8 = (pANTLR3_COMMON_TOKEN) MATCHT(CR, &FOLLOW_CR_in_session_description163);
            if  (HASEXCEPTION())
            {
                goto rulesession_descriptionEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_session_descriptionPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) {
            CR8_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, CR8));
            ADAPTOR->addChild(ADAPTOR, root_0, CR8_tree);
            }

            LF9 = (pANTLR3_COMMON_TOKEN) MATCHT(LF, &FOLLOW_LF_in_session_description165);
            if  (HASEXCEPTION())
            {
                goto rulesession_descriptionEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_session_descriptionPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) {
            LF9_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, LF9));
            ADAPTOR->addChild(ADAPTOR, root_0, LF9_tree);
            }

            // ../grammars/belle_sdp.g:108:26: ( info CR LF )?
            {
                int alt1=2;
                alt1 = cdfa1.predict(ctx, RECOGNIZER, ISTREAM, &cdfa1);
                if  (HASEXCEPTION())
                {
                    goto rulesession_descriptionEx;
                }
                if (HASFAILED())
                {
                    pbelle_sdpParser_session_descriptionPop(ctx);

                    return retval;
                }

                switch (alt1)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:108:27: info CR LF
            	    {
            	        FOLLOWPUSH(FOLLOW_info_in_session_description193);
            	        info10=info(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulesession_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_session_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, info10.tree);

            	        CR11 = (pANTLR3_COMMON_TOKEN) MATCHT(CR, &FOLLOW_CR_in_session_description195);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulesession_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_session_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        CR11_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, CR11));
            	        ADAPTOR->addChild(ADAPTOR, root_0, CR11_tree);
            	        }

            	        LF12 = (pANTLR3_COMMON_TOKEN) MATCHT(LF, &FOLLOW_LF_in_session_description197);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulesession_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_session_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        LF12_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, LF12));
            	        ADAPTOR->addChild(ADAPTOR, root_0, LF12_tree);
            	        }

            	    }
            	    break;

                }
            }

            // ../grammars/belle_sdp.g:109:26: ( uri_field CR LF )?
            {
                int alt2=2;
                alt2 = cdfa2.predict(ctx, RECOGNIZER, ISTREAM, &cdfa2);
                if  (HASEXCEPTION())
                {
                    goto rulesession_descriptionEx;
                }
                if (HASFAILED())
                {
                    pbelle_sdpParser_session_descriptionPop(ctx);

                    return retval;
                }

                switch (alt2)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:109:27: uri_field CR LF
            	    {
            	        FOLLOWPUSH(FOLLOW_uri_field_in_session_description227);
            	        uri_field13=uri_field(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulesession_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_session_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, uri_field13.tree);

            	        CR14 = (pANTLR3_COMMON_TOKEN) MATCHT(CR, &FOLLOW_CR_in_session_description229);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulesession_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_session_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        CR14_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, CR14));
            	        ADAPTOR->addChild(ADAPTOR, root_0, CR14_tree);
            	        }

            	        LF15 = (pANTLR3_COMMON_TOKEN) MATCHT(LF, &FOLLOW_LF_in_session_description231);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulesession_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_session_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        LF15_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, LF15));
            	        ADAPTOR->addChild(ADAPTOR, root_0, LF15_tree);
            	        }

            	    }
            	    break;

                }
            }

            // ../grammars/belle_sdp.g:110:26: ( email CR LF )*

            for (;;)
            {
                int alt3=2;
                alt3 = cdfa3.predict(ctx, RECOGNIZER, ISTREAM, &cdfa3);
                if  (HASEXCEPTION())
                {
                    goto rulesession_descriptionEx;
                }
                if (HASFAILED())
                {
                    pbelle_sdpParser_session_descriptionPop(ctx);

                    return retval;
                }

                switch (alt3)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:110:27: email CR LF
            	    {
            	        FOLLOWPUSH(FOLLOW_email_in_session_description261);
            	        email16=email(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulesession_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_session_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, email16.tree);

            	        CR17 = (pANTLR3_COMMON_TOKEN) MATCHT(CR, &FOLLOW_CR_in_session_description263);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulesession_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_session_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        CR17_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, CR17));
            	        ADAPTOR->addChild(ADAPTOR, root_0, CR17_tree);
            	        }

            	        LF18 = (pANTLR3_COMMON_TOKEN) MATCHT(LF, &FOLLOW_LF_in_session_description265);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulesession_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_session_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        LF18_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, LF18));
            	        ADAPTOR->addChild(ADAPTOR, root_0, LF18_tree);
            	        }

            	    }
            	    break;

            	default:
            	    goto loop3;	/* break out of the loop */
            	    break;
                }
            }
            loop3: ; /* Jump out to here if this rule does not match */


            // ../grammars/belle_sdp.g:111:26: ( phone_field )*

            for (;;)
            {
                int alt4=2;
                alt4 = cdfa4.predict(ctx, RECOGNIZER, ISTREAM, &cdfa4);
                if  (HASEXCEPTION())
                {
                    goto rulesession_descriptionEx;
                }
                if (HASFAILED())
                {
                    pbelle_sdpParser_session_descriptionPop(ctx);

                    return retval;
                }

                switch (alt4)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:111:26: phone_field
            	    {
            	        FOLLOWPUSH(FOLLOW_phone_field_in_session_description294);
            	        phone_field19=phone_field(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulesession_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_session_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, phone_field19.tree);

            	    }
            	    break;

            	default:
            	    goto loop4;	/* break out of the loop */
            	    break;
                }
            }
            loop4: ; /* Jump out to here if this rule does not match */


            // ../grammars/belle_sdp.g:112:26: ( connection CR LF )?
            {
                int alt5=2;
                alt5 = cdfa5.predict(ctx, RECOGNIZER, ISTREAM, &cdfa5);
                if  (HASEXCEPTION())
                {
                    goto rulesession_descriptionEx;
                }
                if (HASFAILED())
                {
                    pbelle_sdpParser_session_descriptionPop(ctx);

                    return retval;
                }

                switch (alt5)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:112:27: connection CR LF
            	    {
            	        FOLLOWPUSH(FOLLOW_connection_in_session_description323);
            	        connection20=connection(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulesession_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_session_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, connection20.tree);

            	        if ( BACKTRACKING==0 )
            	        {
            	            belle_sdp_session_description_set_connection((SCOPE_TOP(session_description))->current,
            	            connection20.ret
            	            );
            	        }


            	        CR21 = (pANTLR3_COMMON_TOKEN) MATCHT(CR, &FOLLOW_CR_in_session_description327);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulesession_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_session_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        CR21_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, CR21));
            	        ADAPTOR->addChild(ADAPTOR, root_0, CR21_tree);
            	        }

            	        LF22 = (pANTLR3_COMMON_TOKEN) MATCHT(LF, &FOLLOW_LF_in_session_description329);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulesession_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_session_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        LF22_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, LF22));
            	        ADAPTOR->addChild(ADAPTOR, root_0, LF22_tree);
            	        }

            	    }
            	    break;

                }
            }

            // ../grammars/belle_sdp.g:113:26: ( bandwidth CR LF )*

            for (;;)
            {
                int alt6=2;
                alt6 = cdfa6.predict(ctx, RECOGNIZER, ISTREAM, &cdfa6);
                if  (HASEXCEPTION())
                {
                    goto rulesession_descriptionEx;
                }
                if (HASFAILED())
                {
                    pbelle_sdpParser_session_descriptionPop(ctx);

                    return retval;
                }

                switch (alt6)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:113:27: bandwidth CR LF
            	    {
            	        FOLLOWPUSH(FOLLOW_bandwidth_in_session_description359);
            	        bandwidth23=bandwidth(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulesession_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_session_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, bandwidth23.tree);

            	        if ( BACKTRACKING==0 )
            	        {
            	            belle_sdp_session_description_add_bandwidth((SCOPE_TOP(session_description))->current,
            	            bandwidth23.ret
            	            );
            	        }


            	        CR24 = (pANTLR3_COMMON_TOKEN) MATCHT(CR, &FOLLOW_CR_in_session_description363);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulesession_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_session_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        CR24_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, CR24));
            	        ADAPTOR->addChild(ADAPTOR, root_0, CR24_tree);
            	        }

            	        LF25 = (pANTLR3_COMMON_TOKEN) MATCHT(LF, &FOLLOW_LF_in_session_description365);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulesession_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_session_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        LF25_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, LF25));
            	        ADAPTOR->addChild(ADAPTOR, root_0, LF25_tree);
            	        }

            	    }
            	    break;

            	default:
            	    goto loop6;	/* break out of the loop */
            	    break;
                }
            }
            loop6: ; /* Jump out to here if this rule does not match */


            FOLLOWPUSH(FOLLOW_time_field_in_session_description394);
            time_field26=time_field(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulesession_descriptionEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_session_descriptionPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, time_field26.tree);

            CR27 = (pANTLR3_COMMON_TOKEN) MATCHT(CR, &FOLLOW_CR_in_session_description396);
            if  (HASEXCEPTION())
            {
                goto rulesession_descriptionEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_session_descriptionPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) {
            CR27_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, CR27));
            ADAPTOR->addChild(ADAPTOR, root_0, CR27_tree);
            }

            LF28 = (pANTLR3_COMMON_TOKEN) MATCHT(LF, &FOLLOW_LF_in_session_description398);
            if  (HASEXCEPTION())
            {
                goto rulesession_descriptionEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_session_descriptionPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) {
            LF28_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, LF28));
            ADAPTOR->addChild(ADAPTOR, root_0, LF28_tree);
            }

            // ../grammars/belle_sdp.g:115:26: ( repeat_time CR LF )*

            for (;;)
            {
                int alt7=2;
                alt7 = cdfa7.predict(ctx, RECOGNIZER, ISTREAM, &cdfa7);
                if  (HASEXCEPTION())
                {
                    goto rulesession_descriptionEx;
                }
                if (HASFAILED())
                {
                    pbelle_sdpParser_session_descriptionPop(ctx);

                    return retval;
                }

                switch (alt7)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:115:27: repeat_time CR LF
            	    {
            	        FOLLOWPUSH(FOLLOW_repeat_time_in_session_description426);
            	        repeat_time29=repeat_time(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulesession_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_session_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, repeat_time29.tree);

            	        CR30 = (pANTLR3_COMMON_TOKEN) MATCHT(CR, &FOLLOW_CR_in_session_description428);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulesession_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_session_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        CR30_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, CR30));
            	        ADAPTOR->addChild(ADAPTOR, root_0, CR30_tree);
            	        }

            	        LF31 = (pANTLR3_COMMON_TOKEN) MATCHT(LF, &FOLLOW_LF_in_session_description430);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulesession_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_session_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        LF31_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, LF31));
            	        ADAPTOR->addChild(ADAPTOR, root_0, LF31_tree);
            	        }

            	    }
            	    break;

            	default:
            	    goto loop7;	/* break out of the loop */
            	    break;
                }
            }
            loop7: ; /* Jump out to here if this rule does not match */


            // ../grammars/belle_sdp.g:116:26: ( zone_adjustments CR LF )?
            {
                int alt8=2;
                alt8 = cdfa8.predict(ctx, RECOGNIZER, ISTREAM, &cdfa8);
                if  (HASEXCEPTION())
                {
                    goto rulesession_descriptionEx;
                }
                if (HASFAILED())
                {
                    pbelle_sdpParser_session_descriptionPop(ctx);

                    return retval;
                }

                switch (alt8)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:116:27: zone_adjustments CR LF
            	    {
            	        FOLLOWPUSH(FOLLOW_zone_adjustments_in_session_description460);
            	        zone_adjustments32=zone_adjustments(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulesession_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_session_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, zone_adjustments32.tree);

            	        CR33 = (pANTLR3_COMMON_TOKEN) MATCHT(CR, &FOLLOW_CR_in_session_description462);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulesession_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_session_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        CR33_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, CR33));
            	        ADAPTOR->addChild(ADAPTOR, root_0, CR33_tree);
            	        }

            	        LF34 = (pANTLR3_COMMON_TOKEN) MATCHT(LF, &FOLLOW_LF_in_session_description464);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulesession_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_session_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        LF34_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, LF34));
            	        ADAPTOR->addChild(ADAPTOR, root_0, LF34_tree);
            	        }

            	    }
            	    break;

                }
            }

            // ../grammars/belle_sdp.g:117:26: ( key_field CR LF )?
            {
                int alt9=2;
                alt9 = cdfa9.predict(ctx, RECOGNIZER, ISTREAM, &cdfa9);
                if  (HASEXCEPTION())
                {
                    goto rulesession_descriptionEx;
                }
                if (HASFAILED())
                {
                    pbelle_sdpParser_session_descriptionPop(ctx);

                    return retval;
                }

                switch (alt9)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:117:27: key_field CR LF
            	    {
            	        FOLLOWPUSH(FOLLOW_key_field_in_session_description494);
            	        key_field35=key_field(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulesession_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_session_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, key_field35.tree);

            	        CR36 = (pANTLR3_COMMON_TOKEN) MATCHT(CR, &FOLLOW_CR_in_session_description496);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulesession_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_session_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        CR36_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, CR36));
            	        ADAPTOR->addChild(ADAPTOR, root_0, CR36_tree);
            	        }

            	        LF37 = (pANTLR3_COMMON_TOKEN) MATCHT(LF, &FOLLOW_LF_in_session_description498);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulesession_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_session_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        LF37_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, LF37));
            	        ADAPTOR->addChild(ADAPTOR, root_0, LF37_tree);
            	        }

            	    }
            	    break;

                }
            }

            // ../grammars/belle_sdp.g:118:26: ( attribute CR LF )*

            for (;;)
            {
                int alt10=2;
                alt10 = cdfa10.predict(ctx, RECOGNIZER, ISTREAM, &cdfa10);
                if  (HASEXCEPTION())
                {
                    goto rulesession_descriptionEx;
                }
                if (HASFAILED())
                {
                    pbelle_sdpParser_session_descriptionPop(ctx);

                    return retval;
                }

                switch (alt10)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:118:27: attribute CR LF
            	    {
            	        FOLLOWPUSH(FOLLOW_attribute_in_session_description528);
            	        attribute38=attribute(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulesession_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_session_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, attribute38.tree);

            	        if ( BACKTRACKING==0 )
            	        {
            	            belle_sdp_session_description_add_attribute((SCOPE_TOP(session_description))->current,
            	            attribute38.ret
            	            );
            	        }


            	        CR39 = (pANTLR3_COMMON_TOKEN) MATCHT(CR, &FOLLOW_CR_in_session_description532);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulesession_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_session_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        CR39_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, CR39));
            	        ADAPTOR->addChild(ADAPTOR, root_0, CR39_tree);
            	        }

            	        LF40 = (pANTLR3_COMMON_TOKEN) MATCHT(LF, &FOLLOW_LF_in_session_description534);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulesession_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_session_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        LF40_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, LF40));
            	        ADAPTOR->addChild(ADAPTOR, root_0, LF40_tree);
            	        }

            	    }
            	    break;

            	default:
            	    goto loop10;	/* break out of the loop */
            	    break;
                }
            }
            loop10: ; /* Jump out to here if this rule does not match */


            // ../grammars/belle_sdp.g:119:26: ( media_description )*

            for (;;)
            {
                int alt11=2;
                switch ( LA(1) )
                {
                case COMMON_CHAR:
                case DIGIT:
                case HEX_CHAR:
                	{
                		alt11=1;
                	}
                    break;

                }

                switch (alt11)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:119:27: media_description
            	    {
            	        FOLLOWPUSH(FOLLOW_media_description_in_session_description564);
            	        media_description41=media_description(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulesession_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_session_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, media_description41.tree);

            	        if ( BACKTRACKING==0 )
            	        {
            	            belle_sdp_session_description_add_media_description((SCOPE_TOP(session_description))->current,
            	            media_description41.ret
            	            );
            	        }


            	    }
            	    break;

            	default:
            	    goto loop11;	/* break out of the loop */
            	    break;
                }
            }
            loop11: ; /* Jump out to here if this rule does not match */


        }

    }

    // This is where rules clean up and exit
    //
    goto rulesession_descriptionEx; /* Prevent compiler warnings */
    rulesession_descriptionEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }


    if	(HASEXCEPTION())
    {
	/* catch(decl,action)
	 */
	{

	    	ANTLR3_LOG_EXCEPTION();
	       belle_sip_object_unref((SCOPE_TOP(session_description))->current);
	       
	    retval.ret=NULL;


	}


    }
    else
    {
    }
    pbelle_sdpParser_session_descriptionPop(ctx);

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

/**
 * $ANTLR start version
 * ../grammars/belle_sdp.g:128:1: version :{...}? alpha_num EQUAL (v= DIGIT )+ ;
 */
static belle_sdpParser_version_return
version(pbelle_sdpParser ctx)
{
    belle_sdpParser_version_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    v;
    pANTLR3_COMMON_TOKEN    EQUAL43;
    belle_sdpParser_alpha_num_return alpha_num42;
    #undef	RETURN_TYPE_alpha_num42
    #define	RETURN_TYPE_alpha_num42 belle_sdpParser_alpha_num_return

    pANTLR3_BASE_TREE v_tree;
    pANTLR3_BASE_TREE EQUAL43_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    v       = NULL;
    EQUAL43       = NULL;
    alpha_num42.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    v_tree   = NULL;
    EQUAL43_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:128:8: ({...}? alpha_num EQUAL (v= DIGIT )+ )
        // ../grammars/belle_sdp.g:128:16: {...}? alpha_num EQUAL (v= DIGIT )+
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(v))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(v)";
                    EXCEPTION->ruleName	 = (void *)"version";


            }

            FOLLOWPUSH(FOLLOW_alpha_num_in_version590);
            alpha_num42=alpha_num(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruleversionEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num42.tree);

            EQUAL43 = (pANTLR3_COMMON_TOKEN) MATCHT(EQUAL, &FOLLOW_EQUAL_in_version592);
            if  (HASEXCEPTION())
            {
                goto ruleversionEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) {
            EQUAL43_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, EQUAL43));
            ADAPTOR->addChild(ADAPTOR, root_0, EQUAL43_tree);
            }

            // ../grammars/belle_sdp.g:128:47: (v= DIGIT )+
            {
                int cnt12=0;

                for (;;)
                {
                    int alt12=2;
            	switch ( LA(1) )
            	{
            	case DIGIT:
            		{
            			alt12=1;
            		}
            	    break;

            	}

            	switch (alt12)
            	{
            	    case 1:
            	        // ../grammars/belle_sdp.g:128:47: v= DIGIT
            	        {
            	            v = (pANTLR3_COMMON_TOKEN) MATCHT(DIGIT, &FOLLOW_DIGIT_in_version596);
            	            if  (HASEXCEPTION())
            	            {
            	                goto ruleversionEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) {
            	            v_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, v));
            	            ADAPTOR->addChild(ADAPTOR, root_0, v_tree);
            	            }

            	        }
            	        break;

            	    default:

            		if ( cnt12 >= 1 )
            		{
            		    goto loop12;
            		}
            		if (BACKTRACKING>0)
            		{
            		    FAILEDFLAG = ANTLR3_TRUE;
            		    return retval;
            		}

            		/* mismatchedSetEx()
            		 */
            		CONSTRUCTEX();
            		EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
            		EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;


            		goto ruleversionEx;
            	}
            	cnt12++;
                }
                loop12: ;	/* Jump to here if this rule does not match */
            }

            if ( BACKTRACKING==0 )
            {
                belle_sdp_version_t* version =belle_sdp_version_new();
                                                                        belle_sdp_version_set_version(version,atoi((const char*)(v->getText(v))->chars));
                                                                        belle_sdp_session_description_set_version((SCOPE_TOP(session_description))->current,version);
            }


        }

    }

    // This is where rules clean up and exit
    //
    goto ruleversionEx; /* Prevent compiler warnings */
    ruleversionEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start origin
 * ../grammars/belle_sdp.g:134:1: origin returns [belle_sdp_origin_t* ret] :{...}? alpha_num EQUAL username SPACE sess_id SPACE sess_version SPACE nettype SPACE addrtype SPACE addr ;
 */
static belle_sdpParser_origin_return
origin(pbelle_sdpParser ctx)
{
    belle_sdpParser_origin_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    EQUAL45;
    pANTLR3_COMMON_TOKEN    SPACE47;
    pANTLR3_COMMON_TOKEN    SPACE49;
    pANTLR3_COMMON_TOKEN    SPACE51;
    pANTLR3_COMMON_TOKEN    SPACE53;
    pANTLR3_COMMON_TOKEN    SPACE55;
    belle_sdpParser_alpha_num_return alpha_num44;
    #undef	RETURN_TYPE_alpha_num44
    #define	RETURN_TYPE_alpha_num44 belle_sdpParser_alpha_num_return

    belle_sdpParser_username_return username46;
    #undef	RETURN_TYPE_username46
    #define	RETURN_TYPE_username46 belle_sdpParser_username_return

    belle_sdpParser_sess_id_return sess_id48;
    #undef	RETURN_TYPE_sess_id48
    #define	RETURN_TYPE_sess_id48 belle_sdpParser_sess_id_return

    belle_sdpParser_sess_version_return sess_version50;
    #undef	RETURN_TYPE_sess_version50
    #define	RETURN_TYPE_sess_version50 belle_sdpParser_sess_version_return

    belle_sdpParser_nettype_return nettype52;
    #undef	RETURN_TYPE_nettype52
    #define	RETURN_TYPE_nettype52 belle_sdpParser_nettype_return

    belle_sdpParser_addrtype_return addrtype54;
    #undef	RETURN_TYPE_addrtype54
    #define	RETURN_TYPE_addrtype54 belle_sdpParser_addrtype_return

    belle_sdpParser_addr_return addr56;
    #undef	RETURN_TYPE_addr56
    #define	RETURN_TYPE_addr56 belle_sdpParser_addr_return

    pANTLR3_BASE_TREE EQUAL45_tree;
    pANTLR3_BASE_TREE SPACE47_tree;
    pANTLR3_BASE_TREE SPACE49_tree;
    pANTLR3_BASE_TREE SPACE51_tree;
    pANTLR3_BASE_TREE SPACE53_tree;
    pANTLR3_BASE_TREE SPACE55_tree;

    /* Initialize rule variables
     */
    ctx->pbelle_sdpParser_originTop = pbelle_sdpParser_originPush(ctx);
    root_0 = NULL;

    (SCOPE_TOP(origin))->current= belle_sdp_origin_new(); 
    retval.ret=(SCOPE_TOP(origin))->current;
     
    EQUAL45       = NULL;
    SPACE47       = NULL;
    SPACE49       = NULL;
    SPACE51       = NULL;
    SPACE53       = NULL;
    SPACE55       = NULL;
    alpha_num44.tree = NULL;

    username46.tree = NULL;

    sess_id48.tree = NULL;

    sess_version50.tree = NULL;

    nettype52.tree = NULL;

    addrtype54.tree = NULL;

    addr56.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    EQUAL45_tree   = NULL;
    SPACE47_tree   = NULL;
    SPACE49_tree   = NULL;
    SPACE51_tree   = NULL;
    SPACE53_tree   = NULL;
    SPACE55_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:137:10: ({...}? alpha_num EQUAL username SPACE sess_id SPACE sess_version SPACE nettype SPACE addrtype SPACE addr )
        // ../grammars/belle_sdp.g:137:10: {...}? alpha_num EQUAL username SPACE sess_id SPACE sess_version SPACE nettype SPACE addrtype SPACE addr
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(o))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    pbelle_sdpParser_originPop(ctx);

                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(o)";
                    EXCEPTION->ruleName	 = (void *)"origin";


            }

            FOLLOWPUSH(FOLLOW_alpha_num_in_origin654);
            alpha_num44=alpha_num(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruleoriginEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_originPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num44.tree);

            EQUAL45 = (pANTLR3_COMMON_TOKEN) MATCHT(EQUAL, &FOLLOW_EQUAL_in_origin656);
            if  (HASEXCEPTION())
            {
                goto ruleoriginEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_originPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) {
            EQUAL45_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, EQUAL45));
            ADAPTOR->addChild(ADAPTOR, root_0, EQUAL45_tree);
            }

            FOLLOWPUSH(FOLLOW_username_in_origin658);
            username46=username(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruleoriginEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_originPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, username46.tree);

            if ( BACKTRACKING==0 )
            {
                belle_sdp_origin_set_username((SCOPE_TOP(origin))->current,(const char*)
                (STRSTREAM->toStringTT(STRSTREAM, username46.start, username46.stop))
                ->chars);
            }


            SPACE47 = (pANTLR3_COMMON_TOKEN) MATCHT(SPACE, &FOLLOW_SPACE_in_origin687);
            if  (HASEXCEPTION())
            {
                goto ruleoriginEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_originPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) {
            SPACE47_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, SPACE47));
            ADAPTOR->addChild(ADAPTOR, root_0, SPACE47_tree);
            }

            FOLLOWPUSH(FOLLOW_sess_id_in_origin689);
            sess_id48=sess_id(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruleoriginEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_originPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, sess_id48.tree);

            if ( BACKTRACKING==0 )
            {
                if ((STRSTREAM->toStringTT(STRSTREAM, sess_id48.start, sess_id48.stop))
                ->chars) belle_sdp_origin_set_session_id((SCOPE_TOP(origin))->current,strtoul((const char*)
                (STRSTREAM->toStringTT(STRSTREAM, sess_id48.start, sess_id48.stop))
                ->chars,NULL,10));
            }


            SPACE49 = (pANTLR3_COMMON_TOKEN) MATCHT(SPACE, &FOLLOW_SPACE_in_origin718);
            if  (HASEXCEPTION())
            {
                goto ruleoriginEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_originPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) {
            SPACE49_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, SPACE49));
            ADAPTOR->addChild(ADAPTOR, root_0, SPACE49_tree);
            }

            FOLLOWPUSH(FOLLOW_sess_version_in_origin720);
            sess_version50=sess_version(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruleoriginEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_originPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, sess_version50.tree);

            if ( BACKTRACKING==0 )
            {
                if ((STRSTREAM->toStringTT(STRSTREAM, sess_version50.start, sess_version50.stop))
                ->chars) belle_sdp_origin_set_session_version((SCOPE_TOP(origin))->current,strtoul((const char*)
                (STRSTREAM->toStringTT(STRSTREAM, sess_version50.start, sess_version50.stop))
                ->chars,NULL,10));
            }


            SPACE51 = (pANTLR3_COMMON_TOKEN) MATCHT(SPACE, &FOLLOW_SPACE_in_origin749);
            if  (HASEXCEPTION())
            {
                goto ruleoriginEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_originPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) {
            SPACE51_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, SPACE51));
            ADAPTOR->addChild(ADAPTOR, root_0, SPACE51_tree);
            }

            FOLLOWPUSH(FOLLOW_nettype_in_origin751);
            nettype52=nettype(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruleoriginEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_originPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, nettype52.tree);

            if ( BACKTRACKING==0 )
            {
                belle_sdp_origin_set_network_type((SCOPE_TOP(origin))->current,(const char*)
                (STRSTREAM->toStringTT(STRSTREAM, nettype52.start, nettype52.stop))
                ->chars);
            }


            SPACE53 = (pANTLR3_COMMON_TOKEN) MATCHT(SPACE, &FOLLOW_SPACE_in_origin780);
            if  (HASEXCEPTION())
            {
                goto ruleoriginEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_originPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) {
            SPACE53_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, SPACE53));
            ADAPTOR->addChild(ADAPTOR, root_0, SPACE53_tree);
            }

            FOLLOWPUSH(FOLLOW_addrtype_in_origin782);
            addrtype54=addrtype(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruleoriginEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_originPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, addrtype54.tree);

            if ( BACKTRACKING==0 )
            {
                belle_sdp_origin_set_address_type((SCOPE_TOP(origin))->current,(const char*)
                (STRSTREAM->toStringTT(STRSTREAM, addrtype54.start, addrtype54.stop))
                ->chars);
            }


            SPACE55 = (pANTLR3_COMMON_TOKEN) MATCHT(SPACE, &FOLLOW_SPACE_in_origin812);
            if  (HASEXCEPTION())
            {
                goto ruleoriginEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_originPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) {
            SPACE55_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, SPACE55));
            ADAPTOR->addChild(ADAPTOR, root_0, SPACE55_tree);
            }

            FOLLOWPUSH(FOLLOW_addr_in_origin814);
            addr56=addr(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruleoriginEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_originPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, addr56.tree);

            if ( BACKTRACKING==0 )
            {
                belle_sdp_origin_set_address((SCOPE_TOP(origin))->current,(const char*)
                (STRSTREAM->toStringTT(STRSTREAM, addr56.start, addr56.stop))
                ->chars);
            }


        }

    }

    // This is where rules clean up and exit
    //
    goto ruleoriginEx; /* Prevent compiler warnings */
    ruleoriginEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }


    if	(HASEXCEPTION())
    {
	/* catch(decl,action)
	 */
	{

	    	ANTLR3_LOG_EXCEPTION();
	       belle_sip_object_unref((SCOPE_TOP(origin))->current);
	       
	    retval.ret=NULL;


	}


    }
    else
    {
    }
    pbelle_sdpParser_originPop(ctx);

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

/**
 * $ANTLR start session_name
 * ../grammars/belle_sdp.g:151:1: session_name :{...}? alpha_num EQUAL text ;
 */
static belle_sdpParser_session_name_return
session_name(pbelle_sdpParser ctx)
{
    belle_sdpParser_session_name_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    EQUAL58;
    belle_sdpParser_alpha_num_return alpha_num57;
    #undef	RETURN_TYPE_alpha_num57
    #define	RETURN_TYPE_alpha_num57 belle_sdpParser_alpha_num_return

    belle_sdpParser_text_return text59;
    #undef	RETURN_TYPE_text59
    #define	RETURN_TYPE_text59 belle_sdpParser_text_return

    pANTLR3_BASE_TREE EQUAL58_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    EQUAL58       = NULL;
    alpha_num57.tree = NULL;

    text59.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    EQUAL58_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:151:13: ({...}? alpha_num EQUAL text )
        // ../grammars/belle_sdp.g:151:16: {...}? alpha_num EQUAL text
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(s))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(s)";
                    EXCEPTION->ruleName	 = (void *)"session_name";


            }

            FOLLOWPUSH(FOLLOW_alpha_num_in_session_name834);
            alpha_num57=alpha_num(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulesession_nameEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num57.tree);

            EQUAL58 = (pANTLR3_COMMON_TOKEN) MATCHT(EQUAL, &FOLLOW_EQUAL_in_session_name836);
            if  (HASEXCEPTION())
            {
                goto rulesession_nameEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) {
            EQUAL58_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, EQUAL58));
            ADAPTOR->addChild(ADAPTOR, root_0, EQUAL58_tree);
            }

            FOLLOWPUSH(FOLLOW_text_in_session_name838);
            text59=text(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulesession_nameEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, text59.tree);

            if ( BACKTRACKING==0 )
            {
                belle_sdp_session_name_t* session_name =belle_sdp_session_name_new();
                                                                        belle_sdp_session_name_set_value(session_name,(const char*)(STRSTREAM->toStringTT(STRSTREAM, text59.start, text59.stop))
                ->chars);
                                                                        belle_sdp_session_description_set_session_name((SCOPE_TOP(session_description))->current,session_name);
            }


        }

    }

    // This is where rules clean up and exit
    //
    goto rulesession_nameEx; /* Prevent compiler warnings */
    rulesession_nameEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start info
 * ../grammars/belle_sdp.g:155:1: info returns [belle_sdp_info_t* ret] :{...}? alpha_num EQUAL info_value ;
 */
static belle_sdpParser_info_return
info(pbelle_sdpParser ctx)
{
    belle_sdpParser_info_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    EQUAL61;
    belle_sdpParser_alpha_num_return alpha_num60;
    #undef	RETURN_TYPE_alpha_num60
    #define	RETURN_TYPE_alpha_num60 belle_sdpParser_alpha_num_return

    belle_sdpParser_info_value_return info_value62;
    #undef	RETURN_TYPE_info_value62
    #define	RETURN_TYPE_info_value62 belle_sdpParser_info_value_return

    pANTLR3_BASE_TREE EQUAL61_tree;

    /* Initialize rule variables
     */
    ctx->pbelle_sdpParser_infoTop = pbelle_sdpParser_infoPush(ctx);
    root_0 = NULL;

    (SCOPE_TOP(info))->current= belle_sdp_info_new(); 
    retval.ret=(SCOPE_TOP(info))->current;
     
    EQUAL61       = NULL;
    alpha_num60.tree = NULL;

    info_value62.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    EQUAL61_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:158:5: ({...}? alpha_num EQUAL info_value )
        // ../grammars/belle_sdp.g:158:5: {...}? alpha_num EQUAL info_value
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(i))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    pbelle_sdpParser_infoPop(ctx);

                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(i)";
                    EXCEPTION->ruleName	 = (void *)"info";


            }

            FOLLOWPUSH(FOLLOW_alpha_num_in_info865);
            alpha_num60=alpha_num(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruleinfoEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_infoPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num60.tree);

            EQUAL61 = (pANTLR3_COMMON_TOKEN) MATCHT(EQUAL, &FOLLOW_EQUAL_in_info867);
            if  (HASEXCEPTION())
            {
                goto ruleinfoEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_infoPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) {
            EQUAL61_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, EQUAL61));
            ADAPTOR->addChild(ADAPTOR, root_0, EQUAL61_tree);
            }

            FOLLOWPUSH(FOLLOW_info_value_in_info869);
            info_value62=info_value(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruleinfoEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_infoPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, info_value62.tree);

            if ( BACKTRACKING==0 )
            {
                belle_sdp_info_set_value((SCOPE_TOP(info))->current,(const char*) 
                (STRSTREAM->toStringTT(STRSTREAM, info_value62.start, info_value62.stop))
                ->chars);
            }


        }

    }

    // This is where rules clean up and exit
    //
    goto ruleinfoEx; /* Prevent compiler warnings */
    ruleinfoEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

    pbelle_sdpParser_infoPop(ctx);

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

/**
 * $ANTLR start info_value
 * ../grammars/belle_sdp.g:160:1: info_value options {greedy=false; } : (~ ( CR | LF ) )* ;
 */
static belle_sdpParser_info_value_return
info_value(pbelle_sdpParser ctx)
{
    belle_sdpParser_info_value_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    set63;

    pANTLR3_BASE_TREE set63_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    set63       = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    set63_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:160:50: ( (~ ( CR | LF ) )* )
        // ../grammars/belle_sdp.g:160:59: (~ ( CR | LF ) )*
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            // ../grammars/belle_sdp.g:160:59: (~ ( CR | LF ) )*

            for (;;)
            {
                int alt13=2;
                switch ( LA(1) )
                {
                case COLON:
                case COMMA:
                case COMMON_CHAR:
                case DASH:
                case DIGIT:
                case DOT:
                case EQUAL:
                case HEX_CHAR:
                case LQUOTE:
                case OCTET:
                case POS_DIGIT:
                case RQUOTE:
                case SLASH:
                case SPACE:
                case STAR:
                case ZERO:
                case 22:
                case 23:
                case 24:
                case 25:
                case 26:
                case 27:
                case 28:
                case 29:
                case 30:
                case 31:
                case 32:
                case 33:
                case 34:
                case 35:
                	{
                		alt13=1;
                	}
                    break;

                }

                switch (alt13)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:
            	    {
            	        set63=(pANTLR3_COMMON_TOKEN)LT(1);

            	        if ( ((LA(1) >= COLON) && (LA(1) <= COMMON_CHAR)) || ((LA(1) >= DASH) && (LA(1) <= HEX_CHAR)) || ((LA(1) >= LQUOTE) && (LA(1) <= 35)) )
            	        {
            	            CONSUME();
            	            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, 
            	            (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set63))
            	            );
            	            PERRORRECOVERY=ANTLR3_FALSE;
            	            FAILEDFLAG=ANTLR3_FALSE;

            	        }
            	        else
            	        {
            	            if (BACKTRACKING>0)
            	            {
            	                FAILEDFLAG = ANTLR3_TRUE;
            	                return retval;
            	            }

            	            CONSTRUCTEX();
            	            EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;
            	            EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;
            	            EXCEPTION->expectingSet = NULL;

            	            goto ruleinfo_valueEx;
            	        }


            	    }
            	    break;

            	default:
            	    goto loop13;	/* break out of the loop */
            	    break;
                }
            }
            loop13: ; /* Jump out to here if this rule does not match */


        }

    }

    // This is where rules clean up and exit
    //
    goto ruleinfo_valueEx; /* Prevent compiler warnings */
    ruleinfo_valueEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start uri_field
 * ../grammars/belle_sdp.g:162:1: uri_field :{...}? alpha_num EQUAL uri ;
 */
static belle_sdpParser_uri_field_return
uri_field(pbelle_sdpParser ctx)
{
    belle_sdpParser_uri_field_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    EQUAL65;
    belle_sdpParser_alpha_num_return alpha_num64;
    #undef	RETURN_TYPE_alpha_num64
    #define	RETURN_TYPE_alpha_num64 belle_sdpParser_alpha_num_return

    belle_sdpParser_uri_return uri66;
    #undef	RETURN_TYPE_uri66
    #define	RETURN_TYPE_uri66 belle_sdpParser_uri_return

    pANTLR3_BASE_TREE EQUAL65_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    EQUAL65       = NULL;
    alpha_num64.tree = NULL;

    uri66.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    EQUAL65_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:162:10: ({...}? alpha_num EQUAL uri )
        // ../grammars/belle_sdp.g:162:22: {...}? alpha_num EQUAL uri
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(u))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(u)";
                    EXCEPTION->ruleName	 = (void *)"uri_field";


            }

            FOLLOWPUSH(FOLLOW_alpha_num_in_uri_field932);
            alpha_num64=alpha_num(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruleuri_fieldEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num64.tree);

            EQUAL65 = (pANTLR3_COMMON_TOKEN) MATCHT(EQUAL, &FOLLOW_EQUAL_in_uri_field934);
            if  (HASEXCEPTION())
            {
                goto ruleuri_fieldEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) {
            EQUAL65_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, EQUAL65));
            ADAPTOR->addChild(ADAPTOR, root_0, EQUAL65_tree);
            }

            FOLLOWPUSH(FOLLOW_uri_in_uri_field936);
            uri66=uri(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruleuri_fieldEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, uri66.tree);

        }

    }

    // This is where rules clean up and exit
    //
    goto ruleuri_fieldEx; /* Prevent compiler warnings */
    ruleuri_fieldEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start email
 * ../grammars/belle_sdp.g:164:1: email returns [belle_sdp_email_t* ret] :{...}? alpha_num EQUAL email_address ;
 */
static belle_sdpParser_email_return
email(pbelle_sdpParser ctx)
{
    belle_sdpParser_email_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    EQUAL68;
    belle_sdpParser_alpha_num_return alpha_num67;
    #undef	RETURN_TYPE_alpha_num67
    #define	RETURN_TYPE_alpha_num67 belle_sdpParser_alpha_num_return

    belle_sdpParser_email_address_return email_address69;
    #undef	RETURN_TYPE_email_address69
    #define	RETURN_TYPE_email_address69 belle_sdpParser_email_address_return

    pANTLR3_BASE_TREE EQUAL68_tree;

    /* Initialize rule variables
     */
    ctx->pbelle_sdpParser_emailTop = pbelle_sdpParser_emailPush(ctx);
    root_0 = NULL;

    (SCOPE_TOP(email))->current= belle_sdp_email_new(); 
    retval.ret=(SCOPE_TOP(email))->current;
     
    EQUAL68       = NULL;
    alpha_num67.tree = NULL;

    email_address69.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    EQUAL68_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:167:3: ({...}? alpha_num EQUAL email_address )
        // ../grammars/belle_sdp.g:167:12: {...}? alpha_num EQUAL email_address
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(e))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    pbelle_sdpParser_emailPop(ctx);

                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(e)";
                    EXCEPTION->ruleName	 = (void *)"email";


            }

            FOLLOWPUSH(FOLLOW_alpha_num_in_email968);
            alpha_num67=alpha_num(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruleemailEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_emailPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num67.tree);

            EQUAL68 = (pANTLR3_COMMON_TOKEN) MATCHT(EQUAL, &FOLLOW_EQUAL_in_email970);
            if  (HASEXCEPTION())
            {
                goto ruleemailEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_emailPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) {
            EQUAL68_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, EQUAL68));
            ADAPTOR->addChild(ADAPTOR, root_0, EQUAL68_tree);
            }

            FOLLOWPUSH(FOLLOW_email_address_in_email972);
            email_address69=email_address(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruleemailEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_emailPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, email_address69.tree);

            if ( BACKTRACKING==0 )
            {
                belle_sdp_email_set_value((SCOPE_TOP(email))->current,(const char*)
                (STRSTREAM->toStringTT(STRSTREAM, email_address69.start, email_address69.stop))
                ->chars);
            }


        }

    }

    // This is where rules clean up and exit
    //
    goto ruleemailEx; /* Prevent compiler warnings */
    ruleemailEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

    pbelle_sdpParser_emailPop(ctx);

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

/**
 * $ANTLR start phone_field
 * ../grammars/belle_sdp.g:169:1: phone_field :{...}? alpha_num EQUAL phone_number CR LF ;
 */
static belle_sdpParser_phone_field_return
phone_field(pbelle_sdpParser ctx)
{
    belle_sdpParser_phone_field_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    EQUAL71;
    pANTLR3_COMMON_TOKEN    CR73;
    pANTLR3_COMMON_TOKEN    LF74;
    belle_sdpParser_alpha_num_return alpha_num70;
    #undef	RETURN_TYPE_alpha_num70
    #define	RETURN_TYPE_alpha_num70 belle_sdpParser_alpha_num_return

    belle_sdpParser_phone_number_return phone_number72;
    #undef	RETURN_TYPE_phone_number72
    #define	RETURN_TYPE_phone_number72 belle_sdpParser_phone_number_return

    pANTLR3_BASE_TREE EQUAL71_tree;
    pANTLR3_BASE_TREE CR73_tree;
    pANTLR3_BASE_TREE LF74_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    EQUAL71       = NULL;
    CR73       = NULL;
    LF74       = NULL;
    alpha_num70.tree = NULL;

    phone_number72.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    EQUAL71_tree   = NULL;
    CR73_tree   = NULL;
    LF74_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:169:12: ({...}? alpha_num EQUAL phone_number CR LF )
        // ../grammars/belle_sdp.g:169:21: {...}? alpha_num EQUAL phone_number CR LF
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(p))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(p)";
                    EXCEPTION->ruleName	 = (void *)"phone_field";


            }

            FOLLOWPUSH(FOLLOW_alpha_num_in_phone_field989);
            alpha_num70=alpha_num(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulephone_fieldEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num70.tree);

            EQUAL71 = (pANTLR3_COMMON_TOKEN) MATCHT(EQUAL, &FOLLOW_EQUAL_in_phone_field991);
            if  (HASEXCEPTION())
            {
                goto rulephone_fieldEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) {
            EQUAL71_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, EQUAL71));
            ADAPTOR->addChild(ADAPTOR, root_0, EQUAL71_tree);
            }

            FOLLOWPUSH(FOLLOW_phone_number_in_phone_field993);
            phone_number72=phone_number(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulephone_fieldEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, phone_number72.tree);

            CR73 = (pANTLR3_COMMON_TOKEN) MATCHT(CR, &FOLLOW_CR_in_phone_field995);
            if  (HASEXCEPTION())
            {
                goto rulephone_fieldEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) {
            CR73_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, CR73));
            ADAPTOR->addChild(ADAPTOR, root_0, CR73_tree);
            }

            LF74 = (pANTLR3_COMMON_TOKEN) MATCHT(LF, &FOLLOW_LF_in_phone_field997);
            if  (HASEXCEPTION())
            {
                goto rulephone_fieldEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) {
            LF74_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, LF74));
            ADAPTOR->addChild(ADAPTOR, root_0, LF74_tree);
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto rulephone_fieldEx; /* Prevent compiler warnings */
    rulephone_fieldEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start connection
 * ../grammars/belle_sdp.g:171:1: connection returns [belle_sdp_connection_t* ret] :{...}? alpha_num EQUAL nettype SPACE addrtype SPACE connection_address ;
 */
static belle_sdpParser_connection_return
connection(pbelle_sdpParser ctx)
{
    belle_sdpParser_connection_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    EQUAL76;
    pANTLR3_COMMON_TOKEN    SPACE78;
    pANTLR3_COMMON_TOKEN    SPACE80;
    belle_sdpParser_alpha_num_return alpha_num75;
    #undef	RETURN_TYPE_alpha_num75
    #define	RETURN_TYPE_alpha_num75 belle_sdpParser_alpha_num_return

    belle_sdpParser_nettype_return nettype77;
    #undef	RETURN_TYPE_nettype77
    #define	RETURN_TYPE_nettype77 belle_sdpParser_nettype_return

    belle_sdpParser_addrtype_return addrtype79;
    #undef	RETURN_TYPE_addrtype79
    #define	RETURN_TYPE_addrtype79 belle_sdpParser_addrtype_return

    belle_sdpParser_connection_address_return connection_address81;
    #undef	RETURN_TYPE_connection_address81
    #define	RETURN_TYPE_connection_address81 belle_sdpParser_connection_address_return

    pANTLR3_BASE_TREE EQUAL76_tree;
    pANTLR3_BASE_TREE SPACE78_tree;
    pANTLR3_BASE_TREE SPACE80_tree;

    /* Initialize rule variables
     */
    ctx->pbelle_sdpParser_connectionTop = pbelle_sdpParser_connectionPush(ctx);
    root_0 = NULL;

    (SCOPE_TOP(connection))->current= belle_sdp_connection_new(); 
    retval.ret=(SCOPE_TOP(connection))->current;
     
    EQUAL76       = NULL;
    SPACE78       = NULL;
    SPACE80       = NULL;
    alpha_num75.tree = NULL;

    nettype77.tree = NULL;

    addrtype79.tree = NULL;

    connection_address81.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    EQUAL76_tree   = NULL;
    SPACE78_tree   = NULL;
    SPACE80_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:174:6: ({...}? alpha_num EQUAL nettype SPACE addrtype SPACE connection_address )
        // ../grammars/belle_sdp.g:174:6: {...}? alpha_num EQUAL nettype SPACE addrtype SPACE connection_address
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(c))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    pbelle_sdpParser_connectionPop(ctx);

                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(c)";
                    EXCEPTION->ruleName	 = (void *)"connection";


            }

            FOLLOWPUSH(FOLLOW_alpha_num_in_connection1022);
            alpha_num75=alpha_num(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruleconnectionEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_connectionPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num75.tree);

            EQUAL76 = (pANTLR3_COMMON_TOKEN) MATCHT(EQUAL, &FOLLOW_EQUAL_in_connection1024);
            if  (HASEXCEPTION())
            {
                goto ruleconnectionEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_connectionPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) {
            EQUAL76_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, EQUAL76));
            ADAPTOR->addChild(ADAPTOR, root_0, EQUAL76_tree);
            }

            FOLLOWPUSH(FOLLOW_nettype_in_connection1026);
            nettype77=nettype(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruleconnectionEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_connectionPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, nettype77.tree);

            if ( BACKTRACKING==0 )
            {
                 belle_sdp_connection_set_network_type((SCOPE_TOP(connection))->current,(const char*)
                (STRSTREAM->toStringTT(STRSTREAM, nettype77.start, nettype77.stop))
                ->chars);
            }


            SPACE78 = (pANTLR3_COMMON_TOKEN) MATCHT(SPACE, &FOLLOW_SPACE_in_connection1048);
            if  (HASEXCEPTION())
            {
                goto ruleconnectionEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_connectionPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) {
            SPACE78_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, SPACE78));
            ADAPTOR->addChild(ADAPTOR, root_0, SPACE78_tree);
            }

            FOLLOWPUSH(FOLLOW_addrtype_in_connection1050);
            addrtype79=addrtype(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruleconnectionEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_connectionPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, addrtype79.tree);

            if ( BACKTRACKING==0 )
            {
                 belle_sdp_connection_set_address_type((SCOPE_TOP(connection))->current,(const char*)
                (STRSTREAM->toStringTT(STRSTREAM, addrtype79.start, addrtype79.stop))
                ->chars);
            }


            SPACE80 = (pANTLR3_COMMON_TOKEN) MATCHT(SPACE, &FOLLOW_SPACE_in_connection1071);
            if  (HASEXCEPTION())
            {
                goto ruleconnectionEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_connectionPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) {
            SPACE80_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, SPACE80));
            ADAPTOR->addChild(ADAPTOR, root_0, SPACE80_tree);
            }

            FOLLOWPUSH(FOLLOW_connection_address_in_connection1073);
            connection_address81=connection_address(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruleconnectionEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_connectionPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, connection_address81.tree);

        }

    }

    // This is where rules clean up and exit
    //
    goto ruleconnectionEx; /* Prevent compiler warnings */
    ruleconnectionEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }


    if	(HASEXCEPTION())
    {
	/* catch(decl,action)
	 */
	{

	    	ANTLR3_LOG_EXCEPTION();
	      belle_sip_object_unref(retval.ret
	    );
	      retval.ret=NULL;


	}


    }
    else
    {
    }
    pbelle_sdpParser_connectionPop(ctx);

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

/**
 * $ANTLR start bandwidth
 * ../grammars/belle_sdp.g:188:1: bandwidth returns [belle_sdp_bandwidth_t* ret] :{...}? alpha_num EQUAL bwtype COLON bandwidth_value ;
 */
static belle_sdpParser_bandwidth_return
bandwidth(pbelle_sdpParser ctx)
{
    belle_sdpParser_bandwidth_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    EQUAL83;
    pANTLR3_COMMON_TOKEN    COLON85;
    belle_sdpParser_alpha_num_return alpha_num82;
    #undef	RETURN_TYPE_alpha_num82
    #define	RETURN_TYPE_alpha_num82 belle_sdpParser_alpha_num_return

    belle_sdpParser_bwtype_return bwtype84;
    #undef	RETURN_TYPE_bwtype84
    #define	RETURN_TYPE_bwtype84 belle_sdpParser_bwtype_return

    belle_sdpParser_bandwidth_value_return bandwidth_value86;
    #undef	RETURN_TYPE_bandwidth_value86
    #define	RETURN_TYPE_bandwidth_value86 belle_sdpParser_bandwidth_value_return

    pANTLR3_BASE_TREE EQUAL83_tree;
    pANTLR3_BASE_TREE COLON85_tree;

    /* Initialize rule variables
     */
    ctx->pbelle_sdpParser_bandwidthTop = pbelle_sdpParser_bandwidthPush(ctx);
    root_0 = NULL;

    (SCOPE_TOP(bandwidth))->current= belle_sdp_bandwidth_new(); 
    retval.ret=(SCOPE_TOP(bandwidth))->current;
     
    EQUAL83       = NULL;
    COLON85       = NULL;
    alpha_num82.tree = NULL;

    bwtype84.tree = NULL;

    bandwidth_value86.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    EQUAL83_tree   = NULL;
    COLON85_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:191:3: ({...}? alpha_num EQUAL bwtype COLON bandwidth_value )
        // ../grammars/belle_sdp.g:191:8: {...}? alpha_num EQUAL bwtype COLON bandwidth_value
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(b))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    pbelle_sdpParser_bandwidthPop(ctx);

                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(b)";
                    EXCEPTION->ruleName	 = (void *)"bandwidth";


            }

            FOLLOWPUSH(FOLLOW_alpha_num_in_bandwidth1203);
            alpha_num82=alpha_num(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulebandwidthEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_bandwidthPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num82.tree);

            EQUAL83 = (pANTLR3_COMMON_TOKEN) MATCHT(EQUAL, &FOLLOW_EQUAL_in_bandwidth1205);
            if  (HASEXCEPTION())
            {
                goto rulebandwidthEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_bandwidthPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) {
            EQUAL83_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, EQUAL83));
            ADAPTOR->addChild(ADAPTOR, root_0, EQUAL83_tree);
            }

            FOLLOWPUSH(FOLLOW_bwtype_in_bandwidth1207);
            bwtype84=bwtype(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulebandwidthEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_bandwidthPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, bwtype84.tree);

            if ( BACKTRACKING==0 )
            {
                belle_sdp_bandwidth_set_type((SCOPE_TOP(bandwidth))->current,(const char*)
                (STRSTREAM->toStringTT(STRSTREAM, bwtype84.start, bwtype84.stop))
                ->chars); 
            }


            COLON85 = (pANTLR3_COMMON_TOKEN) MATCHT(COLON, &FOLLOW_COLON_in_bandwidth1217);
            if  (HASEXCEPTION())
            {
                goto rulebandwidthEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_bandwidthPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) {
            COLON85_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, COLON85));
            ADAPTOR->addChild(ADAPTOR, root_0, COLON85_tree);
            }

            FOLLOWPUSH(FOLLOW_bandwidth_value_in_bandwidth1219);
            bandwidth_value86=bandwidth_value(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulebandwidthEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_bandwidthPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, bandwidth_value86.tree);

            if ( BACKTRACKING==0 )
            {
                belle_sdp_bandwidth_set_value((SCOPE_TOP(bandwidth))->current,atoi((const char*)
                (STRSTREAM->toStringTT(STRSTREAM, bandwidth_value86.start, bandwidth_value86.stop))
                ->chars));
            }


        }

    }

    // This is where rules clean up and exit
    //
    goto rulebandwidthEx; /* Prevent compiler warnings */
    rulebandwidthEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }


    if	(HASEXCEPTION())
    {
	/* catch(decl,action)
	 */
	{

	    	ANTLR3_LOG_EXCEPTION();
	      belle_sip_object_unref(retval.ret
	    );
	      retval.ret=NULL;


	}


    }
    else
    {
    }
    pbelle_sdpParser_bandwidthPop(ctx);

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

/**
 * $ANTLR start time_field
 * ../grammars/belle_sdp.g:199:1: time_field :{...}? alpha_num EQUAL start_time SPACE stop_time ;
 */
static belle_sdpParser_time_field_return
time_field(pbelle_sdpParser ctx)
{
    belle_sdpParser_time_field_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    EQUAL88;
    pANTLR3_COMMON_TOKEN    SPACE90;
    belle_sdpParser_alpha_num_return alpha_num87;
    #undef	RETURN_TYPE_alpha_num87
    #define	RETURN_TYPE_alpha_num87 belle_sdpParser_alpha_num_return

    belle_sdpParser_start_time_return start_time89;
    #undef	RETURN_TYPE_start_time89
    #define	RETURN_TYPE_start_time89 belle_sdpParser_start_time_return

    belle_sdpParser_stop_time_return stop_time91;
    #undef	RETURN_TYPE_stop_time91
    #define	RETURN_TYPE_stop_time91 belle_sdpParser_stop_time_return

    pANTLR3_BASE_TREE EQUAL88_tree;
    pANTLR3_BASE_TREE SPACE90_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    EQUAL88       = NULL;
    SPACE90       = NULL;
    alpha_num87.tree = NULL;

    start_time89.tree = NULL;

    stop_time91.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    EQUAL88_tree   = NULL;
    SPACE90_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:199:11: ({...}? alpha_num EQUAL start_time SPACE stop_time )
        // ../grammars/belle_sdp.g:199:15: {...}? alpha_num EQUAL start_time SPACE stop_time
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(t))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(t)";
                    EXCEPTION->ruleName	 = (void *)"time_field";


            }

            FOLLOWPUSH(FOLLOW_alpha_num_in_time_field1236);
            alpha_num87=alpha_num(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruletime_fieldEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num87.tree);

            EQUAL88 = (pANTLR3_COMMON_TOKEN) MATCHT(EQUAL, &FOLLOW_EQUAL_in_time_field1238);
            if  (HASEXCEPTION())
            {
                goto ruletime_fieldEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) {
            EQUAL88_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, EQUAL88));
            ADAPTOR->addChild(ADAPTOR, root_0, EQUAL88_tree);
            }

            FOLLOWPUSH(FOLLOW_start_time_in_time_field1254);
            start_time89=start_time(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruletime_fieldEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, start_time89.tree);

            SPACE90 = (pANTLR3_COMMON_TOKEN) MATCHT(SPACE, &FOLLOW_SPACE_in_time_field1270);
            if  (HASEXCEPTION())
            {
                goto ruletime_fieldEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) {
            SPACE90_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, SPACE90));
            ADAPTOR->addChild(ADAPTOR, root_0, SPACE90_tree);
            }

            FOLLOWPUSH(FOLLOW_stop_time_in_time_field1286);
            stop_time91=stop_time(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruletime_fieldEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, stop_time91.tree);

            if ( BACKTRACKING==0 )
            {
                belle_sdp_time_description_t* time_description =belle_sdp_time_description_new();
                                         belle_sdp_time_t* time_value =belle_sdp_time_new();
                						 belle_sip_list_t* time_description_list;
                                         belle_sdp_time_set_start(time_value,atoi((const char*)(STRSTREAM->toStringTT(STRSTREAM, start_time89.start, start_time89.stop))
                ->chars));
                                         belle_sdp_time_set_stop(time_value,atoi((const char*)(STRSTREAM->toStringTT(STRSTREAM, stop_time91.start, stop_time91.stop))
                ->chars));
                                         belle_sdp_time_description_set_time(time_description,time_value);
                                         time_description_list = belle_sip_list_append(NULL,time_description);
                                         belle_sdp_session_description_set_time_descriptions((SCOPE_TOP(session_description))->current,time_description_list);
            }


        }

    }

    // This is where rules clean up and exit
    //
    goto ruletime_fieldEx; /* Prevent compiler warnings */
    ruletime_fieldEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start repeat_time
 * ../grammars/belle_sdp.g:211:1: repeat_time :{...}? alpha_num EQUAL repeat_interval ( SPACE typed_time )+ ;
 */
static belle_sdpParser_repeat_time_return
repeat_time(pbelle_sdpParser ctx)
{
    belle_sdpParser_repeat_time_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    EQUAL93;
    pANTLR3_COMMON_TOKEN    SPACE95;
    belle_sdpParser_alpha_num_return alpha_num92;
    #undef	RETURN_TYPE_alpha_num92
    #define	RETURN_TYPE_alpha_num92 belle_sdpParser_alpha_num_return

    belle_sdpParser_repeat_interval_return repeat_interval94;
    #undef	RETURN_TYPE_repeat_interval94
    #define	RETURN_TYPE_repeat_interval94 belle_sdpParser_repeat_interval_return

    belle_sdpParser_typed_time_return typed_time96;
    #undef	RETURN_TYPE_typed_time96
    #define	RETURN_TYPE_typed_time96 belle_sdpParser_typed_time_return

    pANTLR3_BASE_TREE EQUAL93_tree;
    pANTLR3_BASE_TREE SPACE95_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    EQUAL93       = NULL;
    SPACE95       = NULL;
    alpha_num92.tree = NULL;

    repeat_interval94.tree = NULL;

    typed_time96.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    EQUAL93_tree   = NULL;
    SPACE95_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:211:12: ({...}? alpha_num EQUAL repeat_interval ( SPACE typed_time )+ )
        // ../grammars/belle_sdp.g:211:20: {...}? alpha_num EQUAL repeat_interval ( SPACE typed_time )+
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(r))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(r)";
                    EXCEPTION->ruleName	 = (void *)"repeat_time";


            }

            FOLLOWPUSH(FOLLOW_alpha_num_in_repeat_time1302);
            alpha_num92=alpha_num(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulerepeat_timeEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num92.tree);

            EQUAL93 = (pANTLR3_COMMON_TOKEN) MATCHT(EQUAL, &FOLLOW_EQUAL_in_repeat_time1304);
            if  (HASEXCEPTION())
            {
                goto rulerepeat_timeEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) {
            EQUAL93_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, EQUAL93));
            ADAPTOR->addChild(ADAPTOR, root_0, EQUAL93_tree);
            }

            FOLLOWPUSH(FOLLOW_repeat_interval_in_repeat_time1306);
            repeat_interval94=repeat_interval(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulerepeat_timeEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, repeat_interval94.tree);

            // ../grammars/belle_sdp.g:211:66: ( SPACE typed_time )+
            {
                int cnt14=0;

                for (;;)
                {
                    int alt14=2;
            	switch ( LA(1) )
            	{
            	case SPACE:
            		{
            			alt14=1;
            		}
            	    break;

            	}

            	switch (alt14)
            	{
            	    case 1:
            	        // ../grammars/belle_sdp.g:211:67: SPACE typed_time
            	        {
            	            SPACE95 = (pANTLR3_COMMON_TOKEN) MATCHT(SPACE, &FOLLOW_SPACE_in_repeat_time1309);
            	            if  (HASEXCEPTION())
            	            {
            	                goto rulerepeat_timeEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) {
            	            SPACE95_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, SPACE95));
            	            ADAPTOR->addChild(ADAPTOR, root_0, SPACE95_tree);
            	            }

            	            FOLLOWPUSH(FOLLOW_typed_time_in_repeat_time1311);
            	            typed_time96=typed_time(ctx);

            	            FOLLOWPOP();
            	            if  (HASEXCEPTION())
            	            {
            	                goto rulerepeat_timeEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, typed_time96.tree);

            	        }
            	        break;

            	    default:

            		if ( cnt14 >= 1 )
            		{
            		    goto loop14;
            		}
            		if (BACKTRACKING>0)
            		{
            		    FAILEDFLAG = ANTLR3_TRUE;
            		    return retval;
            		}

            		/* mismatchedSetEx()
            		 */
            		CONSTRUCTEX();
            		EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
            		EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;


            		goto rulerepeat_timeEx;
            	}
            	cnt14++;
                }
                loop14: ;	/* Jump to here if this rule does not match */
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto rulerepeat_timeEx; /* Prevent compiler warnings */
    rulerepeat_timeEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start zone_adjustments
 * ../grammars/belle_sdp.g:213:1: zone_adjustments :{...}? alpha_num EQUAL sdp_time SPACE ( '-' )? typed_time ( SPACE sdp_time SPACE ( '-' )? typed_time )* ;
 */
static belle_sdpParser_zone_adjustments_return
zone_adjustments(pbelle_sdpParser ctx)
{
    belle_sdpParser_zone_adjustments_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    EQUAL98;
    pANTLR3_COMMON_TOKEN    SPACE100;
    pANTLR3_COMMON_TOKEN    char_literal101;
    pANTLR3_COMMON_TOKEN    SPACE103;
    pANTLR3_COMMON_TOKEN    SPACE105;
    pANTLR3_COMMON_TOKEN    char_literal106;
    belle_sdpParser_alpha_num_return alpha_num97;
    #undef	RETURN_TYPE_alpha_num97
    #define	RETURN_TYPE_alpha_num97 belle_sdpParser_alpha_num_return

    belle_sdpParser_sdp_time_return sdp_time99;
    #undef	RETURN_TYPE_sdp_time99
    #define	RETURN_TYPE_sdp_time99 belle_sdpParser_sdp_time_return

    belle_sdpParser_typed_time_return typed_time102;
    #undef	RETURN_TYPE_typed_time102
    #define	RETURN_TYPE_typed_time102 belle_sdpParser_typed_time_return

    belle_sdpParser_sdp_time_return sdp_time104;
    #undef	RETURN_TYPE_sdp_time104
    #define	RETURN_TYPE_sdp_time104 belle_sdpParser_sdp_time_return

    belle_sdpParser_typed_time_return typed_time107;
    #undef	RETURN_TYPE_typed_time107
    #define	RETURN_TYPE_typed_time107 belle_sdpParser_typed_time_return

    pANTLR3_BASE_TREE EQUAL98_tree;
    pANTLR3_BASE_TREE SPACE100_tree;
    pANTLR3_BASE_TREE char_literal101_tree;
    pANTLR3_BASE_TREE SPACE103_tree;
    pANTLR3_BASE_TREE SPACE105_tree;
    pANTLR3_BASE_TREE char_literal106_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    EQUAL98       = NULL;
    SPACE100       = NULL;
    char_literal101       = NULL;
    SPACE103       = NULL;
    SPACE105       = NULL;
    char_literal106       = NULL;
    alpha_num97.tree = NULL;

    sdp_time99.tree = NULL;

    typed_time102.tree = NULL;

    sdp_time104.tree = NULL;

    typed_time107.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    EQUAL98_tree   = NULL;
    SPACE100_tree   = NULL;
    char_literal101_tree   = NULL;
    SPACE103_tree   = NULL;
    SPACE105_tree   = NULL;
    char_literal106_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:213:17: ({...}? alpha_num EQUAL sdp_time SPACE ( '-' )? typed_time ( SPACE sdp_time SPACE ( '-' )? typed_time )* )
        // ../grammars/belle_sdp.g:213:22: {...}? alpha_num EQUAL sdp_time SPACE ( '-' )? typed_time ( SPACE sdp_time SPACE ( '-' )? typed_time )*
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(z))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(z)";
                    EXCEPTION->ruleName	 = (void *)"zone_adjustments";


            }

            FOLLOWPUSH(FOLLOW_alpha_num_in_zone_adjustments1325);
            alpha_num97=alpha_num(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulezone_adjustmentsEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num97.tree);

            EQUAL98 = (pANTLR3_COMMON_TOKEN) MATCHT(EQUAL, &FOLLOW_EQUAL_in_zone_adjustments1327);
            if  (HASEXCEPTION())
            {
                goto rulezone_adjustmentsEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) {
            EQUAL98_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, EQUAL98));
            ADAPTOR->addChild(ADAPTOR, root_0, EQUAL98_tree);
            }

            FOLLOWPUSH(FOLLOW_sdp_time_in_zone_adjustments1329);
            sdp_time99=sdp_time(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulezone_adjustmentsEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, sdp_time99.tree);

            SPACE100 = (pANTLR3_COMMON_TOKEN) MATCHT(SPACE, &FOLLOW_SPACE_in_zone_adjustments1331);
            if  (HASEXCEPTION())
            {
                goto rulezone_adjustmentsEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) {
            SPACE100_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, SPACE100));
            ADAPTOR->addChild(ADAPTOR, root_0, SPACE100_tree);
            }

            // ../grammars/belle_sdp.g:213:68: ( '-' )?
            {
                int alt15=2;
                switch ( LA(1) )
                {
                    case DASH:
                    	{
                    		alt15=1;
                    	}
                        break;
                }

                switch (alt15)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:213:68: '-'
            	    {
            	        char_literal101 = (pANTLR3_COMMON_TOKEN) MATCHT(DASH, &FOLLOW_DASH_in_zone_adjustments1333);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulezone_adjustmentsEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        char_literal101_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, char_literal101));
            	        ADAPTOR->addChild(ADAPTOR, root_0, char_literal101_tree);
            	        }

            	    }
            	    break;

                }
            }

            FOLLOWPUSH(FOLLOW_typed_time_in_zone_adjustments1336);
            typed_time102=typed_time(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulezone_adjustmentsEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, typed_time102.tree);

            // ../grammars/belle_sdp.g:214:26: ( SPACE sdp_time SPACE ( '-' )? typed_time )*

            for (;;)
            {
                int alt17=2;
                switch ( LA(1) )
                {
                case SPACE:
                	{
                		alt17=1;
                	}
                    break;

                }

                switch (alt17)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:214:27: SPACE sdp_time SPACE ( '-' )? typed_time
            	    {
            	        SPACE103 = (pANTLR3_COMMON_TOKEN) MATCHT(SPACE, &FOLLOW_SPACE_in_zone_adjustments1364);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulezone_adjustmentsEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        SPACE103_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, SPACE103));
            	        ADAPTOR->addChild(ADAPTOR, root_0, SPACE103_tree);
            	        }

            	        FOLLOWPUSH(FOLLOW_sdp_time_in_zone_adjustments1366);
            	        sdp_time104=sdp_time(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulezone_adjustmentsEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, sdp_time104.tree);

            	        SPACE105 = (pANTLR3_COMMON_TOKEN) MATCHT(SPACE, &FOLLOW_SPACE_in_zone_adjustments1368);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulezone_adjustmentsEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        SPACE105_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, SPACE105));
            	        ADAPTOR->addChild(ADAPTOR, root_0, SPACE105_tree);
            	        }

            	        // ../grammars/belle_sdp.g:214:48: ( '-' )?
            	        {
            	            int alt16=2;
            	            switch ( LA(1) )
            	            {
            	                case DASH:
            	                	{
            	                		alt16=1;
            	                	}
            	                    break;
            	            }

            	            switch (alt16)
            	            {
            	        	case 1:
            	        	    // ../grammars/belle_sdp.g:214:48: '-'
            	        	    {
            	        	        char_literal106 = (pANTLR3_COMMON_TOKEN) MATCHT(DASH, &FOLLOW_DASH_in_zone_adjustments1370);
            	        	        if  (HASEXCEPTION())
            	        	        {
            	        	            goto rulezone_adjustmentsEx;
            	        	        }
            	        	        if (HASFAILED())
            	        	        {
            	        	            return retval;
            	        	        }

            	        	        if ( BACKTRACKING==0 ) {
            	        	        char_literal106_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, char_literal106));
            	        	        ADAPTOR->addChild(ADAPTOR, root_0, char_literal106_tree);
            	        	        }

            	        	    }
            	        	    break;

            	            }
            	        }

            	        FOLLOWPUSH(FOLLOW_typed_time_in_zone_adjustments1373);
            	        typed_time107=typed_time(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulezone_adjustmentsEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, typed_time107.tree);

            	    }
            	    break;

            	default:
            	    goto loop17;	/* break out of the loop */
            	    break;
                }
            }
            loop17: ; /* Jump out to here if this rule does not match */


        }

    }

    // This is where rules clean up and exit
    //
    goto rulezone_adjustmentsEx; /* Prevent compiler warnings */
    rulezone_adjustmentsEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start key_field
 * ../grammars/belle_sdp.g:216:1: key_field :{...}? alpha_num EQUAL key_value ;
 */
static belle_sdpParser_key_field_return
key_field(pbelle_sdpParser ctx)
{
    belle_sdpParser_key_field_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    EQUAL109;
    belle_sdpParser_alpha_num_return alpha_num108;
    #undef	RETURN_TYPE_alpha_num108
    #define	RETURN_TYPE_alpha_num108 belle_sdpParser_alpha_num_return

    belle_sdpParser_key_value_return key_value110;
    #undef	RETURN_TYPE_key_value110
    #define	RETURN_TYPE_key_value110 belle_sdpParser_key_value_return

    pANTLR3_BASE_TREE EQUAL109_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    EQUAL109       = NULL;
    alpha_num108.tree = NULL;

    key_value110.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    EQUAL109_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:216:10: ({...}? alpha_num EQUAL key_value )
        // ../grammars/belle_sdp.g:216:22: {...}? alpha_num EQUAL key_value
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(k))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(k)";
                    EXCEPTION->ruleName	 = (void *)"key_field";


            }

            FOLLOWPUSH(FOLLOW_alpha_num_in_key_field1393);
            alpha_num108=alpha_num(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulekey_fieldEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num108.tree);

            EQUAL109 = (pANTLR3_COMMON_TOKEN) MATCHT(EQUAL, &FOLLOW_EQUAL_in_key_field1395);
            if  (HASEXCEPTION())
            {
                goto rulekey_fieldEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) {
            EQUAL109_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, EQUAL109));
            ADAPTOR->addChild(ADAPTOR, root_0, EQUAL109_tree);
            }

            FOLLOWPUSH(FOLLOW_key_value_in_key_field1397);
            key_value110=key_value(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulekey_fieldEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, key_value110.tree);

        }

    }

    // This is where rules clean up and exit
    //
    goto rulekey_fieldEx; /* Prevent compiler warnings */
    rulekey_fieldEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start key_value
 * ../grammars/belle_sdp.g:217:1: key_value options {greedy=false; } : (~ ( CR | LF ) )* ;
 */
static belle_sdpParser_key_value_return
key_value(pbelle_sdpParser ctx)
{
    belle_sdpParser_key_value_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    set111;

    pANTLR3_BASE_TREE set111_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    set111       = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    set111_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:217:38: ( (~ ( CR | LF ) )* )
        // ../grammars/belle_sdp.g:217:47: (~ ( CR | LF ) )*
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            // ../grammars/belle_sdp.g:217:47: (~ ( CR | LF ) )*

            for (;;)
            {
                int alt18=2;
                switch ( LA(1) )
                {
                case COLON:
                case COMMA:
                case COMMON_CHAR:
                case DASH:
                case DIGIT:
                case DOT:
                case EQUAL:
                case HEX_CHAR:
                case LQUOTE:
                case OCTET:
                case POS_DIGIT:
                case RQUOTE:
                case SLASH:
                case SPACE:
                case STAR:
                case ZERO:
                case 22:
                case 23:
                case 24:
                case 25:
                case 26:
                case 27:
                case 28:
                case 29:
                case 30:
                case 31:
                case 32:
                case 33:
                case 34:
                case 35:
                	{
                		alt18=1;
                	}
                    break;

                }

                switch (alt18)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:
            	    {
            	        set111=(pANTLR3_COMMON_TOKEN)LT(1);

            	        if ( ((LA(1) >= COLON) && (LA(1) <= COMMON_CHAR)) || ((LA(1) >= DASH) && (LA(1) <= HEX_CHAR)) || ((LA(1) >= LQUOTE) && (LA(1) <= 35)) )
            	        {
            	            CONSUME();
            	            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, 
            	            (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set111))
            	            );
            	            PERRORRECOVERY=ANTLR3_FALSE;
            	            FAILEDFLAG=ANTLR3_FALSE;

            	        }
            	        else
            	        {
            	            if (BACKTRACKING>0)
            	            {
            	                FAILEDFLAG = ANTLR3_TRUE;
            	                return retval;
            	            }

            	            CONSTRUCTEX();
            	            EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;
            	            EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;
            	            EXCEPTION->expectingSet = NULL;

            	            goto rulekey_valueEx;
            	        }


            	    }
            	    break;

            	default:
            	    goto loop18;	/* break out of the loop */
            	    break;
                }
            }
            loop18: ; /* Jump out to here if this rule does not match */


        }

    }

    // This is where rules clean up and exit
    //
    goto rulekey_valueEx; /* Prevent compiler warnings */
    rulekey_valueEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start attribute
 * ../grammars/belle_sdp.g:226:1: attribute returns [belle_sdp_attribute_t* ret] :{...}? alpha_num EQUAL attribute_content ;
 */
static belle_sdpParser_attribute_return
attribute(pbelle_sdpParser ctx)
{
    belle_sdpParser_attribute_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    EQUAL113;
    belle_sdpParser_alpha_num_return alpha_num112;
    #undef	RETURN_TYPE_alpha_num112
    #define	RETURN_TYPE_alpha_num112 belle_sdpParser_alpha_num_return

    belle_sdpParser_attribute_content_return attribute_content114;
    #undef	RETURN_TYPE_attribute_content114
    #define	RETURN_TYPE_attribute_content114 belle_sdpParser_attribute_content_return

    pANTLR3_BASE_TREE EQUAL113_tree;

    /* Initialize rule variables
     */
    ctx->pbelle_sdpParser_attributeTop = pbelle_sdpParser_attributePush(ctx);
    root_0 = NULL;

    retval.ret=NULL;

    EQUAL113       = NULL;
    alpha_num112.tree = NULL;

    attribute_content114.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    EQUAL113_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:229:3: ({...}? alpha_num EQUAL attribute_content )
        // ../grammars/belle_sdp.g:229:3: {...}? alpha_num EQUAL attribute_content
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(a))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    pbelle_sdpParser_attributePop(ctx);

                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(a)";
                    EXCEPTION->ruleName	 = (void *)"attribute";


            }

            FOLLOWPUSH(FOLLOW_alpha_num_in_attribute1459);
            alpha_num112=alpha_num(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruleattributeEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_attributePop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num112.tree);

            EQUAL113 = (pANTLR3_COMMON_TOKEN) MATCHT(EQUAL, &FOLLOW_EQUAL_in_attribute1461);
            if  (HASEXCEPTION())
            {
                goto ruleattributeEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_attributePop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) {
            EQUAL113_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, EQUAL113));
            ADAPTOR->addChild(ADAPTOR, root_0, EQUAL113_tree);
            }

            FOLLOWPUSH(FOLLOW_attribute_content_in_attribute1463);
            attribute_content114=attribute_content(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruleattributeEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_attributePop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, attribute_content114.tree);

            if ( BACKTRACKING==0 )
            {
                retval.ret=
                attribute_content114.ret
                ;

            }


        }

    }

    // This is where rules clean up and exit
    //
    goto ruleattributeEx; /* Prevent compiler warnings */
    ruleattributeEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }


    if	(HASEXCEPTION())
    {
	/* catch(decl,action)
	 */
	{

	    	ANTLR3_LOG_EXCEPTION();
	       if (retval.ret
	    ) belle_sip_object_unref(retval.ret
	    );
	       retval.ret=NULL;


	}


    }
    else
    {
    }
    pbelle_sdpParser_attributePop(ctx);

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

/**
 * $ANTLR start attribute_content
 * ../grammars/belle_sdp.g:237:1: attribute_content returns [belle_sdp_attribute_t* ret] : attribute_name ( COLON val= attribute_value )? ;
 */
static belle_sdpParser_attribute_content_return
attribute_content(pbelle_sdpParser ctx)
{
    belle_sdpParser_attribute_content_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    COLON116;
    belle_sdpParser_attribute_value_return val;
    #undef	RETURN_TYPE_val
    #define	RETURN_TYPE_val belle_sdpParser_attribute_value_return

    belle_sdpParser_attribute_name_return attribute_name115;
    #undef	RETURN_TYPE_attribute_name115
    #define	RETURN_TYPE_attribute_name115 belle_sdpParser_attribute_name_return

    pANTLR3_BASE_TREE COLON116_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    retval.ret=NULL;
     
    COLON116       = NULL;
    val.tree = NULL;

    attribute_name115.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    COLON116_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:239:3: ( attribute_name ( COLON val= attribute_value )? )
        // ../grammars/belle_sdp.g:239:3: attribute_name ( COLON val= attribute_value )?
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            FOLLOWPUSH(FOLLOW_attribute_name_in_attribute_content1487);
            attribute_name115=attribute_name(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruleattribute_contentEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, attribute_name115.tree);

            // ../grammars/belle_sdp.g:239:18: ( COLON val= attribute_value )?
            {
                int alt19=2;
                switch ( LA(1) )
                {
                    case COLON:
                    	{
                    		alt19=1;
                    	}
                        break;
                }

                switch (alt19)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:239:19: COLON val= attribute_value
            	    {
            	        COLON116 = (pANTLR3_COMMON_TOKEN) MATCHT(COLON, &FOLLOW_COLON_in_attribute_content1490);
            	        if  (HASEXCEPTION())
            	        {
            	            goto ruleattribute_contentEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        COLON116_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, COLON116));
            	        ADAPTOR->addChild(ADAPTOR, root_0, COLON116_tree);
            	        }

            	        FOLLOWPUSH(FOLLOW_attribute_value_in_attribute_content1494);
            	        val=attribute_value(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto ruleattribute_contentEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, val.tree);

            	        if ( BACKTRACKING==0 )
            	        {
            	            retval.ret=belle_sdp_attribute_create((const char*)
            	            (STRSTREAM->toStringTT(STRSTREAM, attribute_name115.start, attribute_name115.stop))
            	            ->chars,(const char*)(STRSTREAM->toStringTT(STRSTREAM, val.start, val.stop))
            	            ->chars);

            	        }


            	    }
            	    break;

                }
            }

            if ( BACKTRACKING==0 )
            {

                	if (!val.tree) retval.ret=belle_sdp_attribute_create((const char*)
                (STRSTREAM->toStringTT(STRSTREAM, attribute_name115.start, attribute_name115.stop))
                ->chars,NULL);


            }


        }

    }

    // This is where rules clean up and exit
    //
    goto ruleattribute_contentEx; /* Prevent compiler warnings */
    ruleattribute_contentEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start rtcp_xr_attribute
 * ../grammars/belle_sdp.g:244:1: rtcp_xr_attribute returns [belle_sdp_rtcp_xr_attribute_t* ret] :{...}? alpha_num EQUAL {...}? attribute_name ( COLON rtcp_xr_attribute_value ( SPACE rtcp_xr_attribute_value )* )? ;
 */
static belle_sdpParser_rtcp_xr_attribute_return
rtcp_xr_attribute(pbelle_sdpParser ctx)
{
    belle_sdpParser_rtcp_xr_attribute_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    EQUAL118;
    pANTLR3_COMMON_TOKEN    COLON120;
    pANTLR3_COMMON_TOKEN    SPACE122;
    belle_sdpParser_alpha_num_return alpha_num117;
    #undef	RETURN_TYPE_alpha_num117
    #define	RETURN_TYPE_alpha_num117 belle_sdpParser_alpha_num_return

    belle_sdpParser_attribute_name_return attribute_name119;
    #undef	RETURN_TYPE_attribute_name119
    #define	RETURN_TYPE_attribute_name119 belle_sdpParser_attribute_name_return

    belle_sdpParser_rtcp_xr_attribute_value_return rtcp_xr_attribute_value121;
    #undef	RETURN_TYPE_rtcp_xr_attribute_value121
    #define	RETURN_TYPE_rtcp_xr_attribute_value121 belle_sdpParser_rtcp_xr_attribute_value_return

    belle_sdpParser_rtcp_xr_attribute_value_return rtcp_xr_attribute_value123;
    #undef	RETURN_TYPE_rtcp_xr_attribute_value123
    #define	RETURN_TYPE_rtcp_xr_attribute_value123 belle_sdpParser_rtcp_xr_attribute_value_return

    pANTLR3_BASE_TREE EQUAL118_tree;
    pANTLR3_BASE_TREE COLON120_tree;
    pANTLR3_BASE_TREE SPACE122_tree;

    /* Initialize rule variables
     */
    ctx->pbelle_sdpParser_rtcp_xr_attributeTop = pbelle_sdpParser_rtcp_xr_attributePush(ctx);
    root_0 = NULL;

     (SCOPE_TOP(rtcp_xr_attribute))->current= belle_sdp_rtcp_xr_attribute_new();
    retval.ret= (SCOPE_TOP(rtcp_xr_attribute))->current;

    EQUAL118       = NULL;
    COLON120       = NULL;
    SPACE122       = NULL;
    alpha_num117.tree = NULL;

    attribute_name119.tree = NULL;

    rtcp_xr_attribute_value121.tree = NULL;

    rtcp_xr_attribute_value123.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    EQUAL118_tree   = NULL;
    COLON120_tree   = NULL;
    SPACE122_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:247:3: ({...}? alpha_num EQUAL {...}? attribute_name ( COLON rtcp_xr_attribute_value ( SPACE rtcp_xr_attribute_value )* )? )
        // ../grammars/belle_sdp.g:247:3: {...}? alpha_num EQUAL {...}? attribute_name ( COLON rtcp_xr_attribute_value ( SPACE rtcp_xr_attribute_value )* )?
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(a))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    pbelle_sdpParser_rtcp_xr_attributePop(ctx);

                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(a)";
                    EXCEPTION->ruleName	 = (void *)"rtcp_xr_attribute";


            }

            FOLLOWPUSH(FOLLOW_alpha_num_in_rtcp_xr_attribute1523);
            alpha_num117=alpha_num(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulertcp_xr_attributeEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_rtcp_xr_attributePop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num117.tree);

            EQUAL118 = (pANTLR3_COMMON_TOKEN) MATCHT(EQUAL, &FOLLOW_EQUAL_in_rtcp_xr_attribute1525);
            if  (HASEXCEPTION())
            {
                goto rulertcp_xr_attributeEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_rtcp_xr_attributePop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) {
            EQUAL118_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, EQUAL118));
            ADAPTOR->addChild(ADAPTOR, root_0, EQUAL118_tree);
            }

            if ( !((IS_TOKEN(rtcp-xr))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    pbelle_sdpParser_rtcp_xr_attributePop(ctx);

                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(rtcp-xr)";
                    EXCEPTION->ruleName	 = (void *)"rtcp_xr_attribute";


            }

            FOLLOWPUSH(FOLLOW_attribute_name_in_rtcp_xr_attribute1529);
            attribute_name119=attribute_name(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulertcp_xr_attributeEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_rtcp_xr_attributePop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, attribute_name119.tree);

            // ../grammars/belle_sdp.g:247:83: ( COLON rtcp_xr_attribute_value ( SPACE rtcp_xr_attribute_value )* )?
            {
                int alt21=2;
                switch ( LA(1) )
                {
                    case COLON:
                    	{
                    		alt21=1;
                    	}
                        break;
                }

                switch (alt21)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:247:84: COLON rtcp_xr_attribute_value ( SPACE rtcp_xr_attribute_value )*
            	    {
            	        COLON120 = (pANTLR3_COMMON_TOKEN) MATCHT(COLON, &FOLLOW_COLON_in_rtcp_xr_attribute1534);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulertcp_xr_attributeEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_rtcp_xr_attributePop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        COLON120_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, COLON120));
            	        ADAPTOR->addChild(ADAPTOR, root_0, COLON120_tree);
            	        }

            	        FOLLOWPUSH(FOLLOW_rtcp_xr_attribute_value_in_rtcp_xr_attribute1536);
            	        rtcp_xr_attribute_value121=rtcp_xr_attribute_value(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulertcp_xr_attributeEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_rtcp_xr_attributePop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_xr_attribute_value121.tree);

            	        // ../grammars/belle_sdp.g:247:114: ( SPACE rtcp_xr_attribute_value )*

            	        for (;;)
            	        {
            	            int alt20=2;
            	            switch ( LA(1) )
            	            {
            	            case SPACE:
            	            	{
            	            		alt20=1;
            	            	}
            	                break;

            	            }

            	            switch (alt20)
            	            {
            	        	case 1:
            	        	    // ../grammars/belle_sdp.g:247:115: SPACE rtcp_xr_attribute_value
            	        	    {
            	        	        SPACE122 = (pANTLR3_COMMON_TOKEN) MATCHT(SPACE, &FOLLOW_SPACE_in_rtcp_xr_attribute1539);
            	        	        if  (HASEXCEPTION())
            	        	        {
            	        	            goto rulertcp_xr_attributeEx;
            	        	        }
            	        	        if (HASFAILED())
            	        	        {
            	        	            pbelle_sdpParser_rtcp_xr_attributePop(ctx);

            	        	            return retval;
            	        	        }

            	        	        if ( BACKTRACKING==0 ) {
            	        	        SPACE122_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, SPACE122));
            	        	        ADAPTOR->addChild(ADAPTOR, root_0, SPACE122_tree);
            	        	        }

            	        	        FOLLOWPUSH(FOLLOW_rtcp_xr_attribute_value_in_rtcp_xr_attribute1541);
            	        	        rtcp_xr_attribute_value123=rtcp_xr_attribute_value(ctx);

            	        	        FOLLOWPOP();
            	        	        if  (HASEXCEPTION())
            	        	        {
            	        	            goto rulertcp_xr_attributeEx;
            	        	        }
            	        	        if (HASFAILED())
            	        	        {
            	        	            pbelle_sdpParser_rtcp_xr_attributePop(ctx);

            	        	            return retval;
            	        	        }

            	        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_xr_attribute_value123.tree);

            	        	    }
            	        	    break;

            	        	default:
            	        	    goto loop20;	/* break out of the loop */
            	        	    break;
            	            }
            	        }
            	        loop20: ; /* Jump out to here if this rule does not match */


            	    }
            	    break;

                }
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto rulertcp_xr_attributeEx; /* Prevent compiler warnings */
    rulertcp_xr_attributeEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }


    if	(HASEXCEPTION())
    {
	/* catch(decl,action)
	 */
	{

	    	ANTLR3_LOG_EXCEPTION();
	       belle_sip_object_unref(retval.ret
	    );
	       retval.ret=NULL;


	}


    }
    else
    {
    }
    pbelle_sdpParser_rtcp_xr_attributePop(ctx);

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

/**
 * $ANTLR start rtcp_xr_attribute_value
 * ../grammars/belle_sdp.g:254:1: rtcp_xr_attribute_value : ( ( pkt_loss_rle )=> pkt_loss_rle | ( pkt_dup_rle )=> pkt_dup_rle | ( pkt_rcpt_times )=> pkt_rcpt_times | ( rcvr_rtt )=> rcvr_rtt | ( stat_summary )=> stat_summary | ( voip_metrics )=> voip_metrics );
 */
static belle_sdpParser_rtcp_xr_attribute_value_return
rtcp_xr_attribute_value(pbelle_sdpParser ctx)
{
    belle_sdpParser_rtcp_xr_attribute_value_return retval;


    pANTLR3_BASE_TREE root_0;

    belle_sdpParser_pkt_loss_rle_return pkt_loss_rle124;
    #undef	RETURN_TYPE_pkt_loss_rle124
    #define	RETURN_TYPE_pkt_loss_rle124 belle_sdpParser_pkt_loss_rle_return

    belle_sdpParser_pkt_dup_rle_return pkt_dup_rle125;
    #undef	RETURN_TYPE_pkt_dup_rle125
    #define	RETURN_TYPE_pkt_dup_rle125 belle_sdpParser_pkt_dup_rle_return

    belle_sdpParser_pkt_rcpt_times_return pkt_rcpt_times126;
    #undef	RETURN_TYPE_pkt_rcpt_times126
    #define	RETURN_TYPE_pkt_rcpt_times126 belle_sdpParser_pkt_rcpt_times_return

    belle_sdpParser_rcvr_rtt_return rcvr_rtt127;
    #undef	RETURN_TYPE_rcvr_rtt127
    #define	RETURN_TYPE_rcvr_rtt127 belle_sdpParser_rcvr_rtt_return

    belle_sdpParser_stat_summary_return stat_summary128;
    #undef	RETURN_TYPE_stat_summary128
    #define	RETURN_TYPE_stat_summary128 belle_sdpParser_stat_summary_return

    belle_sdpParser_voip_metrics_return voip_metrics129;
    #undef	RETURN_TYPE_voip_metrics129
    #define	RETURN_TYPE_voip_metrics129 belle_sdpParser_voip_metrics_return


    /* Initialize rule variables
     */

    root_0 = NULL;

    pkt_loss_rle124.tree = NULL;

    pkt_dup_rle125.tree = NULL;

    pkt_rcpt_times126.tree = NULL;

    rcvr_rtt127.tree = NULL;

    stat_summary128.tree = NULL;

    voip_metrics129.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;




    retval.tree  = NULL;

    {
        {
            //  ../grammars/belle_sdp.g:254:25: ( ( pkt_loss_rle )=> pkt_loss_rle | ( pkt_dup_rle )=> pkt_dup_rle | ( pkt_rcpt_times )=> pkt_rcpt_times | ( rcvr_rtt )=> rcvr_rtt | ( stat_summary )=> stat_summary | ( voip_metrics )=> voip_metrics )

            ANTLR3_UINT32 alt22;

            alt22=6;

            switch ( LA(1) )
            {
            case COMMON_CHAR:
            case HEX_CHAR:
            	{
            		{
            		    int LA22_1 = LA(2);
            		    if ( (synpred4_belle_sdp(ctx)) && (LA22_1 == EQUAL))
            		    {
            		        alt22=4;
            		    }
            		    else if ( (synpred4_belle_sdp(ctx)) && (LA22_1 == COMMON_CHAR || LA22_1 == HEX_CHAR))
            		    {
            		        alt22=4;
            		    }
            		    else if ( (synpred4_belle_sdp(ctx)) && (LA22_1 == DASH))
            		    {
            		        alt22=4;
            		    }
            		    else if ( (( (( ((IS_TOKEN(pkt-loss-rle))) && ((IS_TOKEN(pkt-loss-rle))) )) && (synpred1_belle_sdp(ctx)) )))
            		    {
            		        alt22=1;
            		    }
            		    else if ( (( (( ((IS_TOKEN(pkt-dup-rle))) && ((IS_TOKEN(pkt-dup-rle))) )) && (synpred2_belle_sdp(ctx)) )))
            		    {
            		        alt22=2;
            		    }
            		    else if ( (( (( (synpred3_belle_sdp(ctx)) && (synpred3_belle_sdp(ctx)) )) && ((IS_TOKEN(pkt-rcpt-times))) )))
            		    {
            		        alt22=3;
            		    }
            		    else if ( (( (( ((IS_TOKEN(stat-summary))) && ((IS_TOKEN(stat-summary))) )) && (synpred5_belle_sdp(ctx)) )))
            		    {
            		        alt22=5;
            		    }
            		    else if ( (( (( ((IS_TOKEN(voip-metrics))) && ((IS_TOKEN(voip-metrics))) )) && (synpred6_belle_sdp(ctx)) )))
            		    {
            		        alt22=6;
            		    }
            		    else
            		    {
            		        if (BACKTRACKING>0)
            		        {
            		            FAILEDFLAG = ANTLR3_TRUE;
            		            return retval;
            		        }


            		        CONSTRUCTEX();
            		        EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
            		        EXCEPTION->message      = (void *)"";
            		        EXCEPTION->decisionNum  = 22;
            		        EXCEPTION->state        = 1;


            		        goto rulertcp_xr_attribute_valueEx;

            		    }
            		}
            	}
                break;
            case DASH:
            	{
            		{
            		    int LA22_2 = LA(2);
            		    if ( (synpred4_belle_sdp(ctx)) && (LA22_2 == EQUAL))
            		    {
            		        alt22=4;
            		    }
            		    else if ( (synpred4_belle_sdp(ctx)) && (LA22_2 == COMMON_CHAR || LA22_2 == HEX_CHAR))
            		    {
            		        alt22=4;
            		    }
            		    else if ( (synpred4_belle_sdp(ctx)) && (LA22_2 == DASH))
            		    {
            		        alt22=4;
            		    }
            		    else if ( (( (( ((IS_TOKEN(pkt-loss-rle))) && ((IS_TOKEN(pkt-loss-rle))) )) && (synpred1_belle_sdp(ctx)) )))
            		    {
            		        alt22=1;
            		    }
            		    else if ( (( (( ((IS_TOKEN(pkt-dup-rle))) && ((IS_TOKEN(pkt-dup-rle))) )) && (synpred2_belle_sdp(ctx)) )))
            		    {
            		        alt22=2;
            		    }
            		    else if ( (( (( (synpred3_belle_sdp(ctx)) && (synpred3_belle_sdp(ctx)) )) && ((IS_TOKEN(pkt-rcpt-times))) )))
            		    {
            		        alt22=3;
            		    }
            		    else if ( (( (( ((IS_TOKEN(stat-summary))) && ((IS_TOKEN(stat-summary))) )) && (synpred5_belle_sdp(ctx)) )))
            		    {
            		        alt22=5;
            		    }
            		    else if ( (( (( ((IS_TOKEN(voip-metrics))) && ((IS_TOKEN(voip-metrics))) )) && (synpred6_belle_sdp(ctx)) )))
            		    {
            		        alt22=6;
            		    }
            		    else
            		    {
            		        if (BACKTRACKING>0)
            		        {
            		            FAILEDFLAG = ANTLR3_TRUE;
            		            return retval;
            		        }


            		        CONSTRUCTEX();
            		        EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
            		        EXCEPTION->message      = (void *)"";
            		        EXCEPTION->decisionNum  = 22;
            		        EXCEPTION->state        = 2;


            		        goto rulertcp_xr_attribute_valueEx;

            		    }
            		}
            	}
                break;

            default:
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                CONSTRUCTEX();
                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
                EXCEPTION->message      = (void *)"";
                EXCEPTION->decisionNum  = 22;
                EXCEPTION->state        = 0;


                goto rulertcp_xr_attribute_valueEx;

            }

            switch (alt22)
            {
        	case 1:
        	    // ../grammars/belle_sdp.g:255:2: ( pkt_loss_rle )=> pkt_loss_rle
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        FOLLOWPUSH(FOLLOW_pkt_loss_rle_in_rtcp_xr_attribute_value1564);
        	        pkt_loss_rle124=pkt_loss_rle(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulertcp_xr_attribute_valueEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, pkt_loss_rle124.tree);

        	    }
        	    break;
        	case 2:
        	    // ../grammars/belle_sdp.g:256:3: ( pkt_dup_rle )=> pkt_dup_rle
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        FOLLOWPUSH(FOLLOW_pkt_dup_rle_in_rtcp_xr_attribute_value1573);
        	        pkt_dup_rle125=pkt_dup_rle(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulertcp_xr_attribute_valueEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, pkt_dup_rle125.tree);

        	    }
        	    break;
        	case 3:
        	    // ../grammars/belle_sdp.g:257:3: ( pkt_rcpt_times )=> pkt_rcpt_times
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        FOLLOWPUSH(FOLLOW_pkt_rcpt_times_in_rtcp_xr_attribute_value1582);
        	        pkt_rcpt_times126=pkt_rcpt_times(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulertcp_xr_attribute_valueEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, pkt_rcpt_times126.tree);

        	    }
        	    break;
        	case 4:
        	    // ../grammars/belle_sdp.g:258:3: ( rcvr_rtt )=> rcvr_rtt
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        FOLLOWPUSH(FOLLOW_rcvr_rtt_in_rtcp_xr_attribute_value1591);
        	        rcvr_rtt127=rcvr_rtt(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulertcp_xr_attribute_valueEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rcvr_rtt127.tree);

        	    }
        	    break;
        	case 5:
        	    // ../grammars/belle_sdp.g:259:3: ( stat_summary )=> stat_summary
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        FOLLOWPUSH(FOLLOW_stat_summary_in_rtcp_xr_attribute_value1600);
        	        stat_summary128=stat_summary(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulertcp_xr_attribute_valueEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, stat_summary128.tree);

        	    }
        	    break;
        	case 6:
        	    // ../grammars/belle_sdp.g:260:3: ( voip_metrics )=> voip_metrics
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        FOLLOWPUSH(FOLLOW_voip_metrics_in_rtcp_xr_attribute_value1609);
        	        voip_metrics129=voip_metrics(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulertcp_xr_attribute_valueEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, voip_metrics129.tree);

        	    }
        	    break;

            }
        }
    }

    // This is where rules clean up and exit
    //
    goto rulertcp_xr_attribute_valueEx; /* Prevent compiler warnings */
    rulertcp_xr_attribute_valueEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start pkt_loss_rle
 * ../grammars/belle_sdp.g:262:1: pkt_loss_rle :{...}? rtcp_xr_attribute_name ( EQUAL rtcp_xr_max_size )? ;
 */
static belle_sdpParser_pkt_loss_rle_return
pkt_loss_rle(pbelle_sdpParser ctx)
{
    belle_sdpParser_pkt_loss_rle_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    EQUAL131;
    belle_sdpParser_rtcp_xr_attribute_name_return rtcp_xr_attribute_name130;
    #undef	RETURN_TYPE_rtcp_xr_attribute_name130
    #define	RETURN_TYPE_rtcp_xr_attribute_name130 belle_sdpParser_rtcp_xr_attribute_name_return

    belle_sdpParser_rtcp_xr_max_size_return rtcp_xr_max_size132;
    #undef	RETURN_TYPE_rtcp_xr_max_size132
    #define	RETURN_TYPE_rtcp_xr_max_size132 belle_sdpParser_rtcp_xr_max_size_return

    pANTLR3_BASE_TREE EQUAL131_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    EQUAL131       = NULL;
    rtcp_xr_attribute_name130.tree = NULL;

    rtcp_xr_max_size132.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    EQUAL131_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:262:14: ({...}? rtcp_xr_attribute_name ( EQUAL rtcp_xr_max_size )? )
        // ../grammars/belle_sdp.g:263:2: {...}? rtcp_xr_attribute_name ( EQUAL rtcp_xr_max_size )?
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(pkt-loss-rle))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(pkt-loss-rle)";
                    EXCEPTION->ruleName	 = (void *)"pkt_loss_rle";


            }

            FOLLOWPUSH(FOLLOW_rtcp_xr_attribute_name_in_pkt_loss_rle1620);
            rtcp_xr_attribute_name130=rtcp_xr_attribute_name(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulepkt_loss_rleEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_xr_attribute_name130.tree);

            // ../grammars/belle_sdp.g:263:70: ( EQUAL rtcp_xr_max_size )?
            {
                int alt23=2;
                switch ( LA(1) )
                {
                    case EQUAL:
                    	{
                    		alt23=1;
                    	}
                        break;
                }

                switch (alt23)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:263:71: EQUAL rtcp_xr_max_size
            	    {
            	        EQUAL131 = (pANTLR3_COMMON_TOKEN) MATCHT(EQUAL, &FOLLOW_EQUAL_in_pkt_loss_rle1625);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulepkt_loss_rleEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        EQUAL131_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, EQUAL131));
            	        ADAPTOR->addChild(ADAPTOR, root_0, EQUAL131_tree);
            	        }

            	        FOLLOWPUSH(FOLLOW_rtcp_xr_max_size_in_pkt_loss_rle1627);
            	        rtcp_xr_max_size132=rtcp_xr_max_size(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulepkt_loss_rleEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_xr_max_size132.tree);

            	    }
            	    break;

                }
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto rulepkt_loss_rleEx; /* Prevent compiler warnings */
    rulepkt_loss_rleEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start pkt_dup_rle
 * ../grammars/belle_sdp.g:265:1: pkt_dup_rle :{...}? rtcp_xr_attribute_name ( EQUAL rtcp_xr_max_size )? ;
 */
static belle_sdpParser_pkt_dup_rle_return
pkt_dup_rle(pbelle_sdpParser ctx)
{
    belle_sdpParser_pkt_dup_rle_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    EQUAL134;
    belle_sdpParser_rtcp_xr_attribute_name_return rtcp_xr_attribute_name133;
    #undef	RETURN_TYPE_rtcp_xr_attribute_name133
    #define	RETURN_TYPE_rtcp_xr_attribute_name133 belle_sdpParser_rtcp_xr_attribute_name_return

    belle_sdpParser_rtcp_xr_max_size_return rtcp_xr_max_size135;
    #undef	RETURN_TYPE_rtcp_xr_max_size135
    #define	RETURN_TYPE_rtcp_xr_max_size135 belle_sdpParser_rtcp_xr_max_size_return

    pANTLR3_BASE_TREE EQUAL134_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    EQUAL134       = NULL;
    rtcp_xr_attribute_name133.tree = NULL;

    rtcp_xr_max_size135.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    EQUAL134_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:265:13: ({...}? rtcp_xr_attribute_name ( EQUAL rtcp_xr_max_size )? )
        // ../grammars/belle_sdp.g:266:2: {...}? rtcp_xr_attribute_name ( EQUAL rtcp_xr_max_size )?
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(pkt-dup-rle))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(pkt-dup-rle)";
                    EXCEPTION->ruleName	 = (void *)"pkt_dup_rle";


            }

            FOLLOWPUSH(FOLLOW_rtcp_xr_attribute_name_in_pkt_dup_rle1641);
            rtcp_xr_attribute_name133=rtcp_xr_attribute_name(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulepkt_dup_rleEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_xr_attribute_name133.tree);

            // ../grammars/belle_sdp.g:266:68: ( EQUAL rtcp_xr_max_size )?
            {
                int alt24=2;
                switch ( LA(1) )
                {
                    case EQUAL:
                    	{
                    		alt24=1;
                    	}
                        break;
                }

                switch (alt24)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:266:69: EQUAL rtcp_xr_max_size
            	    {
            	        EQUAL134 = (pANTLR3_COMMON_TOKEN) MATCHT(EQUAL, &FOLLOW_EQUAL_in_pkt_dup_rle1646);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulepkt_dup_rleEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        EQUAL134_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, EQUAL134));
            	        ADAPTOR->addChild(ADAPTOR, root_0, EQUAL134_tree);
            	        }

            	        FOLLOWPUSH(FOLLOW_rtcp_xr_max_size_in_pkt_dup_rle1648);
            	        rtcp_xr_max_size135=rtcp_xr_max_size(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulepkt_dup_rleEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_xr_max_size135.tree);

            	    }
            	    break;

                }
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto rulepkt_dup_rleEx; /* Prevent compiler warnings */
    rulepkt_dup_rleEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start pkt_rcpt_times
 * ../grammars/belle_sdp.g:268:1: pkt_rcpt_times :{...}? rtcp_xr_attribute_name ( EQUAL rtcp_xr_max_size )? ;
 */
static belle_sdpParser_pkt_rcpt_times_return
pkt_rcpt_times(pbelle_sdpParser ctx)
{
    belle_sdpParser_pkt_rcpt_times_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    EQUAL137;
    belle_sdpParser_rtcp_xr_attribute_name_return rtcp_xr_attribute_name136;
    #undef	RETURN_TYPE_rtcp_xr_attribute_name136
    #define	RETURN_TYPE_rtcp_xr_attribute_name136 belle_sdpParser_rtcp_xr_attribute_name_return

    belle_sdpParser_rtcp_xr_max_size_return rtcp_xr_max_size138;
    #undef	RETURN_TYPE_rtcp_xr_max_size138
    #define	RETURN_TYPE_rtcp_xr_max_size138 belle_sdpParser_rtcp_xr_max_size_return

    pANTLR3_BASE_TREE EQUAL137_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    EQUAL137       = NULL;
    rtcp_xr_attribute_name136.tree = NULL;

    rtcp_xr_max_size138.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    EQUAL137_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:268:16: ({...}? rtcp_xr_attribute_name ( EQUAL rtcp_xr_max_size )? )
        // ../grammars/belle_sdp.g:269:2: {...}? rtcp_xr_attribute_name ( EQUAL rtcp_xr_max_size )?
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(pkt-rcpt-times))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(pkt-rcpt-times)";
                    EXCEPTION->ruleName	 = (void *)"pkt_rcpt_times";


            }

            FOLLOWPUSH(FOLLOW_rtcp_xr_attribute_name_in_pkt_rcpt_times1662);
            rtcp_xr_attribute_name136=rtcp_xr_attribute_name(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulepkt_rcpt_timesEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_xr_attribute_name136.tree);

            // ../grammars/belle_sdp.g:269:74: ( EQUAL rtcp_xr_max_size )?
            {
                int alt25=2;
                switch ( LA(1) )
                {
                    case EQUAL:
                    	{
                    		alt25=1;
                    	}
                        break;
                }

                switch (alt25)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:269:75: EQUAL rtcp_xr_max_size
            	    {
            	        EQUAL137 = (pANTLR3_COMMON_TOKEN) MATCHT(EQUAL, &FOLLOW_EQUAL_in_pkt_rcpt_times1667);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulepkt_rcpt_timesEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        EQUAL137_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, EQUAL137));
            	        ADAPTOR->addChild(ADAPTOR, root_0, EQUAL137_tree);
            	        }

            	        FOLLOWPUSH(FOLLOW_rtcp_xr_max_size_in_pkt_rcpt_times1669);
            	        rtcp_xr_max_size138=rtcp_xr_max_size(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulepkt_rcpt_timesEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_xr_max_size138.tree);

            	    }
            	    break;

                }
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto rulepkt_rcpt_timesEx; /* Prevent compiler warnings */
    rulepkt_rcpt_timesEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start rcvr_rtt
 * ../grammars/belle_sdp.g:271:1: rcvr_rtt :{...}? rtcp_xr_attribute_name EQUAL {...}? rtcp_xr_rcvr_rtt_mode ( COLON val= rtcp_xr_max_size )? ;
 */
static belle_sdpParser_rcvr_rtt_return
rcvr_rtt(pbelle_sdpParser ctx)
{
    belle_sdpParser_rcvr_rtt_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    EQUAL140;
    pANTLR3_COMMON_TOKEN    COLON142;
    belle_sdpParser_rtcp_xr_max_size_return val;
    #undef	RETURN_TYPE_val
    #define	RETURN_TYPE_val belle_sdpParser_rtcp_xr_max_size_return

    belle_sdpParser_rtcp_xr_attribute_name_return rtcp_xr_attribute_name139;
    #undef	RETURN_TYPE_rtcp_xr_attribute_name139
    #define	RETURN_TYPE_rtcp_xr_attribute_name139 belle_sdpParser_rtcp_xr_attribute_name_return

    belle_sdpParser_rtcp_xr_rcvr_rtt_mode_return rtcp_xr_rcvr_rtt_mode141;
    #undef	RETURN_TYPE_rtcp_xr_rcvr_rtt_mode141
    #define	RETURN_TYPE_rtcp_xr_rcvr_rtt_mode141 belle_sdpParser_rtcp_xr_rcvr_rtt_mode_return

    pANTLR3_BASE_TREE EQUAL140_tree;
    pANTLR3_BASE_TREE COLON142_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    EQUAL140       = NULL;
    COLON142       = NULL;
    val.tree = NULL;

    rtcp_xr_attribute_name139.tree = NULL;

    rtcp_xr_rcvr_rtt_mode141.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    EQUAL140_tree   = NULL;
    COLON142_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:271:10: ({...}? rtcp_xr_attribute_name EQUAL {...}? rtcp_xr_rcvr_rtt_mode ( COLON val= rtcp_xr_max_size )? )
        // ../grammars/belle_sdp.g:272:2: {...}? rtcp_xr_attribute_name EQUAL {...}? rtcp_xr_rcvr_rtt_mode ( COLON val= rtcp_xr_max_size )?
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(rcvr-rtt))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(rcvr-rtt)";
                    EXCEPTION->ruleName	 = (void *)"rcvr_rtt";


            }

            FOLLOWPUSH(FOLLOW_rtcp_xr_attribute_name_in_rcvr_rtt1683);
            rtcp_xr_attribute_name139=rtcp_xr_attribute_name(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulercvr_rttEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_xr_attribute_name139.tree);

            EQUAL140 = (pANTLR3_COMMON_TOKEN) MATCHT(EQUAL, &FOLLOW_EQUAL_in_rcvr_rtt1687);
            if  (HASEXCEPTION())
            {
                goto rulercvr_rttEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) {
            EQUAL140_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, EQUAL140));
            ADAPTOR->addChild(ADAPTOR, root_0, EQUAL140_tree);
            }

            if ( !((IS_TOKEN(all) || IS_TOKEN(sender))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(all) || IS_TOKEN(sender)";
                    EXCEPTION->ruleName	 = (void *)"rcvr_rtt";


            }

            FOLLOWPUSH(FOLLOW_rtcp_xr_rcvr_rtt_mode_in_rcvr_rtt1691);
            rtcp_xr_rcvr_rtt_mode141=rtcp_xr_rcvr_rtt_mode(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulercvr_rttEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_xr_rcvr_rtt_mode141.tree);

            // ../grammars/belle_sdp.g:272:127: ( COLON val= rtcp_xr_max_size )?
            {
                int alt26=2;
                switch ( LA(1) )
                {
                    case COLON:
                    	{
                    		alt26=1;
                    	}
                        break;
                }

                switch (alt26)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:272:128: COLON val= rtcp_xr_max_size
            	    {
            	        COLON142 = (pANTLR3_COMMON_TOKEN) MATCHT(COLON, &FOLLOW_COLON_in_rcvr_rtt1694);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulercvr_rttEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        COLON142_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, COLON142));
            	        ADAPTOR->addChild(ADAPTOR, root_0, COLON142_tree);
            	        }

            	        FOLLOWPUSH(FOLLOW_rtcp_xr_max_size_in_rcvr_rtt1698);
            	        val=rtcp_xr_max_size(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulercvr_rttEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, val.tree);

            	    }
            	    break;

                }
            }

            if ( BACKTRACKING==0 )
            {

                		belle_sdp_rtcp_xr_attribute_set_rcvr_rtt_mode((SCOPE_TOP(rtcp_xr_attribute))->current,(const char*)
                (STRSTREAM->toStringTT(STRSTREAM, rtcp_xr_rcvr_rtt_mode141.start, rtcp_xr_rcvr_rtt_mode141.stop))
                ->chars);
                		if (val.tree) belle_sdp_rtcp_xr_attribute_set_rcvr_rtt_max_size((SCOPE_TOP(rtcp_xr_attribute))->current,atoi((const char*)
                (STRSTREAM->toStringTT(STRSTREAM, val.start, val.stop))
                ->chars));
                	
            }


        }

    }

    // This is where rules clean up and exit
    //
    goto rulercvr_rttEx; /* Prevent compiler warnings */
    rulercvr_rttEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start stat_summary
 * ../grammars/belle_sdp.g:277:1: stat_summary :{...}? rtcp_xr_attribute_name ( EQUAL rtcp_xr_stat_summary_flag ( COMMA rtcp_xr_stat_summary_flag )* )? ;
 */
static belle_sdpParser_stat_summary_return
stat_summary(pbelle_sdpParser ctx)
{
    belle_sdpParser_stat_summary_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    EQUAL144;
    pANTLR3_COMMON_TOKEN    COMMA146;
    belle_sdpParser_rtcp_xr_attribute_name_return rtcp_xr_attribute_name143;
    #undef	RETURN_TYPE_rtcp_xr_attribute_name143
    #define	RETURN_TYPE_rtcp_xr_attribute_name143 belle_sdpParser_rtcp_xr_attribute_name_return

    belle_sdpParser_rtcp_xr_stat_summary_flag_return rtcp_xr_stat_summary_flag145;
    #undef	RETURN_TYPE_rtcp_xr_stat_summary_flag145
    #define	RETURN_TYPE_rtcp_xr_stat_summary_flag145 belle_sdpParser_rtcp_xr_stat_summary_flag_return

    belle_sdpParser_rtcp_xr_stat_summary_flag_return rtcp_xr_stat_summary_flag147;
    #undef	RETURN_TYPE_rtcp_xr_stat_summary_flag147
    #define	RETURN_TYPE_rtcp_xr_stat_summary_flag147 belle_sdpParser_rtcp_xr_stat_summary_flag_return

    pANTLR3_BASE_TREE EQUAL144_tree;
    pANTLR3_BASE_TREE COMMA146_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    EQUAL144       = NULL;
    COMMA146       = NULL;
    rtcp_xr_attribute_name143.tree = NULL;

    rtcp_xr_stat_summary_flag145.tree = NULL;

    rtcp_xr_stat_summary_flag147.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    EQUAL144_tree   = NULL;
    COMMA146_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:277:14: ({...}? rtcp_xr_attribute_name ( EQUAL rtcp_xr_stat_summary_flag ( COMMA rtcp_xr_stat_summary_flag )* )? )
        // ../grammars/belle_sdp.g:278:2: {...}? rtcp_xr_attribute_name ( EQUAL rtcp_xr_stat_summary_flag ( COMMA rtcp_xr_stat_summary_flag )* )?
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(stat-summary))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(stat-summary)";
                    EXCEPTION->ruleName	 = (void *)"stat_summary";


            }

            FOLLOWPUSH(FOLLOW_rtcp_xr_attribute_name_in_stat_summary1713);
            rtcp_xr_attribute_name143=rtcp_xr_attribute_name(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulestat_summaryEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_xr_attribute_name143.tree);

            if ( BACKTRACKING==0 )
            {

                		belle_sdp_rtcp_xr_attribute_set_stat_summary((SCOPE_TOP(rtcp_xr_attribute))->current,1);
                	
            }


            // ../grammars/belle_sdp.g:280:4: ( EQUAL rtcp_xr_stat_summary_flag ( COMMA rtcp_xr_stat_summary_flag )* )?
            {
                int alt28=2;
                switch ( LA(1) )
                {
                    case EQUAL:
                    	{
                    		alt28=1;
                    	}
                        break;
                }

                switch (alt28)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:280:5: EQUAL rtcp_xr_stat_summary_flag ( COMMA rtcp_xr_stat_summary_flag )*
            	    {
            	        EQUAL144 = (pANTLR3_COMMON_TOKEN) MATCHT(EQUAL, &FOLLOW_EQUAL_in_stat_summary1720);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulestat_summaryEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        EQUAL144_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, EQUAL144));
            	        ADAPTOR->addChild(ADAPTOR, root_0, EQUAL144_tree);
            	        }

            	        FOLLOWPUSH(FOLLOW_rtcp_xr_stat_summary_flag_in_stat_summary1722);
            	        rtcp_xr_stat_summary_flag145=rtcp_xr_stat_summary_flag(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulestat_summaryEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_xr_stat_summary_flag145.tree);

            	        // ../grammars/belle_sdp.g:280:37: ( COMMA rtcp_xr_stat_summary_flag )*

            	        for (;;)
            	        {
            	            int alt27=2;
            	            switch ( LA(1) )
            	            {
            	            case COMMA:
            	            	{
            	            		alt27=1;
            	            	}
            	                break;

            	            }

            	            switch (alt27)
            	            {
            	        	case 1:
            	        	    // ../grammars/belle_sdp.g:280:38: COMMA rtcp_xr_stat_summary_flag
            	        	    {
            	        	        COMMA146 = (pANTLR3_COMMON_TOKEN) MATCHT(COMMA, &FOLLOW_COMMA_in_stat_summary1725);
            	        	        if  (HASEXCEPTION())
            	        	        {
            	        	            goto rulestat_summaryEx;
            	        	        }
            	        	        if (HASFAILED())
            	        	        {
            	        	            return retval;
            	        	        }

            	        	        if ( BACKTRACKING==0 ) {
            	        	        COMMA146_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, COMMA146));
            	        	        ADAPTOR->addChild(ADAPTOR, root_0, COMMA146_tree);
            	        	        }

            	        	        FOLLOWPUSH(FOLLOW_rtcp_xr_stat_summary_flag_in_stat_summary1727);
            	        	        rtcp_xr_stat_summary_flag147=rtcp_xr_stat_summary_flag(ctx);

            	        	        FOLLOWPOP();
            	        	        if  (HASEXCEPTION())
            	        	        {
            	        	            goto rulestat_summaryEx;
            	        	        }
            	        	        if (HASFAILED())
            	        	        {
            	        	            return retval;
            	        	        }

            	        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_xr_stat_summary_flag147.tree);

            	        	    }
            	        	    break;

            	        	default:
            	        	    goto loop27;	/* break out of the loop */
            	        	    break;
            	            }
            	        }
            	        loop27: ; /* Jump out to here if this rule does not match */


            	    }
            	    break;

                }
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto rulestat_summaryEx; /* Prevent compiler warnings */
    rulestat_summaryEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start voip_metrics
 * ../grammars/belle_sdp.g:282:1: voip_metrics :{...}? rtcp_xr_attribute_name ;
 */
static belle_sdpParser_voip_metrics_return
voip_metrics(pbelle_sdpParser ctx)
{
    belle_sdpParser_voip_metrics_return retval;


    pANTLR3_BASE_TREE root_0;

    belle_sdpParser_rtcp_xr_attribute_name_return rtcp_xr_attribute_name148;
    #undef	RETURN_TYPE_rtcp_xr_attribute_name148
    #define	RETURN_TYPE_rtcp_xr_attribute_name148 belle_sdpParser_rtcp_xr_attribute_name_return


    /* Initialize rule variables
     */

    root_0 = NULL;

    rtcp_xr_attribute_name148.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;




    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:282:14: ({...}? rtcp_xr_attribute_name )
        // ../grammars/belle_sdp.g:283:2: {...}? rtcp_xr_attribute_name
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(voip-metrics))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(voip-metrics)";
                    EXCEPTION->ruleName	 = (void *)"voip_metrics";


            }

            FOLLOWPUSH(FOLLOW_rtcp_xr_attribute_name_in_voip_metrics1742);
            rtcp_xr_attribute_name148=rtcp_xr_attribute_name(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulevoip_metricsEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_xr_attribute_name148.tree);

            if ( BACKTRACKING==0 )
            {

                		belle_sdp_rtcp_xr_attribute_set_voip_metrics((SCOPE_TOP(rtcp_xr_attribute))->current,1);
                	
            }


        }

    }

    // This is where rules clean up and exit
    //
    goto rulevoip_metricsEx; /* Prevent compiler warnings */
    rulevoip_metricsEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start rtcp_xr_stat_summary_flag
 * ../grammars/belle_sdp.g:287:1: rtcp_xr_stat_summary_flag :{...}? rtcp_xr_stat_summary_flag_value ;
 */
static belle_sdpParser_rtcp_xr_stat_summary_flag_return
rtcp_xr_stat_summary_flag(pbelle_sdpParser ctx)
{
    belle_sdpParser_rtcp_xr_stat_summary_flag_return retval;


    pANTLR3_BASE_TREE root_0;

    belle_sdpParser_rtcp_xr_stat_summary_flag_value_return rtcp_xr_stat_summary_flag_value149;
    #undef	RETURN_TYPE_rtcp_xr_stat_summary_flag_value149
    #define	RETURN_TYPE_rtcp_xr_stat_summary_flag_value149 belle_sdpParser_rtcp_xr_stat_summary_flag_value_return


    /* Initialize rule variables
     */

    root_0 = NULL;

    rtcp_xr_stat_summary_flag_value149.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;




    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:287:27: ({...}? rtcp_xr_stat_summary_flag_value )
        // ../grammars/belle_sdp.g:288:2: {...}? rtcp_xr_stat_summary_flag_value
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(loss) || IS_TOKEN(dup) || IS_TOKEN(jitt) || IS_TOKEN(TTL) || IS_TOKEN(HL))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(loss) || IS_TOKEN(dup) || IS_TOKEN(jitt) || IS_TOKEN(TTL) || IS_TOKEN(HL)";
                    EXCEPTION->ruleName	 = (void *)"rtcp_xr_stat_summary_flag";


            }

            FOLLOWPUSH(FOLLOW_rtcp_xr_stat_summary_flag_value_in_rtcp_xr_stat_summary_flag1756);
            rtcp_xr_stat_summary_flag_value149=rtcp_xr_stat_summary_flag_value(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulertcp_xr_stat_summary_flagEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_xr_stat_summary_flag_value149.tree);

            if ( BACKTRACKING==0 )
            {

                		belle_sdp_rtcp_xr_attribute_add_stat_summary_flag((SCOPE_TOP(rtcp_xr_attribute))->current,(const char*)
                (STRSTREAM->toStringTT(STRSTREAM, rtcp_xr_stat_summary_flag_value149.start, rtcp_xr_stat_summary_flag_value149.stop))
                ->chars);
                	
            }


        }

    }

    // This is where rules clean up and exit
    //
    goto rulertcp_xr_stat_summary_flagEx; /* Prevent compiler warnings */
    rulertcp_xr_stat_summary_flagEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start rtcp_xr_max_size
 * ../grammars/belle_sdp.g:292:1: rtcp_xr_max_size : ( DIGIT )+ ;
 */
static belle_sdpParser_rtcp_xr_max_size_return
rtcp_xr_max_size(pbelle_sdpParser ctx)
{
    belle_sdpParser_rtcp_xr_max_size_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    DIGIT150;

    pANTLR3_BASE_TREE DIGIT150_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    DIGIT150       = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    DIGIT150_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:292:18: ( ( DIGIT )+ )
        // ../grammars/belle_sdp.g:292:20: ( DIGIT )+
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            // ../grammars/belle_sdp.g:292:20: ( DIGIT )+
            {
                int cnt29=0;

                for (;;)
                {
                    int alt29=2;
            	switch ( LA(1) )
            	{
            	case DIGIT:
            		{
            			alt29=1;
            		}
            	    break;

            	}

            	switch (alt29)
            	{
            	    case 1:
            	        // ../grammars/belle_sdp.g:292:20: DIGIT
            	        {
            	            DIGIT150 = (pANTLR3_COMMON_TOKEN) MATCHT(DIGIT, &FOLLOW_DIGIT_in_rtcp_xr_max_size1766);
            	            if  (HASEXCEPTION())
            	            {
            	                goto rulertcp_xr_max_sizeEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) {
            	            DIGIT150_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DIGIT150));
            	            ADAPTOR->addChild(ADAPTOR, root_0, DIGIT150_tree);
            	            }

            	        }
            	        break;

            	    default:

            		if ( cnt29 >= 1 )
            		{
            		    goto loop29;
            		}
            		if (BACKTRACKING>0)
            		{
            		    FAILEDFLAG = ANTLR3_TRUE;
            		    return retval;
            		}

            		/* mismatchedSetEx()
            		 */
            		CONSTRUCTEX();
            		EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
            		EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;


            		goto rulertcp_xr_max_sizeEx;
            	}
            	cnt29++;
                }
                loop29: ;	/* Jump to here if this rule does not match */
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto rulertcp_xr_max_sizeEx; /* Prevent compiler warnings */
    rulertcp_xr_max_sizeEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start rtcp_fb_attribute
 * ../grammars/belle_sdp.g:294:1: rtcp_fb_attribute returns [belle_sdp_rtcp_fb_attribute_t* ret] :{...}? alpha_num EQUAL {...}? attribute_name COLON rtcp_fb_pt SPACE rtcp_fb_val ;
 */
static belle_sdpParser_rtcp_fb_attribute_return
rtcp_fb_attribute(pbelle_sdpParser ctx)
{
    belle_sdpParser_rtcp_fb_attribute_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    EQUAL152;
    pANTLR3_COMMON_TOKEN    COLON154;
    pANTLR3_COMMON_TOKEN    SPACE156;
    belle_sdpParser_alpha_num_return alpha_num151;
    #undef	RETURN_TYPE_alpha_num151
    #define	RETURN_TYPE_alpha_num151 belle_sdpParser_alpha_num_return

    belle_sdpParser_attribute_name_return attribute_name153;
    #undef	RETURN_TYPE_attribute_name153
    #define	RETURN_TYPE_attribute_name153 belle_sdpParser_attribute_name_return

    belle_sdpParser_rtcp_fb_pt_return rtcp_fb_pt155;
    #undef	RETURN_TYPE_rtcp_fb_pt155
    #define	RETURN_TYPE_rtcp_fb_pt155 belle_sdpParser_rtcp_fb_pt_return

    belle_sdpParser_rtcp_fb_val_return rtcp_fb_val157;
    #undef	RETURN_TYPE_rtcp_fb_val157
    #define	RETURN_TYPE_rtcp_fb_val157 belle_sdpParser_rtcp_fb_val_return

    pANTLR3_BASE_TREE EQUAL152_tree;
    pANTLR3_BASE_TREE COLON154_tree;
    pANTLR3_BASE_TREE SPACE156_tree;

    /* Initialize rule variables
     */
    ctx->pbelle_sdpParser_rtcp_fb_attributeTop = pbelle_sdpParser_rtcp_fb_attributePush(ctx);
    root_0 = NULL;

     (SCOPE_TOP(rtcp_fb_attribute))->current= belle_sdp_rtcp_fb_attribute_new();
    retval.ret= (SCOPE_TOP(rtcp_fb_attribute))->current;

    EQUAL152       = NULL;
    COLON154       = NULL;
    SPACE156       = NULL;
    alpha_num151.tree = NULL;

    attribute_name153.tree = NULL;

    rtcp_fb_pt155.tree = NULL;

    rtcp_fb_val157.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    EQUAL152_tree   = NULL;
    COLON154_tree   = NULL;
    SPACE156_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:297:3: ({...}? alpha_num EQUAL {...}? attribute_name COLON rtcp_fb_pt SPACE rtcp_fb_val )
        // ../grammars/belle_sdp.g:297:3: {...}? alpha_num EQUAL {...}? attribute_name COLON rtcp_fb_pt SPACE rtcp_fb_val
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(a))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    pbelle_sdpParser_rtcp_fb_attributePop(ctx);

                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(a)";
                    EXCEPTION->ruleName	 = (void *)"rtcp_fb_attribute";


            }

            FOLLOWPUSH(FOLLOW_alpha_num_in_rtcp_fb_attribute1789);
            alpha_num151=alpha_num(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulertcp_fb_attributeEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_rtcp_fb_attributePop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num151.tree);

            EQUAL152 = (pANTLR3_COMMON_TOKEN) MATCHT(EQUAL, &FOLLOW_EQUAL_in_rtcp_fb_attribute1791);
            if  (HASEXCEPTION())
            {
                goto rulertcp_fb_attributeEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_rtcp_fb_attributePop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) {
            EQUAL152_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, EQUAL152));
            ADAPTOR->addChild(ADAPTOR, root_0, EQUAL152_tree);
            }

            if ( !((IS_TOKEN(rtcp-fb))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    pbelle_sdpParser_rtcp_fb_attributePop(ctx);

                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(rtcp-fb)";
                    EXCEPTION->ruleName	 = (void *)"rtcp_fb_attribute";


            }

            FOLLOWPUSH(FOLLOW_attribute_name_in_rtcp_fb_attribute1795);
            attribute_name153=attribute_name(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulertcp_fb_attributeEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_rtcp_fb_attributePop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, attribute_name153.tree);

            COLON154 = (pANTLR3_COMMON_TOKEN) MATCHT(COLON, &FOLLOW_COLON_in_rtcp_fb_attribute1799);
            if  (HASEXCEPTION())
            {
                goto rulertcp_fb_attributeEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_rtcp_fb_attributePop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) {
            COLON154_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, COLON154));
            ADAPTOR->addChild(ADAPTOR, root_0, COLON154_tree);
            }

            FOLLOWPUSH(FOLLOW_rtcp_fb_pt_in_rtcp_fb_attribute1801);
            rtcp_fb_pt155=rtcp_fb_pt(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulertcp_fb_attributeEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_rtcp_fb_attributePop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_pt155.tree);

            SPACE156 = (pANTLR3_COMMON_TOKEN) MATCHT(SPACE, &FOLLOW_SPACE_in_rtcp_fb_attribute1803);
            if  (HASEXCEPTION())
            {
                goto rulertcp_fb_attributeEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_rtcp_fb_attributePop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) {
            SPACE156_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, SPACE156));
            ADAPTOR->addChild(ADAPTOR, root_0, SPACE156_tree);
            }

            FOLLOWPUSH(FOLLOW_rtcp_fb_val_in_rtcp_fb_attribute1805);
            rtcp_fb_val157=rtcp_fb_val(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulertcp_fb_attributeEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_rtcp_fb_attributePop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_val157.tree);

        }

    }

    // This is where rules clean up and exit
    //
    goto rulertcp_fb_attributeEx; /* Prevent compiler warnings */
    rulertcp_fb_attributeEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }


    if	(HASEXCEPTION())
    {
	/* catch(decl,action)
	 */
	{

	    	ANTLR3_LOG_EXCEPTION();
	    	belle_sip_object_unref(retval.ret
	    );
	    	retval.ret=NULL;


	}


    }
    else
    {
    }
    pbelle_sdpParser_rtcp_fb_attributePop(ctx);

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

/**
 * $ANTLR start rtcp_fb_pt
 * ../grammars/belle_sdp.g:305:1: rtcp_fb_pt : ( STAR | integer );
 */
static belle_sdpParser_rtcp_fb_pt_return
rtcp_fb_pt(pbelle_sdpParser ctx)
{
    belle_sdpParser_rtcp_fb_pt_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    STAR158;
    belle_sdpParser_integer_return integer159;
    #undef	RETURN_TYPE_integer159
    #define	RETURN_TYPE_integer159 belle_sdpParser_integer_return

    pANTLR3_BASE_TREE STAR158_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    STAR158       = NULL;
    integer159.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    STAR158_tree   = NULL;


    retval.tree  = NULL;

    {
        {
            //  ../grammars/belle_sdp.g:305:11: ( STAR | integer )

            ANTLR3_UINT32 alt30;

            alt30=2;

            switch ( LA(1) )
            {
            case STAR:
            	{
            		alt30=1;
            	}
                break;
            case DIGIT:
            	{
            		alt30=2;
            	}
                break;

            default:
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                CONSTRUCTEX();
                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
                EXCEPTION->message      = (void *)"";
                EXCEPTION->decisionNum  = 30;
                EXCEPTION->state        = 0;


                goto rulertcp_fb_ptEx;

            }

            switch (alt30)
            {
        	case 1:
        	    // ../grammars/belle_sdp.g:305:13: STAR
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        STAR158 = (pANTLR3_COMMON_TOKEN) MATCHT(STAR, &FOLLOW_STAR_in_rtcp_fb_pt1818);
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulertcp_fb_ptEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) {
        	        STAR158_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, STAR158));
        	        ADAPTOR->addChild(ADAPTOR, root_0, STAR158_tree);
        	        }

        	        if ( BACKTRACKING==0 )
        	        {

        	            	belle_sdp_rtcp_fb_attribute_set_id((SCOPE_TOP(rtcp_fb_attribute))->current,-1);

        	        }


        	    }
        	    break;
        	case 2:
        	    // ../grammars/belle_sdp.g:307:5: integer
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        FOLLOWPUSH(FOLLOW_integer_in_rtcp_fb_pt1824);
        	        integer159=integer(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulertcp_fb_ptEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, integer159.tree);

        	        if ( BACKTRACKING==0 )
        	        {

        	            	belle_sdp_rtcp_fb_attribute_set_id((SCOPE_TOP(rtcp_fb_attribute))->current,atoi((const char*)
        	            (STRSTREAM->toStringTT(STRSTREAM, integer159.start, integer159.stop))
        	            ->chars));

        	        }


        	    }
        	    break;

            }
        }
    }

    // This is where rules clean up and exit
    //
    goto rulertcp_fb_ptEx; /* Prevent compiler warnings */
    rulertcp_fb_ptEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start rtcp_fb_val
 * ../grammars/belle_sdp.g:311:1: rtcp_fb_val : ( ( rtcp_fb_ack_val )=> rtcp_fb_ack_val | ( rtcp_fb_nack_val )=> rtcp_fb_nack_val | ( rtcp_fb_trr_int_val )=> rtcp_fb_trr_int_val | ( rtcp_fb_ccm_val )=> rtcp_fb_ccm_val | ( rtcp_fb_id_val )=> rtcp_fb_id_val );
 */
static belle_sdpParser_rtcp_fb_val_return
rtcp_fb_val(pbelle_sdpParser ctx)
{
    belle_sdpParser_rtcp_fb_val_return retval;


    pANTLR3_BASE_TREE root_0;

    belle_sdpParser_rtcp_fb_ack_val_return rtcp_fb_ack_val160;
    #undef	RETURN_TYPE_rtcp_fb_ack_val160
    #define	RETURN_TYPE_rtcp_fb_ack_val160 belle_sdpParser_rtcp_fb_ack_val_return

    belle_sdpParser_rtcp_fb_nack_val_return rtcp_fb_nack_val161;
    #undef	RETURN_TYPE_rtcp_fb_nack_val161
    #define	RETURN_TYPE_rtcp_fb_nack_val161 belle_sdpParser_rtcp_fb_nack_val_return

    belle_sdpParser_rtcp_fb_trr_int_val_return rtcp_fb_trr_int_val162;
    #undef	RETURN_TYPE_rtcp_fb_trr_int_val162
    #define	RETURN_TYPE_rtcp_fb_trr_int_val162 belle_sdpParser_rtcp_fb_trr_int_val_return

    belle_sdpParser_rtcp_fb_ccm_val_return rtcp_fb_ccm_val163;
    #undef	RETURN_TYPE_rtcp_fb_ccm_val163
    #define	RETURN_TYPE_rtcp_fb_ccm_val163 belle_sdpParser_rtcp_fb_ccm_val_return

    belle_sdpParser_rtcp_fb_id_val_return rtcp_fb_id_val164;
    #undef	RETURN_TYPE_rtcp_fb_id_val164
    #define	RETURN_TYPE_rtcp_fb_id_val164 belle_sdpParser_rtcp_fb_id_val_return


    /* Initialize rule variables
     */

    root_0 = NULL;

    rtcp_fb_ack_val160.tree = NULL;

    rtcp_fb_nack_val161.tree = NULL;

    rtcp_fb_trr_int_val162.tree = NULL;

    rtcp_fb_ccm_val163.tree = NULL;

    rtcp_fb_id_val164.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;




    retval.tree  = NULL;

    {
        {
            //  ../grammars/belle_sdp.g:311:13: ( ( rtcp_fb_ack_val )=> rtcp_fb_ack_val | ( rtcp_fb_nack_val )=> rtcp_fb_nack_val | ( rtcp_fb_trr_int_val )=> rtcp_fb_trr_int_val | ( rtcp_fb_ccm_val )=> rtcp_fb_ccm_val | ( rtcp_fb_id_val )=> rtcp_fb_id_val )

            ANTLR3_UINT32 alt31;

            alt31=5;

            switch ( LA(1) )
            {
            case COMMON_CHAR:
            case HEX_CHAR:
            	{
            		{
            		    int LA31_1 = LA(2);
            		    if ( (synpred9_belle_sdp(ctx)) && (LA31_1 == SPACE))
            		    {
            		        alt31=3;
            		    }
            		    else if ( (synpred9_belle_sdp(ctx)) && (LA31_1 == COMMON_CHAR || LA31_1 == HEX_CHAR))
            		    {
            		        alt31=3;
            		    }
            		    else if ( (synpred9_belle_sdp(ctx)) && (LA31_1 == DASH))
            		    {
            		        alt31=3;
            		    }
            		    else if ( (( (( ((IS_TOKEN(ack))) && ((IS_TOKEN(ack))) )) && (synpred7_belle_sdp(ctx)) )))
            		    {
            		        alt31=1;
            		    }
            		    else if ( (( (( (synpred8_belle_sdp(ctx)) && (synpred8_belle_sdp(ctx)) )) && ((IS_TOKEN(nack))) )))
            		    {
            		        alt31=2;
            		    }
            		    else if ( (( (( ((IS_TOKEN(ccm))) && ((IS_TOKEN(ccm))) )) && (synpred10_belle_sdp(ctx)) )))
            		    {
            		        alt31=4;
            		    }
            		    else if ( (synpred11_belle_sdp(ctx)))
            		    {
            		        alt31=5;
            		    }
            		    else
            		    {
            		        if (BACKTRACKING>0)
            		        {
            		            FAILEDFLAG = ANTLR3_TRUE;
            		            return retval;
            		        }


            		        CONSTRUCTEX();
            		        EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
            		        EXCEPTION->message      = (void *)"";
            		        EXCEPTION->decisionNum  = 31;
            		        EXCEPTION->state        = 1;


            		        goto rulertcp_fb_valEx;

            		    }
            		}
            	}
                break;
            case DASH:
            	{
            		{
            		    int LA31_2 = LA(2);
            		    if ( (synpred9_belle_sdp(ctx)) && (LA31_2 == SPACE))
            		    {
            		        alt31=3;
            		    }
            		    else if ( (synpred9_belle_sdp(ctx)) && (LA31_2 == COMMON_CHAR || LA31_2 == HEX_CHAR))
            		    {
            		        alt31=3;
            		    }
            		    else if ( (synpred9_belle_sdp(ctx)) && (LA31_2 == DASH))
            		    {
            		        alt31=3;
            		    }
            		    else if ( (( (( ((IS_TOKEN(ack))) && ((IS_TOKEN(ack))) )) && (synpred7_belle_sdp(ctx)) )))
            		    {
            		        alt31=1;
            		    }
            		    else if ( (( (( (synpred8_belle_sdp(ctx)) && (synpred8_belle_sdp(ctx)) )) && ((IS_TOKEN(nack))) )))
            		    {
            		        alt31=2;
            		    }
            		    else if ( (( (( ((IS_TOKEN(ccm))) && ((IS_TOKEN(ccm))) )) && (synpred10_belle_sdp(ctx)) )))
            		    {
            		        alt31=4;
            		    }
            		    else if ( (synpred11_belle_sdp(ctx)))
            		    {
            		        alt31=5;
            		    }
            		    else
            		    {
            		        if (BACKTRACKING>0)
            		        {
            		            FAILEDFLAG = ANTLR3_TRUE;
            		            return retval;
            		        }


            		        CONSTRUCTEX();
            		        EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
            		        EXCEPTION->message      = (void *)"";
            		        EXCEPTION->decisionNum  = 31;
            		        EXCEPTION->state        = 2;


            		        goto rulertcp_fb_valEx;

            		    }
            		}
            	}
                break;

            default:
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                CONSTRUCTEX();
                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
                EXCEPTION->message      = (void *)"";
                EXCEPTION->decisionNum  = 31;
                EXCEPTION->state        = 0;


                goto rulertcp_fb_valEx;

            }

            switch (alt31)
            {
        	case 1:
        	    // ../grammars/belle_sdp.g:312:2: ( rtcp_fb_ack_val )=> rtcp_fb_ack_val
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        FOLLOWPUSH(FOLLOW_rtcp_fb_ack_val_in_rtcp_fb_val1839);
        	        rtcp_fb_ack_val160=rtcp_fb_ack_val(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulertcp_fb_valEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_ack_val160.tree);

        	    }
        	    break;
        	case 2:
        	    // ../grammars/belle_sdp.g:313:3: ( rtcp_fb_nack_val )=> rtcp_fb_nack_val
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        FOLLOWPUSH(FOLLOW_rtcp_fb_nack_val_in_rtcp_fb_val1847);
        	        rtcp_fb_nack_val161=rtcp_fb_nack_val(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulertcp_fb_valEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_nack_val161.tree);

        	    }
        	    break;
        	case 3:
        	    // ../grammars/belle_sdp.g:314:3: ( rtcp_fb_trr_int_val )=> rtcp_fb_trr_int_val
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        FOLLOWPUSH(FOLLOW_rtcp_fb_trr_int_val_in_rtcp_fb_val1855);
        	        rtcp_fb_trr_int_val162=rtcp_fb_trr_int_val(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulertcp_fb_valEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_trr_int_val162.tree);

        	    }
        	    break;
        	case 4:
        	    // ../grammars/belle_sdp.g:315:3: ( rtcp_fb_ccm_val )=> rtcp_fb_ccm_val
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        FOLLOWPUSH(FOLLOW_rtcp_fb_ccm_val_in_rtcp_fb_val1863);
        	        rtcp_fb_ccm_val163=rtcp_fb_ccm_val(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulertcp_fb_valEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_ccm_val163.tree);

        	    }
        	    break;
        	case 5:
        	    // ../grammars/belle_sdp.g:316:3: ( rtcp_fb_id_val )=> rtcp_fb_id_val
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        FOLLOWPUSH(FOLLOW_rtcp_fb_id_val_in_rtcp_fb_val1871);
        	        rtcp_fb_id_val164=rtcp_fb_id_val(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulertcp_fb_valEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_id_val164.tree);

        	    }
        	    break;

            }
        }
    }

    // This is where rules clean up and exit
    //
    goto rulertcp_fb_valEx; /* Prevent compiler warnings */
    rulertcp_fb_valEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start rtcp_fb_ack_val
 * ../grammars/belle_sdp.g:318:1: rtcp_fb_ack_val :{...}? rtcp_fb_attribute_name ( SPACE rtcp_fb_ack_param )? ;
 */
static belle_sdpParser_rtcp_fb_ack_val_return
rtcp_fb_ack_val(pbelle_sdpParser ctx)
{
    belle_sdpParser_rtcp_fb_ack_val_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    SPACE166;
    belle_sdpParser_rtcp_fb_attribute_name_return rtcp_fb_attribute_name165;
    #undef	RETURN_TYPE_rtcp_fb_attribute_name165
    #define	RETURN_TYPE_rtcp_fb_attribute_name165 belle_sdpParser_rtcp_fb_attribute_name_return

    belle_sdpParser_rtcp_fb_ack_param_return rtcp_fb_ack_param167;
    #undef	RETURN_TYPE_rtcp_fb_ack_param167
    #define	RETURN_TYPE_rtcp_fb_ack_param167 belle_sdpParser_rtcp_fb_ack_param_return

    pANTLR3_BASE_TREE SPACE166_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    SPACE166       = NULL;
    rtcp_fb_attribute_name165.tree = NULL;

    rtcp_fb_ack_param167.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    SPACE166_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:318:16: ({...}? rtcp_fb_attribute_name ( SPACE rtcp_fb_ack_param )? )
        // ../grammars/belle_sdp.g:319:2: {...}? rtcp_fb_attribute_name ( SPACE rtcp_fb_ack_param )?
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(ack))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(ack)";
                    EXCEPTION->ruleName	 = (void *)"rtcp_fb_ack_val";


            }

            FOLLOWPUSH(FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_ack_val1881);
            rtcp_fb_attribute_name165=rtcp_fb_attribute_name(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulertcp_fb_ack_valEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_attribute_name165.tree);

            // ../grammars/belle_sdp.g:319:52: ( SPACE rtcp_fb_ack_param )?
            {
                int alt32=2;
                switch ( LA(1) )
                {
                    case SPACE:
                    	{
                    		alt32=1;
                    	}
                        break;
                }

                switch (alt32)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:319:53: SPACE rtcp_fb_ack_param
            	    {
            	        SPACE166 = (pANTLR3_COMMON_TOKEN) MATCHT(SPACE, &FOLLOW_SPACE_in_rtcp_fb_ack_val1886);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulertcp_fb_ack_valEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        SPACE166_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, SPACE166));
            	        ADAPTOR->addChild(ADAPTOR, root_0, SPACE166_tree);
            	        }

            	        FOLLOWPUSH(FOLLOW_rtcp_fb_ack_param_in_rtcp_fb_ack_val1888);
            	        rtcp_fb_ack_param167=rtcp_fb_ack_param(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulertcp_fb_ack_valEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_ack_param167.tree);

            	    }
            	    break;

                }
            }

            if ( BACKTRACKING==0 )
            {

                		belle_sdp_rtcp_fb_attribute_set_type((SCOPE_TOP(rtcp_fb_attribute))->current,BELLE_SDP_RTCP_FB_ACK);
                	
            }


        }

    }

    // This is where rules clean up and exit
    //
    goto rulertcp_fb_ack_valEx; /* Prevent compiler warnings */
    rulertcp_fb_ack_valEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start rtcp_fb_nack_val
 * ../grammars/belle_sdp.g:323:1: rtcp_fb_nack_val :{...}? rtcp_fb_attribute_name ( SPACE rtcp_fb_nack_param )? ;
 */
static belle_sdpParser_rtcp_fb_nack_val_return
rtcp_fb_nack_val(pbelle_sdpParser ctx)
{
    belle_sdpParser_rtcp_fb_nack_val_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    SPACE169;
    belle_sdpParser_rtcp_fb_attribute_name_return rtcp_fb_attribute_name168;
    #undef	RETURN_TYPE_rtcp_fb_attribute_name168
    #define	RETURN_TYPE_rtcp_fb_attribute_name168 belle_sdpParser_rtcp_fb_attribute_name_return

    belle_sdpParser_rtcp_fb_nack_param_return rtcp_fb_nack_param170;
    #undef	RETURN_TYPE_rtcp_fb_nack_param170
    #define	RETURN_TYPE_rtcp_fb_nack_param170 belle_sdpParser_rtcp_fb_nack_param_return

    pANTLR3_BASE_TREE SPACE169_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    SPACE169       = NULL;
    rtcp_fb_attribute_name168.tree = NULL;

    rtcp_fb_nack_param170.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    SPACE169_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:323:17: ({...}? rtcp_fb_attribute_name ( SPACE rtcp_fb_nack_param )? )
        // ../grammars/belle_sdp.g:324:2: {...}? rtcp_fb_attribute_name ( SPACE rtcp_fb_nack_param )?
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(nack))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(nack)";
                    EXCEPTION->ruleName	 = (void *)"rtcp_fb_nack_val";


            }

            FOLLOWPUSH(FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_nack_val1902);
            rtcp_fb_attribute_name168=rtcp_fb_attribute_name(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulertcp_fb_nack_valEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_attribute_name168.tree);

            // ../grammars/belle_sdp.g:324:54: ( SPACE rtcp_fb_nack_param )?
            {
                int alt33=2;
                switch ( LA(1) )
                {
                    case SPACE:
                    	{
                    		alt33=1;
                    	}
                        break;
                }

                switch (alt33)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:324:55: SPACE rtcp_fb_nack_param
            	    {
            	        SPACE169 = (pANTLR3_COMMON_TOKEN) MATCHT(SPACE, &FOLLOW_SPACE_in_rtcp_fb_nack_val1907);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulertcp_fb_nack_valEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        SPACE169_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, SPACE169));
            	        ADAPTOR->addChild(ADAPTOR, root_0, SPACE169_tree);
            	        }

            	        FOLLOWPUSH(FOLLOW_rtcp_fb_nack_param_in_rtcp_fb_nack_val1909);
            	        rtcp_fb_nack_param170=rtcp_fb_nack_param(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulertcp_fb_nack_valEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_nack_param170.tree);

            	    }
            	    break;

                }
            }

            if ( BACKTRACKING==0 )
            {

                		belle_sdp_rtcp_fb_attribute_set_type((SCOPE_TOP(rtcp_fb_attribute))->current,BELLE_SDP_RTCP_FB_NACK);
                	
            }


        }

    }

    // This is where rules clean up and exit
    //
    goto rulertcp_fb_nack_valEx; /* Prevent compiler warnings */
    rulertcp_fb_nack_valEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start rtcp_fb_trr_int_val
 * ../grammars/belle_sdp.g:328:1: rtcp_fb_trr_int_val :{...}? rtcp_fb_attribute_name SPACE integer ;
 */
static belle_sdpParser_rtcp_fb_trr_int_val_return
rtcp_fb_trr_int_val(pbelle_sdpParser ctx)
{
    belle_sdpParser_rtcp_fb_trr_int_val_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    SPACE172;
    belle_sdpParser_rtcp_fb_attribute_name_return rtcp_fb_attribute_name171;
    #undef	RETURN_TYPE_rtcp_fb_attribute_name171
    #define	RETURN_TYPE_rtcp_fb_attribute_name171 belle_sdpParser_rtcp_fb_attribute_name_return

    belle_sdpParser_integer_return integer173;
    #undef	RETURN_TYPE_integer173
    #define	RETURN_TYPE_integer173 belle_sdpParser_integer_return

    pANTLR3_BASE_TREE SPACE172_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    SPACE172       = NULL;
    rtcp_fb_attribute_name171.tree = NULL;

    integer173.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    SPACE172_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:328:20: ({...}? rtcp_fb_attribute_name SPACE integer )
        // ../grammars/belle_sdp.g:329:2: {...}? rtcp_fb_attribute_name SPACE integer
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(trr-int))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(trr-int)";
                    EXCEPTION->ruleName	 = (void *)"rtcp_fb_trr_int_val";


            }

            FOLLOWPUSH(FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_trr_int_val1923);
            rtcp_fb_attribute_name171=rtcp_fb_attribute_name(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulertcp_fb_trr_int_valEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_attribute_name171.tree);

            SPACE172 = (pANTLR3_COMMON_TOKEN) MATCHT(SPACE, &FOLLOW_SPACE_in_rtcp_fb_trr_int_val1927);
            if  (HASEXCEPTION())
            {
                goto rulertcp_fb_trr_int_valEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) {
            SPACE172_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, SPACE172));
            ADAPTOR->addChild(ADAPTOR, root_0, SPACE172_tree);
            }

            FOLLOWPUSH(FOLLOW_integer_in_rtcp_fb_trr_int_val1929);
            integer173=integer(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulertcp_fb_trr_int_valEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, integer173.tree);

            if ( BACKTRACKING==0 )
            {

                		belle_sdp_rtcp_fb_attribute_set_type((SCOPE_TOP(rtcp_fb_attribute))->current,BELLE_SDP_RTCP_FB_TRR_INT);
                		belle_sdp_rtcp_fb_attribute_set_trr_int((SCOPE_TOP(rtcp_fb_attribute))->current,(uint16_t)atoi((const char*)
                (STRSTREAM->toStringTT(STRSTREAM, integer173.start, integer173.stop))
                ->chars));
                	
            }


        }

    }

    // This is where rules clean up and exit
    //
    goto rulertcp_fb_trr_int_valEx; /* Prevent compiler warnings */
    rulertcp_fb_trr_int_valEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start rtcp_fb_ccm_val
 * ../grammars/belle_sdp.g:334:1: rtcp_fb_ccm_val :{...}? rtcp_fb_attribute_name ( SPACE rtcp_fb_ccm_param )? ;
 */
static belle_sdpParser_rtcp_fb_ccm_val_return
rtcp_fb_ccm_val(pbelle_sdpParser ctx)
{
    belle_sdpParser_rtcp_fb_ccm_val_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    SPACE175;
    belle_sdpParser_rtcp_fb_attribute_name_return rtcp_fb_attribute_name174;
    #undef	RETURN_TYPE_rtcp_fb_attribute_name174
    #define	RETURN_TYPE_rtcp_fb_attribute_name174 belle_sdpParser_rtcp_fb_attribute_name_return

    belle_sdpParser_rtcp_fb_ccm_param_return rtcp_fb_ccm_param176;
    #undef	RETURN_TYPE_rtcp_fb_ccm_param176
    #define	RETURN_TYPE_rtcp_fb_ccm_param176 belle_sdpParser_rtcp_fb_ccm_param_return

    pANTLR3_BASE_TREE SPACE175_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    SPACE175       = NULL;
    rtcp_fb_attribute_name174.tree = NULL;

    rtcp_fb_ccm_param176.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    SPACE175_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:334:16: ({...}? rtcp_fb_attribute_name ( SPACE rtcp_fb_ccm_param )? )
        // ../grammars/belle_sdp.g:335:2: {...}? rtcp_fb_attribute_name ( SPACE rtcp_fb_ccm_param )?
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(ccm))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(ccm)";
                    EXCEPTION->ruleName	 = (void *)"rtcp_fb_ccm_val";


            }

            FOLLOWPUSH(FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_ccm_val1941);
            rtcp_fb_attribute_name174=rtcp_fb_attribute_name(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulertcp_fb_ccm_valEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_attribute_name174.tree);

            // ../grammars/belle_sdp.g:335:52: ( SPACE rtcp_fb_ccm_param )?
            {
                int alt34=2;
                switch ( LA(1) )
                {
                    case SPACE:
                    	{
                    		alt34=1;
                    	}
                        break;
                }

                switch (alt34)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:335:53: SPACE rtcp_fb_ccm_param
            	    {
            	        SPACE175 = (pANTLR3_COMMON_TOKEN) MATCHT(SPACE, &FOLLOW_SPACE_in_rtcp_fb_ccm_val1946);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulertcp_fb_ccm_valEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        SPACE175_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, SPACE175));
            	        ADAPTOR->addChild(ADAPTOR, root_0, SPACE175_tree);
            	        }

            	        FOLLOWPUSH(FOLLOW_rtcp_fb_ccm_param_in_rtcp_fb_ccm_val1948);
            	        rtcp_fb_ccm_param176=rtcp_fb_ccm_param(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulertcp_fb_ccm_valEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_ccm_param176.tree);

            	    }
            	    break;

                }
            }

            if ( BACKTRACKING==0 )
            {
                 /* TODO: rtcp_fb_ccm_param should be mandatory */
                		belle_sdp_rtcp_fb_attribute_set_type((SCOPE_TOP(rtcp_fb_attribute))->current,BELLE_SDP_RTCP_FB_CCM);
                	
            }


        }

    }

    // This is where rules clean up and exit
    //
    goto rulertcp_fb_ccm_valEx; /* Prevent compiler warnings */
    rulertcp_fb_ccm_valEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start rtcp_fb_id_val
 * ../grammars/belle_sdp.g:339:1: rtcp_fb_id_val : rtcp_fb_attribute_name ( SPACE rtcp_fb_param )? ;
 */
static belle_sdpParser_rtcp_fb_id_val_return
rtcp_fb_id_val(pbelle_sdpParser ctx)
{
    belle_sdpParser_rtcp_fb_id_val_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    SPACE178;
    belle_sdpParser_rtcp_fb_attribute_name_return rtcp_fb_attribute_name177;
    #undef	RETURN_TYPE_rtcp_fb_attribute_name177
    #define	RETURN_TYPE_rtcp_fb_attribute_name177 belle_sdpParser_rtcp_fb_attribute_name_return

    belle_sdpParser_rtcp_fb_param_return rtcp_fb_param179;
    #undef	RETURN_TYPE_rtcp_fb_param179
    #define	RETURN_TYPE_rtcp_fb_param179 belle_sdpParser_rtcp_fb_param_return

    pANTLR3_BASE_TREE SPACE178_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    SPACE178       = NULL;
    rtcp_fb_attribute_name177.tree = NULL;

    rtcp_fb_param179.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    SPACE178_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:339:15: ( rtcp_fb_attribute_name ( SPACE rtcp_fb_param )? )
        // ../grammars/belle_sdp.g:340:2: rtcp_fb_attribute_name ( SPACE rtcp_fb_param )?
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            FOLLOWPUSH(FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_id_val1960);
            rtcp_fb_attribute_name177=rtcp_fb_attribute_name(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulertcp_fb_id_valEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_attribute_name177.tree);

            // ../grammars/belle_sdp.g:340:25: ( SPACE rtcp_fb_param )?
            {
                int alt35=2;
                switch ( LA(1) )
                {
                    case SPACE:
                    	{
                    		alt35=1;
                    	}
                        break;
                }

                switch (alt35)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:340:26: SPACE rtcp_fb_param
            	    {
            	        SPACE178 = (pANTLR3_COMMON_TOKEN) MATCHT(SPACE, &FOLLOW_SPACE_in_rtcp_fb_id_val1963);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulertcp_fb_id_valEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        SPACE178_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, SPACE178));
            	        ADAPTOR->addChild(ADAPTOR, root_0, SPACE178_tree);
            	        }

            	        FOLLOWPUSH(FOLLOW_rtcp_fb_param_in_rtcp_fb_id_val1965);
            	        rtcp_fb_param179=rtcp_fb_param(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulertcp_fb_id_valEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_param179.tree);

            	    }
            	    break;

                }
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto rulertcp_fb_id_valEx; /* Prevent compiler warnings */
    rulertcp_fb_id_valEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start rtcp_fb_param
 * ../grammars/belle_sdp.g:342:1: rtcp_fb_param : ( ( rtcp_fb_app_param )=> rtcp_fb_app_param | ( rtcp_fb_token_param )=> rtcp_fb_token_param );
 */
static belle_sdpParser_rtcp_fb_param_return
rtcp_fb_param(pbelle_sdpParser ctx)
{
    belle_sdpParser_rtcp_fb_param_return retval;


    pANTLR3_BASE_TREE root_0;

    belle_sdpParser_rtcp_fb_app_param_return rtcp_fb_app_param180;
    #undef	RETURN_TYPE_rtcp_fb_app_param180
    #define	RETURN_TYPE_rtcp_fb_app_param180 belle_sdpParser_rtcp_fb_app_param_return

    belle_sdpParser_rtcp_fb_token_param_return rtcp_fb_token_param181;
    #undef	RETURN_TYPE_rtcp_fb_token_param181
    #define	RETURN_TYPE_rtcp_fb_token_param181 belle_sdpParser_rtcp_fb_token_param_return


    /* Initialize rule variables
     */

    root_0 = NULL;

    rtcp_fb_app_param180.tree = NULL;

    rtcp_fb_token_param181.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;




    retval.tree  = NULL;

    {
        {
            //  ../grammars/belle_sdp.g:342:14: ( ( rtcp_fb_app_param )=> rtcp_fb_app_param | ( rtcp_fb_token_param )=> rtcp_fb_token_param )

            ANTLR3_UINT32 alt36;

            alt36=2;

            alt36 = cdfa36.predict(ctx, RECOGNIZER, ISTREAM, &cdfa36);
            if  (HASEXCEPTION())
            {
                goto rulertcp_fb_paramEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            switch (alt36)
            {
        	case 1:
        	    // ../grammars/belle_sdp.g:343:2: ( rtcp_fb_app_param )=> rtcp_fb_app_param
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        FOLLOWPUSH(FOLLOW_rtcp_fb_app_param_in_rtcp_fb_param1979);
        	        rtcp_fb_app_param180=rtcp_fb_app_param(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulertcp_fb_paramEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_app_param180.tree);

        	    }
        	    break;
        	case 2:
        	    // ../grammars/belle_sdp.g:344:3: ( rtcp_fb_token_param )=> rtcp_fb_token_param
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        FOLLOWPUSH(FOLLOW_rtcp_fb_token_param_in_rtcp_fb_param1987);
        	        rtcp_fb_token_param181=rtcp_fb_token_param(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulertcp_fb_paramEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_token_param181.tree);

        	    }
        	    break;

            }
        }
    }

    // This is where rules clean up and exit
    //
    goto rulertcp_fb_paramEx; /* Prevent compiler warnings */
    rulertcp_fb_paramEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start rtcp_fb_ack_param
 * ../grammars/belle_sdp.g:346:1: rtcp_fb_ack_param : ( ( rtcp_fb_rpsi_param )=> rtcp_fb_rpsi_param | ( rtcp_fb_app_param )=> rtcp_fb_app_param | ( rtcp_fb_token_param )=> rtcp_fb_token_param );
 */
static belle_sdpParser_rtcp_fb_ack_param_return
rtcp_fb_ack_param(pbelle_sdpParser ctx)
{
    belle_sdpParser_rtcp_fb_ack_param_return retval;


    pANTLR3_BASE_TREE root_0;

    belle_sdpParser_rtcp_fb_rpsi_param_return rtcp_fb_rpsi_param182;
    #undef	RETURN_TYPE_rtcp_fb_rpsi_param182
    #define	RETURN_TYPE_rtcp_fb_rpsi_param182 belle_sdpParser_rtcp_fb_rpsi_param_return

    belle_sdpParser_rtcp_fb_app_param_return rtcp_fb_app_param183;
    #undef	RETURN_TYPE_rtcp_fb_app_param183
    #define	RETURN_TYPE_rtcp_fb_app_param183 belle_sdpParser_rtcp_fb_app_param_return

    belle_sdpParser_rtcp_fb_token_param_return rtcp_fb_token_param184;
    #undef	RETURN_TYPE_rtcp_fb_token_param184
    #define	RETURN_TYPE_rtcp_fb_token_param184 belle_sdpParser_rtcp_fb_token_param_return


    /* Initialize rule variables
     */

    root_0 = NULL;

    rtcp_fb_rpsi_param182.tree = NULL;

    rtcp_fb_app_param183.tree = NULL;

    rtcp_fb_token_param184.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;




    retval.tree  = NULL;

    {
        {
            //  ../grammars/belle_sdp.g:346:18: ( ( rtcp_fb_rpsi_param )=> rtcp_fb_rpsi_param | ( rtcp_fb_app_param )=> rtcp_fb_app_param | ( rtcp_fb_token_param )=> rtcp_fb_token_param )

            ANTLR3_UINT32 alt37;

            alt37=3;

            switch ( LA(1) )
            {
            case COMMON_CHAR:
            case HEX_CHAR:
            	{
            		{
            		    int LA37_1 = LA(2);
            		    if ( (synpred15_belle_sdp(ctx)) && (LA37_1 == COMMON_CHAR || LA37_1 == HEX_CHAR))
            		    {
            		        alt37=2;
            		    }
            		    else if ( (synpred15_belle_sdp(ctx)) && (LA37_1 == DASH))
            		    {
            		        alt37=2;
            		    }
            		    else if ( (synpred15_belle_sdp(ctx)) && (LA37_1 == SPACE))
            		    {
            		        alt37=2;
            		    }
            		    else if ( (( (( (synpred14_belle_sdp(ctx)) && (synpred14_belle_sdp(ctx)) )) && ((IS_TOKEN(rpsi))) )))
            		    {
            		        alt37=1;
            		    }
            		    else if ( (synpred16_belle_sdp(ctx)))
            		    {
            		        alt37=3;
            		    }
            		    else
            		    {
            		        if (BACKTRACKING>0)
            		        {
            		            FAILEDFLAG = ANTLR3_TRUE;
            		            return retval;
            		        }


            		        CONSTRUCTEX();
            		        EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
            		        EXCEPTION->message      = (void *)"";
            		        EXCEPTION->decisionNum  = 37;
            		        EXCEPTION->state        = 1;


            		        goto rulertcp_fb_ack_paramEx;

            		    }
            		}
            	}
                break;
            case DASH:
            	{
            		{
            		    int LA37_2 = LA(2);
            		    if ( (synpred15_belle_sdp(ctx)) && (LA37_2 == COMMON_CHAR || LA37_2 == HEX_CHAR))
            		    {
            		        alt37=2;
            		    }
            		    else if ( (synpred15_belle_sdp(ctx)) && (LA37_2 == DASH))
            		    {
            		        alt37=2;
            		    }
            		    else if ( (synpred15_belle_sdp(ctx)) && (LA37_2 == SPACE))
            		    {
            		        alt37=2;
            		    }
            		    else if ( (( (( (synpred14_belle_sdp(ctx)) && (synpred14_belle_sdp(ctx)) )) && ((IS_TOKEN(rpsi))) )))
            		    {
            		        alt37=1;
            		    }
            		    else if ( (synpred16_belle_sdp(ctx)))
            		    {
            		        alt37=3;
            		    }
            		    else
            		    {
            		        if (BACKTRACKING>0)
            		        {
            		            FAILEDFLAG = ANTLR3_TRUE;
            		            return retval;
            		        }


            		        CONSTRUCTEX();
            		        EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
            		        EXCEPTION->message      = (void *)"";
            		        EXCEPTION->decisionNum  = 37;
            		        EXCEPTION->state        = 2;


            		        goto rulertcp_fb_ack_paramEx;

            		    }
            		}
            	}
                break;

            default:
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                CONSTRUCTEX();
                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
                EXCEPTION->message      = (void *)"";
                EXCEPTION->decisionNum  = 37;
                EXCEPTION->state        = 0;


                goto rulertcp_fb_ack_paramEx;

            }

            switch (alt37)
            {
        	case 1:
        	    // ../grammars/belle_sdp.g:347:2: ( rtcp_fb_rpsi_param )=> rtcp_fb_rpsi_param
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        FOLLOWPUSH(FOLLOW_rtcp_fb_rpsi_param_in_rtcp_fb_ack_param1999);
        	        rtcp_fb_rpsi_param182=rtcp_fb_rpsi_param(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulertcp_fb_ack_paramEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_rpsi_param182.tree);

        	    }
        	    break;
        	case 2:
        	    // ../grammars/belle_sdp.g:348:3: ( rtcp_fb_app_param )=> rtcp_fb_app_param
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        FOLLOWPUSH(FOLLOW_rtcp_fb_app_param_in_rtcp_fb_ack_param2007);
        	        rtcp_fb_app_param183=rtcp_fb_app_param(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulertcp_fb_ack_paramEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_app_param183.tree);

        	    }
        	    break;
        	case 3:
        	    // ../grammars/belle_sdp.g:349:3: ( rtcp_fb_token_param )=> rtcp_fb_token_param
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        FOLLOWPUSH(FOLLOW_rtcp_fb_token_param_in_rtcp_fb_ack_param2015);
        	        rtcp_fb_token_param184=rtcp_fb_token_param(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulertcp_fb_ack_paramEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_token_param184.tree);

        	    }
        	    break;

            }
        }
    }

    // This is where rules clean up and exit
    //
    goto rulertcp_fb_ack_paramEx; /* Prevent compiler warnings */
    rulertcp_fb_ack_paramEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start rtcp_fb_nack_param
 * ../grammars/belle_sdp.g:351:1: rtcp_fb_nack_param : ( ( rtcp_fb_pli_param )=> rtcp_fb_pli_param | ( rtcp_fb_sli_param )=> rtcp_fb_sli_param | ( rtcp_fb_rpsi_param )=> rtcp_fb_rpsi_param | ( rtcp_fb_app_param )=> rtcp_fb_app_param | ( rtcp_fb_token_param )=> rtcp_fb_token_param );
 */
static belle_sdpParser_rtcp_fb_nack_param_return
rtcp_fb_nack_param(pbelle_sdpParser ctx)
{
    belle_sdpParser_rtcp_fb_nack_param_return retval;


    pANTLR3_BASE_TREE root_0;

    belle_sdpParser_rtcp_fb_pli_param_return rtcp_fb_pli_param185;
    #undef	RETURN_TYPE_rtcp_fb_pli_param185
    #define	RETURN_TYPE_rtcp_fb_pli_param185 belle_sdpParser_rtcp_fb_pli_param_return

    belle_sdpParser_rtcp_fb_sli_param_return rtcp_fb_sli_param186;
    #undef	RETURN_TYPE_rtcp_fb_sli_param186
    #define	RETURN_TYPE_rtcp_fb_sli_param186 belle_sdpParser_rtcp_fb_sli_param_return

    belle_sdpParser_rtcp_fb_rpsi_param_return rtcp_fb_rpsi_param187;
    #undef	RETURN_TYPE_rtcp_fb_rpsi_param187
    #define	RETURN_TYPE_rtcp_fb_rpsi_param187 belle_sdpParser_rtcp_fb_rpsi_param_return

    belle_sdpParser_rtcp_fb_app_param_return rtcp_fb_app_param188;
    #undef	RETURN_TYPE_rtcp_fb_app_param188
    #define	RETURN_TYPE_rtcp_fb_app_param188 belle_sdpParser_rtcp_fb_app_param_return

    belle_sdpParser_rtcp_fb_token_param_return rtcp_fb_token_param189;
    #undef	RETURN_TYPE_rtcp_fb_token_param189
    #define	RETURN_TYPE_rtcp_fb_token_param189 belle_sdpParser_rtcp_fb_token_param_return


    /* Initialize rule variables
     */

    root_0 = NULL;

    rtcp_fb_pli_param185.tree = NULL;

    rtcp_fb_sli_param186.tree = NULL;

    rtcp_fb_rpsi_param187.tree = NULL;

    rtcp_fb_app_param188.tree = NULL;

    rtcp_fb_token_param189.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;




    retval.tree  = NULL;

    {
        {
            //  ../grammars/belle_sdp.g:351:19: ( ( rtcp_fb_pli_param )=> rtcp_fb_pli_param | ( rtcp_fb_sli_param )=> rtcp_fb_sli_param | ( rtcp_fb_rpsi_param )=> rtcp_fb_rpsi_param | ( rtcp_fb_app_param )=> rtcp_fb_app_param | ( rtcp_fb_token_param )=> rtcp_fb_token_param )

            ANTLR3_UINT32 alt38;

            alt38=5;

            switch ( LA(1) )
            {
            case COMMON_CHAR:
            case HEX_CHAR:
            	{
            		{
            		    int LA38_1 = LA(2);
            		    if ( (synpred20_belle_sdp(ctx)) && (LA38_1 == COMMON_CHAR || LA38_1 == HEX_CHAR))
            		    {
            		        alt38=4;
            		    }
            		    else if ( (synpred20_belle_sdp(ctx)) && (LA38_1 == DASH))
            		    {
            		        alt38=4;
            		    }
            		    else if ( (synpred20_belle_sdp(ctx)) && (LA38_1 == SPACE))
            		    {
            		        alt38=4;
            		    }
            		    else if ( (( (( ((IS_TOKEN(pli))) && ((IS_TOKEN(pli))) )) && (synpred17_belle_sdp(ctx)) )))
            		    {
            		        alt38=1;
            		    }
            		    else if ( (( (( (synpred18_belle_sdp(ctx)) && (synpred18_belle_sdp(ctx)) )) && ((IS_TOKEN(sli))) )))
            		    {
            		        alt38=2;
            		    }
            		    else if ( (( (( ((IS_TOKEN(rpsi))) && ((IS_TOKEN(rpsi))) )) && (synpred19_belle_sdp(ctx)) )))
            		    {
            		        alt38=3;
            		    }
            		    else if ( (synpred21_belle_sdp(ctx)))
            		    {
            		        alt38=5;
            		    }
            		    else
            		    {
            		        if (BACKTRACKING>0)
            		        {
            		            FAILEDFLAG = ANTLR3_TRUE;
            		            return retval;
            		        }


            		        CONSTRUCTEX();
            		        EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
            		        EXCEPTION->message      = (void *)"";
            		        EXCEPTION->decisionNum  = 38;
            		        EXCEPTION->state        = 1;


            		        goto rulertcp_fb_nack_paramEx;

            		    }
            		}
            	}
                break;
            case DASH:
            	{
            		{
            		    int LA38_2 = LA(2);
            		    if ( (synpred20_belle_sdp(ctx)) && (LA38_2 == COMMON_CHAR || LA38_2 == HEX_CHAR))
            		    {
            		        alt38=4;
            		    }
            		    else if ( (synpred20_belle_sdp(ctx)) && (LA38_2 == DASH))
            		    {
            		        alt38=4;
            		    }
            		    else if ( (synpred20_belle_sdp(ctx)) && (LA38_2 == SPACE))
            		    {
            		        alt38=4;
            		    }
            		    else if ( (( (( ((IS_TOKEN(pli))) && ((IS_TOKEN(pli))) )) && (synpred17_belle_sdp(ctx)) )))
            		    {
            		        alt38=1;
            		    }
            		    else if ( (( (( (synpred18_belle_sdp(ctx)) && (synpred18_belle_sdp(ctx)) )) && ((IS_TOKEN(sli))) )))
            		    {
            		        alt38=2;
            		    }
            		    else if ( (( (( ((IS_TOKEN(rpsi))) && ((IS_TOKEN(rpsi))) )) && (synpred19_belle_sdp(ctx)) )))
            		    {
            		        alt38=3;
            		    }
            		    else if ( (synpred21_belle_sdp(ctx)))
            		    {
            		        alt38=5;
            		    }
            		    else
            		    {
            		        if (BACKTRACKING>0)
            		        {
            		            FAILEDFLAG = ANTLR3_TRUE;
            		            return retval;
            		        }


            		        CONSTRUCTEX();
            		        EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
            		        EXCEPTION->message      = (void *)"";
            		        EXCEPTION->decisionNum  = 38;
            		        EXCEPTION->state        = 2;


            		        goto rulertcp_fb_nack_paramEx;

            		    }
            		}
            	}
                break;

            default:
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                CONSTRUCTEX();
                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
                EXCEPTION->message      = (void *)"";
                EXCEPTION->decisionNum  = 38;
                EXCEPTION->state        = 0;


                goto rulertcp_fb_nack_paramEx;

            }

            switch (alt38)
            {
        	case 1:
        	    // ../grammars/belle_sdp.g:352:2: ( rtcp_fb_pli_param )=> rtcp_fb_pli_param
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        FOLLOWPUSH(FOLLOW_rtcp_fb_pli_param_in_rtcp_fb_nack_param2027);
        	        rtcp_fb_pli_param185=rtcp_fb_pli_param(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulertcp_fb_nack_paramEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_pli_param185.tree);

        	    }
        	    break;
        	case 2:
        	    // ../grammars/belle_sdp.g:353:3: ( rtcp_fb_sli_param )=> rtcp_fb_sli_param
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        FOLLOWPUSH(FOLLOW_rtcp_fb_sli_param_in_rtcp_fb_nack_param2035);
        	        rtcp_fb_sli_param186=rtcp_fb_sli_param(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulertcp_fb_nack_paramEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_sli_param186.tree);

        	    }
        	    break;
        	case 3:
        	    // ../grammars/belle_sdp.g:354:3: ( rtcp_fb_rpsi_param )=> rtcp_fb_rpsi_param
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        FOLLOWPUSH(FOLLOW_rtcp_fb_rpsi_param_in_rtcp_fb_nack_param2043);
        	        rtcp_fb_rpsi_param187=rtcp_fb_rpsi_param(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulertcp_fb_nack_paramEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_rpsi_param187.tree);

        	    }
        	    break;
        	case 4:
        	    // ../grammars/belle_sdp.g:355:3: ( rtcp_fb_app_param )=> rtcp_fb_app_param
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        FOLLOWPUSH(FOLLOW_rtcp_fb_app_param_in_rtcp_fb_nack_param2051);
        	        rtcp_fb_app_param188=rtcp_fb_app_param(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulertcp_fb_nack_paramEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_app_param188.tree);

        	    }
        	    break;
        	case 5:
        	    // ../grammars/belle_sdp.g:356:3: ( rtcp_fb_token_param )=> rtcp_fb_token_param
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        FOLLOWPUSH(FOLLOW_rtcp_fb_token_param_in_rtcp_fb_nack_param2059);
        	        rtcp_fb_token_param189=rtcp_fb_token_param(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulertcp_fb_nack_paramEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_token_param189.tree);

        	    }
        	    break;

            }
        }
    }

    // This is where rules clean up and exit
    //
    goto rulertcp_fb_nack_paramEx; /* Prevent compiler warnings */
    rulertcp_fb_nack_paramEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start rtcp_fb_pli_param
 * ../grammars/belle_sdp.g:358:1: rtcp_fb_pli_param :{...}? rtcp_fb_attribute_name ;
 */
static belle_sdpParser_rtcp_fb_pli_param_return
rtcp_fb_pli_param(pbelle_sdpParser ctx)
{
    belle_sdpParser_rtcp_fb_pli_param_return retval;


    pANTLR3_BASE_TREE root_0;

    belle_sdpParser_rtcp_fb_attribute_name_return rtcp_fb_attribute_name190;
    #undef	RETURN_TYPE_rtcp_fb_attribute_name190
    #define	RETURN_TYPE_rtcp_fb_attribute_name190 belle_sdpParser_rtcp_fb_attribute_name_return


    /* Initialize rule variables
     */

    root_0 = NULL;

    rtcp_fb_attribute_name190.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;




    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:358:18: ({...}? rtcp_fb_attribute_name )
        // ../grammars/belle_sdp.g:359:2: {...}? rtcp_fb_attribute_name
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(pli))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(pli)";
                    EXCEPTION->ruleName	 = (void *)"rtcp_fb_pli_param";


            }

            FOLLOWPUSH(FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_pli_param2069);
            rtcp_fb_attribute_name190=rtcp_fb_attribute_name(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulertcp_fb_pli_paramEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_attribute_name190.tree);

            if ( BACKTRACKING==0 )
            {

                		belle_sdp_rtcp_fb_attribute_set_param((SCOPE_TOP(rtcp_fb_attribute))->current,BELLE_SDP_RTCP_FB_PLI);
                	
            }


        }

    }

    // This is where rules clean up and exit
    //
    goto rulertcp_fb_pli_paramEx; /* Prevent compiler warnings */
    rulertcp_fb_pli_paramEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start rtcp_fb_sli_param
 * ../grammars/belle_sdp.g:363:1: rtcp_fb_sli_param :{...}? rtcp_fb_attribute_name ;
 */
static belle_sdpParser_rtcp_fb_sli_param_return
rtcp_fb_sli_param(pbelle_sdpParser ctx)
{
    belle_sdpParser_rtcp_fb_sli_param_return retval;


    pANTLR3_BASE_TREE root_0;

    belle_sdpParser_rtcp_fb_attribute_name_return rtcp_fb_attribute_name191;
    #undef	RETURN_TYPE_rtcp_fb_attribute_name191
    #define	RETURN_TYPE_rtcp_fb_attribute_name191 belle_sdpParser_rtcp_fb_attribute_name_return


    /* Initialize rule variables
     */

    root_0 = NULL;

    rtcp_fb_attribute_name191.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;




    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:363:18: ({...}? rtcp_fb_attribute_name )
        // ../grammars/belle_sdp.g:364:2: {...}? rtcp_fb_attribute_name
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(sli))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(sli)";
                    EXCEPTION->ruleName	 = (void *)"rtcp_fb_sli_param";


            }

            FOLLOWPUSH(FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_sli_param2083);
            rtcp_fb_attribute_name191=rtcp_fb_attribute_name(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulertcp_fb_sli_paramEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_attribute_name191.tree);

            if ( BACKTRACKING==0 )
            {

                		belle_sdp_rtcp_fb_attribute_set_param((SCOPE_TOP(rtcp_fb_attribute))->current,BELLE_SDP_RTCP_FB_SLI);
                	
            }


        }

    }

    // This is where rules clean up and exit
    //
    goto rulertcp_fb_sli_paramEx; /* Prevent compiler warnings */
    rulertcp_fb_sli_paramEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start rtcp_fb_rpsi_param
 * ../grammars/belle_sdp.g:368:1: rtcp_fb_rpsi_param :{...}? rtcp_fb_attribute_name ;
 */
static belle_sdpParser_rtcp_fb_rpsi_param_return
rtcp_fb_rpsi_param(pbelle_sdpParser ctx)
{
    belle_sdpParser_rtcp_fb_rpsi_param_return retval;


    pANTLR3_BASE_TREE root_0;

    belle_sdpParser_rtcp_fb_attribute_name_return rtcp_fb_attribute_name192;
    #undef	RETURN_TYPE_rtcp_fb_attribute_name192
    #define	RETURN_TYPE_rtcp_fb_attribute_name192 belle_sdpParser_rtcp_fb_attribute_name_return


    /* Initialize rule variables
     */

    root_0 = NULL;

    rtcp_fb_attribute_name192.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;




    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:368:19: ({...}? rtcp_fb_attribute_name )
        // ../grammars/belle_sdp.g:369:2: {...}? rtcp_fb_attribute_name
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(rpsi))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(rpsi)";
                    EXCEPTION->ruleName	 = (void *)"rtcp_fb_rpsi_param";


            }

            FOLLOWPUSH(FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_rpsi_param2097);
            rtcp_fb_attribute_name192=rtcp_fb_attribute_name(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulertcp_fb_rpsi_paramEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_attribute_name192.tree);

            if ( BACKTRACKING==0 )
            {

                		belle_sdp_rtcp_fb_attribute_set_param((SCOPE_TOP(rtcp_fb_attribute))->current,BELLE_SDP_RTCP_FB_RPSI);
                	
            }


        }

    }

    // This is where rules clean up and exit
    //
    goto rulertcp_fb_rpsi_paramEx; /* Prevent compiler warnings */
    rulertcp_fb_rpsi_paramEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start rtcp_fb_app_param
 * ../grammars/belle_sdp.g:373:1: rtcp_fb_app_param :{...}? rtcp_fb_attribute_name ( SPACE byte_string ) ;
 */
static belle_sdpParser_rtcp_fb_app_param_return
rtcp_fb_app_param(pbelle_sdpParser ctx)
{
    belle_sdpParser_rtcp_fb_app_param_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    SPACE194;
    belle_sdpParser_rtcp_fb_attribute_name_return rtcp_fb_attribute_name193;
    #undef	RETURN_TYPE_rtcp_fb_attribute_name193
    #define	RETURN_TYPE_rtcp_fb_attribute_name193 belle_sdpParser_rtcp_fb_attribute_name_return

    belle_sdpParser_byte_string_return byte_string195;
    #undef	RETURN_TYPE_byte_string195
    #define	RETURN_TYPE_byte_string195 belle_sdpParser_byte_string_return

    pANTLR3_BASE_TREE SPACE194_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    SPACE194       = NULL;
    rtcp_fb_attribute_name193.tree = NULL;

    byte_string195.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    SPACE194_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:373:18: ({...}? rtcp_fb_attribute_name ( SPACE byte_string ) )
        // ../grammars/belle_sdp.g:374:2: {...}? rtcp_fb_attribute_name ( SPACE byte_string )
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(app))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(app)";
                    EXCEPTION->ruleName	 = (void *)"rtcp_fb_app_param";


            }

            FOLLOWPUSH(FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_app_param2111);
            rtcp_fb_attribute_name193=rtcp_fb_attribute_name(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulertcp_fb_app_paramEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_attribute_name193.tree);

            // ../grammars/belle_sdp.g:374:52: ( SPACE byte_string )
            // ../grammars/belle_sdp.g:374:53: SPACE byte_string
            {
                SPACE194 = (pANTLR3_COMMON_TOKEN) MATCHT(SPACE, &FOLLOW_SPACE_in_rtcp_fb_app_param2116);
                if  (HASEXCEPTION())
                {
                    goto rulertcp_fb_app_paramEx;
                }
                if (HASFAILED())
                {
                    return retval;
                }

                if ( BACKTRACKING==0 ) {
                SPACE194_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, SPACE194));
                ADAPTOR->addChild(ADAPTOR, root_0, SPACE194_tree);
                }

                FOLLOWPUSH(FOLLOW_byte_string_in_rtcp_fb_app_param2118);
                byte_string195=byte_string(ctx);

                FOLLOWPOP();
                if  (HASEXCEPTION())
                {
                    goto rulertcp_fb_app_paramEx;
                }
                if (HASFAILED())
                {
                    return retval;
                }

                if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, byte_string195.tree);

            }


            if ( BACKTRACKING==0 )
            {

                		belle_sdp_rtcp_fb_attribute_set_param((SCOPE_TOP(rtcp_fb_attribute))->current,BELLE_SDP_RTCP_FB_APP);
                	
            }


        }

    }

    // This is where rules clean up and exit
    //
    goto rulertcp_fb_app_paramEx; /* Prevent compiler warnings */
    rulertcp_fb_app_paramEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start rtcp_fb_ccm_param
 * ../grammars/belle_sdp.g:378:1: rtcp_fb_ccm_param : ( ( rtcp_fb_fir_param )=> rtcp_fb_fir_param | ( rtcp_fb_tmmbr_param )=> rtcp_fb_tmmbr_param | ( rtcp_fb_token_param )=> rtcp_fb_token_param );
 */
static belle_sdpParser_rtcp_fb_ccm_param_return
rtcp_fb_ccm_param(pbelle_sdpParser ctx)
{
    belle_sdpParser_rtcp_fb_ccm_param_return retval;


    pANTLR3_BASE_TREE root_0;

    belle_sdpParser_rtcp_fb_fir_param_return rtcp_fb_fir_param196;
    #undef	RETURN_TYPE_rtcp_fb_fir_param196
    #define	RETURN_TYPE_rtcp_fb_fir_param196 belle_sdpParser_rtcp_fb_fir_param_return

    belle_sdpParser_rtcp_fb_tmmbr_param_return rtcp_fb_tmmbr_param197;
    #undef	RETURN_TYPE_rtcp_fb_tmmbr_param197
    #define	RETURN_TYPE_rtcp_fb_tmmbr_param197 belle_sdpParser_rtcp_fb_tmmbr_param_return

    belle_sdpParser_rtcp_fb_token_param_return rtcp_fb_token_param198;
    #undef	RETURN_TYPE_rtcp_fb_token_param198
    #define	RETURN_TYPE_rtcp_fb_token_param198 belle_sdpParser_rtcp_fb_token_param_return


    /* Initialize rule variables
     */

    root_0 = NULL;

    rtcp_fb_fir_param196.tree = NULL;

    rtcp_fb_tmmbr_param197.tree = NULL;

    rtcp_fb_token_param198.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;




    retval.tree  = NULL;

    {
        {
            //  ../grammars/belle_sdp.g:378:18: ( ( rtcp_fb_fir_param )=> rtcp_fb_fir_param | ( rtcp_fb_tmmbr_param )=> rtcp_fb_tmmbr_param | ( rtcp_fb_token_param )=> rtcp_fb_token_param )

            ANTLR3_UINT32 alt39;

            alt39=3;

            switch ( LA(1) )
            {
            case COMMON_CHAR:
            case HEX_CHAR:
            	{
            		{
            		    int LA39_1 = LA(2);
            		    if ( (( (( ((IS_TOKEN(fir))) && ((IS_TOKEN(fir))) )) && (synpred22_belle_sdp(ctx)) )))
            		    {
            		        alt39=1;
            		    }
            		    else if ( (( (( (synpred23_belle_sdp(ctx)) && (synpred23_belle_sdp(ctx)) )) && ((IS_TOKEN(tmmbr))) )))
            		    {
            		        alt39=2;
            		    }
            		    else if ( (synpred24_belle_sdp(ctx)))
            		    {
            		        alt39=3;
            		    }
            		    else
            		    {
            		        if (BACKTRACKING>0)
            		        {
            		            FAILEDFLAG = ANTLR3_TRUE;
            		            return retval;
            		        }


            		        CONSTRUCTEX();
            		        EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
            		        EXCEPTION->message      = (void *)"";
            		        EXCEPTION->decisionNum  = 39;
            		        EXCEPTION->state        = 1;


            		        goto rulertcp_fb_ccm_paramEx;

            		    }
            		}
            	}
                break;
            case DASH:
            	{
            		{
            		    int LA39_2 = LA(2);
            		    if ( (( (( ((IS_TOKEN(fir))) && ((IS_TOKEN(fir))) )) && (synpred22_belle_sdp(ctx)) )))
            		    {
            		        alt39=1;
            		    }
            		    else if ( (( (( (synpred23_belle_sdp(ctx)) && (synpred23_belle_sdp(ctx)) )) && ((IS_TOKEN(tmmbr))) )))
            		    {
            		        alt39=2;
            		    }
            		    else if ( (synpred24_belle_sdp(ctx)))
            		    {
            		        alt39=3;
            		    }
            		    else
            		    {
            		        if (BACKTRACKING>0)
            		        {
            		            FAILEDFLAG = ANTLR3_TRUE;
            		            return retval;
            		        }


            		        CONSTRUCTEX();
            		        EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
            		        EXCEPTION->message      = (void *)"";
            		        EXCEPTION->decisionNum  = 39;
            		        EXCEPTION->state        = 2;


            		        goto rulertcp_fb_ccm_paramEx;

            		    }
            		}
            	}
                break;

            default:
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                CONSTRUCTEX();
                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
                EXCEPTION->message      = (void *)"";
                EXCEPTION->decisionNum  = 39;
                EXCEPTION->state        = 0;


                goto rulertcp_fb_ccm_paramEx;

            }

            switch (alt39)
            {
        	case 1:
        	    // ../grammars/belle_sdp.g:379:2: ( rtcp_fb_fir_param )=> rtcp_fb_fir_param
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        FOLLOWPUSH(FOLLOW_rtcp_fb_fir_param_in_rtcp_fb_ccm_param2133);
        	        rtcp_fb_fir_param196=rtcp_fb_fir_param(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulertcp_fb_ccm_paramEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_fir_param196.tree);

        	    }
        	    break;
        	case 2:
        	    // ../grammars/belle_sdp.g:380:3: ( rtcp_fb_tmmbr_param )=> rtcp_fb_tmmbr_param
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        FOLLOWPUSH(FOLLOW_rtcp_fb_tmmbr_param_in_rtcp_fb_ccm_param2141);
        	        rtcp_fb_tmmbr_param197=rtcp_fb_tmmbr_param(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulertcp_fb_ccm_paramEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_tmmbr_param197.tree);

        	    }
        	    break;
        	case 3:
        	    // ../grammars/belle_sdp.g:381:3: ( rtcp_fb_token_param )=> rtcp_fb_token_param
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        FOLLOWPUSH(FOLLOW_rtcp_fb_token_param_in_rtcp_fb_ccm_param2149);
        	        rtcp_fb_token_param198=rtcp_fb_token_param(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulertcp_fb_ccm_paramEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_token_param198.tree);

        	    }
        	    break;

            }
        }
    }

    // This is where rules clean up and exit
    //
    goto rulertcp_fb_ccm_paramEx; /* Prevent compiler warnings */
    rulertcp_fb_ccm_paramEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start rtcp_fb_fir_param
 * ../grammars/belle_sdp.g:383:1: rtcp_fb_fir_param :{...}? rtcp_fb_attribute_name ;
 */
static belle_sdpParser_rtcp_fb_fir_param_return
rtcp_fb_fir_param(pbelle_sdpParser ctx)
{
    belle_sdpParser_rtcp_fb_fir_param_return retval;


    pANTLR3_BASE_TREE root_0;

    belle_sdpParser_rtcp_fb_attribute_name_return rtcp_fb_attribute_name199;
    #undef	RETURN_TYPE_rtcp_fb_attribute_name199
    #define	RETURN_TYPE_rtcp_fb_attribute_name199 belle_sdpParser_rtcp_fb_attribute_name_return


    /* Initialize rule variables
     */

    root_0 = NULL;

    rtcp_fb_attribute_name199.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;




    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:383:18: ({...}? rtcp_fb_attribute_name )
        // ../grammars/belle_sdp.g:384:2: {...}? rtcp_fb_attribute_name
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(fir))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(fir)";
                    EXCEPTION->ruleName	 = (void *)"rtcp_fb_fir_param";


            }

            FOLLOWPUSH(FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_fir_param2159);
            rtcp_fb_attribute_name199=rtcp_fb_attribute_name(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulertcp_fb_fir_paramEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_attribute_name199.tree);

            if ( BACKTRACKING==0 )
            {

                		belle_sdp_rtcp_fb_attribute_set_param((SCOPE_TOP(rtcp_fb_attribute))->current,BELLE_SDP_RTCP_FB_FIR);
                	
            }


        }

    }

    // This is where rules clean up and exit
    //
    goto rulertcp_fb_fir_paramEx; /* Prevent compiler warnings */
    rulertcp_fb_fir_paramEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start rtcp_fb_tmmbr_param
 * ../grammars/belle_sdp.g:388:1: rtcp_fb_tmmbr_param :{...}? rtcp_fb_attribute_name ( SPACE rtcp_fb_tmmbr_smaxpr_param )? ;
 */
static belle_sdpParser_rtcp_fb_tmmbr_param_return
rtcp_fb_tmmbr_param(pbelle_sdpParser ctx)
{
    belle_sdpParser_rtcp_fb_tmmbr_param_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    SPACE201;
    belle_sdpParser_rtcp_fb_attribute_name_return rtcp_fb_attribute_name200;
    #undef	RETURN_TYPE_rtcp_fb_attribute_name200
    #define	RETURN_TYPE_rtcp_fb_attribute_name200 belle_sdpParser_rtcp_fb_attribute_name_return

    belle_sdpParser_rtcp_fb_tmmbr_smaxpr_param_return rtcp_fb_tmmbr_smaxpr_param202;
    #undef	RETURN_TYPE_rtcp_fb_tmmbr_smaxpr_param202
    #define	RETURN_TYPE_rtcp_fb_tmmbr_smaxpr_param202 belle_sdpParser_rtcp_fb_tmmbr_smaxpr_param_return

    pANTLR3_BASE_TREE SPACE201_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    SPACE201       = NULL;
    rtcp_fb_attribute_name200.tree = NULL;

    rtcp_fb_tmmbr_smaxpr_param202.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    SPACE201_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:388:20: ({...}? rtcp_fb_attribute_name ( SPACE rtcp_fb_tmmbr_smaxpr_param )? )
        // ../grammars/belle_sdp.g:389:2: {...}? rtcp_fb_attribute_name ( SPACE rtcp_fb_tmmbr_smaxpr_param )?
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(tmmbr))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(tmmbr)";
                    EXCEPTION->ruleName	 = (void *)"rtcp_fb_tmmbr_param";


            }

            FOLLOWPUSH(FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_tmmbr_param2173);
            rtcp_fb_attribute_name200=rtcp_fb_attribute_name(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulertcp_fb_tmmbr_paramEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_attribute_name200.tree);

            // ../grammars/belle_sdp.g:389:56: ( SPACE rtcp_fb_tmmbr_smaxpr_param )?
            {
                int alt40=2;
                switch ( LA(1) )
                {
                    case SPACE:
                    	{
                    		alt40=1;
                    	}
                        break;
                }

                switch (alt40)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:389:57: SPACE rtcp_fb_tmmbr_smaxpr_param
            	    {
            	        SPACE201 = (pANTLR3_COMMON_TOKEN) MATCHT(SPACE, &FOLLOW_SPACE_in_rtcp_fb_tmmbr_param2178);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulertcp_fb_tmmbr_paramEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        SPACE201_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, SPACE201));
            	        ADAPTOR->addChild(ADAPTOR, root_0, SPACE201_tree);
            	        }

            	        FOLLOWPUSH(FOLLOW_rtcp_fb_tmmbr_smaxpr_param_in_rtcp_fb_tmmbr_param2180);
            	        rtcp_fb_tmmbr_smaxpr_param202=rtcp_fb_tmmbr_smaxpr_param(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulertcp_fb_tmmbr_paramEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_tmmbr_smaxpr_param202.tree);

            	    }
            	    break;

                }
            }

            if ( BACKTRACKING==0 )
            {

                		belle_sdp_rtcp_fb_attribute_set_param((SCOPE_TOP(rtcp_fb_attribute))->current,BELLE_SDP_RTCP_FB_TMMBR);
                	
            }


        }

    }

    // This is where rules clean up and exit
    //
    goto rulertcp_fb_tmmbr_paramEx; /* Prevent compiler warnings */
    rulertcp_fb_tmmbr_paramEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start rtcp_fb_tmmbr_smaxpr_param
 * ../grammars/belle_sdp.g:393:1: rtcp_fb_tmmbr_smaxpr_param :{...}? rtcp_fb_attribute_name EQUAL val= rtcp_fb_tmmbr_smaxpr ;
 */
static belle_sdpParser_rtcp_fb_tmmbr_smaxpr_param_return
rtcp_fb_tmmbr_smaxpr_param(pbelle_sdpParser ctx)
{
    belle_sdpParser_rtcp_fb_tmmbr_smaxpr_param_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    EQUAL204;
    belle_sdpParser_rtcp_fb_tmmbr_smaxpr_return val;
    #undef	RETURN_TYPE_val
    #define	RETURN_TYPE_val belle_sdpParser_rtcp_fb_tmmbr_smaxpr_return

    belle_sdpParser_rtcp_fb_attribute_name_return rtcp_fb_attribute_name203;
    #undef	RETURN_TYPE_rtcp_fb_attribute_name203
    #define	RETURN_TYPE_rtcp_fb_attribute_name203 belle_sdpParser_rtcp_fb_attribute_name_return

    pANTLR3_BASE_TREE EQUAL204_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    EQUAL204       = NULL;
    val.tree = NULL;

    rtcp_fb_attribute_name203.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    EQUAL204_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:393:27: ({...}? rtcp_fb_attribute_name EQUAL val= rtcp_fb_tmmbr_smaxpr )
        // ../grammars/belle_sdp.g:394:2: {...}? rtcp_fb_attribute_name EQUAL val= rtcp_fb_tmmbr_smaxpr
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(smaxpr))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(smaxpr)";
                    EXCEPTION->ruleName	 = (void *)"rtcp_fb_tmmbr_smaxpr_param";


            }

            FOLLOWPUSH(FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_tmmbr_smaxpr_param2194);
            rtcp_fb_attribute_name203=rtcp_fb_attribute_name(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulertcp_fb_tmmbr_smaxpr_paramEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_attribute_name203.tree);

            EQUAL204 = (pANTLR3_COMMON_TOKEN) MATCHT(EQUAL, &FOLLOW_EQUAL_in_rtcp_fb_tmmbr_smaxpr_param2198);
            if  (HASEXCEPTION())
            {
                goto rulertcp_fb_tmmbr_smaxpr_paramEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) {
            EQUAL204_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, EQUAL204));
            ADAPTOR->addChild(ADAPTOR, root_0, EQUAL204_tree);
            }

            FOLLOWPUSH(FOLLOW_rtcp_fb_tmmbr_smaxpr_in_rtcp_fb_tmmbr_smaxpr_param2202);
            val=rtcp_fb_tmmbr_smaxpr(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulertcp_fb_tmmbr_smaxpr_paramEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, val.tree);

            if ( BACKTRACKING==0 )
            {

                		if (val.tree) belle_sdp_rtcp_fb_attribute_set_smaxpr((SCOPE_TOP(rtcp_fb_attribute))->current,atoi((const char*)
                (STRSTREAM->toStringTT(STRSTREAM, val.start, val.stop))
                ->chars));
                	
            }


        }

    }

    // This is where rules clean up and exit
    //
    goto rulertcp_fb_tmmbr_smaxpr_paramEx; /* Prevent compiler warnings */
    rulertcp_fb_tmmbr_smaxpr_paramEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start rtcp_fb_tmmbr_smaxpr
 * ../grammars/belle_sdp.g:398:1: rtcp_fb_tmmbr_smaxpr : ( DIGIT )+ ;
 */
static belle_sdpParser_rtcp_fb_tmmbr_smaxpr_return
rtcp_fb_tmmbr_smaxpr(pbelle_sdpParser ctx)
{
    belle_sdpParser_rtcp_fb_tmmbr_smaxpr_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    DIGIT205;

    pANTLR3_BASE_TREE DIGIT205_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    DIGIT205       = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    DIGIT205_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:398:22: ( ( DIGIT )+ )
        // ../grammars/belle_sdp.g:398:24: ( DIGIT )+
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            // ../grammars/belle_sdp.g:398:24: ( DIGIT )+
            {
                int cnt41=0;

                for (;;)
                {
                    int alt41=2;
            	switch ( LA(1) )
            	{
            	case DIGIT:
            		{
            			alt41=1;
            		}
            	    break;

            	}

            	switch (alt41)
            	{
            	    case 1:
            	        // ../grammars/belle_sdp.g:398:24: DIGIT
            	        {
            	            DIGIT205 = (pANTLR3_COMMON_TOKEN) MATCHT(DIGIT, &FOLLOW_DIGIT_in_rtcp_fb_tmmbr_smaxpr2212);
            	            if  (HASEXCEPTION())
            	            {
            	                goto rulertcp_fb_tmmbr_smaxprEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) {
            	            DIGIT205_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DIGIT205));
            	            ADAPTOR->addChild(ADAPTOR, root_0, DIGIT205_tree);
            	            }

            	        }
            	        break;

            	    default:

            		if ( cnt41 >= 1 )
            		{
            		    goto loop41;
            		}
            		if (BACKTRACKING>0)
            		{
            		    FAILEDFLAG = ANTLR3_TRUE;
            		    return retval;
            		}

            		/* mismatchedSetEx()
            		 */
            		CONSTRUCTEX();
            		EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
            		EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;


            		goto rulertcp_fb_tmmbr_smaxprEx;
            	}
            	cnt41++;
                }
                loop41: ;	/* Jump to here if this rule does not match */
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto rulertcp_fb_tmmbr_smaxprEx; /* Prevent compiler warnings */
    rulertcp_fb_tmmbr_smaxprEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start rtcp_fb_token_param
 * ../grammars/belle_sdp.g:400:1: rtcp_fb_token_param : rtcp_fb_attribute_name ( SPACE byte_string )? ;
 */
static belle_sdpParser_rtcp_fb_token_param_return
rtcp_fb_token_param(pbelle_sdpParser ctx)
{
    belle_sdpParser_rtcp_fb_token_param_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    SPACE207;
    belle_sdpParser_rtcp_fb_attribute_name_return rtcp_fb_attribute_name206;
    #undef	RETURN_TYPE_rtcp_fb_attribute_name206
    #define	RETURN_TYPE_rtcp_fb_attribute_name206 belle_sdpParser_rtcp_fb_attribute_name_return

    belle_sdpParser_byte_string_return byte_string208;
    #undef	RETURN_TYPE_byte_string208
    #define	RETURN_TYPE_byte_string208 belle_sdpParser_byte_string_return

    pANTLR3_BASE_TREE SPACE207_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    SPACE207       = NULL;
    rtcp_fb_attribute_name206.tree = NULL;

    byte_string208.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    SPACE207_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:400:20: ( rtcp_fb_attribute_name ( SPACE byte_string )? )
        // ../grammars/belle_sdp.g:401:2: rtcp_fb_attribute_name ( SPACE byte_string )?
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            FOLLOWPUSH(FOLLOW_rtcp_fb_attribute_name_in_rtcp_fb_token_param2221);
            rtcp_fb_attribute_name206=rtcp_fb_attribute_name(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulertcp_fb_token_paramEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, rtcp_fb_attribute_name206.tree);

            // ../grammars/belle_sdp.g:401:25: ( SPACE byte_string )?
            {
                int alt42=2;
                switch ( LA(1) )
                {
                    case SPACE:
                    	{
                    		alt42=1;
                    	}
                        break;
                }

                switch (alt42)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:401:26: SPACE byte_string
            	    {
            	        SPACE207 = (pANTLR3_COMMON_TOKEN) MATCHT(SPACE, &FOLLOW_SPACE_in_rtcp_fb_token_param2224);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulertcp_fb_token_paramEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        SPACE207_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, SPACE207));
            	        ADAPTOR->addChild(ADAPTOR, root_0, SPACE207_tree);
            	        }

            	        FOLLOWPUSH(FOLLOW_byte_string_in_rtcp_fb_token_param2226);
            	        byte_string208=byte_string(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulertcp_fb_token_paramEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, byte_string208.tree);

            	    }
            	    break;

                }
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto rulertcp_fb_token_paramEx; /* Prevent compiler warnings */
    rulertcp_fb_token_paramEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start media_description
 * ../grammars/belle_sdp.g:403:1: media_description returns [belle_sdp_media_description_t* ret] : media CR LF ( info CR LF )? ( connection CR LF )? ( bandwidth CR LF )* ( key_field CR LF )? ( attribute CR LF )* ;
 */
static belle_sdpParser_media_description_return
media_description(pbelle_sdpParser ctx)
{
    belle_sdpParser_media_description_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    CR210;
    pANTLR3_COMMON_TOKEN    LF211;
    pANTLR3_COMMON_TOKEN    CR213;
    pANTLR3_COMMON_TOKEN    LF214;
    pANTLR3_COMMON_TOKEN    CR216;
    pANTLR3_COMMON_TOKEN    LF217;
    pANTLR3_COMMON_TOKEN    CR219;
    pANTLR3_COMMON_TOKEN    LF220;
    pANTLR3_COMMON_TOKEN    CR222;
    pANTLR3_COMMON_TOKEN    LF223;
    pANTLR3_COMMON_TOKEN    CR225;
    pANTLR3_COMMON_TOKEN    LF226;
    belle_sdpParser_media_return media209;
    #undef	RETURN_TYPE_media209
    #define	RETURN_TYPE_media209 belle_sdpParser_media_return

    belle_sdpParser_info_return info212;
    #undef	RETURN_TYPE_info212
    #define	RETURN_TYPE_info212 belle_sdpParser_info_return

    belle_sdpParser_connection_return connection215;
    #undef	RETURN_TYPE_connection215
    #define	RETURN_TYPE_connection215 belle_sdpParser_connection_return

    belle_sdpParser_bandwidth_return bandwidth218;
    #undef	RETURN_TYPE_bandwidth218
    #define	RETURN_TYPE_bandwidth218 belle_sdpParser_bandwidth_return

    belle_sdpParser_key_field_return key_field221;
    #undef	RETURN_TYPE_key_field221
    #define	RETURN_TYPE_key_field221 belle_sdpParser_key_field_return

    belle_sdpParser_attribute_return attribute224;
    #undef	RETURN_TYPE_attribute224
    #define	RETURN_TYPE_attribute224 belle_sdpParser_attribute_return

    pANTLR3_BASE_TREE CR210_tree;
    pANTLR3_BASE_TREE LF211_tree;
    pANTLR3_BASE_TREE CR213_tree;
    pANTLR3_BASE_TREE LF214_tree;
    pANTLR3_BASE_TREE CR216_tree;
    pANTLR3_BASE_TREE LF217_tree;
    pANTLR3_BASE_TREE CR219_tree;
    pANTLR3_BASE_TREE LF220_tree;
    pANTLR3_BASE_TREE CR222_tree;
    pANTLR3_BASE_TREE LF223_tree;
    pANTLR3_BASE_TREE CR225_tree;
    pANTLR3_BASE_TREE LF226_tree;

    /* Initialize rule variables
     */
    ctx->pbelle_sdpParser_media_descriptionTop = pbelle_sdpParser_media_descriptionPush(ctx);
    root_0 = NULL;

    (SCOPE_TOP(media_description))->current= belle_sdp_media_description_new(); 
    retval.ret=(SCOPE_TOP(media_description))->current;
     
    CR210       = NULL;
    LF211       = NULL;
    CR213       = NULL;
    LF214       = NULL;
    CR216       = NULL;
    LF217       = NULL;
    CR219       = NULL;
    LF220       = NULL;
    CR222       = NULL;
    LF223       = NULL;
    CR225       = NULL;
    LF226       = NULL;
    media209.tree = NULL;

    info212.tree = NULL;

    connection215.tree = NULL;

    bandwidth218.tree = NULL;

    key_field221.tree = NULL;

    attribute224.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    CR210_tree   = NULL;
    LF211_tree   = NULL;
    CR213_tree   = NULL;
    LF214_tree   = NULL;
    CR216_tree   = NULL;
    LF217_tree   = NULL;
    CR219_tree   = NULL;
    LF220_tree   = NULL;
    CR222_tree   = NULL;
    LF223_tree   = NULL;
    CR225_tree   = NULL;
    LF226_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:406:22: ( media CR LF ( info CR LF )? ( connection CR LF )? ( bandwidth CR LF )* ( key_field CR LF )? ( attribute CR LF )* )
        // ../grammars/belle_sdp.g:406:22: media CR LF ( info CR LF )? ( connection CR LF )? ( bandwidth CR LF )* ( key_field CR LF )? ( attribute CR LF )*
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            FOLLOWPUSH(FOLLOW_media_in_media_description2269);
            media209=media(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulemedia_descriptionEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_media_descriptionPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, media209.tree);

            CR210 = (pANTLR3_COMMON_TOKEN) MATCHT(CR, &FOLLOW_CR_in_media_description2271);
            if  (HASEXCEPTION())
            {
                goto rulemedia_descriptionEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_media_descriptionPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) {
            CR210_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, CR210));
            ADAPTOR->addChild(ADAPTOR, root_0, CR210_tree);
            }

            LF211 = (pANTLR3_COMMON_TOKEN) MATCHT(LF, &FOLLOW_LF_in_media_description2273);
            if  (HASEXCEPTION())
            {
                goto rulemedia_descriptionEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_media_descriptionPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) {
            LF211_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, LF211));
            ADAPTOR->addChild(ADAPTOR, root_0, LF211_tree);
            }

            if ( BACKTRACKING==0 )
            {
                belle_sdp_media_description_set_media((SCOPE_TOP(media_description))->current,
                media209.ret
                );
            }


            // ../grammars/belle_sdp.g:407:21: ( info CR LF )?
            {
                int alt43=2;
                alt43 = cdfa43.predict(ctx, RECOGNIZER, ISTREAM, &cdfa43);
                if  (HASEXCEPTION())
                {
                    goto rulemedia_descriptionEx;
                }
                if (HASFAILED())
                {
                    pbelle_sdpParser_media_descriptionPop(ctx);

                    return retval;
                }

                switch (alt43)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:407:22: info CR LF
            	    {
            	        FOLLOWPUSH(FOLLOW_info_in_media_description2299);
            	        info212=info(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulemedia_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_media_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, info212.tree);

            	        if ( BACKTRACKING==0 )
            	        {
            	            belle_sdp_media_description_set_info((SCOPE_TOP(media_description))->current,
            	            info212.ret
            	            );
            	        }


            	        CR213 = (pANTLR3_COMMON_TOKEN) MATCHT(CR, &FOLLOW_CR_in_media_description2303);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulemedia_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_media_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        CR213_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, CR213));
            	        ADAPTOR->addChild(ADAPTOR, root_0, CR213_tree);
            	        }

            	        LF214 = (pANTLR3_COMMON_TOKEN) MATCHT(LF, &FOLLOW_LF_in_media_description2305);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulemedia_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_media_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        LF214_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, LF214));
            	        ADAPTOR->addChild(ADAPTOR, root_0, LF214_tree);
            	        }

            	    }
            	    break;

                }
            }

            // ../grammars/belle_sdp.g:408:22: ( connection CR LF )?
            {
                int alt44=2;
                alt44 = cdfa44.predict(ctx, RECOGNIZER, ISTREAM, &cdfa44);
                if  (HASEXCEPTION())
                {
                    goto rulemedia_descriptionEx;
                }
                if (HASFAILED())
                {
                    pbelle_sdpParser_media_descriptionPop(ctx);

                    return retval;
                }

                switch (alt44)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:408:23: connection CR LF
            	    {
            	        FOLLOWPUSH(FOLLOW_connection_in_media_description2331);
            	        connection215=connection(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulemedia_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_media_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, connection215.tree);

            	        if ( BACKTRACKING==0 )
            	        {
            	             belle_sdp_media_description_set_connection((SCOPE_TOP(media_description))->current,
            	            connection215.ret
            	            );
            	        }


            	        CR216 = (pANTLR3_COMMON_TOKEN) MATCHT(CR, &FOLLOW_CR_in_media_description2335);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulemedia_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_media_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        CR216_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, CR216));
            	        ADAPTOR->addChild(ADAPTOR, root_0, CR216_tree);
            	        }

            	        LF217 = (pANTLR3_COMMON_TOKEN) MATCHT(LF, &FOLLOW_LF_in_media_description2337);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulemedia_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_media_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        LF217_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, LF217));
            	        ADAPTOR->addChild(ADAPTOR, root_0, LF217_tree);
            	        }

            	    }
            	    break;

                }
            }

            // ../grammars/belle_sdp.g:409:22: ( bandwidth CR LF )*

            for (;;)
            {
                int alt45=2;
                alt45 = cdfa45.predict(ctx, RECOGNIZER, ISTREAM, &cdfa45);
                if  (HASEXCEPTION())
                {
                    goto rulemedia_descriptionEx;
                }
                if (HASFAILED())
                {
                    pbelle_sdpParser_media_descriptionPop(ctx);

                    return retval;
                }

                switch (alt45)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:409:23: bandwidth CR LF
            	    {
            	        FOLLOWPUSH(FOLLOW_bandwidth_in_media_description2363);
            	        bandwidth218=bandwidth(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulemedia_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_media_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, bandwidth218.tree);

            	        if ( BACKTRACKING==0 )
            	        {
            	            belle_sdp_media_description_add_bandwidth((SCOPE_TOP(media_description))->current,
            	            bandwidth218.ret
            	            );
            	        }


            	        CR219 = (pANTLR3_COMMON_TOKEN) MATCHT(CR, &FOLLOW_CR_in_media_description2367);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulemedia_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_media_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        CR219_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, CR219));
            	        ADAPTOR->addChild(ADAPTOR, root_0, CR219_tree);
            	        }

            	        LF220 = (pANTLR3_COMMON_TOKEN) MATCHT(LF, &FOLLOW_LF_in_media_description2369);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulemedia_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_media_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        LF220_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, LF220));
            	        ADAPTOR->addChild(ADAPTOR, root_0, LF220_tree);
            	        }

            	    }
            	    break;

            	default:
            	    goto loop45;	/* break out of the loop */
            	    break;
                }
            }
            loop45: ; /* Jump out to here if this rule does not match */


            // ../grammars/belle_sdp.g:410:22: ( key_field CR LF )?
            {
                int alt46=2;
                alt46 = cdfa46.predict(ctx, RECOGNIZER, ISTREAM, &cdfa46);
                if  (HASEXCEPTION())
                {
                    goto rulemedia_descriptionEx;
                }
                if (HASFAILED())
                {
                    pbelle_sdpParser_media_descriptionPop(ctx);

                    return retval;
                }

                switch (alt46)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:410:23: key_field CR LF
            	    {
            	        FOLLOWPUSH(FOLLOW_key_field_in_media_description2395);
            	        key_field221=key_field(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulemedia_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_media_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, key_field221.tree);

            	        CR222 = (pANTLR3_COMMON_TOKEN) MATCHT(CR, &FOLLOW_CR_in_media_description2397);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulemedia_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_media_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        CR222_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, CR222));
            	        ADAPTOR->addChild(ADAPTOR, root_0, CR222_tree);
            	        }

            	        LF223 = (pANTLR3_COMMON_TOKEN) MATCHT(LF, &FOLLOW_LF_in_media_description2399);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulemedia_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_media_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        LF223_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, LF223));
            	        ADAPTOR->addChild(ADAPTOR, root_0, LF223_tree);
            	        }

            	    }
            	    break;

                }
            }

            // ../grammars/belle_sdp.g:411:22: ( attribute CR LF )*

            for (;;)
            {
                int alt47=2;
                alt47 = cdfa47.predict(ctx, RECOGNIZER, ISTREAM, &cdfa47);
                if  (HASEXCEPTION())
                {
                    goto rulemedia_descriptionEx;
                }
                if (HASFAILED())
                {
                    pbelle_sdpParser_media_descriptionPop(ctx);

                    return retval;
                }

                switch (alt47)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:411:23: attribute CR LF
            	    {
            	        FOLLOWPUSH(FOLLOW_attribute_in_media_description2425);
            	        attribute224=attribute(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulemedia_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_media_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, attribute224.tree);

            	        if ( BACKTRACKING==0 )
            	        {
            	            if (attribute224.ret
            	            )belle_sdp_media_description_add_attribute((SCOPE_TOP(media_description))->current,
            	            attribute224.ret
            	            );
            	        }


            	        CR225 = (pANTLR3_COMMON_TOKEN) MATCHT(CR, &FOLLOW_CR_in_media_description2429);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulemedia_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_media_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        CR225_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, CR225));
            	        ADAPTOR->addChild(ADAPTOR, root_0, CR225_tree);
            	        }

            	        LF226 = (pANTLR3_COMMON_TOKEN) MATCHT(LF, &FOLLOW_LF_in_media_description2431);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulemedia_descriptionEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_media_descriptionPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        LF226_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, LF226));
            	        ADAPTOR->addChild(ADAPTOR, root_0, LF226_tree);
            	        }

            	    }
            	    break;

            	default:
            	    goto loop47;	/* break out of the loop */
            	    break;
                }
            }
            loop47: ; /* Jump out to here if this rule does not match */


        }

    }

    // This is where rules clean up and exit
    //
    goto rulemedia_descriptionEx; /* Prevent compiler warnings */
    rulemedia_descriptionEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }


    if	(HASEXCEPTION())
    {
	/* catch(decl,action)
	 */
	{

	    	ANTLR3_LOG_EXCEPTION();
	      belle_sip_object_unref(retval.ret
	    );
	      retval.ret=NULL;


	}


    }
    else
    {
    }
    pbelle_sdpParser_media_descriptionPop(ctx);

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

/**
 * $ANTLR start media
 * ../grammars/belle_sdp.g:419:1: media returns [belle_sdp_media_t* ret] :{...}? alpha_num EQUAL media_value SPACE port ( SLASH integer )? SPACE proto ( SPACE fmt )+ ;
 */
static belle_sdpParser_media_return
media(pbelle_sdpParser ctx)
{
    belle_sdpParser_media_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    EQUAL228;
    pANTLR3_COMMON_TOKEN    SPACE230;
    pANTLR3_COMMON_TOKEN    SLASH232;
    pANTLR3_COMMON_TOKEN    SPACE234;
    pANTLR3_COMMON_TOKEN    SPACE236;
    belle_sdpParser_alpha_num_return alpha_num227;
    #undef	RETURN_TYPE_alpha_num227
    #define	RETURN_TYPE_alpha_num227 belle_sdpParser_alpha_num_return

    belle_sdpParser_media_value_return media_value229;
    #undef	RETURN_TYPE_media_value229
    #define	RETURN_TYPE_media_value229 belle_sdpParser_media_value_return

    belle_sdpParser_port_return port231;
    #undef	RETURN_TYPE_port231
    #define	RETURN_TYPE_port231 belle_sdpParser_port_return

    belle_sdpParser_integer_return integer233;
    #undef	RETURN_TYPE_integer233
    #define	RETURN_TYPE_integer233 belle_sdpParser_integer_return

    belle_sdpParser_proto_return proto235;
    #undef	RETURN_TYPE_proto235
    #define	RETURN_TYPE_proto235 belle_sdpParser_proto_return

    belle_sdpParser_fmt_return fmt237;
    #undef	RETURN_TYPE_fmt237
    #define	RETURN_TYPE_fmt237 belle_sdpParser_fmt_return

    pANTLR3_BASE_TREE EQUAL228_tree;
    pANTLR3_BASE_TREE SPACE230_tree;
    pANTLR3_BASE_TREE SLASH232_tree;
    pANTLR3_BASE_TREE SPACE234_tree;
    pANTLR3_BASE_TREE SPACE236_tree;

    /* Initialize rule variables
     */
    ctx->pbelle_sdpParser_mediaTop = pbelle_sdpParser_mediaPush(ctx);
    root_0 = NULL;

    (SCOPE_TOP(media))->current= belle_sdp_media_new(); 
    retval.ret=(SCOPE_TOP(media))->current;
     
    EQUAL228       = NULL;
    SPACE230       = NULL;
    SLASH232       = NULL;
    SPACE234       = NULL;
    SPACE236       = NULL;
    alpha_num227.tree = NULL;

    media_value229.tree = NULL;

    port231.tree = NULL;

    integer233.tree = NULL;

    proto235.tree = NULL;

    fmt237.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    EQUAL228_tree   = NULL;
    SPACE230_tree   = NULL;
    SLASH232_tree   = NULL;
    SPACE234_tree   = NULL;
    SPACE236_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:422:11: ({...}? alpha_num EQUAL media_value SPACE port ( SLASH integer )? SPACE proto ( SPACE fmt )+ )
        // ../grammars/belle_sdp.g:422:11: {...}? alpha_num EQUAL media_value SPACE port ( SLASH integer )? SPACE proto ( SPACE fmt )+
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            if ( !((IS_TOKEN(m))) )
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    pbelle_sdpParser_mediaPop(ctx);

                    return retval;
                }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
                    EXCEPTION->message      = (void *)"IS_TOKEN(m)";
                    EXCEPTION->ruleName	 = (void *)"media";


            }

            FOLLOWPUSH(FOLLOW_alpha_num_in_media2469);
            alpha_num227=alpha_num(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulemediaEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_mediaPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num227.tree);

            EQUAL228 = (pANTLR3_COMMON_TOKEN) MATCHT(EQUAL, &FOLLOW_EQUAL_in_media2471);
            if  (HASEXCEPTION())
            {
                goto rulemediaEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_mediaPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) {
            EQUAL228_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, EQUAL228));
            ADAPTOR->addChild(ADAPTOR, root_0, EQUAL228_tree);
            }

            FOLLOWPUSH(FOLLOW_media_value_in_media2483);
            media_value229=media_value(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulemediaEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_mediaPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, media_value229.tree);

            if ( BACKTRACKING==0 )
            {
                belle_sdp_media_set_media_type((SCOPE_TOP(media))->current,(const char*)
                (STRSTREAM->toStringTT(STRSTREAM, media_value229.start, media_value229.stop))
                ->chars);
            }


            SPACE230 = (pANTLR3_COMMON_TOKEN) MATCHT(SPACE, &FOLLOW_SPACE_in_media2497);
            if  (HASEXCEPTION())
            {
                goto rulemediaEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_mediaPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) {
            SPACE230_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, SPACE230));
            ADAPTOR->addChild(ADAPTOR, root_0, SPACE230_tree);
            }

            FOLLOWPUSH(FOLLOW_port_in_media2499);
            port231=port(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulemediaEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_mediaPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, port231.tree);

            if ( BACKTRACKING==0 )
            {
                belle_sdp_media_set_media_port((SCOPE_TOP(media))->current,atoi((const char*)
                (STRSTREAM->toStringTT(STRSTREAM, port231.start, port231.stop))
                ->chars));
            }


            // ../grammars/belle_sdp.g:425:11: ( SLASH integer )?
            {
                int alt48=2;
                switch ( LA(1) )
                {
                    case SLASH:
                    	{
                    		alt48=1;
                    	}
                        break;
                }

                switch (alt48)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:425:12: SLASH integer
            	    {
            	        SLASH232 = (pANTLR3_COMMON_TOKEN) MATCHT(SLASH, &FOLLOW_SLASH_in_media2514);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulemediaEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_mediaPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        SLASH232_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, SLASH232));
            	        ADAPTOR->addChild(ADAPTOR, root_0, SLASH232_tree);
            	        }

            	        FOLLOWPUSH(FOLLOW_integer_in_media2516);
            	        integer233=integer(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulemediaEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_mediaPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, integer233.tree);

            	        if ( BACKTRACKING==0 )
            	        {
            	            belle_sdp_media_set_port_count((SCOPE_TOP(media))->current,atoi((const char*)
            	            (STRSTREAM->toStringTT(STRSTREAM, integer233.start, integer233.stop))
            	            ->chars));
            	        }


            	    }
            	    break;

                }
            }

            SPACE234 = (pANTLR3_COMMON_TOKEN) MATCHT(SPACE, &FOLLOW_SPACE_in_media2531);
            if  (HASEXCEPTION())
            {
                goto rulemediaEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_mediaPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) {
            SPACE234_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, SPACE234));
            ADAPTOR->addChild(ADAPTOR, root_0, SPACE234_tree);
            }

            FOLLOWPUSH(FOLLOW_proto_in_media2533);
            proto235=proto(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulemediaEx;
            }
            if (HASFAILED())
            {
                pbelle_sdpParser_mediaPop(ctx);

                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, proto235.tree);

            if ( BACKTRACKING==0 )
            {
                belle_sdp_media_set_protocol((SCOPE_TOP(media))->current,(const char*)
                (STRSTREAM->toStringTT(STRSTREAM, proto235.start, proto235.stop))
                ->chars);
            }


            // ../grammars/belle_sdp.g:427:11: ( SPACE fmt )+
            {
                int cnt49=0;

                for (;;)
                {
                    int alt49=2;
            	switch ( LA(1) )
            	{
            	case SPACE:
            		{
            			alt49=1;
            		}
            	    break;

            	}

            	switch (alt49)
            	{
            	    case 1:
            	        // ../grammars/belle_sdp.g:427:12: SPACE fmt
            	        {
            	            SPACE236 = (pANTLR3_COMMON_TOKEN) MATCHT(SPACE, &FOLLOW_SPACE_in_media2548);
            	            if  (HASEXCEPTION())
            	            {
            	                goto rulemediaEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                pbelle_sdpParser_mediaPop(ctx);

            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) {
            	            SPACE236_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, SPACE236));
            	            ADAPTOR->addChild(ADAPTOR, root_0, SPACE236_tree);
            	            }

            	            FOLLOWPUSH(FOLLOW_fmt_in_media2550);
            	            fmt237=fmt(ctx);

            	            FOLLOWPOP();
            	            if  (HASEXCEPTION())
            	            {
            	                goto rulemediaEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                pbelle_sdpParser_mediaPop(ctx);

            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, fmt237.tree);

            	        }
            	        break;

            	    default:

            		if ( cnt49 >= 1 )
            		{
            		    goto loop49;
            		}
            		if (BACKTRACKING>0)
            		{
            		    FAILEDFLAG = ANTLR3_TRUE;
            		    pbelle_sdpParser_mediaPop(ctx);

            		    return retval;
            		}

            		/* mismatchedSetEx()
            		 */
            		CONSTRUCTEX();
            		EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
            		EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;


            		goto rulemediaEx;
            	}
            	cnt49++;
                }
                loop49: ;	/* Jump to here if this rule does not match */
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto rulemediaEx; /* Prevent compiler warnings */
    rulemediaEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }


    if	(HASEXCEPTION())
    {
	/* catch(decl,action)
	 */
	{

	    	ANTLR3_LOG_EXCEPTION();
	      belle_sip_object_unref(retval.ret
	    );
	      retval.ret=NULL;


	}


    }
    else
    {
    }
    pbelle_sdpParser_mediaPop(ctx);

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

/**
 * $ANTLR start media_value
 * ../grammars/belle_sdp.g:434:1: media_value : ( alpha_num )+ ;
 */
static belle_sdpParser_media_value_return
media_value(pbelle_sdpParser ctx)
{
    belle_sdpParser_media_value_return retval;


    pANTLR3_BASE_TREE root_0;

    belle_sdpParser_alpha_num_return alpha_num238;
    #undef	RETURN_TYPE_alpha_num238
    #define	RETURN_TYPE_alpha_num238 belle_sdpParser_alpha_num_return


    /* Initialize rule variables
     */

    root_0 = NULL;

    alpha_num238.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;




    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:434:12: ( ( alpha_num )+ )
        // ../grammars/belle_sdp.g:434:28: ( alpha_num )+
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            // ../grammars/belle_sdp.g:434:28: ( alpha_num )+
            {
                int cnt50=0;

                for (;;)
                {
                    int alt50=2;
            	switch ( LA(1) )
            	{
            	case COMMON_CHAR:
            	case DIGIT:
            	case HEX_CHAR:
            		{
            			alt50=1;
            		}
            	    break;

            	}

            	switch (alt50)
            	{
            	    case 1:
            	        // ../grammars/belle_sdp.g:434:28: alpha_num
            	        {
            	            FOLLOWPUSH(FOLLOW_alpha_num_in_media_value2578);
            	            alpha_num238=alpha_num(ctx);

            	            FOLLOWPOP();
            	            if  (HASEXCEPTION())
            	            {
            	                goto rulemedia_valueEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num238.tree);

            	        }
            	        break;

            	    default:

            		if ( cnt50 >= 1 )
            		{
            		    goto loop50;
            		}
            		if (BACKTRACKING>0)
            		{
            		    FAILEDFLAG = ANTLR3_TRUE;
            		    return retval;
            		}

            		/* mismatchedSetEx()
            		 */
            		CONSTRUCTEX();
            		EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
            		EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;


            		goto rulemedia_valueEx;
            	}
            	cnt50++;
                }
                loop50: ;	/* Jump to here if this rule does not match */
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto rulemedia_valueEx; /* Prevent compiler warnings */
    rulemedia_valueEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start fmt
 * ../grammars/belle_sdp.g:438:1: fmt : ( ( ( DIGIT )+ )=> ( ( DIGIT )+ ) | token ) ;
 */
static belle_sdpParser_fmt_return
fmt(pbelle_sdpParser ctx)
{
    belle_sdpParser_fmt_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    DIGIT239;
    belle_sdpParser_token_return token240;
    #undef	RETURN_TYPE_token240
    #define	RETURN_TYPE_token240 belle_sdpParser_token_return

    pANTLR3_BASE_TREE DIGIT239_tree;

    /* Initialize rule variables
     */
    ctx->pbelle_sdpParser_fmtTop = pbelle_sdpParser_fmtPush(ctx);
    root_0 = NULL;

     (SCOPE_TOP(fmt))->is_number=0;
    DIGIT239       = NULL;
    token240.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    DIGIT239_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:440:28: ( ( ( ( DIGIT )+ )=> ( ( DIGIT )+ ) | token ) )
        // ../grammars/belle_sdp.g:440:46: ( ( ( DIGIT )+ )=> ( ( DIGIT )+ ) | token )
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            // ../grammars/belle_sdp.g:440:46: ( ( ( DIGIT )+ )=> ( ( DIGIT )+ ) | token )
            {
                int alt52=2;
                switch ( LA(1) )
                {
                case DIGIT:
                	{
                		{
                		    int LA52_1 = LA(2);
                		    if ( (synpred25_belle_sdp(ctx)))
                		    {
                		        alt52=1;
                		    }
                		    else if ( (ANTLR3_TRUE))
                		    {
                		        alt52=2;
                		    }
                		    else
                		    {
                		        if (BACKTRACKING>0)
                		        {
                		            FAILEDFLAG = ANTLR3_TRUE;
                		            pbelle_sdpParser_fmtPop(ctx);

                		            return retval;
                		        }


                		        CONSTRUCTEX();
                		        EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
                		        EXCEPTION->message      = (void *)"";
                		        EXCEPTION->decisionNum  = 52;
                		        EXCEPTION->state        = 1;


                		        goto rulefmtEx;

                		    }
                		}
                	}
                    break;
                case COMMON_CHAR:
                case DASH:
                case DOT:
                case HEX_CHAR:
                case STAR:
                case 22:
                case 23:
                case 24:
                case 25:
                case 26:
                case 27:
                case 28:
                case 29:
                case 30:
                case 31:
                case 32:
                case 33:
                case 34:
                case 35:
                	{
                		alt52=2;
                	}
                    break;

                default:
                    if (BACKTRACKING>0)
                    {
                        FAILEDFLAG = ANTLR3_TRUE;
                        pbelle_sdpParser_fmtPop(ctx);

                        return retval;
                    }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
                    EXCEPTION->message      = (void *)"";
                    EXCEPTION->decisionNum  = 52;
                    EXCEPTION->state        = 0;


                    goto rulefmtEx;

                }

                switch (alt52)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:440:47: ( ( DIGIT )+ )=> ( ( DIGIT )+ )
            	    {
            	        // ../grammars/belle_sdp.g:440:57: ( ( DIGIT )+ )
            	        // ../grammars/belle_sdp.g:440:58: ( DIGIT )+
            	        {
            	            // ../grammars/belle_sdp.g:440:58: ( DIGIT )+
            	            {
            	                int cnt51=0;

            	                for (;;)
            	                {
            	                    int alt51=2;
            	            	switch ( LA(1) )
            	            	{
            	            	case DIGIT:
            	            		{
            	            			alt51=1;
            	            		}
            	            	    break;

            	            	}

            	            	switch (alt51)
            	            	{
            	            	    case 1:
            	            	        // ../grammars/belle_sdp.g:440:58: DIGIT
            	            	        {
            	            	            DIGIT239 = (pANTLR3_COMMON_TOKEN) MATCHT(DIGIT, &FOLLOW_DIGIT_in_fmt2662);
            	            	            if  (HASEXCEPTION())
            	            	            {
            	            	                goto rulefmtEx;
            	            	            }
            	            	            if (HASFAILED())
            	            	            {
            	            	                pbelle_sdpParser_fmtPop(ctx);

            	            	                return retval;
            	            	            }

            	            	            if ( BACKTRACKING==0 ) {
            	            	            DIGIT239_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DIGIT239));
            	            	            ADAPTOR->addChild(ADAPTOR, root_0, DIGIT239_tree);
            	            	            }

            	            	        }
            	            	        break;

            	            	    default:

            	            		if ( cnt51 >= 1 )
            	            		{
            	            		    goto loop51;
            	            		}
            	            		if (BACKTRACKING>0)
            	            		{
            	            		    FAILEDFLAG = ANTLR3_TRUE;
            	            		    pbelle_sdpParser_fmtPop(ctx);

            	            		    return retval;
            	            		}

            	            		/* mismatchedSetEx()
            	            		 */
            	            		CONSTRUCTEX();
            	            		EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
            	            		EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;


            	            		goto rulefmtEx;
            	            	}
            	            	cnt51++;
            	                }
            	                loop51: ;	/* Jump to here if this rule does not match */
            	            }

            	        }


            	        if ( BACKTRACKING==0 )
            	        {
            	            (SCOPE_TOP(fmt))->is_number=1;
            	        }


            	    }
            	    break;
            	case 2:
            	    // ../grammars/belle_sdp.g:440:88: token
            	    {
            	        FOLLOWPUSH(FOLLOW_token_in_fmt2669);
            	        token240=token(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulefmtEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            pbelle_sdpParser_fmtPop(ctx);

            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, token240.tree);

            	    }
            	    break;

                }
            }

            if ( BACKTRACKING==0 )
            {
                belle_sdp_media_set_media_formats((SCOPE_TOP(media))->current
                                                                                          ,belle_sip_list_append(belle_sdp_media_get_media_formats((SCOPE_TOP(media))->current)
                                                                                          ,(void*)((SCOPE_TOP(fmt))->is_number?(void*)(intptr_t)atoi((const char*)
                STRSTREAM->toStringTT(STRSTREAM, retval.start, LT(-1))
                ->chars):STRSTREAM->toStringTT(STRSTREAM, retval.start, LT(-1))
                ->chars)));
            }


        }

    }

    // This is where rules clean up and exit
    //
    goto rulefmtEx; /* Prevent compiler warnings */
    rulefmtEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

    pbelle_sdpParser_fmtPop(ctx);

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

/**
 * $ANTLR start proto
 * ../grammars/belle_sdp.g:446:1: proto options {greedy=false; } : (~ ( SPACE | CR | LF ) )* ;
 */
static belle_sdpParser_proto_return
proto(pbelle_sdpParser ctx)
{
    belle_sdpParser_proto_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    set241;

    pANTLR3_BASE_TREE set241_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    set241       = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    set241_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:446:47: ( (~ ( SPACE | CR | LF ) )* )
        // ../grammars/belle_sdp.g:446:56: (~ ( SPACE | CR | LF ) )*
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            // ../grammars/belle_sdp.g:446:56: (~ ( SPACE | CR | LF ) )*

            for (;;)
            {
                int alt53=2;
                switch ( LA(1) )
                {
                case COLON:
                case COMMA:
                case COMMON_CHAR:
                case DASH:
                case DIGIT:
                case DOT:
                case EQUAL:
                case HEX_CHAR:
                case LQUOTE:
                case OCTET:
                case POS_DIGIT:
                case RQUOTE:
                case SLASH:
                case STAR:
                case ZERO:
                case 22:
                case 23:
                case 24:
                case 25:
                case 26:
                case 27:
                case 28:
                case 29:
                case 30:
                case 31:
                case 32:
                case 33:
                case 34:
                case 35:
                	{
                		alt53=1;
                	}
                    break;

                }

                switch (alt53)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:
            	    {
            	        set241=(pANTLR3_COMMON_TOKEN)LT(1);

            	        if ( ((LA(1) >= COLON) && (LA(1) <= COMMON_CHAR)) || ((LA(1) >= DASH) && (LA(1) <= HEX_CHAR)) || ((LA(1) >= LQUOTE) && (LA(1) <= SLASH)) || ((LA(1) >= STAR) && (LA(1) <= 35)) )
            	        {
            	            CONSUME();
            	            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, 
            	            (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set241))
            	            );
            	            PERRORRECOVERY=ANTLR3_FALSE;
            	            FAILEDFLAG=ANTLR3_FALSE;

            	        }
            	        else
            	        {
            	            if (BACKTRACKING>0)
            	            {
            	                FAILEDFLAG = ANTLR3_TRUE;
            	                return retval;
            	            }

            	            CONSTRUCTEX();
            	            EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;
            	            EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;
            	            EXCEPTION->expectingSet = NULL;

            	            goto ruleprotoEx;
            	        }


            	    }
            	    break;

            	default:
            	    goto loop53;	/* break out of the loop */
            	    break;
                }
            }
            loop53: ; /* Jump out to here if this rule does not match */


        }

    }

    // This is where rules clean up and exit
    //
    goto ruleprotoEx; /* Prevent compiler warnings */
    ruleprotoEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start port
 * ../grammars/belle_sdp.g:449:1: port : ( DIGIT )+ ;
 */
static belle_sdpParser_port_return
port(pbelle_sdpParser ctx)
{
    belle_sdpParser_port_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    DIGIT242;

    pANTLR3_BASE_TREE DIGIT242_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    DIGIT242       = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    DIGIT242_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:449:5: ( ( DIGIT )+ )
        // ../grammars/belle_sdp.g:449:22: ( DIGIT )+
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            // ../grammars/belle_sdp.g:449:22: ( DIGIT )+
            {
                int cnt54=0;

                for (;;)
                {
                    int alt54=2;
            	switch ( LA(1) )
            	{
            	case DIGIT:
            		{
            			alt54=1;
            		}
            	    break;

            	}

            	switch (alt54)
            	{
            	    case 1:
            	        // ../grammars/belle_sdp.g:449:22: DIGIT
            	        {
            	            DIGIT242 = (pANTLR3_COMMON_TOKEN) MATCHT(DIGIT, &FOLLOW_DIGIT_in_port2880);
            	            if  (HASEXCEPTION())
            	            {
            	                goto ruleportEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) {
            	            DIGIT242_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DIGIT242));
            	            ADAPTOR->addChild(ADAPTOR, root_0, DIGIT242_tree);
            	            }

            	        }
            	        break;

            	    default:

            		if ( cnt54 >= 1 )
            		{
            		    goto loop54;
            		}
            		if (BACKTRACKING>0)
            		{
            		    FAILEDFLAG = ANTLR3_TRUE;
            		    return retval;
            		}

            		/* mismatchedSetEx()
            		 */
            		CONSTRUCTEX();
            		EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
            		EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;


            		goto ruleportEx;
            	}
            	cnt54++;
                }
                loop54: ;	/* Jump to here if this rule does not match */
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto ruleportEx; /* Prevent compiler warnings */
    ruleportEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start attribute_name
 * ../grammars/belle_sdp.g:453:1: attribute_name : token ;
 */
static belle_sdpParser_attribute_name_return
attribute_name(pbelle_sdpParser ctx)
{
    belle_sdpParser_attribute_name_return retval;


    pANTLR3_BASE_TREE root_0;

    belle_sdpParser_token_return token243;
    #undef	RETURN_TYPE_token243
    #define	RETURN_TYPE_token243 belle_sdpParser_token_return


    /* Initialize rule variables
     */

    root_0 = NULL;

    token243.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;




    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:453:15: ( token )
        // ../grammars/belle_sdp.g:453:17: token
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            FOLLOWPUSH(FOLLOW_token_in_attribute_name2932);
            token243=token(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruleattribute_nameEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, token243.tree);

        }

    }

    // This is where rules clean up and exit
    //
    goto ruleattribute_nameEx; /* Prevent compiler warnings */
    ruleattribute_nameEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start attribute_value
 * ../grammars/belle_sdp.g:455:1: attribute_value options {greedy=false; } : (~ ( CR | LF ) )* ;
 */
static belle_sdpParser_attribute_value_return
attribute_value(pbelle_sdpParser ctx)
{
    belle_sdpParser_attribute_value_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    set244;

    pANTLR3_BASE_TREE set244_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    set244       = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    set244_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:455:44: ( (~ ( CR | LF ) )* )
        // ../grammars/belle_sdp.g:455:46: (~ ( CR | LF ) )*
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            // ../grammars/belle_sdp.g:455:46: (~ ( CR | LF ) )*

            for (;;)
            {
                int alt55=2;
                switch ( LA(1) )
                {
                case COLON:
                case COMMA:
                case COMMON_CHAR:
                case DASH:
                case DIGIT:
                case DOT:
                case EQUAL:
                case HEX_CHAR:
                case LQUOTE:
                case OCTET:
                case POS_DIGIT:
                case RQUOTE:
                case SLASH:
                case SPACE:
                case STAR:
                case ZERO:
                case 22:
                case 23:
                case 24:
                case 25:
                case 26:
                case 27:
                case 28:
                case 29:
                case 30:
                case 31:
                case 32:
                case 33:
                case 34:
                case 35:
                	{
                		alt55=1;
                	}
                    break;

                }

                switch (alt55)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:
            	    {
            	        set244=(pANTLR3_COMMON_TOKEN)LT(1);

            	        if ( ((LA(1) >= COLON) && (LA(1) <= COMMON_CHAR)) || ((LA(1) >= DASH) && (LA(1) <= HEX_CHAR)) || ((LA(1) >= LQUOTE) && (LA(1) <= 35)) )
            	        {
            	            CONSUME();
            	            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, 
            	            (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set244))
            	            );
            	            PERRORRECOVERY=ANTLR3_FALSE;
            	            FAILEDFLAG=ANTLR3_FALSE;

            	        }
            	        else
            	        {
            	            if (BACKTRACKING>0)
            	            {
            	                FAILEDFLAG = ANTLR3_TRUE;
            	                return retval;
            	            }

            	            CONSTRUCTEX();
            	            EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;
            	            EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;
            	            EXCEPTION->expectingSet = NULL;

            	            goto ruleattribute_valueEx;
            	        }


            	    }
            	    break;

            	default:
            	    goto loop55;	/* break out of the loop */
            	    break;
                }
            }
            loop55: ; /* Jump out to here if this rule does not match */


        }

    }

    // This is where rules clean up and exit
    //
    goto ruleattribute_valueEx; /* Prevent compiler warnings */
    ruleattribute_valueEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start rtcp_xr_attribute_name
 * ../grammars/belle_sdp.g:457:1: rtcp_xr_attribute_name : word ;
 */
static belle_sdpParser_rtcp_xr_attribute_name_return
rtcp_xr_attribute_name(pbelle_sdpParser ctx)
{
    belle_sdpParser_rtcp_xr_attribute_name_return retval;


    pANTLR3_BASE_TREE root_0;

    belle_sdpParser_word_return word245;
    #undef	RETURN_TYPE_word245
    #define	RETURN_TYPE_word245 belle_sdpParser_word_return


    /* Initialize rule variables
     */

    root_0 = NULL;

    word245.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;




    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:457:23: ( word )
        // ../grammars/belle_sdp.g:457:25: word
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            FOLLOWPUSH(FOLLOW_word_in_rtcp_xr_attribute_name2963);
            word245=word(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulertcp_xr_attribute_nameEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, word245.tree);

        }

    }

    // This is where rules clean up and exit
    //
    goto rulertcp_xr_attribute_nameEx; /* Prevent compiler warnings */
    rulertcp_xr_attribute_nameEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start rtcp_xr_rcvr_rtt_mode
 * ../grammars/belle_sdp.g:459:1: rtcp_xr_rcvr_rtt_mode : word ;
 */
static belle_sdpParser_rtcp_xr_rcvr_rtt_mode_return
rtcp_xr_rcvr_rtt_mode(pbelle_sdpParser ctx)
{
    belle_sdpParser_rtcp_xr_rcvr_rtt_mode_return retval;


    pANTLR3_BASE_TREE root_0;

    belle_sdpParser_word_return word246;
    #undef	RETURN_TYPE_word246
    #define	RETURN_TYPE_word246 belle_sdpParser_word_return


    /* Initialize rule variables
     */

    root_0 = NULL;

    word246.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;




    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:459:22: ( word )
        // ../grammars/belle_sdp.g:459:24: word
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            FOLLOWPUSH(FOLLOW_word_in_rtcp_xr_rcvr_rtt_mode2970);
            word246=word(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulertcp_xr_rcvr_rtt_modeEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, word246.tree);

        }

    }

    // This is where rules clean up and exit
    //
    goto rulertcp_xr_rcvr_rtt_modeEx; /* Prevent compiler warnings */
    rulertcp_xr_rcvr_rtt_modeEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start rtcp_xr_stat_summary_flag_value
 * ../grammars/belle_sdp.g:461:1: rtcp_xr_stat_summary_flag_value : word ;
 */
static belle_sdpParser_rtcp_xr_stat_summary_flag_value_return
rtcp_xr_stat_summary_flag_value(pbelle_sdpParser ctx)
{
    belle_sdpParser_rtcp_xr_stat_summary_flag_value_return retval;


    pANTLR3_BASE_TREE root_0;

    belle_sdpParser_word_return word247;
    #undef	RETURN_TYPE_word247
    #define	RETURN_TYPE_word247 belle_sdpParser_word_return


    /* Initialize rule variables
     */

    root_0 = NULL;

    word247.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;




    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:461:32: ( word )
        // ../grammars/belle_sdp.g:461:34: word
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            FOLLOWPUSH(FOLLOW_word_in_rtcp_xr_stat_summary_flag_value2977);
            word247=word(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulertcp_xr_stat_summary_flag_valueEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, word247.tree);

        }

    }

    // This is where rules clean up and exit
    //
    goto rulertcp_xr_stat_summary_flag_valueEx; /* Prevent compiler warnings */
    rulertcp_xr_stat_summary_flag_valueEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start rtcp_fb_attribute_name
 * ../grammars/belle_sdp.g:463:1: rtcp_fb_attribute_name : word ;
 */
static belle_sdpParser_rtcp_fb_attribute_name_return
rtcp_fb_attribute_name(pbelle_sdpParser ctx)
{
    belle_sdpParser_rtcp_fb_attribute_name_return retval;


    pANTLR3_BASE_TREE root_0;

    belle_sdpParser_word_return word248;
    #undef	RETURN_TYPE_word248
    #define	RETURN_TYPE_word248 belle_sdpParser_word_return


    /* Initialize rule variables
     */

    root_0 = NULL;

    word248.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;




    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:463:23: ( word )
        // ../grammars/belle_sdp.g:463:25: word
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            FOLLOWPUSH(FOLLOW_word_in_rtcp_fb_attribute_name2984);
            word248=word(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulertcp_fb_attribute_nameEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, word248.tree);

        }

    }

    // This is where rules clean up and exit
    //
    goto rulertcp_fb_attribute_nameEx; /* Prevent compiler warnings */
    rulertcp_fb_attribute_nameEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start sess_id
 * ../grammars/belle_sdp.g:465:1: sess_id : ( DIGIT )+ ;
 */
static belle_sdpParser_sess_id_return
sess_id(pbelle_sdpParser ctx)
{
    belle_sdpParser_sess_id_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    DIGIT249;

    pANTLR3_BASE_TREE DIGIT249_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    DIGIT249       = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    DIGIT249_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:465:8: ( ( DIGIT )+ )
        // ../grammars/belle_sdp.g:465:22: ( DIGIT )+
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            // ../grammars/belle_sdp.g:465:22: ( DIGIT )+
            {
                int cnt56=0;

                for (;;)
                {
                    int alt56=2;
            	switch ( LA(1) )
            	{
            	case DIGIT:
            		{
            			alt56=1;
            		}
            	    break;

            	}

            	switch (alt56)
            	{
            	    case 1:
            	        // ../grammars/belle_sdp.g:465:22: DIGIT
            	        {
            	            DIGIT249 = (pANTLR3_COMMON_TOKEN) MATCHT(DIGIT, &FOLLOW_DIGIT_in_sess_id3003);
            	            if  (HASEXCEPTION())
            	            {
            	                goto rulesess_idEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) {
            	            DIGIT249_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DIGIT249));
            	            ADAPTOR->addChild(ADAPTOR, root_0, DIGIT249_tree);
            	            }

            	        }
            	        break;

            	    default:

            		if ( cnt56 >= 1 )
            		{
            		    goto loop56;
            		}
            		if (BACKTRACKING>0)
            		{
            		    FAILEDFLAG = ANTLR3_TRUE;
            		    return retval;
            		}

            		/* mismatchedSetEx()
            		 */
            		CONSTRUCTEX();
            		EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
            		EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;


            		goto rulesess_idEx;
            	}
            	cnt56++;
                }
                loop56: ;	/* Jump to here if this rule does not match */
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto rulesess_idEx; /* Prevent compiler warnings */
    rulesess_idEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start sess_version
 * ../grammars/belle_sdp.g:468:1: sess_version : ( DIGIT )+ ;
 */
static belle_sdpParser_sess_version_return
sess_version(pbelle_sdpParser ctx)
{
    belle_sdpParser_sess_version_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    DIGIT250;

    pANTLR3_BASE_TREE DIGIT250_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    DIGIT250       = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    DIGIT250_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:468:13: ( ( DIGIT )+ )
        // ../grammars/belle_sdp.g:468:22: ( DIGIT )+
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            // ../grammars/belle_sdp.g:468:22: ( DIGIT )+
            {
                int cnt57=0;

                for (;;)
                {
                    int alt57=2;
            	switch ( LA(1) )
            	{
            	case DIGIT:
            		{
            			alt57=1;
            		}
            	    break;

            	}

            	switch (alt57)
            	{
            	    case 1:
            	        // ../grammars/belle_sdp.g:468:22: DIGIT
            	        {
            	            DIGIT250 = (pANTLR3_COMMON_TOKEN) MATCHT(DIGIT, &FOLLOW_DIGIT_in_sess_version3043);
            	            if  (HASEXCEPTION())
            	            {
            	                goto rulesess_versionEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) {
            	            DIGIT250_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DIGIT250));
            	            ADAPTOR->addChild(ADAPTOR, root_0, DIGIT250_tree);
            	            }

            	        }
            	        break;

            	    default:

            		if ( cnt57 >= 1 )
            		{
            		    goto loop57;
            		}
            		if (BACKTRACKING>0)
            		{
            		    FAILEDFLAG = ANTLR3_TRUE;
            		    return retval;
            		}

            		/* mismatchedSetEx()
            		 */
            		CONSTRUCTEX();
            		EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
            		EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;


            		goto rulesess_versionEx;
            	}
            	cnt57++;
                }
                loop57: ;	/* Jump to here if this rule does not match */
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto rulesess_versionEx; /* Prevent compiler warnings */
    rulesess_versionEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start connection_address
 * ../grammars/belle_sdp.g:471:1: connection_address : addr ( multicast_part )? ;
 */
static belle_sdpParser_connection_address_return
connection_address(pbelle_sdpParser ctx)
{
    belle_sdpParser_connection_address_return retval;


    pANTLR3_BASE_TREE root_0;

    belle_sdpParser_addr_return addr251;
    #undef	RETURN_TYPE_addr251
    #define	RETURN_TYPE_addr251 belle_sdpParser_addr_return

    belle_sdpParser_multicast_part_return multicast_part252;
    #undef	RETURN_TYPE_multicast_part252
    #define	RETURN_TYPE_multicast_part252 belle_sdpParser_multicast_part_return


    /* Initialize rule variables
     */

    root_0 = NULL;

    addr251.tree = NULL;

    multicast_part252.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;




    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:471:19: ( addr ( multicast_part )? )
        // ../grammars/belle_sdp.g:474:22: addr ( multicast_part )?
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            FOLLOWPUSH(FOLLOW_addr_in_connection_address3097);
            addr251=addr(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruleconnection_addressEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, addr251.tree);

            if ( BACKTRACKING==0 )
            {
                belle_sdp_connection_set_address((SCOPE_TOP(connection))->current,(const char*)
                (STRSTREAM->toStringTT(STRSTREAM, addr251.start, addr251.stop))
                ->chars);
            }


            // ../grammars/belle_sdp.g:474:116: ( multicast_part )?
            {
                int alt58=2;
                switch ( LA(1) )
                {
                    case SLASH:
                    	{
                    		alt58=1;
                    	}
                        break;
                }

                switch (alt58)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:474:116: multicast_part
            	    {
            	        FOLLOWPUSH(FOLLOW_multicast_part_in_connection_address3101);
            	        multicast_part252=multicast_part(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto ruleconnection_addressEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, multicast_part252.tree);

            	    }
            	    break;

                }
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto ruleconnection_addressEx; /* Prevent compiler warnings */
    ruleconnection_addressEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start multicast_address
 * ../grammars/belle_sdp.g:476:1: multicast_address : unicast_address '/' ttl ;
 */
static belle_sdpParser_multicast_address_return
multicast_address(pbelle_sdpParser ctx)
{
    belle_sdpParser_multicast_address_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    char_literal254;
    belle_sdpParser_unicast_address_return unicast_address253;
    #undef	RETURN_TYPE_unicast_address253
    #define	RETURN_TYPE_unicast_address253 belle_sdpParser_unicast_address_return

    belle_sdpParser_ttl_return ttl255;
    #undef	RETURN_TYPE_ttl255
    #define	RETURN_TYPE_ttl255 belle_sdpParser_ttl_return

    pANTLR3_BASE_TREE char_literal254_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    char_literal254       = NULL;
    unicast_address253.tree = NULL;

    ttl255.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    char_literal254_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:476:18: ( unicast_address '/' ttl )
        // ../grammars/belle_sdp.g:476:22: unicast_address '/' ttl
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            FOLLOWPUSH(FOLLOW_unicast_address_in_multicast_address3111);
            unicast_address253=unicast_address(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulemulticast_addressEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, unicast_address253.tree);

            char_literal254 = (pANTLR3_COMMON_TOKEN) MATCHT(SLASH, &FOLLOW_SLASH_in_multicast_address3113);
            if  (HASEXCEPTION())
            {
                goto rulemulticast_addressEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) {
            char_literal254_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, char_literal254));
            ADAPTOR->addChild(ADAPTOR, root_0, char_literal254_tree);
            }

            FOLLOWPUSH(FOLLOW_ttl_in_multicast_address3115);
            ttl255=ttl(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulemulticast_addressEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, ttl255.tree);

        }

    }

    // This is where rules clean up and exit
    //
    goto rulemulticast_addressEx; /* Prevent compiler warnings */
    rulemulticast_addressEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start ttl
 * ../grammars/belle_sdp.g:481:1: ttl : decimal_uchar ;
 */
static belle_sdpParser_ttl_return
ttl(pbelle_sdpParser ctx)
{
    belle_sdpParser_ttl_return retval;


    pANTLR3_BASE_TREE root_0;

    belle_sdpParser_decimal_uchar_return decimal_uchar256;
    #undef	RETURN_TYPE_decimal_uchar256
    #define	RETURN_TYPE_decimal_uchar256 belle_sdpParser_decimal_uchar_return


    /* Initialize rule variables
     */

    root_0 = NULL;

    decimal_uchar256.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;




    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:481:4: ( decimal_uchar )
        // ../grammars/belle_sdp.g:481:22: decimal_uchar
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            FOLLOWPUSH(FOLLOW_decimal_uchar_in_ttl3217);
            decimal_uchar256=decimal_uchar(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulettlEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, decimal_uchar256.tree);

        }

    }

    // This is where rules clean up and exit
    //
    goto rulettlEx; /* Prevent compiler warnings */
    rulettlEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start start_time
 * ../grammars/belle_sdp.g:483:1: start_time : ( DIGIT )+ ;
 */
static belle_sdpParser_start_time_return
start_time(pbelle_sdpParser ctx)
{
    belle_sdpParser_start_time_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    DIGIT257;

    pANTLR3_BASE_TREE DIGIT257_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    DIGIT257       = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    DIGIT257_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:483:11: ( ( DIGIT )+ )
        // ../grammars/belle_sdp.g:483:23: ( DIGIT )+
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            // ../grammars/belle_sdp.g:483:23: ( DIGIT )+
            {
                int cnt59=0;

                for (;;)
                {
                    int alt59=2;
            	switch ( LA(1) )
            	{
            	case DIGIT:
            		{
            			alt59=1;
            		}
            	    break;

            	}

            	switch (alt59)
            	{
            	    case 1:
            	        // ../grammars/belle_sdp.g:483:23: DIGIT
            	        {
            	            DIGIT257 = (pANTLR3_COMMON_TOKEN) MATCHT(DIGIT, &FOLLOW_DIGIT_in_start_time3234);
            	            if  (HASEXCEPTION())
            	            {
            	                goto rulestart_timeEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) {
            	            DIGIT257_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DIGIT257));
            	            ADAPTOR->addChild(ADAPTOR, root_0, DIGIT257_tree);
            	            }

            	        }
            	        break;

            	    default:

            		if ( cnt59 >= 1 )
            		{
            		    goto loop59;
            		}
            		if (BACKTRACKING>0)
            		{
            		    FAILEDFLAG = ANTLR3_TRUE;
            		    return retval;
            		}

            		/* mismatchedSetEx()
            		 */
            		CONSTRUCTEX();
            		EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
            		EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;


            		goto rulestart_timeEx;
            	}
            	cnt59++;
                }
                loop59: ;	/* Jump to here if this rule does not match */
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto rulestart_timeEx; /* Prevent compiler warnings */
    rulestart_timeEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start stop_time
 * ../grammars/belle_sdp.g:485:1: stop_time : ( DIGIT )+ ;
 */
static belle_sdpParser_stop_time_return
stop_time(pbelle_sdpParser ctx)
{
    belle_sdpParser_stop_time_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    DIGIT258;

    pANTLR3_BASE_TREE DIGIT258_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    DIGIT258       = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    DIGIT258_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:485:10: ( ( DIGIT )+ )
        // ../grammars/belle_sdp.g:485:22: ( DIGIT )+
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            // ../grammars/belle_sdp.g:485:22: ( DIGIT )+
            {
                int cnt60=0;

                for (;;)
                {
                    int alt60=2;
            	switch ( LA(1) )
            	{
            	case DIGIT:
            		{
            			alt60=1;
            		}
            	    break;

            	}

            	switch (alt60)
            	{
            	    case 1:
            	        // ../grammars/belle_sdp.g:485:22: DIGIT
            	        {
            	            DIGIT258 = (pANTLR3_COMMON_TOKEN) MATCHT(DIGIT, &FOLLOW_DIGIT_in_stop_time3254);
            	            if  (HASEXCEPTION())
            	            {
            	                goto rulestop_timeEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) {
            	            DIGIT258_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DIGIT258));
            	            ADAPTOR->addChild(ADAPTOR, root_0, DIGIT258_tree);
            	            }

            	        }
            	        break;

            	    default:

            		if ( cnt60 >= 1 )
            		{
            		    goto loop60;
            		}
            		if (BACKTRACKING>0)
            		{
            		    FAILEDFLAG = ANTLR3_TRUE;
            		    return retval;
            		}

            		/* mismatchedSetEx()
            		 */
            		CONSTRUCTEX();
            		EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
            		EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;


            		goto rulestop_timeEx;
            	}
            	cnt60++;
                }
                loop60: ;	/* Jump to here if this rule does not match */
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto rulestop_timeEx; /* Prevent compiler warnings */
    rulestop_timeEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start sdp_time
 * ../grammars/belle_sdp.g:487:1: sdp_time : ( DIGIT )+ ;
 */
static belle_sdpParser_sdp_time_return
sdp_time(pbelle_sdpParser ctx)
{
    belle_sdpParser_sdp_time_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    DIGIT259;

    pANTLR3_BASE_TREE DIGIT259_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    DIGIT259       = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    DIGIT259_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:487:9: ( ( DIGIT )+ )
        // ../grammars/belle_sdp.g:487:27: ( DIGIT )+
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            // ../grammars/belle_sdp.g:487:27: ( DIGIT )+
            {
                int cnt61=0;

                for (;;)
                {
                    int alt61=2;
            	switch ( LA(1) )
            	{
            	case DIGIT:
            		{
            			alt61=1;
            		}
            	    break;

            	}

            	switch (alt61)
            	{
            	    case 1:
            	        // ../grammars/belle_sdp.g:487:27: DIGIT
            	        {
            	            DIGIT259 = (pANTLR3_COMMON_TOKEN) MATCHT(DIGIT, &FOLLOW_DIGIT_in_sdp_time3280);
            	            if  (HASEXCEPTION())
            	            {
            	                goto rulesdp_timeEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) {
            	            DIGIT259_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DIGIT259));
            	            ADAPTOR->addChild(ADAPTOR, root_0, DIGIT259_tree);
            	            }

            	        }
            	        break;

            	    default:

            		if ( cnt61 >= 1 )
            		{
            		    goto loop61;
            		}
            		if (BACKTRACKING>0)
            		{
            		    FAILEDFLAG = ANTLR3_TRUE;
            		    return retval;
            		}

            		/* mismatchedSetEx()
            		 */
            		CONSTRUCTEX();
            		EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
            		EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;


            		goto rulesdp_timeEx;
            	}
            	cnt61++;
                }
                loop61: ;	/* Jump to here if this rule does not match */
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto rulesdp_timeEx; /* Prevent compiler warnings */
    rulesdp_timeEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start repeat_interval
 * ../grammars/belle_sdp.g:490:1: repeat_interval : typed_time ;
 */
static belle_sdpParser_repeat_interval_return
repeat_interval(pbelle_sdpParser ctx)
{
    belle_sdpParser_repeat_interval_return retval;


    pANTLR3_BASE_TREE root_0;

    belle_sdpParser_typed_time_return typed_time260;
    #undef	RETURN_TYPE_typed_time260
    #define	RETURN_TYPE_typed_time260 belle_sdpParser_typed_time_return


    /* Initialize rule variables
     */

    root_0 = NULL;

    typed_time260.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;




    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:490:16: ( typed_time )
        // ../grammars/belle_sdp.g:490:22: typed_time
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            FOLLOWPUSH(FOLLOW_typed_time_in_repeat_interval3314);
            typed_time260=typed_time(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulerepeat_intervalEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, typed_time260.tree);

        }

    }

    // This is where rules clean up and exit
    //
    goto rulerepeat_intervalEx; /* Prevent compiler warnings */
    rulerepeat_intervalEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start typed_time
 * ../grammars/belle_sdp.g:492:1: typed_time : ( DIGIT )* ( fixed_len_time_unit )? ;
 */
static belle_sdpParser_typed_time_return
typed_time(pbelle_sdpParser ctx)
{
    belle_sdpParser_typed_time_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    DIGIT261;
    belle_sdpParser_fixed_len_time_unit_return fixed_len_time_unit262;
    #undef	RETURN_TYPE_fixed_len_time_unit262
    #define	RETURN_TYPE_fixed_len_time_unit262 belle_sdpParser_fixed_len_time_unit_return

    pANTLR3_BASE_TREE DIGIT261_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    DIGIT261       = NULL;
    fixed_len_time_unit262.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    DIGIT261_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:492:11: ( ( DIGIT )* ( fixed_len_time_unit )? )
        // ../grammars/belle_sdp.g:492:22: ( DIGIT )* ( fixed_len_time_unit )?
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            // ../grammars/belle_sdp.g:492:22: ( DIGIT )*

            for (;;)
            {
                int alt62=2;
                switch ( LA(1) )
                {
                case DIGIT:
                	{
                		{
                		   /* dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState)
                		    */
                		    int LA62_2 = LA(2);
                		    if ( (!( ((((IS_TOKEN(h)))||((IS_TOKEN(m)))||((IS_TOKEN(s)))||((IS_TOKEN(d))))) )))
                		    {
                		        alt62=1;
                		    }

                		}
                	}
                    break;

                }

                switch (alt62)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:492:22: DIGIT
            	    {
            	        DIGIT261 = (pANTLR3_COMMON_TOKEN) MATCHT(DIGIT, &FOLLOW_DIGIT_in_typed_time3330);
            	        if  (HASEXCEPTION())
            	        {
            	            goto ruletyped_timeEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        DIGIT261_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DIGIT261));
            	        ADAPTOR->addChild(ADAPTOR, root_0, DIGIT261_tree);
            	        }

            	    }
            	    break;

            	default:
            	    goto loop62;	/* break out of the loop */
            	    break;
                }
            }
            loop62: ; /* Jump out to here if this rule does not match */


            // ../grammars/belle_sdp.g:492:29: ( fixed_len_time_unit )?
            {
                int alt63=2;
                switch ( LA(1) )
                {
                    case COMMON_CHAR:
                    case DIGIT:
                    case HEX_CHAR:
                    	{
                    		alt63=1;
                    	}
                        break;
                }

                switch (alt63)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:492:29: fixed_len_time_unit
            	    {
            	        FOLLOWPUSH(FOLLOW_fixed_len_time_unit_in_typed_time3333);
            	        fixed_len_time_unit262=fixed_len_time_unit(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto ruletyped_timeEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, fixed_len_time_unit262.tree);

            	    }
            	    break;

                }
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto ruletyped_timeEx; /* Prevent compiler warnings */
    ruletyped_timeEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start fixed_len_time_unit
 * ../grammars/belle_sdp.g:494:1: fixed_len_time_unit : ({...}? alpha_num |{...}? alpha_num |{...}? alpha_num |{...}? alpha_num );
 */
static belle_sdpParser_fixed_len_time_unit_return
fixed_len_time_unit(pbelle_sdpParser ctx)
{
    belle_sdpParser_fixed_len_time_unit_return retval;


    pANTLR3_BASE_TREE root_0;

    belle_sdpParser_alpha_num_return alpha_num263;
    #undef	RETURN_TYPE_alpha_num263
    #define	RETURN_TYPE_alpha_num263 belle_sdpParser_alpha_num_return

    belle_sdpParser_alpha_num_return alpha_num264;
    #undef	RETURN_TYPE_alpha_num264
    #define	RETURN_TYPE_alpha_num264 belle_sdpParser_alpha_num_return

    belle_sdpParser_alpha_num_return alpha_num265;
    #undef	RETURN_TYPE_alpha_num265
    #define	RETURN_TYPE_alpha_num265 belle_sdpParser_alpha_num_return

    belle_sdpParser_alpha_num_return alpha_num266;
    #undef	RETURN_TYPE_alpha_num266
    #define	RETURN_TYPE_alpha_num266 belle_sdpParser_alpha_num_return


    /* Initialize rule variables
     */

    root_0 = NULL;

    alpha_num263.tree = NULL;

    alpha_num264.tree = NULL;

    alpha_num265.tree = NULL;

    alpha_num266.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;




    retval.tree  = NULL;

    {
        {
            //  ../grammars/belle_sdp.g:494:20: ({...}? alpha_num |{...}? alpha_num |{...}? alpha_num |{...}? alpha_num )

            ANTLR3_UINT32 alt64;

            alt64=4;

            switch ( LA(1) )
            {
            case COMMON_CHAR:
            case HEX_CHAR:
            	{
            		{
            		    int LA64_1 = LA(2);
            		    if ( ((IS_TOKEN(d))))
            		    {
            		        alt64=1;
            		    }
            		    else if ( ((IS_TOKEN(h))))
            		    {
            		        alt64=2;
            		    }
            		    else if ( ((IS_TOKEN(m))))
            		    {
            		        alt64=3;
            		    }
            		    else if ( ((IS_TOKEN(s))))
            		    {
            		        alt64=4;
            		    }
            		    else
            		    {
            		        if (BACKTRACKING>0)
            		        {
            		            FAILEDFLAG = ANTLR3_TRUE;
            		            return retval;
            		        }


            		        CONSTRUCTEX();
            		        EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
            		        EXCEPTION->message      = (void *)"";
            		        EXCEPTION->decisionNum  = 64;
            		        EXCEPTION->state        = 1;


            		        goto rulefixed_len_time_unitEx;

            		    }
            		}
            	}
                break;
            case DIGIT:
            	{
            		{
            		    int LA64_2 = LA(2);
            		    if ( ((IS_TOKEN(d))))
            		    {
            		        alt64=1;
            		    }
            		    else if ( ((IS_TOKEN(h))))
            		    {
            		        alt64=2;
            		    }
            		    else if ( ((IS_TOKEN(m))))
            		    {
            		        alt64=3;
            		    }
            		    else if ( ((IS_TOKEN(s))))
            		    {
            		        alt64=4;
            		    }
            		    else
            		    {
            		        if (BACKTRACKING>0)
            		        {
            		            FAILEDFLAG = ANTLR3_TRUE;
            		            return retval;
            		        }


            		        CONSTRUCTEX();
            		        EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
            		        EXCEPTION->message      = (void *)"";
            		        EXCEPTION->decisionNum  = 64;
            		        EXCEPTION->state        = 2;


            		        goto rulefixed_len_time_unitEx;

            		    }
            		}
            	}
                break;

            default:
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                CONSTRUCTEX();
                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
                EXCEPTION->message      = (void *)"";
                EXCEPTION->decisionNum  = 64;
                EXCEPTION->state        = 0;


                goto rulefixed_len_time_unitEx;

            }

            switch (alt64)
            {
        	case 1:
        	    // ../grammars/belle_sdp.g:494:22: {...}? alpha_num
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        if ( !((IS_TOKEN(d))) )
        	        {
        	            if (BACKTRACKING>0)
        	            {
        	                FAILEDFLAG = ANTLR3_TRUE;
        	                return retval;
        	            }

        	                CONSTRUCTEX();
        	                EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
        	                EXCEPTION->message      = (void *)"IS_TOKEN(d)";
        	                EXCEPTION->ruleName	 = (void *)"fixed_len_time_unit";


        	        }

        	        FOLLOWPUSH(FOLLOW_alpha_num_in_fixed_len_time_unit3343);
        	        alpha_num263=alpha_num(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulefixed_len_time_unitEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num263.tree);

        	    }
        	    break;
        	case 2:
        	    // ../grammars/belle_sdp.g:495:25: {...}? alpha_num
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        if ( !((IS_TOKEN(h))) )
        	        {
        	            if (BACKTRACKING>0)
        	            {
        	                FAILEDFLAG = ANTLR3_TRUE;
        	                return retval;
        	            }

        	                CONSTRUCTEX();
        	                EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
        	                EXCEPTION->message      = (void *)"IS_TOKEN(h)";
        	                EXCEPTION->ruleName	 = (void *)"fixed_len_time_unit";


        	        }

        	        FOLLOWPUSH(FOLLOW_alpha_num_in_fixed_len_time_unit3371);
        	        alpha_num264=alpha_num(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulefixed_len_time_unitEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num264.tree);

        	    }
        	    break;
        	case 3:
        	    // ../grammars/belle_sdp.g:496:25: {...}? alpha_num
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        if ( !((IS_TOKEN(m))) )
        	        {
        	            if (BACKTRACKING>0)
        	            {
        	                FAILEDFLAG = ANTLR3_TRUE;
        	                return retval;
        	            }

        	                CONSTRUCTEX();
        	                EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
        	                EXCEPTION->message      = (void *)"IS_TOKEN(m)";
        	                EXCEPTION->ruleName	 = (void *)"fixed_len_time_unit";


        	        }

        	        FOLLOWPUSH(FOLLOW_alpha_num_in_fixed_len_time_unit3399);
        	        alpha_num265=alpha_num(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulefixed_len_time_unitEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num265.tree);

        	    }
        	    break;
        	case 4:
        	    // ../grammars/belle_sdp.g:497:25: {...}? alpha_num
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        if ( !((IS_TOKEN(s))) )
        	        {
        	            if (BACKTRACKING>0)
        	            {
        	                FAILEDFLAG = ANTLR3_TRUE;
        	                return retval;
        	            }

        	                CONSTRUCTEX();
        	                EXCEPTION->type         = ANTLR3_FAILED_PREDICATE_EXCEPTION;
        	                EXCEPTION->message      = (void *)"IS_TOKEN(s)";
        	                EXCEPTION->ruleName	 = (void *)"fixed_len_time_unit";


        	        }

        	        FOLLOWPUSH(FOLLOW_alpha_num_in_fixed_len_time_unit3427);
        	        alpha_num266=alpha_num(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulefixed_len_time_unitEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num266.tree);

        	    }
        	    break;

            }
        }
    }

    // This is where rules clean up and exit
    //
    goto rulefixed_len_time_unitEx; /* Prevent compiler warnings */
    rulefixed_len_time_unitEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start bwtype
 * ../grammars/belle_sdp.g:499:1: bwtype : ( alpha_num )+ ;
 */
static belle_sdpParser_bwtype_return
bwtype(pbelle_sdpParser ctx)
{
    belle_sdpParser_bwtype_return retval;


    pANTLR3_BASE_TREE root_0;

    belle_sdpParser_alpha_num_return alpha_num267;
    #undef	RETURN_TYPE_alpha_num267
    #define	RETURN_TYPE_alpha_num267 belle_sdpParser_alpha_num_return


    /* Initialize rule variables
     */

    root_0 = NULL;

    alpha_num267.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;




    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:499:7: ( ( alpha_num )+ )
        // ../grammars/belle_sdp.g:499:22: ( alpha_num )+
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            // ../grammars/belle_sdp.g:499:22: ( alpha_num )+
            {
                int cnt65=0;

                for (;;)
                {
                    int alt65=2;
            	switch ( LA(1) )
            	{
            	case COMMON_CHAR:
            	case DIGIT:
            	case HEX_CHAR:
            		{
            			alt65=1;
            		}
            	    break;

            	}

            	switch (alt65)
            	{
            	    case 1:
            	        // ../grammars/belle_sdp.g:499:22: alpha_num
            	        {
            	            FOLLOWPUSH(FOLLOW_alpha_num_in_bwtype3447);
            	            alpha_num267=alpha_num(ctx);

            	            FOLLOWPOP();
            	            if  (HASEXCEPTION())
            	            {
            	                goto rulebwtypeEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num267.tree);

            	        }
            	        break;

            	    default:

            		if ( cnt65 >= 1 )
            		{
            		    goto loop65;
            		}
            		if (BACKTRACKING>0)
            		{
            		    FAILEDFLAG = ANTLR3_TRUE;
            		    return retval;
            		}

            		/* mismatchedSetEx()
            		 */
            		CONSTRUCTEX();
            		EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
            		EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;


            		goto rulebwtypeEx;
            	}
            	cnt65++;
                }
                loop65: ;	/* Jump to here if this rule does not match */
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto rulebwtypeEx; /* Prevent compiler warnings */
    rulebwtypeEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start bandwidth_value
 * ../grammars/belle_sdp.g:501:1: bandwidth_value : ( DIGIT )+ ;
 */
static belle_sdpParser_bandwidth_value_return
bandwidth_value(pbelle_sdpParser ctx)
{
    belle_sdpParser_bandwidth_value_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    DIGIT268;

    pANTLR3_BASE_TREE DIGIT268_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    DIGIT268       = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    DIGIT268_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:501:16: ( ( DIGIT )+ )
        // ../grammars/belle_sdp.g:501:28: ( DIGIT )+
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            // ../grammars/belle_sdp.g:501:28: ( DIGIT )+
            {
                int cnt66=0;

                for (;;)
                {
                    int alt66=2;
            	switch ( LA(1) )
            	{
            	case DIGIT:
            		{
            			alt66=1;
            		}
            	    break;

            	}

            	switch (alt66)
            	{
            	    case 1:
            	        // ../grammars/belle_sdp.g:501:28: DIGIT
            	        {
            	            DIGIT268 = (pANTLR3_COMMON_TOKEN) MATCHT(DIGIT, &FOLLOW_DIGIT_in_bandwidth_value3465);
            	            if  (HASEXCEPTION())
            	            {
            	                goto rulebandwidth_valueEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) {
            	            DIGIT268_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DIGIT268));
            	            ADAPTOR->addChild(ADAPTOR, root_0, DIGIT268_tree);
            	            }

            	        }
            	        break;

            	    default:

            		if ( cnt66 >= 1 )
            		{
            		    goto loop66;
            		}
            		if (BACKTRACKING>0)
            		{
            		    FAILEDFLAG = ANTLR3_TRUE;
            		    return retval;
            		}

            		/* mismatchedSetEx()
            		 */
            		CONSTRUCTEX();
            		EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
            		EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;


            		goto rulebandwidth_valueEx;
            	}
            	cnt66++;
                }
                loop66: ;	/* Jump to here if this rule does not match */
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto rulebandwidth_valueEx; /* Prevent compiler warnings */
    rulebandwidth_valueEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start username
 * ../grammars/belle_sdp.g:503:1: username : email_safe ;
 */
static belle_sdpParser_username_return
username(pbelle_sdpParser ctx)
{
    belle_sdpParser_username_return retval;


    pANTLR3_BASE_TREE root_0;

    belle_sdpParser_email_safe_return email_safe269;
    #undef	RETURN_TYPE_email_safe269
    #define	RETURN_TYPE_email_safe269 belle_sdpParser_email_safe_return


    /* Initialize rule variables
     */

    root_0 = NULL;

    email_safe269.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;




    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:503:9: ( email_safe )
        // ../grammars/belle_sdp.g:503:22: email_safe
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            FOLLOWPUSH(FOLLOW_email_safe_in_username3484);
            email_safe269=email_safe(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruleusernameEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, email_safe269.tree);

        }

    }

    // This is where rules clean up and exit
    //
    goto ruleusernameEx; /* Prevent compiler warnings */
    ruleusernameEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start email_address
 * ../grammars/belle_sdp.g:506:1: email_address options {greedy=false; } : (~ ( CR | LF ) )* ;
 */
static belle_sdpParser_email_address_return
email_address(pbelle_sdpParser ctx)
{
    belle_sdpParser_email_address_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    set270;

    pANTLR3_BASE_TREE set270_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    set270       = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    set270_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:506:48: ( (~ ( CR | LF ) )* )
        // ../grammars/belle_sdp.g:506:57: (~ ( CR | LF ) )*
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            // ../grammars/belle_sdp.g:506:57: (~ ( CR | LF ) )*

            for (;;)
            {
                int alt67=2;
                switch ( LA(1) )
                {
                case COLON:
                case COMMA:
                case COMMON_CHAR:
                case DASH:
                case DIGIT:
                case DOT:
                case EQUAL:
                case HEX_CHAR:
                case LQUOTE:
                case OCTET:
                case POS_DIGIT:
                case RQUOTE:
                case SLASH:
                case SPACE:
                case STAR:
                case ZERO:
                case 22:
                case 23:
                case 24:
                case 25:
                case 26:
                case 27:
                case 28:
                case 29:
                case 30:
                case 31:
                case 32:
                case 33:
                case 34:
                case 35:
                	{
                		alt67=1;
                	}
                    break;

                }

                switch (alt67)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:
            	    {
            	        set270=(pANTLR3_COMMON_TOKEN)LT(1);

            	        if ( ((LA(1) >= COLON) && (LA(1) <= COMMON_CHAR)) || ((LA(1) >= DASH) && (LA(1) <= HEX_CHAR)) || ((LA(1) >= LQUOTE) && (LA(1) <= 35)) )
            	        {
            	            CONSUME();
            	            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, 
            	            (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set270))
            	            );
            	            PERRORRECOVERY=ANTLR3_FALSE;
            	            FAILEDFLAG=ANTLR3_FALSE;

            	        }
            	        else
            	        {
            	            if (BACKTRACKING>0)
            	            {
            	                FAILEDFLAG = ANTLR3_TRUE;
            	                return retval;
            	            }

            	            CONSTRUCTEX();
            	            EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;
            	            EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;
            	            EXCEPTION->expectingSet = NULL;

            	            goto ruleemail_addressEx;
            	        }


            	    }
            	    break;

            	default:
            	    goto loop67;	/* break out of the loop */
            	    break;
                }
            }
            loop67: ; /* Jump out to here if this rule does not match */


        }

    }

    // This is where rules clean up and exit
    //
    goto ruleemail_addressEx; /* Prevent compiler warnings */
    ruleemail_addressEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start uri
 * ../grammars/belle_sdp.g:510:1: uri : text ;
 */
static belle_sdpParser_uri_return
uri(pbelle_sdpParser ctx)
{
    belle_sdpParser_uri_return retval;


    pANTLR3_BASE_TREE root_0;

    belle_sdpParser_text_return text271;
    #undef	RETURN_TYPE_text271
    #define	RETURN_TYPE_text271 belle_sdpParser_text_return


    /* Initialize rule variables
     */

    root_0 = NULL;

    text271.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;




    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:510:4: ( text )
        // ../grammars/belle_sdp.g:510:15: text
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            FOLLOWPUSH(FOLLOW_text_in_uri3593);
            text271=text(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruleuriEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, text271.tree);

        }

    }

    // This is where rules clean up and exit
    //
    goto ruleuriEx; /* Prevent compiler warnings */
    ruleuriEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start phone_number
 * ../grammars/belle_sdp.g:512:1: phone_number : phone ;
 */
static belle_sdpParser_phone_number_return
phone_number(pbelle_sdpParser ctx)
{
    belle_sdpParser_phone_number_return retval;


    pANTLR3_BASE_TREE root_0;

    belle_sdpParser_phone_return phone272;
    #undef	RETURN_TYPE_phone272
    #define	RETURN_TYPE_phone272 belle_sdpParser_phone_return


    /* Initialize rule variables
     */

    root_0 = NULL;

    phone272.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;




    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:512:13: ( phone )
        // ../grammars/belle_sdp.g:512:23: phone
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            FOLLOWPUSH(FOLLOW_phone_in_phone_number3616);
            phone272=phone(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulephone_numberEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, phone272.tree);

        }

    }

    // This is where rules clean up and exit
    //
    goto rulephone_numberEx; /* Prevent compiler warnings */
    rulephone_numberEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start phone
 * ../grammars/belle_sdp.g:516:1: phone : text ;
 */
static belle_sdpParser_phone_return
phone(pbelle_sdpParser ctx)
{
    belle_sdpParser_phone_return retval;


    pANTLR3_BASE_TREE root_0;

    belle_sdpParser_text_return text273;
    #undef	RETURN_TYPE_text273
    #define	RETURN_TYPE_text273 belle_sdpParser_text_return


    /* Initialize rule variables
     */

    root_0 = NULL;

    text273.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;




    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:516:6: ( text )
        // ../grammars/belle_sdp.g:516:22: text
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            FOLLOWPUSH(FOLLOW_text_in_phone3638);
            text273=text(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulephoneEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, text273.tree);

        }

    }

    // This is where rules clean up and exit
    //
    goto rulephoneEx; /* Prevent compiler warnings */
    rulephoneEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start nettype
 * ../grammars/belle_sdp.g:520:1: nettype : ( alpha_num )+ ;
 */
static belle_sdpParser_nettype_return
nettype(pbelle_sdpParser ctx)
{
    belle_sdpParser_nettype_return retval;


    pANTLR3_BASE_TREE root_0;

    belle_sdpParser_alpha_num_return alpha_num274;
    #undef	RETURN_TYPE_alpha_num274
    #define	RETURN_TYPE_alpha_num274 belle_sdpParser_alpha_num_return


    /* Initialize rule variables
     */

    root_0 = NULL;

    alpha_num274.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;




    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:520:8: ( ( alpha_num )+ )
        // ../grammars/belle_sdp.g:520:22: ( alpha_num )+
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            // ../grammars/belle_sdp.g:520:22: ( alpha_num )+
            {
                int cnt68=0;

                for (;;)
                {
                    int alt68=2;
            	switch ( LA(1) )
            	{
            	case COMMON_CHAR:
            	case DIGIT:
            	case HEX_CHAR:
            		{
            			alt68=1;
            		}
            	    break;

            	}

            	switch (alt68)
            	{
            	    case 1:
            	        // ../grammars/belle_sdp.g:520:22: alpha_num
            	        {
            	            FOLLOWPUSH(FOLLOW_alpha_num_in_nettype3709);
            	            alpha_num274=alpha_num(ctx);

            	            FOLLOWPOP();
            	            if  (HASEXCEPTION())
            	            {
            	                goto rulenettypeEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num274.tree);

            	        }
            	        break;

            	    default:

            		if ( cnt68 >= 1 )
            		{
            		    goto loop68;
            		}
            		if (BACKTRACKING>0)
            		{
            		    FAILEDFLAG = ANTLR3_TRUE;
            		    return retval;
            		}

            		/* mismatchedSetEx()
            		 */
            		CONSTRUCTEX();
            		EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
            		EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;


            		goto rulenettypeEx;
            	}
            	cnt68++;
                }
                loop68: ;	/* Jump to here if this rule does not match */
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto rulenettypeEx; /* Prevent compiler warnings */
    rulenettypeEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start addrtype
 * ../grammars/belle_sdp.g:523:1: addrtype : ( alpha_num )+ ;
 */
static belle_sdpParser_addrtype_return
addrtype(pbelle_sdpParser ctx)
{
    belle_sdpParser_addrtype_return retval;


    pANTLR3_BASE_TREE root_0;

    belle_sdpParser_alpha_num_return alpha_num275;
    #undef	RETURN_TYPE_alpha_num275
    #define	RETURN_TYPE_alpha_num275 belle_sdpParser_alpha_num_return


    /* Initialize rule variables
     */

    root_0 = NULL;

    alpha_num275.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;




    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:523:9: ( ( alpha_num )+ )
        // ../grammars/belle_sdp.g:523:22: ( alpha_num )+
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            // ../grammars/belle_sdp.g:523:22: ( alpha_num )+
            {
                int cnt69=0;

                for (;;)
                {
                    int alt69=2;
            	switch ( LA(1) )
            	{
            	case COMMON_CHAR:
            	case DIGIT:
            	case HEX_CHAR:
            		{
            			alt69=1;
            		}
            	    break;

            	}

            	switch (alt69)
            	{
            	    case 1:
            	        // ../grammars/belle_sdp.g:523:22: alpha_num
            	        {
            	            FOLLOWPUSH(FOLLOW_alpha_num_in_addrtype3753);
            	            alpha_num275=alpha_num(ctx);

            	            FOLLOWPOP();
            	            if  (HASEXCEPTION())
            	            {
            	                goto ruleaddrtypeEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num275.tree);

            	        }
            	        break;

            	    default:

            		if ( cnt69 >= 1 )
            		{
            		    goto loop69;
            		}
            		if (BACKTRACKING>0)
            		{
            		    FAILEDFLAG = ANTLR3_TRUE;
            		    return retval;
            		}

            		/* mismatchedSetEx()
            		 */
            		CONSTRUCTEX();
            		EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
            		EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;


            		goto ruleaddrtypeEx;
            	}
            	cnt69++;
                }
                loop69: ;	/* Jump to here if this rule does not match */
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto ruleaddrtypeEx; /* Prevent compiler warnings */
    ruleaddrtypeEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start addr
 * ../grammars/belle_sdp.g:526:1: addr : unicast_address ;
 */
static belle_sdpParser_addr_return
addr(pbelle_sdpParser ctx)
{
    belle_sdpParser_addr_return retval;


    pANTLR3_BASE_TREE root_0;

    belle_sdpParser_unicast_address_return unicast_address276;
    #undef	RETURN_TYPE_unicast_address276
    #define	RETURN_TYPE_unicast_address276 belle_sdpParser_unicast_address_return


    /* Initialize rule variables
     */

    root_0 = NULL;

    unicast_address276.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;




    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:526:5: ( unicast_address )
        // ../grammars/belle_sdp.g:526:23: unicast_address
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            FOLLOWPUSH(FOLLOW_unicast_address_in_addr3805);
            unicast_address276=unicast_address(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruleaddrEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, unicast_address276.tree);

        }

    }

    // This is where rules clean up and exit
    //
    goto ruleaddrEx; /* Prevent compiler warnings */
    ruleaddrEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start multicast_part
 * ../grammars/belle_sdp.g:528:2: multicast_part : ( SLASH num+= integer )+ ;
 */
static belle_sdpParser_multicast_part_return
multicast_part(pbelle_sdpParser ctx)
{
    belle_sdpParser_multicast_part_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    SLASH277;
    pANTLR3_VECTOR    list_num;
    belle_sdpParser_integer_return num;
    #undef	RETURN_TYPE_num
    #define	RETURN_TYPE_num belle_sdpParser_integer_return

    pANTLR3_BASE_TREE SLASH277_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    SLASH277       = NULL;
    list_num     = NULL;
    num.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    SLASH277_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:528:16: ( ( SLASH num+= integer )+ )
        // ../grammars/belle_sdp.g:528:18: ( SLASH num+= integer )+
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            // ../grammars/belle_sdp.g:528:18: ( SLASH num+= integer )+
            {
                int cnt70=0;

                for (;;)
                {
                    int alt70=2;
            	switch ( LA(1) )
            	{
            	case SLASH:
            		{
            			alt70=1;
            		}
            	    break;

            	}

            	switch (alt70)
            	{
            	    case 1:
            	        // ../grammars/belle_sdp.g:528:19: SLASH num+= integer
            	        {
            	            SLASH277 = (pANTLR3_COMMON_TOKEN) MATCHT(SLASH, &FOLLOW_SLASH_in_multicast_part3815);
            	            if  (HASEXCEPTION())
            	            {
            	                goto rulemulticast_partEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) {
            	            SLASH277_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, SLASH277));
            	            ADAPTOR->addChild(ADAPTOR, root_0, SLASH277_tree);
            	            }

            	            FOLLOWPUSH(FOLLOW_integer_in_multicast_part3819);
            	            num=integer(ctx);

            	            FOLLOWPOP();
            	            if  (HASEXCEPTION())
            	            {
            	                goto rulemulticast_partEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, num.tree);
            	            if (list_num == NULL)
            	            {
            	                list_num=ctx->vectors->newVector(ctx->vectors);
            	            }
            	            {
            	                RETURN_TYPE_num * tcopy;

            	                tcopy = (RETURN_TYPE_num *)ANTLR3_MALLOC(sizeof(RETURN_TYPE_num)); /* Note no memory allocation checks! */
            	                ANTLR3_MEMCPY((void *)(tcopy), (const void *)&num, sizeof(RETURN_TYPE_num));
            	                list_num->add(list_num, (void *)tcopy, freeScope);  /* Add whatever the return type is */

            	            }

            	            if ( BACKTRACKING==0 )
            	            {

            	                 			if (strcmp( belle_sdp_connection_get_address_type((SCOPE_TOP(connection))->current),"IP6")==0)
            	                 				belle_sdp_connection_set_range((SCOPE_TOP(connection))->current,atoi((const char*)
            	                (STRSTREAM->toStringTT(STRSTREAM, num.start, num.stop))
            	                ->chars));
            	                 			else if (list_num->count ==1)
            	                				belle_sdp_connection_set_ttl((SCOPE_TOP(connection))->current,atoi((const char*)
            	                (STRSTREAM->toStringTT(STRSTREAM, num.start, num.stop))
            	                ->chars));
            	                			else if (list_num->count ==2)
            	                				belle_sdp_connection_set_range((SCOPE_TOP(connection))->current,atoi((const char*)
            	                (STRSTREAM->toStringTT(STRSTREAM, num.start, num.stop))
            	                ->chars));
            	                			
            	            }


            	        }
            	        break;

            	    default:

            		if ( cnt70 >= 1 )
            		{
            		    goto loop70;
            		}
            		if (BACKTRACKING>0)
            		{
            		    FAILEDFLAG = ANTLR3_TRUE;
            		    return retval;
            		}

            		/* mismatchedSetEx()
            		 */
            		CONSTRUCTEX();
            		EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
            		EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;


            		goto rulemulticast_partEx;
            	}
            	cnt70++;
                }
                loop70: ;	/* Jump to here if this rule does not match */
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto rulemulticast_partEx; /* Prevent compiler warnings */
    rulemulticast_partEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start fqdn
 * ../grammars/belle_sdp.g:537:1: fqdn : ( domainlabel DOT )* toplabel ( DOT )? ;
 */
static belle_sdpParser_fqdn_return
fqdn(pbelle_sdpParser ctx)
{
    belle_sdpParser_fqdn_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    DOT279;
    pANTLR3_COMMON_TOKEN    DOT281;
    belle_sdpParser_domainlabel_return domainlabel278;
    #undef	RETURN_TYPE_domainlabel278
    #define	RETURN_TYPE_domainlabel278 belle_sdpParser_domainlabel_return

    belle_sdpParser_toplabel_return toplabel280;
    #undef	RETURN_TYPE_toplabel280
    #define	RETURN_TYPE_toplabel280 belle_sdpParser_toplabel_return

    pANTLR3_BASE_TREE DOT279_tree;
    pANTLR3_BASE_TREE DOT281_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    DOT279       = NULL;
    DOT281       = NULL;
    domainlabel278.tree = NULL;

    toplabel280.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    DOT279_tree   = NULL;
    DOT281_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:537:13: ( ( domainlabel DOT )* toplabel ( DOT )? )
        // ../grammars/belle_sdp.g:537:17: ( domainlabel DOT )* toplabel ( DOT )?
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            // ../grammars/belle_sdp.g:537:17: ( domainlabel DOT )*

            for (;;)
            {
                int alt71=2;
                alt71 = cdfa71.predict(ctx, RECOGNIZER, ISTREAM, &cdfa71);
                if  (HASEXCEPTION())
                {
                    goto rulefqdnEx;
                }
                if (HASFAILED())
                {
                    return retval;
                }

                switch (alt71)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:537:19: domainlabel DOT
            	    {
            	        FOLLOWPUSH(FOLLOW_domainlabel_in_fqdn3843);
            	        domainlabel278=domainlabel(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulefqdnEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, domainlabel278.tree);

            	        DOT279 = (pANTLR3_COMMON_TOKEN) MATCHT(DOT, &FOLLOW_DOT_in_fqdn3845);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulefqdnEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        DOT279_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DOT279));
            	        ADAPTOR->addChild(ADAPTOR, root_0, DOT279_tree);
            	        }

            	    }
            	    break;

            	default:
            	    goto loop71;	/* break out of the loop */
            	    break;
                }
            }
            loop71: ; /* Jump out to here if this rule does not match */


            FOLLOWPUSH(FOLLOW_toplabel_in_fqdn3850);
            toplabel280=toplabel(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulefqdnEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, toplabel280.tree);

            // ../grammars/belle_sdp.g:537:47: ( DOT )?
            {
                int alt72=2;
                switch ( LA(1) )
                {
                    case DOT:
                    	{
                    		alt72=1;
                    	}
                        break;
                }

                switch (alt72)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:537:47: DOT
            	    {
            	        DOT281 = (pANTLR3_COMMON_TOKEN) MATCHT(DOT, &FOLLOW_DOT_in_fqdn3852);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulefqdnEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        DOT281_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DOT281));
            	        ADAPTOR->addChild(ADAPTOR, root_0, DOT281_tree);
            	        }

            	    }
            	    break;

                }
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto rulefqdnEx; /* Prevent compiler warnings */
    rulefqdnEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start domainlabel
 * ../grammars/belle_sdp.g:539:1: domainlabel : ( alpha_num | ( alpha_num ( alpha_num | DASH )* alpha_num ) );
 */
static belle_sdpParser_domainlabel_return
domainlabel(pbelle_sdpParser ctx)
{
    belle_sdpParser_domainlabel_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    DASH285;
    belle_sdpParser_alpha_num_return alpha_num282;
    #undef	RETURN_TYPE_alpha_num282
    #define	RETURN_TYPE_alpha_num282 belle_sdpParser_alpha_num_return

    belle_sdpParser_alpha_num_return alpha_num283;
    #undef	RETURN_TYPE_alpha_num283
    #define	RETURN_TYPE_alpha_num283 belle_sdpParser_alpha_num_return

    belle_sdpParser_alpha_num_return alpha_num284;
    #undef	RETURN_TYPE_alpha_num284
    #define	RETURN_TYPE_alpha_num284 belle_sdpParser_alpha_num_return

    belle_sdpParser_alpha_num_return alpha_num286;
    #undef	RETURN_TYPE_alpha_num286
    #define	RETURN_TYPE_alpha_num286 belle_sdpParser_alpha_num_return

    pANTLR3_BASE_TREE DASH285_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    DASH285       = NULL;
    alpha_num282.tree = NULL;

    alpha_num283.tree = NULL;

    alpha_num284.tree = NULL;

    alpha_num286.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    DASH285_tree   = NULL;


    retval.tree  = NULL;

    {
        {
            //  ../grammars/belle_sdp.g:539:17: ( alpha_num | ( alpha_num ( alpha_num | DASH )* alpha_num ) )

            ANTLR3_UINT32 alt74;

            alt74=2;

            switch ( LA(1) )
            {
            case COMMON_CHAR:
            case HEX_CHAR:
            	{
            		switch ( LA(2) )
            		{
            		case DOT:
            			{
            				alt74=1;
            			}
            		    break;
            		case COMMON_CHAR:
            		case DASH:
            		case DIGIT:
            		case HEX_CHAR:
            			{
            				alt74=2;
            			}
            		    break;

            		default:
            		    if (BACKTRACKING>0)
            		    {
            		        FAILEDFLAG = ANTLR3_TRUE;
            		        return retval;
            		    }

            		    CONSTRUCTEX();
            		    EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
            		    EXCEPTION->message      = (void *)"";
            		    EXCEPTION->decisionNum  = 74;
            		    EXCEPTION->state        = 1;


            		    goto ruledomainlabelEx;

            		}

            	}
                break;
            case DIGIT:
            	{
            		switch ( LA(2) )
            		{
            		case DOT:
            			{
            				alt74=1;
            			}
            		    break;
            		case COMMON_CHAR:
            		case DASH:
            		case DIGIT:
            		case HEX_CHAR:
            			{
            				alt74=2;
            			}
            		    break;

            		default:
            		    if (BACKTRACKING>0)
            		    {
            		        FAILEDFLAG = ANTLR3_TRUE;
            		        return retval;
            		    }

            		    CONSTRUCTEX();
            		    EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
            		    EXCEPTION->message      = (void *)"";
            		    EXCEPTION->decisionNum  = 74;
            		    EXCEPTION->state        = 2;


            		    goto ruledomainlabelEx;

            		}

            	}
                break;

            default:
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                CONSTRUCTEX();
                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
                EXCEPTION->message      = (void *)"";
                EXCEPTION->decisionNum  = 74;
                EXCEPTION->state        = 0;


                goto ruledomainlabelEx;

            }

            switch (alt74)
            {
        	case 1:
        	    // ../grammars/belle_sdp.g:539:21: alpha_num
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        FOLLOWPUSH(FOLLOW_alpha_num_in_domainlabel3868);
        	        alpha_num282=alpha_num(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruledomainlabelEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num282.tree);

        	    }
        	    break;
        	case 2:
        	    // ../grammars/belle_sdp.g:539:33: ( alpha_num ( alpha_num | DASH )* alpha_num )
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        // ../grammars/belle_sdp.g:539:33: ( alpha_num ( alpha_num | DASH )* alpha_num )
        	        // ../grammars/belle_sdp.g:539:34: alpha_num ( alpha_num | DASH )* alpha_num
        	        {
        	            FOLLOWPUSH(FOLLOW_alpha_num_in_domainlabel3873);
        	            alpha_num283=alpha_num(ctx);

        	            FOLLOWPOP();
        	            if  (HASEXCEPTION())
        	            {
        	                goto ruledomainlabelEx;
        	            }
        	            if (HASFAILED())
        	            {
        	                return retval;
        	            }

        	            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num283.tree);

        	            // ../grammars/belle_sdp.g:539:44: ( alpha_num | DASH )*

        	            for (;;)
        	            {
        	                int alt73=3;
        	                switch ( LA(1) )
        	                {
        	                case COMMON_CHAR:
        	                case HEX_CHAR:
        	                	{
        	                		switch ( LA(2) )
        	                		{
        	                		case COMMON_CHAR:
        	                		case DASH:
        	                		case DIGIT:
        	                		case HEX_CHAR:
        	                			{
        	                				alt73=1;
        	                			}
        	                		    break;

        	                		}

        	                	}
        	                    break;
        	                case DIGIT:
        	                	{
        	                		switch ( LA(2) )
        	                		{
        	                		case COMMON_CHAR:
        	                		case DASH:
        	                		case DIGIT:
        	                		case HEX_CHAR:
        	                			{
        	                				alt73=1;
        	                			}
        	                		    break;

        	                		}

        	                	}
        	                    break;
        	                case DASH:
        	                	{
        	                		alt73=2;
        	                	}
        	                    break;

        	                }

        	                switch (alt73)
        	                {
        	            	case 1:
        	            	    // ../grammars/belle_sdp.g:539:46: alpha_num
        	            	    {
        	            	        FOLLOWPUSH(FOLLOW_alpha_num_in_domainlabel3877);
        	            	        alpha_num284=alpha_num(ctx);

        	            	        FOLLOWPOP();
        	            	        if  (HASEXCEPTION())
        	            	        {
        	            	            goto ruledomainlabelEx;
        	            	        }
        	            	        if (HASFAILED())
        	            	        {
        	            	            return retval;
        	            	        }

        	            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num284.tree);

        	            	    }
        	            	    break;
        	            	case 2:
        	            	    // ../grammars/belle_sdp.g:539:58: DASH
        	            	    {
        	            	        DASH285 = (pANTLR3_COMMON_TOKEN) MATCHT(DASH, &FOLLOW_DASH_in_domainlabel3881);
        	            	        if  (HASEXCEPTION())
        	            	        {
        	            	            goto ruledomainlabelEx;
        	            	        }
        	            	        if (HASFAILED())
        	            	        {
        	            	            return retval;
        	            	        }

        	            	        if ( BACKTRACKING==0 ) {
        	            	        DASH285_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DASH285));
        	            	        ADAPTOR->addChild(ADAPTOR, root_0, DASH285_tree);
        	            	        }

        	            	    }
        	            	    break;

        	            	default:
        	            	    goto loop73;	/* break out of the loop */
        	            	    break;
        	                }
        	            }
        	            loop73: ; /* Jump out to here if this rule does not match */


        	            FOLLOWPUSH(FOLLOW_alpha_num_in_domainlabel3886);
        	            alpha_num286=alpha_num(ctx);

        	            FOLLOWPOP();
        	            if  (HASEXCEPTION())
        	            {
        	                goto ruledomainlabelEx;
        	            }
        	            if (HASFAILED())
        	            {
        	                return retval;
        	            }

        	            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num286.tree);

        	        }


        	    }
        	    break;

            }
        }
    }

    // This is where rules clean up and exit
    //
    goto ruledomainlabelEx; /* Prevent compiler warnings */
    ruledomainlabelEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start toplabel
 * ../grammars/belle_sdp.g:540:1: toplabel : ( alpha | ( alpha ( alpha_num | DASH )* alpha_num ) );
 */
static belle_sdpParser_toplabel_return
toplabel(pbelle_sdpParser ctx)
{
    belle_sdpParser_toplabel_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    DASH290;
    belle_sdpParser_alpha_return alpha287;
    #undef	RETURN_TYPE_alpha287
    #define	RETURN_TYPE_alpha287 belle_sdpParser_alpha_return

    belle_sdpParser_alpha_return alpha288;
    #undef	RETURN_TYPE_alpha288
    #define	RETURN_TYPE_alpha288 belle_sdpParser_alpha_return

    belle_sdpParser_alpha_num_return alpha_num289;
    #undef	RETURN_TYPE_alpha_num289
    #define	RETURN_TYPE_alpha_num289 belle_sdpParser_alpha_num_return

    belle_sdpParser_alpha_num_return alpha_num291;
    #undef	RETURN_TYPE_alpha_num291
    #define	RETURN_TYPE_alpha_num291 belle_sdpParser_alpha_num_return

    pANTLR3_BASE_TREE DASH290_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    DASH290       = NULL;
    alpha287.tree = NULL;

    alpha288.tree = NULL;

    alpha_num289.tree = NULL;

    alpha_num291.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    DASH290_tree   = NULL;


    retval.tree  = NULL;

    {
        {
            //  ../grammars/belle_sdp.g:540:17: ( alpha | ( alpha ( alpha_num | DASH )* alpha_num ) )

            ANTLR3_UINT32 alt76;

            alt76=2;

            switch ( LA(1) )
            {
            case COMMON_CHAR:
            case HEX_CHAR:
            	{
            		switch ( LA(2) )
            		{
            		case EOF:
            		case DOT:
            			{
            				alt76=1;
            			}
            		    break;
            		case COMMON_CHAR:
            		case DASH:
            		case DIGIT:
            		case HEX_CHAR:
            			{
            				alt76=2;
            			}
            		    break;

            		default:
            		    if (BACKTRACKING>0)
            		    {
            		        FAILEDFLAG = ANTLR3_TRUE;
            		        return retval;
            		    }

            		    CONSTRUCTEX();
            		    EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
            		    EXCEPTION->message      = (void *)"";
            		    EXCEPTION->decisionNum  = 76;
            		    EXCEPTION->state        = 1;


            		    goto ruletoplabelEx;

            		}

            	}
                break;

            default:
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                CONSTRUCTEX();
                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
                EXCEPTION->message      = (void *)"";
                EXCEPTION->decisionNum  = 76;
                EXCEPTION->state        = 0;


                goto ruletoplabelEx;

            }

            switch (alt76)
            {
        	case 1:
        	    // ../grammars/belle_sdp.g:540:21: alpha
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        FOLLOWPUSH(FOLLOW_alpha_in_toplabel3904);
        	        alpha287=alpha(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruletoplabelEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha287.tree);

        	    }
        	    break;
        	case 2:
        	    // ../grammars/belle_sdp.g:540:29: ( alpha ( alpha_num | DASH )* alpha_num )
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        // ../grammars/belle_sdp.g:540:29: ( alpha ( alpha_num | DASH )* alpha_num )
        	        // ../grammars/belle_sdp.g:540:30: alpha ( alpha_num | DASH )* alpha_num
        	        {
        	            FOLLOWPUSH(FOLLOW_alpha_in_toplabel3909);
        	            alpha288=alpha(ctx);

        	            FOLLOWPOP();
        	            if  (HASEXCEPTION())
        	            {
        	                goto ruletoplabelEx;
        	            }
        	            if (HASFAILED())
        	            {
        	                return retval;
        	            }

        	            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha288.tree);

        	            // ../grammars/belle_sdp.g:540:36: ( alpha_num | DASH )*

        	            for (;;)
        	            {
        	                int alt75=3;
        	                switch ( LA(1) )
        	                {
        	                case COMMON_CHAR:
        	                case HEX_CHAR:
        	                	{
        	                		switch ( LA(2) )
        	                		{
        	                		case COMMON_CHAR:
        	                		case DASH:
        	                		case DIGIT:
        	                		case HEX_CHAR:
        	                			{
        	                				alt75=1;
        	                			}
        	                		    break;

        	                		}

        	                	}
        	                    break;
        	                case DIGIT:
        	                	{
        	                		switch ( LA(2) )
        	                		{
        	                		case COMMON_CHAR:
        	                		case DASH:
        	                		case DIGIT:
        	                		case HEX_CHAR:
        	                			{
        	                				alt75=1;
        	                			}
        	                		    break;

        	                		}

        	                	}
        	                    break;
        	                case DASH:
        	                	{
        	                		alt75=2;
        	                	}
        	                    break;

        	                }

        	                switch (alt75)
        	                {
        	            	case 1:
        	            	    // ../grammars/belle_sdp.g:540:38: alpha_num
        	            	    {
        	            	        FOLLOWPUSH(FOLLOW_alpha_num_in_toplabel3913);
        	            	        alpha_num289=alpha_num(ctx);

        	            	        FOLLOWPOP();
        	            	        if  (HASEXCEPTION())
        	            	        {
        	            	            goto ruletoplabelEx;
        	            	        }
        	            	        if (HASFAILED())
        	            	        {
        	            	            return retval;
        	            	        }

        	            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num289.tree);

        	            	    }
        	            	    break;
        	            	case 2:
        	            	    // ../grammars/belle_sdp.g:540:50: DASH
        	            	    {
        	            	        DASH290 = (pANTLR3_COMMON_TOKEN) MATCHT(DASH, &FOLLOW_DASH_in_toplabel3917);
        	            	        if  (HASEXCEPTION())
        	            	        {
        	            	            goto ruletoplabelEx;
        	            	        }
        	            	        if (HASFAILED())
        	            	        {
        	            	            return retval;
        	            	        }

        	            	        if ( BACKTRACKING==0 ) {
        	            	        DASH290_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DASH290));
        	            	        ADAPTOR->addChild(ADAPTOR, root_0, DASH290_tree);
        	            	        }

        	            	    }
        	            	    break;

        	            	default:
        	            	    goto loop75;	/* break out of the loop */
        	            	    break;
        	                }
        	            }
        	            loop75: ; /* Jump out to here if this rule does not match */


        	            FOLLOWPUSH(FOLLOW_alpha_num_in_toplabel3922);
        	            alpha_num291=alpha_num(ctx);

        	            FOLLOWPOP();
        	            if  (HASEXCEPTION())
        	            {
        	                goto ruletoplabelEx;
        	            }
        	            if (HASFAILED())
        	            {
        	                return retval;
        	            }

        	            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num291.tree);

        	        }


        	    }
        	    break;

            }
        }
    }

    // This is where rules clean up and exit
    //
    goto ruletoplabelEx; /* Prevent compiler warnings */
    ruletoplabelEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start unicast_address
 * ../grammars/belle_sdp.g:542:1: unicast_address : ( alpha_num | DOT | COLON | DASH )* ;
 */
static belle_sdpParser_unicast_address_return
unicast_address(pbelle_sdpParser ctx)
{
    belle_sdpParser_unicast_address_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    DOT293;
    pANTLR3_COMMON_TOKEN    COLON294;
    pANTLR3_COMMON_TOKEN    DASH295;
    belle_sdpParser_alpha_num_return alpha_num292;
    #undef	RETURN_TYPE_alpha_num292
    #define	RETURN_TYPE_alpha_num292 belle_sdpParser_alpha_num_return

    pANTLR3_BASE_TREE DOT293_tree;
    pANTLR3_BASE_TREE COLON294_tree;
    pANTLR3_BASE_TREE DASH295_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    DOT293       = NULL;
    COLON294       = NULL;
    DASH295       = NULL;
    alpha_num292.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    DOT293_tree   = NULL;
    COLON294_tree   = NULL;
    DASH295_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:542:17: ( ( alpha_num | DOT | COLON | DASH )* )
        // ../grammars/belle_sdp.g:542:21: ( alpha_num | DOT | COLON | DASH )*
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            // ../grammars/belle_sdp.g:542:21: ( alpha_num | DOT | COLON | DASH )*

            for (;;)
            {
                int alt77=5;
                switch ( LA(1) )
                {
                case COMMON_CHAR:
                case DIGIT:
                case HEX_CHAR:
                	{
                		alt77=1;
                	}
                    break;
                case DOT:
                	{
                		alt77=2;
                	}
                    break;
                case COLON:
                	{
                		alt77=3;
                	}
                    break;
                case DASH:
                	{
                		alt77=4;
                	}
                    break;

                }

                switch (alt77)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:542:22: alpha_num
            	    {
            	        FOLLOWPUSH(FOLLOW_alpha_num_in_unicast_address3935);
            	        alpha_num292=alpha_num(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto ruleunicast_addressEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num292.tree);

            	    }
            	    break;
            	case 2:
            	    // ../grammars/belle_sdp.g:542:34: DOT
            	    {
            	        DOT293 = (pANTLR3_COMMON_TOKEN) MATCHT(DOT, &FOLLOW_DOT_in_unicast_address3939);
            	        if  (HASEXCEPTION())
            	        {
            	            goto ruleunicast_addressEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        DOT293_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DOT293));
            	        ADAPTOR->addChild(ADAPTOR, root_0, DOT293_tree);
            	        }

            	    }
            	    break;
            	case 3:
            	    // ../grammars/belle_sdp.g:542:40: COLON
            	    {
            	        COLON294 = (pANTLR3_COMMON_TOKEN) MATCHT(COLON, &FOLLOW_COLON_in_unicast_address3943);
            	        if  (HASEXCEPTION())
            	        {
            	            goto ruleunicast_addressEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        COLON294_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, COLON294));
            	        ADAPTOR->addChild(ADAPTOR, root_0, COLON294_tree);
            	        }

            	    }
            	    break;
            	case 4:
            	    // ../grammars/belle_sdp.g:542:47: DASH
            	    {
            	        DASH295 = (pANTLR3_COMMON_TOKEN) MATCHT(DASH, &FOLLOW_DASH_in_unicast_address3946);
            	        if  (HASEXCEPTION())
            	        {
            	            goto ruleunicast_addressEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        DASH295_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DASH295));
            	        ADAPTOR->addChild(ADAPTOR, root_0, DASH295_tree);
            	        }

            	    }
            	    break;

            	default:
            	    goto loop77;	/* break out of the loop */
            	    break;
                }
            }
            loop77: ; /* Jump out to here if this rule does not match */


        }

    }

    // This is where rules clean up and exit
    //
    goto ruleunicast_addressEx; /* Prevent compiler warnings */
    ruleunicast_addressEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start ipv4_address
 * ../grammars/belle_sdp.g:547:1: ipv4_address : decimal_uchar DOT decimal_uchar DOT decimal_uchar DOT decimal_uchar ;
 */
static belle_sdpParser_ipv4_address_return
ipv4_address(pbelle_sdpParser ctx)
{
    belle_sdpParser_ipv4_address_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    DOT297;
    pANTLR3_COMMON_TOKEN    DOT299;
    pANTLR3_COMMON_TOKEN    DOT301;
    belle_sdpParser_decimal_uchar_return decimal_uchar296;
    #undef	RETURN_TYPE_decimal_uchar296
    #define	RETURN_TYPE_decimal_uchar296 belle_sdpParser_decimal_uchar_return

    belle_sdpParser_decimal_uchar_return decimal_uchar298;
    #undef	RETURN_TYPE_decimal_uchar298
    #define	RETURN_TYPE_decimal_uchar298 belle_sdpParser_decimal_uchar_return

    belle_sdpParser_decimal_uchar_return decimal_uchar300;
    #undef	RETURN_TYPE_decimal_uchar300
    #define	RETURN_TYPE_decimal_uchar300 belle_sdpParser_decimal_uchar_return

    belle_sdpParser_decimal_uchar_return decimal_uchar302;
    #undef	RETURN_TYPE_decimal_uchar302
    #define	RETURN_TYPE_decimal_uchar302 belle_sdpParser_decimal_uchar_return

    pANTLR3_BASE_TREE DOT297_tree;
    pANTLR3_BASE_TREE DOT299_tree;
    pANTLR3_BASE_TREE DOT301_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    DOT297       = NULL;
    DOT299       = NULL;
    DOT301       = NULL;
    decimal_uchar296.tree = NULL;

    decimal_uchar298.tree = NULL;

    decimal_uchar300.tree = NULL;

    decimal_uchar302.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    DOT297_tree   = NULL;
    DOT299_tree   = NULL;
    DOT301_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:547:14: ( decimal_uchar DOT decimal_uchar DOT decimal_uchar DOT decimal_uchar )
        // ../grammars/belle_sdp.g:547:24: decimal_uchar DOT decimal_uchar DOT decimal_uchar DOT decimal_uchar
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            FOLLOWPUSH(FOLLOW_decimal_uchar_in_ipv4_address3989);
            decimal_uchar296=decimal_uchar(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruleipv4_addressEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, decimal_uchar296.tree);

            DOT297 = (pANTLR3_COMMON_TOKEN) MATCHT(DOT, &FOLLOW_DOT_in_ipv4_address3991);
            if  (HASEXCEPTION())
            {
                goto ruleipv4_addressEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) {
            DOT297_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DOT297));
            ADAPTOR->addChild(ADAPTOR, root_0, DOT297_tree);
            }

            FOLLOWPUSH(FOLLOW_decimal_uchar_in_ipv4_address3993);
            decimal_uchar298=decimal_uchar(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruleipv4_addressEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, decimal_uchar298.tree);

            DOT299 = (pANTLR3_COMMON_TOKEN) MATCHT(DOT, &FOLLOW_DOT_in_ipv4_address3995);
            if  (HASEXCEPTION())
            {
                goto ruleipv4_addressEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) {
            DOT299_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DOT299));
            ADAPTOR->addChild(ADAPTOR, root_0, DOT299_tree);
            }

            FOLLOWPUSH(FOLLOW_decimal_uchar_in_ipv4_address3997);
            decimal_uchar300=decimal_uchar(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruleipv4_addressEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, decimal_uchar300.tree);

            DOT301 = (pANTLR3_COMMON_TOKEN) MATCHT(DOT, &FOLLOW_DOT_in_ipv4_address3999);
            if  (HASEXCEPTION())
            {
                goto ruleipv4_addressEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) {
            DOT301_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DOT301));
            ADAPTOR->addChild(ADAPTOR, root_0, DOT301_tree);
            }

            FOLLOWPUSH(FOLLOW_decimal_uchar_in_ipv4_address4001);
            decimal_uchar302=decimal_uchar(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruleipv4_addressEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, decimal_uchar302.tree);

        }

    }

    // This is where rules clean up and exit
    //
    goto ruleipv4_addressEx; /* Prevent compiler warnings */
    ruleipv4_addressEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start ipv6_address
 * ../grammars/belle_sdp.g:551:1: ipv6_address : ( hexpart )=> hexpart ( COLON ipv4_address )? ;
 */
static belle_sdpParser_ipv6_address_return
ipv6_address(pbelle_sdpParser ctx)
{
    belle_sdpParser_ipv6_address_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    COLON304;
    belle_sdpParser_hexpart_return hexpart303;
    #undef	RETURN_TYPE_hexpart303
    #define	RETURN_TYPE_hexpart303 belle_sdpParser_hexpart_return

    belle_sdpParser_ipv4_address_return ipv4_address305;
    #undef	RETURN_TYPE_ipv4_address305
    #define	RETURN_TYPE_ipv4_address305 belle_sdpParser_ipv4_address_return

    pANTLR3_BASE_TREE COLON304_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    COLON304       = NULL;
    hexpart303.tree = NULL;

    ipv4_address305.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    COLON304_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:551:17: ( ( hexpart )=> hexpart ( COLON ipv4_address )? )
        // ../grammars/belle_sdp.g:551:20: ( hexpart )=> hexpart ( COLON ipv4_address )?
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            FOLLOWPUSH(FOLLOW_hexpart_in_ipv6_address4020);
            hexpart303=hexpart(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruleipv6_addressEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, hexpart303.tree);

            // ../grammars/belle_sdp.g:551:39: ( COLON ipv4_address )?
            {
                int alt78=2;
                switch ( LA(1) )
                {
                    case COLON:
                    	{
                    		alt78=1;
                    	}
                        break;
                }

                switch (alt78)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:551:41: COLON ipv4_address
            	    {
            	        COLON304 = (pANTLR3_COMMON_TOKEN) MATCHT(COLON, &FOLLOW_COLON_in_ipv6_address4024);
            	        if  (HASEXCEPTION())
            	        {
            	            goto ruleipv6_addressEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        COLON304_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, COLON304));
            	        ADAPTOR->addChild(ADAPTOR, root_0, COLON304_tree);
            	        }

            	        FOLLOWPUSH(FOLLOW_ipv4_address_in_ipv6_address4026);
            	        ipv4_address305=ipv4_address(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto ruleipv6_addressEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, ipv4_address305.tree);

            	    }
            	    break;

                }
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto ruleipv6_addressEx; /* Prevent compiler warnings */
    ruleipv6_addressEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start hexpart
 * ../grammars/belle_sdp.g:552:1: hexpart : ( hexseq | hexseq COLON COLON ( hexseq )? | COLON COLON ( hexseq )? );
 */
static belle_sdpParser_hexpart_return
hexpart(pbelle_sdpParser ctx)
{
    belle_sdpParser_hexpart_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    COLON308;
    pANTLR3_COMMON_TOKEN    COLON309;
    pANTLR3_COMMON_TOKEN    COLON311;
    pANTLR3_COMMON_TOKEN    COLON312;
    belle_sdpParser_hexseq_return hexseq306;
    #undef	RETURN_TYPE_hexseq306
    #define	RETURN_TYPE_hexseq306 belle_sdpParser_hexseq_return

    belle_sdpParser_hexseq_return hexseq307;
    #undef	RETURN_TYPE_hexseq307
    #define	RETURN_TYPE_hexseq307 belle_sdpParser_hexseq_return

    belle_sdpParser_hexseq_return hexseq310;
    #undef	RETURN_TYPE_hexseq310
    #define	RETURN_TYPE_hexseq310 belle_sdpParser_hexseq_return

    belle_sdpParser_hexseq_return hexseq313;
    #undef	RETURN_TYPE_hexseq313
    #define	RETURN_TYPE_hexseq313 belle_sdpParser_hexseq_return

    pANTLR3_BASE_TREE COLON308_tree;
    pANTLR3_BASE_TREE COLON309_tree;
    pANTLR3_BASE_TREE COLON311_tree;
    pANTLR3_BASE_TREE COLON312_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    COLON308       = NULL;
    COLON309       = NULL;
    COLON311       = NULL;
    COLON312       = NULL;
    hexseq306.tree = NULL;

    hexseq307.tree = NULL;

    hexseq310.tree = NULL;

    hexseq313.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    COLON308_tree   = NULL;
    COLON309_tree   = NULL;
    COLON311_tree   = NULL;
    COLON312_tree   = NULL;


    retval.tree  = NULL;

    {
        {
            //  ../grammars/belle_sdp.g:552:16: ( hexseq | hexseq COLON COLON ( hexseq )? | COLON COLON ( hexseq )? )

            ANTLR3_UINT32 alt81;

            alt81=3;

            alt81 = cdfa81.predict(ctx, RECOGNIZER, ISTREAM, &cdfa81);
            if  (HASEXCEPTION())
            {
                goto rulehexpartEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            switch (alt81)
            {
        	case 1:
        	    // ../grammars/belle_sdp.g:552:19: hexseq
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        FOLLOWPUSH(FOLLOW_hexseq_in_hexpart4045);
        	        hexseq306=hexseq(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulehexpartEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, hexseq306.tree);

        	    }
        	    break;
        	case 2:
        	    // ../grammars/belle_sdp.g:552:28: hexseq COLON COLON ( hexseq )?
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        FOLLOWPUSH(FOLLOW_hexseq_in_hexpart4049);
        	        hexseq307=hexseq(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulehexpartEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, hexseq307.tree);

        	        COLON308 = (pANTLR3_COMMON_TOKEN) MATCHT(COLON, &FOLLOW_COLON_in_hexpart4051);
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulehexpartEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) {
        	        COLON308_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, COLON308));
        	        ADAPTOR->addChild(ADAPTOR, root_0, COLON308_tree);
        	        }

        	        COLON309 = (pANTLR3_COMMON_TOKEN) MATCHT(COLON, &FOLLOW_COLON_in_hexpart4053);
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulehexpartEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) {
        	        COLON309_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, COLON309));
        	        ADAPTOR->addChild(ADAPTOR, root_0, COLON309_tree);
        	        }

        	        // ../grammars/belle_sdp.g:552:47: ( hexseq )?
        	        {
        	            int alt79=2;
        	            switch ( LA(1) )
        	            {
        	                case DIGIT:
        	                case HEX_CHAR:
        	                	{
        	                		alt79=1;
        	                	}
        	                    break;
        	            }

        	            switch (alt79)
        	            {
        	        	case 1:
        	        	    // ../grammars/belle_sdp.g:552:47: hexseq
        	        	    {
        	        	        FOLLOWPUSH(FOLLOW_hexseq_in_hexpart4055);
        	        	        hexseq310=hexseq(ctx);

        	        	        FOLLOWPOP();
        	        	        if  (HASEXCEPTION())
        	        	        {
        	        	            goto rulehexpartEx;
        	        	        }
        	        	        if (HASFAILED())
        	        	        {
        	        	            return retval;
        	        	        }

        	        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, hexseq310.tree);

        	        	    }
        	        	    break;

        	            }
        	        }

        	    }
        	    break;
        	case 3:
        	    // ../grammars/belle_sdp.g:552:57: COLON COLON ( hexseq )?
        	    {
        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


        	        COLON311 = (pANTLR3_COMMON_TOKEN) MATCHT(COLON, &FOLLOW_COLON_in_hexpart4060);
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulehexpartEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) {
        	        COLON311_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, COLON311));
        	        ADAPTOR->addChild(ADAPTOR, root_0, COLON311_tree);
        	        }

        	        COLON312 = (pANTLR3_COMMON_TOKEN) MATCHT(COLON, &FOLLOW_COLON_in_hexpart4062);
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulehexpartEx;
        	        }
        	        if (HASFAILED())
        	        {
        	            return retval;
        	        }

        	        if ( BACKTRACKING==0 ) {
        	        COLON312_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, COLON312));
        	        ADAPTOR->addChild(ADAPTOR, root_0, COLON312_tree);
        	        }

        	        // ../grammars/belle_sdp.g:552:69: ( hexseq )?
        	        {
        	            int alt80=2;
        	            switch ( LA(1) )
        	            {
        	                case DIGIT:
        	                case HEX_CHAR:
        	                	{
        	                		alt80=1;
        	                	}
        	                    break;
        	            }

        	            switch (alt80)
        	            {
        	        	case 1:
        	        	    // ../grammars/belle_sdp.g:552:69: hexseq
        	        	    {
        	        	        FOLLOWPUSH(FOLLOW_hexseq_in_hexpart4064);
        	        	        hexseq313=hexseq(ctx);

        	        	        FOLLOWPOP();
        	        	        if  (HASEXCEPTION())
        	        	        {
        	        	            goto rulehexpartEx;
        	        	        }
        	        	        if (HASFAILED())
        	        	        {
        	        	            return retval;
        	        	        }

        	        	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, hexseq313.tree);

        	        	    }
        	        	    break;

        	            }
        	        }

        	    }
        	    break;

            }
        }
    }

    // This is where rules clean up and exit
    //
    goto rulehexpartEx; /* Prevent compiler warnings */
    rulehexpartEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start hexseq
 * ../grammars/belle_sdp.g:553:1: hexseq : hex4 ( COLON hex4 )* ;
 */
static belle_sdpParser_hexseq_return
hexseq(pbelle_sdpParser ctx)
{
    belle_sdpParser_hexseq_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    COLON315;
    belle_sdpParser_hex4_return hex4314;
    #undef	RETURN_TYPE_hex4314
    #define	RETURN_TYPE_hex4314 belle_sdpParser_hex4_return

    belle_sdpParser_hex4_return hex4316;
    #undef	RETURN_TYPE_hex4316
    #define	RETURN_TYPE_hex4316 belle_sdpParser_hex4_return

    pANTLR3_BASE_TREE COLON315_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    COLON315       = NULL;
    hex4314.tree = NULL;

    hex4316.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    COLON315_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:553:16: ( hex4 ( COLON hex4 )* )
        // ../grammars/belle_sdp.g:553:19: hex4 ( COLON hex4 )*
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            FOLLOWPUSH(FOLLOW_hex4_in_hexseq4082);
            hex4314=hex4(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulehexseqEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, hex4314.tree);

            // ../grammars/belle_sdp.g:553:24: ( COLON hex4 )*

            for (;;)
            {
                int alt82=2;
                alt82 = cdfa82.predict(ctx, RECOGNIZER, ISTREAM, &cdfa82);
                if  (HASEXCEPTION())
                {
                    goto rulehexseqEx;
                }
                if (HASFAILED())
                {
                    return retval;
                }

                switch (alt82)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:553:26: COLON hex4
            	    {
            	        COLON315 = (pANTLR3_COMMON_TOKEN) MATCHT(COLON, &FOLLOW_COLON_in_hexseq4086);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulehexseqEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        COLON315_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, COLON315));
            	        ADAPTOR->addChild(ADAPTOR, root_0, COLON315_tree);
            	        }

            	        FOLLOWPUSH(FOLLOW_hex4_in_hexseq4088);
            	        hex4316=hex4(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulehexseqEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, hex4316.tree);

            	    }
            	    break;

            	default:
            	    goto loop82;	/* break out of the loop */
            	    break;
                }
            }
            loop82: ; /* Jump out to here if this rule does not match */


        }

    }

    // This is where rules clean up and exit
    //
    goto rulehexseqEx; /* Prevent compiler warnings */
    rulehexseqEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start hex4
 * ../grammars/belle_sdp.g:554:1: hex4 : ( hexdigit )+ ;
 */
static belle_sdpParser_hex4_return
hex4(pbelle_sdpParser ctx)
{
    belle_sdpParser_hex4_return retval;


    pANTLR3_BASE_TREE root_0;

    belle_sdpParser_hexdigit_return hexdigit317;
    #undef	RETURN_TYPE_hexdigit317
    #define	RETURN_TYPE_hexdigit317 belle_sdpParser_hexdigit_return


    /* Initialize rule variables
     */

    root_0 = NULL;

    hexdigit317.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;




    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:554:16: ( ( hexdigit )+ )
        // ../grammars/belle_sdp.g:554:19: ( hexdigit )+
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            // ../grammars/belle_sdp.g:554:19: ( hexdigit )+
            {
                int cnt83=0;

                for (;;)
                {
                    int alt83=2;
            	switch ( LA(1) )
            	{
            	case DIGIT:
            	case HEX_CHAR:
            		{
            			alt83=1;
            		}
            	    break;

            	}

            	switch (alt83)
            	{
            	    case 1:
            	        // ../grammars/belle_sdp.g:554:19: hexdigit
            	        {
            	            FOLLOWPUSH(FOLLOW_hexdigit_in_hex44109);
            	            hexdigit317=hexdigit(ctx);

            	            FOLLOWPOP();
            	            if  (HASEXCEPTION())
            	            {
            	                goto rulehex4Ex;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, hexdigit317.tree);

            	        }
            	        break;

            	    default:

            		if ( cnt83 >= 1 )
            		{
            		    goto loop83;
            		}
            		if (BACKTRACKING>0)
            		{
            		    FAILEDFLAG = ANTLR3_TRUE;
            		    return retval;
            		}

            		/* mismatchedSetEx()
            		 */
            		CONSTRUCTEX();
            		EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
            		EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;


            		goto rulehex4Ex;
            	}
            	cnt83++;
                }
                loop83: ;	/* Jump to here if this rule does not match */
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto rulehex4Ex; /* Prevent compiler warnings */
    rulehex4Ex: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start text
 * ../grammars/belle_sdp.g:556:1: text : (~ ( CR | LF ) )* ;
 */
static belle_sdpParser_text_return
text(pbelle_sdpParser ctx)
{
    belle_sdpParser_text_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    set318;

    pANTLR3_BASE_TREE set318_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    set318       = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    set318_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:556:6: ( (~ ( CR | LF ) )* )
        // ../grammars/belle_sdp.g:556:23: (~ ( CR | LF ) )*
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            // ../grammars/belle_sdp.g:556:23: (~ ( CR | LF ) )*

            for (;;)
            {
                int alt84=2;
                switch ( LA(1) )
                {
                case COLON:
                case COMMA:
                case COMMON_CHAR:
                case DASH:
                case DIGIT:
                case DOT:
                case EQUAL:
                case HEX_CHAR:
                case LQUOTE:
                case OCTET:
                case POS_DIGIT:
                case RQUOTE:
                case SLASH:
                case SPACE:
                case STAR:
                case ZERO:
                case 22:
                case 23:
                case 24:
                case 25:
                case 26:
                case 27:
                case 28:
                case 29:
                case 30:
                case 31:
                case 32:
                case 33:
                case 34:
                case 35:
                	{
                		alt84=1;
                	}
                    break;

                }

                switch (alt84)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:
            	    {
            	        set318=(pANTLR3_COMMON_TOKEN)LT(1);

            	        if ( ((LA(1) >= COLON) && (LA(1) <= COMMON_CHAR)) || ((LA(1) >= DASH) && (LA(1) <= HEX_CHAR)) || ((LA(1) >= LQUOTE) && (LA(1) <= 35)) )
            	        {
            	            CONSUME();
            	            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, 
            	            (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set318))
            	            );
            	            PERRORRECOVERY=ANTLR3_FALSE;
            	            FAILEDFLAG=ANTLR3_FALSE;

            	        }
            	        else
            	        {
            	            if (BACKTRACKING>0)
            	            {
            	                FAILEDFLAG = ANTLR3_TRUE;
            	                return retval;
            	            }

            	            CONSTRUCTEX();
            	            EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;
            	            EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;
            	            EXCEPTION->expectingSet = NULL;

            	            goto ruletextEx;
            	        }


            	    }
            	    break;

            	default:
            	    goto loop84;	/* break out of the loop */
            	    break;
                }
            }
            loop84: ; /* Jump out to here if this rule does not match */


        }

    }

    // This is where rules clean up and exit
    //
    goto ruletextEx; /* Prevent compiler warnings */
    ruletextEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start byte_string
 * ../grammars/belle_sdp.g:561:1: byte_string options {greedy=false; } : ( OCTET )* ;
 */
static belle_sdpParser_byte_string_return
byte_string(pbelle_sdpParser ctx)
{
    belle_sdpParser_byte_string_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    OCTET319;

    pANTLR3_BASE_TREE OCTET319_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    OCTET319       = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    OCTET319_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:561:40: ( ( OCTET )* )
        // ../grammars/belle_sdp.g:561:49: ( OCTET )*
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            // ../grammars/belle_sdp.g:561:49: ( OCTET )*

            for (;;)
            {
                int alt85=2;
                switch ( LA(1) )
                {
                case OCTET:
                	{
                		alt85=1;
                	}
                    break;

                }

                switch (alt85)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:561:50: OCTET
            	    {
            	        OCTET319 = (pANTLR3_COMMON_TOKEN) MATCHT(OCTET, &FOLLOW_OCTET_in_byte_string4237);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulebyte_stringEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        OCTET319_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, OCTET319));
            	        ADAPTOR->addChild(ADAPTOR, root_0, OCTET319_tree);
            	        }

            	    }
            	    break;

            	default:
            	    goto loop85;	/* break out of the loop */
            	    break;
                }
            }
            loop85: ; /* Jump out to here if this rule does not match */


        }

    }

    // This is where rules clean up and exit
    //
    goto rulebyte_stringEx; /* Prevent compiler warnings */
    rulebyte_stringEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start decimal_uchar
 * ../grammars/belle_sdp.g:564:1: decimal_uchar : integer ;
 */
static belle_sdpParser_decimal_uchar_return
decimal_uchar(pbelle_sdpParser ctx)
{
    belle_sdpParser_decimal_uchar_return retval;


    pANTLR3_BASE_TREE root_0;

    belle_sdpParser_integer_return integer320;
    #undef	RETURN_TYPE_integer320
    #define	RETURN_TYPE_integer320 belle_sdpParser_integer_return


    /* Initialize rule variables
     */

    root_0 = NULL;

    integer320.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;




    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:564:14: ( integer )
        // ../grammars/belle_sdp.g:564:22: integer
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            FOLLOWPUSH(FOLLOW_integer_in_decimal_uchar4279);
            integer320=integer(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruledecimal_ucharEx;
            }
            if (HASFAILED())
            {
                return retval;
            }

            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, integer320.tree);

        }

    }

    // This is where rules clean up and exit
    //
    goto ruledecimal_ucharEx; /* Prevent compiler warnings */
    ruledecimal_ucharEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start integer
 * ../grammars/belle_sdp.g:566:1: integer : ( DIGIT )+ ;
 */
static belle_sdpParser_integer_return
integer(pbelle_sdpParser ctx)
{
    belle_sdpParser_integer_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    DIGIT321;

    pANTLR3_BASE_TREE DIGIT321_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    DIGIT321       = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    DIGIT321_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:566:8: ( ( DIGIT )+ )
        // ../grammars/belle_sdp.g:566:22: ( DIGIT )+
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            // ../grammars/belle_sdp.g:566:22: ( DIGIT )+
            {
                int cnt86=0;

                for (;;)
                {
                    int alt86=2;
            	switch ( LA(1) )
            	{
            	case DIGIT:
            		{
            			alt86=1;
            		}
            	    break;

            	}

            	switch (alt86)
            	{
            	    case 1:
            	        // ../grammars/belle_sdp.g:566:22: DIGIT
            	        {
            	            DIGIT321 = (pANTLR3_COMMON_TOKEN) MATCHT(DIGIT, &FOLLOW_DIGIT_in_integer4298);
            	            if  (HASEXCEPTION())
            	            {
            	                goto ruleintegerEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) {
            	            DIGIT321_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DIGIT321));
            	            ADAPTOR->addChild(ADAPTOR, root_0, DIGIT321_tree);
            	            }

            	        }
            	        break;

            	    default:

            		if ( cnt86 >= 1 )
            		{
            		    goto loop86;
            		}
            		if (BACKTRACKING>0)
            		{
            		    FAILEDFLAG = ANTLR3_TRUE;
            		    return retval;
            		}

            		/* mismatchedSetEx()
            		 */
            		CONSTRUCTEX();
            		EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
            		EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;


            		goto ruleintegerEx;
            	}
            	cnt86++;
                }
                loop86: ;	/* Jump to here if this rule does not match */
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto ruleintegerEx; /* Prevent compiler warnings */
    ruleintegerEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start email_safe
 * ../grammars/belle_sdp.g:568:1: email_safe : (~ ( SPACE ) )* ;
 */
static belle_sdpParser_email_safe_return
email_safe(pbelle_sdpParser ctx)
{
    belle_sdpParser_email_safe_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    set322;

    pANTLR3_BASE_TREE set322_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    set322       = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    set322_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:568:12: ( (~ ( SPACE ) )* )
        // ../grammars/belle_sdp.g:568:14: (~ ( SPACE ) )*
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            // ../grammars/belle_sdp.g:568:14: (~ ( SPACE ) )*

            for (;;)
            {
                int alt87=2;
                switch ( LA(1) )
                {
                case COLON:
                case COMMA:
                case COMMON_CHAR:
                case CR:
                case DASH:
                case DIGIT:
                case DOT:
                case EQUAL:
                case HEX_CHAR:
                case LF:
                case LQUOTE:
                case OCTET:
                case POS_DIGIT:
                case RQUOTE:
                case SLASH:
                case STAR:
                case ZERO:
                case 22:
                case 23:
                case 24:
                case 25:
                case 26:
                case 27:
                case 28:
                case 29:
                case 30:
                case 31:
                case 32:
                case 33:
                case 34:
                case 35:
                	{
                		alt87=1;
                	}
                    break;

                }

                switch (alt87)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:
            	    {
            	        set322=(pANTLR3_COMMON_TOKEN)LT(1);

            	        if ( ((LA(1) >= COLON) && (LA(1) <= SLASH)) || ((LA(1) >= STAR) && (LA(1) <= 35)) )
            	        {
            	            CONSUME();
            	            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, 
            	            (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set322))
            	            );
            	            PERRORRECOVERY=ANTLR3_FALSE;
            	            FAILEDFLAG=ANTLR3_FALSE;

            	        }
            	        else
            	        {
            	            if (BACKTRACKING>0)
            	            {
            	                FAILEDFLAG = ANTLR3_TRUE;
            	                return retval;
            	            }

            	            CONSTRUCTEX();
            	            EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;
            	            EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;
            	            EXCEPTION->expectingSet = NULL;

            	            goto ruleemail_safeEx;
            	        }


            	    }
            	    break;

            	default:
            	    goto loop87;	/* break out of the loop */
            	    break;
                }
            }
            loop87: ; /* Jump out to here if this rule does not match */


        }

    }

    // This is where rules clean up and exit
    //
    goto ruleemail_safeEx; /* Prevent compiler warnings */
    ruleemail_safeEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start token
 * ../grammars/belle_sdp.g:570:1: token : ( alpha_num | '!' | '#' | '$' | '&' | '%' | '\\'' | '*' | '+' | DASH | DOT | '^' | '_' | '`' | '{' | '|' | '}' | '~' )+ ;
 */
static belle_sdpParser_token_return
token(pbelle_sdpParser ctx)
{
    belle_sdpParser_token_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    char_literal324;
    pANTLR3_COMMON_TOKEN    char_literal325;
    pANTLR3_COMMON_TOKEN    char_literal326;
    pANTLR3_COMMON_TOKEN    char_literal327;
    pANTLR3_COMMON_TOKEN    char_literal328;
    pANTLR3_COMMON_TOKEN    char_literal329;
    pANTLR3_COMMON_TOKEN    char_literal330;
    pANTLR3_COMMON_TOKEN    char_literal331;
    pANTLR3_COMMON_TOKEN    DASH332;
    pANTLR3_COMMON_TOKEN    DOT333;
    pANTLR3_COMMON_TOKEN    char_literal334;
    pANTLR3_COMMON_TOKEN    char_literal335;
    pANTLR3_COMMON_TOKEN    char_literal336;
    pANTLR3_COMMON_TOKEN    char_literal337;
    pANTLR3_COMMON_TOKEN    char_literal338;
    pANTLR3_COMMON_TOKEN    char_literal339;
    pANTLR3_COMMON_TOKEN    char_literal340;
    belle_sdpParser_alpha_num_return alpha_num323;
    #undef	RETURN_TYPE_alpha_num323
    #define	RETURN_TYPE_alpha_num323 belle_sdpParser_alpha_num_return

    pANTLR3_BASE_TREE char_literal324_tree;
    pANTLR3_BASE_TREE char_literal325_tree;
    pANTLR3_BASE_TREE char_literal326_tree;
    pANTLR3_BASE_TREE char_literal327_tree;
    pANTLR3_BASE_TREE char_literal328_tree;
    pANTLR3_BASE_TREE char_literal329_tree;
    pANTLR3_BASE_TREE char_literal330_tree;
    pANTLR3_BASE_TREE char_literal331_tree;
    pANTLR3_BASE_TREE DASH332_tree;
    pANTLR3_BASE_TREE DOT333_tree;
    pANTLR3_BASE_TREE char_literal334_tree;
    pANTLR3_BASE_TREE char_literal335_tree;
    pANTLR3_BASE_TREE char_literal336_tree;
    pANTLR3_BASE_TREE char_literal337_tree;
    pANTLR3_BASE_TREE char_literal338_tree;
    pANTLR3_BASE_TREE char_literal339_tree;
    pANTLR3_BASE_TREE char_literal340_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    char_literal324       = NULL;
    char_literal325       = NULL;
    char_literal326       = NULL;
    char_literal327       = NULL;
    char_literal328       = NULL;
    char_literal329       = NULL;
    char_literal330       = NULL;
    char_literal331       = NULL;
    DASH332       = NULL;
    DOT333       = NULL;
    char_literal334       = NULL;
    char_literal335       = NULL;
    char_literal336       = NULL;
    char_literal337       = NULL;
    char_literal338       = NULL;
    char_literal339       = NULL;
    char_literal340       = NULL;
    alpha_num323.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    char_literal324_tree   = NULL;
    char_literal325_tree   = NULL;
    char_literal326_tree   = NULL;
    char_literal327_tree   = NULL;
    char_literal328_tree   = NULL;
    char_literal329_tree   = NULL;
    char_literal330_tree   = NULL;
    char_literal331_tree   = NULL;
    DASH332_tree   = NULL;
    DOT333_tree   = NULL;
    char_literal334_tree   = NULL;
    char_literal335_tree   = NULL;
    char_literal336_tree   = NULL;
    char_literal337_tree   = NULL;
    char_literal338_tree   = NULL;
    char_literal339_tree   = NULL;
    char_literal340_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:570:7: ( ( alpha_num | '!' | '#' | '$' | '&' | '%' | '\\'' | '*' | '+' | DASH | DOT | '^' | '_' | '`' | '{' | '|' | '}' | '~' )+ )
        // ../grammars/belle_sdp.g:570:9: ( alpha_num | '!' | '#' | '$' | '&' | '%' | '\\'' | '*' | '+' | DASH | DOT | '^' | '_' | '`' | '{' | '|' | '}' | '~' )+
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            // ../grammars/belle_sdp.g:570:9: ( alpha_num | '!' | '#' | '$' | '&' | '%' | '\\'' | '*' | '+' | DASH | DOT | '^' | '_' | '`' | '{' | '|' | '}' | '~' )+
            {
                int cnt88=0;

                for (;;)
                {
                    int alt88=19;
            	switch ( LA(1) )
            	{
            	case COMMON_CHAR:
            	case DIGIT:
            	case HEX_CHAR:
            		{
            			alt88=1;
            		}
            	    break;
            	case 22:
            		{
            			alt88=2;
            		}
            	    break;
            	case 23:
            		{
            			alt88=3;
            		}
            	    break;
            	case 24:
            		{
            			alt88=4;
            		}
            	    break;
            	case 26:
            		{
            			alt88=5;
            		}
            	    break;
            	case 25:
            		{
            			alt88=6;
            		}
            	    break;
            	case 28:
            		{
            			alt88=7;
            		}
            	    break;
            	case STAR:
            		{
            			alt88=8;
            		}
            	    break;
            	case 27:
            		{
            			alt88=9;
            		}
            	    break;
            	case DASH:
            		{
            			alt88=10;
            		}
            	    break;
            	case DOT:
            		{
            			alt88=11;
            		}
            	    break;
            	case 29:
            		{
            			alt88=12;
            		}
            	    break;
            	case 30:
            		{
            			alt88=13;
            		}
            	    break;
            	case 31:
            		{
            			alt88=14;
            		}
            	    break;
            	case 32:
            		{
            			alt88=15;
            		}
            	    break;
            	case 33:
            		{
            			alt88=16;
            		}
            	    break;
            	case 34:
            		{
            			alt88=17;
            		}
            	    break;
            	case 35:
            		{
            			alt88=18;
            		}
            	    break;

            	}

            	switch (alt88)
            	{
            	    case 1:
            	        // ../grammars/belle_sdp.g:570:10: alpha_num
            	        {
            	            FOLLOWPUSH(FOLLOW_alpha_num_in_token4320);
            	            alpha_num323=alpha_num(ctx);

            	            FOLLOWPOP();
            	            if  (HASEXCEPTION())
            	            {
            	                goto ruletokenEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha_num323.tree);

            	        }
            	        break;
            	    case 2:
            	        // ../grammars/belle_sdp.g:570:22: '!'
            	        {
            	            char_literal324 = (pANTLR3_COMMON_TOKEN) MATCHT(22, &FOLLOW_22_in_token4324);
            	            if  (HASEXCEPTION())
            	            {
            	                goto ruletokenEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) {
            	            char_literal324_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, char_literal324));
            	            ADAPTOR->addChild(ADAPTOR, root_0, char_literal324_tree);
            	            }

            	        }
            	        break;
            	    case 3:
            	        // ../grammars/belle_sdp.g:570:28: '#'
            	        {
            	            char_literal325 = (pANTLR3_COMMON_TOKEN) MATCHT(23, &FOLLOW_23_in_token4328);
            	            if  (HASEXCEPTION())
            	            {
            	                goto ruletokenEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) {
            	            char_literal325_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, char_literal325));
            	            ADAPTOR->addChild(ADAPTOR, root_0, char_literal325_tree);
            	            }

            	        }
            	        break;
            	    case 4:
            	        // ../grammars/belle_sdp.g:570:34: '$'
            	        {
            	            char_literal326 = (pANTLR3_COMMON_TOKEN) MATCHT(24, &FOLLOW_24_in_token4332);
            	            if  (HASEXCEPTION())
            	            {
            	                goto ruletokenEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) {
            	            char_literal326_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, char_literal326));
            	            ADAPTOR->addChild(ADAPTOR, root_0, char_literal326_tree);
            	            }

            	        }
            	        break;
            	    case 5:
            	        // ../grammars/belle_sdp.g:570:39: '&'
            	        {
            	            char_literal327 = (pANTLR3_COMMON_TOKEN) MATCHT(26, &FOLLOW_26_in_token4335);
            	            if  (HASEXCEPTION())
            	            {
            	                goto ruletokenEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) {
            	            char_literal327_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, char_literal327));
            	            ADAPTOR->addChild(ADAPTOR, root_0, char_literal327_tree);
            	            }

            	        }
            	        break;
            	    case 6:
            	        // ../grammars/belle_sdp.g:570:44: '%'
            	        {
            	            char_literal328 = (pANTLR3_COMMON_TOKEN) MATCHT(25, &FOLLOW_25_in_token4338);
            	            if  (HASEXCEPTION())
            	            {
            	                goto ruletokenEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) {
            	            char_literal328_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, char_literal328));
            	            ADAPTOR->addChild(ADAPTOR, root_0, char_literal328_tree);
            	            }

            	        }
            	        break;
            	    case 7:
            	        // ../grammars/belle_sdp.g:570:49: '\\''
            	        {
            	            char_literal329 = (pANTLR3_COMMON_TOKEN) MATCHT(28, &FOLLOW_28_in_token4341);
            	            if  (HASEXCEPTION())
            	            {
            	                goto ruletokenEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) {
            	            char_literal329_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, char_literal329));
            	            ADAPTOR->addChild(ADAPTOR, root_0, char_literal329_tree);
            	            }

            	        }
            	        break;
            	    case 8:
            	        // ../grammars/belle_sdp.g:570:56: '*'
            	        {
            	            char_literal330 = (pANTLR3_COMMON_TOKEN) MATCHT(STAR, &FOLLOW_STAR_in_token4345);
            	            if  (HASEXCEPTION())
            	            {
            	                goto ruletokenEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) {
            	            char_literal330_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, char_literal330));
            	            ADAPTOR->addChild(ADAPTOR, root_0, char_literal330_tree);
            	            }

            	        }
            	        break;
            	    case 9:
            	        // ../grammars/belle_sdp.g:570:61: '+'
            	        {
            	            char_literal331 = (pANTLR3_COMMON_TOKEN) MATCHT(27, &FOLLOW_27_in_token4348);
            	            if  (HASEXCEPTION())
            	            {
            	                goto ruletokenEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) {
            	            char_literal331_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, char_literal331));
            	            ADAPTOR->addChild(ADAPTOR, root_0, char_literal331_tree);
            	            }

            	        }
            	        break;
            	    case 10:
            	        // ../grammars/belle_sdp.g:570:67: DASH
            	        {
            	            DASH332 = (pANTLR3_COMMON_TOKEN) MATCHT(DASH, &FOLLOW_DASH_in_token4352);
            	            if  (HASEXCEPTION())
            	            {
            	                goto ruletokenEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) {
            	            DASH332_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DASH332));
            	            ADAPTOR->addChild(ADAPTOR, root_0, DASH332_tree);
            	            }

            	        }
            	        break;
            	    case 11:
            	        // ../grammars/belle_sdp.g:570:74: DOT
            	        {
            	            DOT333 = (pANTLR3_COMMON_TOKEN) MATCHT(DOT, &FOLLOW_DOT_in_token4356);
            	            if  (HASEXCEPTION())
            	            {
            	                goto ruletokenEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) {
            	            DOT333_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DOT333));
            	            ADAPTOR->addChild(ADAPTOR, root_0, DOT333_tree);
            	            }

            	        }
            	        break;
            	    case 12:
            	        // ../grammars/belle_sdp.g:570:80: '^'
            	        {
            	            char_literal334 = (pANTLR3_COMMON_TOKEN) MATCHT(29, &FOLLOW_29_in_token4360);
            	            if  (HASEXCEPTION())
            	            {
            	                goto ruletokenEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) {
            	            char_literal334_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, char_literal334));
            	            ADAPTOR->addChild(ADAPTOR, root_0, char_literal334_tree);
            	            }

            	        }
            	        break;
            	    case 13:
            	        // ../grammars/belle_sdp.g:570:86: '_'
            	        {
            	            char_literal335 = (pANTLR3_COMMON_TOKEN) MATCHT(30, &FOLLOW_30_in_token4364);
            	            if  (HASEXCEPTION())
            	            {
            	                goto ruletokenEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) {
            	            char_literal335_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, char_literal335));
            	            ADAPTOR->addChild(ADAPTOR, root_0, char_literal335_tree);
            	            }

            	        }
            	        break;
            	    case 14:
            	        // ../grammars/belle_sdp.g:570:92: '`'
            	        {
            	            char_literal336 = (pANTLR3_COMMON_TOKEN) MATCHT(31, &FOLLOW_31_in_token4368);
            	            if  (HASEXCEPTION())
            	            {
            	                goto ruletokenEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) {
            	            char_literal336_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, char_literal336));
            	            ADAPTOR->addChild(ADAPTOR, root_0, char_literal336_tree);
            	            }

            	        }
            	        break;
            	    case 15:
            	        // ../grammars/belle_sdp.g:570:98: '{'
            	        {
            	            char_literal337 = (pANTLR3_COMMON_TOKEN) MATCHT(32, &FOLLOW_32_in_token4372);
            	            if  (HASEXCEPTION())
            	            {
            	                goto ruletokenEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) {
            	            char_literal337_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, char_literal337));
            	            ADAPTOR->addChild(ADAPTOR, root_0, char_literal337_tree);
            	            }

            	        }
            	        break;
            	    case 16:
            	        // ../grammars/belle_sdp.g:570:104: '|'
            	        {
            	            char_literal338 = (pANTLR3_COMMON_TOKEN) MATCHT(33, &FOLLOW_33_in_token4376);
            	            if  (HASEXCEPTION())
            	            {
            	                goto ruletokenEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) {
            	            char_literal338_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, char_literal338));
            	            ADAPTOR->addChild(ADAPTOR, root_0, char_literal338_tree);
            	            }

            	        }
            	        break;
            	    case 17:
            	        // ../grammars/belle_sdp.g:570:110: '}'
            	        {
            	            char_literal339 = (pANTLR3_COMMON_TOKEN) MATCHT(34, &FOLLOW_34_in_token4380);
            	            if  (HASEXCEPTION())
            	            {
            	                goto ruletokenEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) {
            	            char_literal339_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, char_literal339));
            	            ADAPTOR->addChild(ADAPTOR, root_0, char_literal339_tree);
            	            }

            	        }
            	        break;
            	    case 18:
            	        // ../grammars/belle_sdp.g:570:116: '~'
            	        {
            	            char_literal340 = (pANTLR3_COMMON_TOKEN) MATCHT(35, &FOLLOW_35_in_token4384);
            	            if  (HASEXCEPTION())
            	            {
            	                goto ruletokenEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) {
            	            char_literal340_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, char_literal340));
            	            ADAPTOR->addChild(ADAPTOR, root_0, char_literal340_tree);
            	            }

            	        }
            	        break;

            	    default:

            		if ( cnt88 >= 1 )
            		{
            		    goto loop88;
            		}
            		if (BACKTRACKING>0)
            		{
            		    FAILEDFLAG = ANTLR3_TRUE;
            		    return retval;
            		}

            		/* mismatchedSetEx()
            		 */
            		CONSTRUCTEX();
            		EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
            		EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;


            		goto ruletokenEx;
            	}
            	cnt88++;
                }
                loop88: ;	/* Jump to here if this rule does not match */
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto ruletokenEx; /* Prevent compiler warnings */
    ruletokenEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start alpha_num
 * ../grammars/belle_sdp.g:572:1: alpha_num : ( alpha | DIGIT ) ;
 */
static belle_sdpParser_alpha_num_return
alpha_num(pbelle_sdpParser ctx)
{
    belle_sdpParser_alpha_num_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    DIGIT342;
    belle_sdpParser_alpha_return alpha341;
    #undef	RETURN_TYPE_alpha341
    #define	RETURN_TYPE_alpha341 belle_sdpParser_alpha_return

    pANTLR3_BASE_TREE DIGIT342_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    DIGIT342       = NULL;
    alpha341.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    DIGIT342_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:572:10: ( ( alpha | DIGIT ) )
        // ../grammars/belle_sdp.g:572:15: ( alpha | DIGIT )
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            // ../grammars/belle_sdp.g:572:15: ( alpha | DIGIT )
            {
                int alt89=2;
                switch ( LA(1) )
                {
                case COMMON_CHAR:
                case HEX_CHAR:
                	{
                		alt89=1;
                	}
                    break;
                case DIGIT:
                	{
                		alt89=2;
                	}
                    break;

                default:
                    if (BACKTRACKING>0)
                    {
                        FAILEDFLAG = ANTLR3_TRUE;
                        return retval;
                    }

                    CONSTRUCTEX();
                    EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
                    EXCEPTION->message      = (void *)"";
                    EXCEPTION->decisionNum  = 89;
                    EXCEPTION->state        = 0;


                    goto rulealpha_numEx;

                }

                switch (alt89)
                {
            	case 1:
            	    // ../grammars/belle_sdp.g:572:16: alpha
            	    {
            	        FOLLOWPUSH(FOLLOW_alpha_in_alpha_num4397);
            	        alpha341=alpha(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulealpha_numEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha341.tree);

            	    }
            	    break;
            	case 2:
            	    // ../grammars/belle_sdp.g:572:24: DIGIT
            	    {
            	        DIGIT342 = (pANTLR3_COMMON_TOKEN) MATCHT(DIGIT, &FOLLOW_DIGIT_in_alpha_num4401);
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulealpha_numEx;
            	        }
            	        if (HASFAILED())
            	        {
            	            return retval;
            	        }

            	        if ( BACKTRACKING==0 ) {
            	        DIGIT342_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DIGIT342));
            	        ADAPTOR->addChild(ADAPTOR, root_0, DIGIT342_tree);
            	        }

            	    }
            	    break;

                }
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto rulealpha_numEx; /* Prevent compiler warnings */
    rulealpha_numEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start hexdigit
 * ../grammars/belle_sdp.g:573:1: hexdigit : ( HEX_CHAR | DIGIT ) ;
 */
static belle_sdpParser_hexdigit_return
hexdigit(pbelle_sdpParser ctx)
{
    belle_sdpParser_hexdigit_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    set343;

    pANTLR3_BASE_TREE set343_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    set343       = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    set343_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:573:9: ( ( HEX_CHAR | DIGIT ) )
        // ../grammars/belle_sdp.g:
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            set343=(pANTLR3_COMMON_TOKEN)LT(1);

            if ( LA(1) == DIGIT || LA(1) == HEX_CHAR )
            {
                CONSUME();
                if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, 
                (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set343))
                );
                PERRORRECOVERY=ANTLR3_FALSE;
                FAILEDFLAG=ANTLR3_FALSE;

            }
            else
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                CONSTRUCTEX();
                EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;
                EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;
                EXCEPTION->expectingSet = NULL;

                goto rulehexdigitEx;
            }


        }

    }

    // This is where rules clean up and exit
    //
    goto rulehexdigitEx; /* Prevent compiler warnings */
    rulehexdigitEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start word
 * ../grammars/belle_sdp.g:574:1: word : ( alpha | DASH )+ ;
 */
static belle_sdpParser_word_return
word(pbelle_sdpParser ctx)
{
    belle_sdpParser_word_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    DASH345;
    belle_sdpParser_alpha_return alpha344;
    #undef	RETURN_TYPE_alpha344
    #define	RETURN_TYPE_alpha344 belle_sdpParser_alpha_return

    pANTLR3_BASE_TREE DASH345_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    DASH345       = NULL;
    alpha344.tree = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    DASH345_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:574:5: ( ( alpha | DASH )+ )
        // ../grammars/belle_sdp.g:574:7: ( alpha | DASH )+
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            // ../grammars/belle_sdp.g:574:7: ( alpha | DASH )+
            {
                int cnt90=0;

                for (;;)
                {
                    int alt90=3;
            	switch ( LA(1) )
            	{
            	case COMMON_CHAR:
            	case HEX_CHAR:
            		{
            			alt90=1;
            		}
            	    break;
            	case DASH:
            		{
            			alt90=2;
            		}
            	    break;

            	}

            	switch (alt90)
            	{
            	    case 1:
            	        // ../grammars/belle_sdp.g:574:8: alpha
            	        {
            	            FOLLOWPUSH(FOLLOW_alpha_in_word4423);
            	            alpha344=alpha(ctx);

            	            FOLLOWPOP();
            	            if  (HASEXCEPTION())
            	            {
            	                goto rulewordEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, alpha344.tree);

            	        }
            	        break;
            	    case 2:
            	        // ../grammars/belle_sdp.g:574:16: DASH
            	        {
            	            DASH345 = (pANTLR3_COMMON_TOKEN) MATCHT(DASH, &FOLLOW_DASH_in_word4427);
            	            if  (HASEXCEPTION())
            	            {
            	                goto rulewordEx;
            	            }
            	            if (HASFAILED())
            	            {
            	                return retval;
            	            }

            	            if ( BACKTRACKING==0 ) {
            	            DASH345_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DASH345));
            	            ADAPTOR->addChild(ADAPTOR, root_0, DASH345_tree);
            	            }

            	        }
            	        break;

            	    default:

            		if ( cnt90 >= 1 )
            		{
            		    goto loop90;
            		}
            		if (BACKTRACKING>0)
            		{
            		    FAILEDFLAG = ANTLR3_TRUE;
            		    return retval;
            		}

            		/* mismatchedSetEx()
            		 */
            		CONSTRUCTEX();
            		EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
            		EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;


            		goto rulewordEx;
            	}
            	cnt90++;
                }
                loop90: ;	/* Jump to here if this rule does not match */
            }

        }

    }

    // This is where rules clean up and exit
    //
    goto rulewordEx; /* Prevent compiler warnings */
    rulewordEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

/**
 * $ANTLR start alpha
 * ../grammars/belle_sdp.g:575:1: alpha : ( COMMON_CHAR | HEX_CHAR );
 */
static belle_sdpParser_alpha_return
alpha(pbelle_sdpParser ctx)
{
    belle_sdpParser_alpha_return retval;


    pANTLR3_BASE_TREE root_0;

    pANTLR3_COMMON_TOKEN    set346;

    pANTLR3_BASE_TREE set346_tree;

    /* Initialize rule variables
     */

    root_0 = NULL;

    set346       = NULL;
    retval.start = LT(1); retval.stop = retval.start;


    set346_tree   = NULL;


    retval.tree  = NULL;

    {
        // ../grammars/belle_sdp.g:575:6: ( COMMON_CHAR | HEX_CHAR )
        // ../grammars/belle_sdp.g:
        {
            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));


            set346=(pANTLR3_COMMON_TOKEN)LT(1);

            if ( LA(1) == COMMON_CHAR || LA(1) == HEX_CHAR )
            {
                CONSUME();
                if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, 
                (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set346))
                );
                PERRORRECOVERY=ANTLR3_FALSE;
                FAILEDFLAG=ANTLR3_FALSE;

            }
            else
            {
                if (BACKTRACKING>0)
                {
                    FAILEDFLAG = ANTLR3_TRUE;
                    return retval;
                }

                CONSTRUCTEX();
                EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;
                EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;
                EXCEPTION->expectingSet = NULL;

                goto rulealphaEx;
            }


        }

    }

    // This is where rules clean up and exit
    //
    goto rulealphaEx; /* Prevent compiler warnings */
    rulealphaEx: ;
    retval.stop = LT(-1);


    if ( BACKTRACKING==0 )
    {

    	retval.stop = LT(-1);

    	retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
    	ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
    }



                if (HASEXCEPTION())
                {

                // This is ugly.  We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
                // catch them.
                //PREPORTERROR();
                EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
                }

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

// $ANTLR start synpred1_belle_sdp
static void synpred1_belle_sdp_fragment(pbelle_sdpParser ctx )
{
    // ../grammars/belle_sdp.g:255:2: ( pkt_loss_rle )
    // ../grammars/belle_sdp.g:255:3: pkt_loss_rle
    {
        FOLLOWPUSH(FOLLOW_pkt_loss_rle_in_synpred1_belle_sdp1560);
        pkt_loss_rle(ctx);

        FOLLOWPOP();
        if  (HASEXCEPTION())
        {
            goto rulesynpred1_belle_sdpEx;
        }
        if (HASFAILED())
        {
            return ;
        }


    }

// This is where rules clean up and exit
//
goto rulesynpred1_belle_sdpEx; /* Prevent compiler warnings */
rulesynpred1_belle_sdpEx: ;

}
// $ANTLR end synpred1_belle_sdp

// $ANTLR start synpred2_belle_sdp
static void synpred2_belle_sdp_fragment(pbelle_sdpParser ctx )
{
    // ../grammars/belle_sdp.g:256:3: ( pkt_dup_rle )
    // ../grammars/belle_sdp.g:256:4: pkt_dup_rle
    {
        FOLLOWPUSH(FOLLOW_pkt_dup_rle_in_synpred2_belle_sdp1569);
        pkt_dup_rle(ctx);

        FOLLOWPOP();
        if  (HASEXCEPTION())
        {
            goto rulesynpred2_belle_sdpEx;
        }
        if (HASFAILED())
        {
            return ;
        }


    }

// This is where rules clean up and exit
//
goto rulesynpred2_belle_sdpEx; /* Prevent compiler warnings */
rulesynpred2_belle_sdpEx: ;

}
// $ANTLR end synpred2_belle_sdp

// $ANTLR start synpred3_belle_sdp
static void synpred3_belle_sdp_fragment(pbelle_sdpParser ctx )
{
    // ../grammars/belle_sdp.g:257:3: ( pkt_rcpt_times )
    // ../grammars/belle_sdp.g:257:4: pkt_rcpt_times
    {
        FOLLOWPUSH(FOLLOW_pkt_rcpt_times_in_synpred3_belle_sdp1578);
        pkt_rcpt_times(ctx);

        FOLLOWPOP();
        if  (HASEXCEPTION())
        {
            goto rulesynpred3_belle_sdpEx;
        }
        if (HASFAILED())
        {
            return ;
        }


    }

// This is where rules clean up and exit
//
goto rulesynpred3_belle_sdpEx; /* Prevent compiler warnings */
rulesynpred3_belle_sdpEx: ;

}
// $ANTLR end synpred3_belle_sdp

// $ANTLR start synpred4_belle_sdp
static void synpred4_belle_sdp_fragment(pbelle_sdpParser ctx )
{
    // ../grammars/belle_sdp.g:258:3: ( rcvr_rtt )
    // ../grammars/belle_sdp.g:258:4: rcvr_rtt
    {
        FOLLOWPUSH(FOLLOW_rcvr_rtt_in_synpred4_belle_sdp1587);
        rcvr_rtt(ctx);

        FOLLOWPOP();
        if  (HASEXCEPTION())
        {
            goto rulesynpred4_belle_sdpEx;
        }
        if (HASFAILED())
        {
            return ;
        }


    }

// This is where rules clean up and exit
//
goto rulesynpred4_belle_sdpEx; /* Prevent compiler warnings */
rulesynpred4_belle_sdpEx: ;

}
// $ANTLR end synpred4_belle_sdp

// $ANTLR start synpred5_belle_sdp
static void synpred5_belle_sdp_fragment(pbelle_sdpParser ctx )
{
    // ../grammars/belle_sdp.g:259:3: ( stat_summary )
    // ../grammars/belle_sdp.g:259:4: stat_summary
    {
        FOLLOWPUSH(FOLLOW_stat_summary_in_synpred5_belle_sdp1596);
        stat_summary(ctx);

        FOLLOWPOP();
        if  (HASEXCEPTION())
        {
            goto rulesynpred5_belle_sdpEx;
        }
        if (HASFAILED())
        {
            return ;
        }


    }

// This is where rules clean up and exit
//
goto rulesynpred5_belle_sdpEx; /* Prevent compiler warnings */
rulesynpred5_belle_sdpEx: ;

}
// $ANTLR end synpred5_belle_sdp

// $ANTLR start synpred6_belle_sdp
static void synpred6_belle_sdp_fragment(pbelle_sdpParser ctx )
{
    // ../grammars/belle_sdp.g:260:3: ( voip_metrics )
    // ../grammars/belle_sdp.g:260:4: voip_metrics
    {
        FOLLOWPUSH(FOLLOW_voip_metrics_in_synpred6_belle_sdp1605);
        voip_metrics(ctx);

        FOLLOWPOP();
        if  (HASEXCEPTION())
        {
            goto rulesynpred6_belle_sdpEx;
        }
        if (HASFAILED())
        {
            return ;
        }


    }

// This is where rules clean up and exit
//
goto rulesynpred6_belle_sdpEx; /* Prevent compiler warnings */
rulesynpred6_belle_sdpEx: ;

}
// $ANTLR end synpred6_belle_sdp

// $ANTLR start synpred7_belle_sdp
static void synpred7_belle_sdp_fragment(pbelle_sdpParser ctx )
{
    // ../grammars/belle_sdp.g:312:2: ( rtcp_fb_ack_val )
    // ../grammars/belle_sdp.g:312:3: rtcp_fb_ack_val
    {
        FOLLOWPUSH(FOLLOW_rtcp_fb_ack_val_in_synpred7_belle_sdp1836);
        rtcp_fb_ack_val(ctx);

        FOLLOWPOP();
        if  (HASEXCEPTION())
        {
            goto rulesynpred7_belle_sdpEx;
        }
        if (HASFAILED())
        {
            return ;
        }


    }

// This is where rules clean up and exit
//
goto rulesynpred7_belle_sdpEx; /* Prevent compiler warnings */
rulesynpred7_belle_sdpEx: ;

}
// $ANTLR end synpred7_belle_sdp

// $ANTLR start synpred8_belle_sdp
static void synpred8_belle_sdp_fragment(pbelle_sdpParser ctx )
{
    // ../grammars/belle_sdp.g:313:3: ( rtcp_fb_nack_val )
    // ../grammars/belle_sdp.g:313:4: rtcp_fb_nack_val
    {
        FOLLOWPUSH(FOLLOW_rtcp_fb_nack_val_in_synpred8_belle_sdp1844);
        rtcp_fb_nack_val(ctx);

        FOLLOWPOP();
        if  (HASEXCEPTION())
        {
            goto rulesynpred8_belle_sdpEx;
        }
        if (HASFAILED())
        {
            return ;
        }


    }

// This is where rules clean up and exit
//
goto rulesynpred8_belle_sdpEx; /* Prevent compiler warnings */
rulesynpred8_belle_sdpEx: ;

}
// $ANTLR end synpred8_belle_sdp

// $ANTLR start synpred9_belle_sdp
static void synpred9_belle_sdp_fragment(pbelle_sdpParser ctx )
{
    // ../grammars/belle_sdp.g:314:3: ( rtcp_fb_trr_int_val )
    // ../grammars/belle_sdp.g:314:4: rtcp_fb_trr_int_val
    {
        FOLLOWPUSH(FOLLOW_rtcp_fb_trr_int_val_in_synpred9_belle_sdp1852);
        rtcp_fb_trr_int_val(ctx);

        FOLLOWPOP();
        if  (HASEXCEPTION())
        {
            goto rulesynpred9_belle_sdpEx;
        }
        if (HASFAILED())
        {
            return ;
        }


    }

// This is where rules clean up and exit
//
goto rulesynpred9_belle_sdpEx; /* Prevent compiler warnings */
rulesynpred9_belle_sdpEx: ;

}
// $ANTLR end synpred9_belle_sdp

// $ANTLR start synpred10_belle_sdp
static void synpred10_belle_sdp_fragment(pbelle_sdpParser ctx )
{
    // ../grammars/belle_sdp.g:315:3: ( rtcp_fb_ccm_val )
    // ../grammars/belle_sdp.g:315:4: rtcp_fb_ccm_val
    {
        FOLLOWPUSH(FOLLOW_rtcp_fb_ccm_val_in_synpred10_belle_sdp1860);
        rtcp_fb_ccm_val(ctx);

        FOLLOWPOP();
        if  (HASEXCEPTION())
        {
            goto rulesynpred10_belle_sdpEx;
        }
        if (HASFAILED())
        {
            return ;
        }


    }

// This is where rules clean up and exit
//
goto rulesynpred10_belle_sdpEx; /* Prevent compiler warnings */
rulesynpred10_belle_sdpEx: ;

}
// $ANTLR end synpred10_belle_sdp

// $ANTLR start synpred11_belle_sdp
static void synpred11_belle_sdp_fragment(pbelle_sdpParser ctx )
{
    // ../grammars/belle_sdp.g:316:3: ( rtcp_fb_id_val )
    // ../grammars/belle_sdp.g:316:4: rtcp_fb_id_val
    {
        FOLLOWPUSH(FOLLOW_rtcp_fb_id_val_in_synpred11_belle_sdp1868);
        rtcp_fb_id_val(ctx);

        FOLLOWPOP();
        if  (HASEXCEPTION())
        {
            goto rulesynpred11_belle_sdpEx;
        }
        if (HASFAILED())
        {
            return ;
        }


    }

// This is where rules clean up and exit
//
goto rulesynpred11_belle_sdpEx; /* Prevent compiler warnings */
rulesynpred11_belle_sdpEx: ;

}
// $ANTLR end synpred11_belle_sdp

// $ANTLR start synpred12_belle_sdp
static void synpred12_belle_sdp_fragment(pbelle_sdpParser ctx )
{
    // ../grammars/belle_sdp.g:343:2: ( rtcp_fb_app_param )
    // ../grammars/belle_sdp.g:343:3: rtcp_fb_app_param
    {
        FOLLOWPUSH(FOLLOW_rtcp_fb_app_param_in_synpred12_belle_sdp1976);
        rtcp_fb_app_param(ctx);

        FOLLOWPOP();
        if  (HASEXCEPTION())
        {
            goto rulesynpred12_belle_sdpEx;
        }
        if (HASFAILED())
        {
            return ;
        }


    }

// This is where rules clean up and exit
//
goto rulesynpred12_belle_sdpEx; /* Prevent compiler warnings */
rulesynpred12_belle_sdpEx: ;

}
// $ANTLR end synpred12_belle_sdp

// $ANTLR start synpred13_belle_sdp
static void synpred13_belle_sdp_fragment(pbelle_sdpParser ctx )
{
    // ../grammars/belle_sdp.g:344:3: ( rtcp_fb_token_param )
    // ../grammars/belle_sdp.g:344:4: rtcp_fb_token_param
    {
        FOLLOWPUSH(FOLLOW_rtcp_fb_token_param_in_synpred13_belle_sdp1984);
        rtcp_fb_token_param(ctx);

        FOLLOWPOP();
        if  (HASEXCEPTION())
        {
            goto rulesynpred13_belle_sdpEx;
        }
        if (HASFAILED())
        {
            return ;
        }


    }

// This is where rules clean up and exit
//
goto rulesynpred13_belle_sdpEx; /* Prevent compiler warnings */
rulesynpred13_belle_sdpEx: ;

}
// $ANTLR end synpred13_belle_sdp

// $ANTLR start synpred14_belle_sdp
static void synpred14_belle_sdp_fragment(pbelle_sdpParser ctx )
{
    // ../grammars/belle_sdp.g:347:2: ( rtcp_fb_rpsi_param )
    // ../grammars/belle_sdp.g:347:3: rtcp_fb_rpsi_param
    {
        FOLLOWPUSH(FOLLOW_rtcp_fb_rpsi_param_in_synpred14_belle_sdp1996);
        rtcp_fb_rpsi_param(ctx);

        FOLLOWPOP();
        if  (HASEXCEPTION())
        {
            goto rulesynpred14_belle_sdpEx;
        }
        if (HASFAILED())
        {
            return ;
        }


    }

// This is where rules clean up and exit
//
goto rulesynpred14_belle_sdpEx; /* Prevent compiler warnings */
rulesynpred14_belle_sdpEx: ;

}
// $ANTLR end synpred14_belle_sdp

// $ANTLR start synpred15_belle_sdp
static void synpred15_belle_sdp_fragment(pbelle_sdpParser ctx )
{
    // ../grammars/belle_sdp.g:348:3: ( rtcp_fb_app_param )
    // ../grammars/belle_sdp.g:348:4: rtcp_fb_app_param
    {
        FOLLOWPUSH(FOLLOW_rtcp_fb_app_param_in_synpred15_belle_sdp2004);
        rtcp_fb_app_param(ctx);

        FOLLOWPOP();
        if  (HASEXCEPTION())
        {
            goto rulesynpred15_belle_sdpEx;
        }
        if (HASFAILED())
        {
            return ;
        }


    }

// This is where rules clean up and exit
//
goto rulesynpred15_belle_sdpEx; /* Prevent compiler warnings */
rulesynpred15_belle_sdpEx: ;

}
// $ANTLR end synpred15_belle_sdp

// $ANTLR start synpred16_belle_sdp
static void synpred16_belle_sdp_fragment(pbelle_sdpParser ctx )
{
    // ../grammars/belle_sdp.g:349:3: ( rtcp_fb_token_param )
    // ../grammars/belle_sdp.g:349:4: rtcp_fb_token_param
    {
        FOLLOWPUSH(FOLLOW_rtcp_fb_token_param_in_synpred16_belle_sdp2012);
        rtcp_fb_token_param(ctx);

        FOLLOWPOP();
        if  (HASEXCEPTION())
        {
            goto rulesynpred16_belle_sdpEx;
        }
        if (HASFAILED())
        {
            return ;
        }


    }

// This is where rules clean up and exit
//
goto rulesynpred16_belle_sdpEx; /* Prevent compiler warnings */
rulesynpred16_belle_sdpEx: ;

}
// $ANTLR end synpred16_belle_sdp

// $ANTLR start synpred17_belle_sdp
static void synpred17_belle_sdp_fragment(pbelle_sdpParser ctx )
{
    // ../grammars/belle_sdp.g:352:2: ( rtcp_fb_pli_param )
    // ../grammars/belle_sdp.g:352:3: rtcp_fb_pli_param
    {
        FOLLOWPUSH(FOLLOW_rtcp_fb_pli_param_in_synpred17_belle_sdp2024);
        rtcp_fb_pli_param(ctx);

        FOLLOWPOP();
        if  (HASEXCEPTION())
        {
            goto rulesynpred17_belle_sdpEx;
        }
        if (HASFAILED())
        {
            return ;
        }


    }

// This is where rules clean up and exit
//
goto rulesynpred17_belle_sdpEx; /* Prevent compiler warnings */
rulesynpred17_belle_sdpEx: ;

}
// $ANTLR end synpred17_belle_sdp

// $ANTLR start synpred18_belle_sdp
static void synpred18_belle_sdp_fragment(pbelle_sdpParser ctx )
{
    // ../grammars/belle_sdp.g:353:3: ( rtcp_fb_sli_param )
    // ../grammars/belle_sdp.g:353:4: rtcp_fb_sli_param
    {
        FOLLOWPUSH(FOLLOW_rtcp_fb_sli_param_in_synpred18_belle_sdp2032);
        rtcp_fb_sli_param(ctx);

        FOLLOWPOP();
        if  (HASEXCEPTION())
        {
            goto rulesynpred18_belle_sdpEx;
        }
        if (HASFAILED())
        {
            return ;
        }


    }

// This is where rules clean up and exit
//
goto rulesynpred18_belle_sdpEx; /* Prevent compiler warnings */
rulesynpred18_belle_sdpEx: ;

}
// $ANTLR end synpred18_belle_sdp

// $ANTLR start synpred19_belle_sdp
static void synpred19_belle_sdp_fragment(pbelle_sdpParser ctx )
{
    // ../grammars/belle_sdp.g:354:3: ( rtcp_fb_rpsi_param )
    // ../grammars/belle_sdp.g:354:4: rtcp_fb_rpsi_param
    {
        FOLLOWPUSH(FOLLOW_rtcp_fb_rpsi_param_in_synpred19_belle_sdp2040);
        rtcp_fb_rpsi_param(ctx);

        FOLLOWPOP();
        if  (HASEXCEPTION())
        {
            goto rulesynpred19_belle_sdpEx;
        }
        if (HASFAILED())
        {
            return ;
        }


    }

// This is where rules clean up and exit
//
goto rulesynpred19_belle_sdpEx; /* Prevent compiler warnings */
rulesynpred19_belle_sdpEx: ;

}
// $ANTLR end synpred19_belle_sdp

// $ANTLR start synpred20_belle_sdp
static void synpred20_belle_sdp_fragment(pbelle_sdpParser ctx )
{
    // ../grammars/belle_sdp.g:355:3: ( rtcp_fb_app_param )
    // ../grammars/belle_sdp.g:355:4: rtcp_fb_app_param
    {
        FOLLOWPUSH(FOLLOW_rtcp_fb_app_param_in_synpred20_belle_sdp2048);
        rtcp_fb_app_param(ctx);

        FOLLOWPOP();
        if  (HASEXCEPTION())
        {
            goto rulesynpred20_belle_sdpEx;
        }
        if (HASFAILED())
        {
            return ;
        }


    }

// This is where rules clean up and exit
//
goto rulesynpred20_belle_sdpEx; /* Prevent compiler warnings */
rulesynpred20_belle_sdpEx: ;

}
// $ANTLR end synpred20_belle_sdp

// $ANTLR start synpred21_belle_sdp
static void synpred21_belle_sdp_fragment(pbelle_sdpParser ctx )
{
    // ../grammars/belle_sdp.g:356:3: ( rtcp_fb_token_param )
    // ../grammars/belle_sdp.g:356:4: rtcp_fb_token_param
    {
        FOLLOWPUSH(FOLLOW_rtcp_fb_token_param_in_synpred21_belle_sdp2056);
        rtcp_fb_token_param(ctx);

        FOLLOWPOP();
        if  (HASEXCEPTION())
        {
            goto rulesynpred21_belle_sdpEx;
        }
        if (HASFAILED())
        {
            return ;
        }


    }

// This is where rules clean up and exit
//
goto rulesynpred21_belle_sdpEx; /* Prevent compiler warnings */
rulesynpred21_belle_sdpEx: ;

}
// $ANTLR end synpred21_belle_sdp

// $ANTLR start synpred22_belle_sdp
static void synpred22_belle_sdp_fragment(pbelle_sdpParser ctx )
{
    // ../grammars/belle_sdp.g:379:2: ( rtcp_fb_fir_param )
    // ../grammars/belle_sdp.g:379:3: rtcp_fb_fir_param
    {
        FOLLOWPUSH(FOLLOW_rtcp_fb_fir_param_in_synpred22_belle_sdp2130);
        rtcp_fb_fir_param(ctx);

        FOLLOWPOP();
        if  (HASEXCEPTION())
        {
            goto rulesynpred22_belle_sdpEx;
        }
        if (HASFAILED())
        {
            return ;
        }


    }

// This is where rules clean up and exit
//
goto rulesynpred22_belle_sdpEx; /* Prevent compiler warnings */
rulesynpred22_belle_sdpEx: ;

}
// $ANTLR end synpred22_belle_sdp

// $ANTLR start synpred23_belle_sdp
static void synpred23_belle_sdp_fragment(pbelle_sdpParser ctx )
{
    // ../grammars/belle_sdp.g:380:3: ( rtcp_fb_tmmbr_param )
    // ../grammars/belle_sdp.g:380:4: rtcp_fb_tmmbr_param
    {
        FOLLOWPUSH(FOLLOW_rtcp_fb_tmmbr_param_in_synpred23_belle_sdp2138);
        rtcp_fb_tmmbr_param(ctx);

        FOLLOWPOP();
        if  (HASEXCEPTION())
        {
            goto rulesynpred23_belle_sdpEx;
        }
        if (HASFAILED())
        {
            return ;
        }


    }

// This is where rules clean up and exit
//
goto rulesynpred23_belle_sdpEx; /* Prevent compiler warnings */
rulesynpred23_belle_sdpEx: ;

}
// $ANTLR end synpred23_belle_sdp

// $ANTLR start synpred24_belle_sdp
static void synpred24_belle_sdp_fragment(pbelle_sdpParser ctx )
{
    // ../grammars/belle_sdp.g:381:3: ( rtcp_fb_token_param )
    // ../grammars/belle_sdp.g:381:4: rtcp_fb_token_param
    {
        FOLLOWPUSH(FOLLOW_rtcp_fb_token_param_in_synpred24_belle_sdp2146);
        rtcp_fb_token_param(ctx);

        FOLLOWPOP();
        if  (HASEXCEPTION())
        {
            goto rulesynpred24_belle_sdpEx;
        }
        if (HASFAILED())
        {
            return ;
        }


    }

// This is where rules clean up and exit
//
goto rulesynpred24_belle_sdpEx; /* Prevent compiler warnings */
rulesynpred24_belle_sdpEx: ;

}
// $ANTLR end synpred24_belle_sdp

// $ANTLR start synpred25_belle_sdp
static void synpred25_belle_sdp_fragment(pbelle_sdpParser ctx )
{
    // ../grammars/belle_sdp.g:440:47: ( ( DIGIT )+ )
    // ../grammars/belle_sdp.g:440:48: ( DIGIT )+
    {
        // ../grammars/belle_sdp.g:440:48: ( DIGIT )+
        {
            int cnt91=0;

            for (;;)
            {
                int alt91=2;
        	switch ( LA(1) )
        	{
        	case DIGIT:
        		{
        			alt91=1;
        		}
        	    break;

        	}

        	switch (alt91)
        	{
        	    case 1:
        	        // ../grammars/belle_sdp.g:440:48: DIGIT
        	        {
        	             MATCHT(DIGIT, &FOLLOW_DIGIT_in_synpred25_belle_sdp2657);
        	            if  (HASEXCEPTION())
        	            {
        	                goto rulesynpred25_belle_sdpEx;
        	            }
        	            if (HASFAILED())
        	            {
        	                return ;
        	            }


        	        }
        	        break;

        	    default:

        		if ( cnt91 >= 1 )
        		{
        		    goto loop91;
        		}
        		if (BACKTRACKING>0)
        		{
        		    FAILEDFLAG = ANTLR3_TRUE;
        		    return ;
        		}

        		/* mismatchedSetEx()
        		 */
        		CONSTRUCTEX();
        		EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
        		EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;


        		goto rulesynpred25_belle_sdpEx;
        	}
        	cnt91++;
            }
            loop91: ;	/* Jump to here if this rule does not match */
        }

    }

// This is where rules clean up and exit
//
goto rulesynpred25_belle_sdpEx; /* Prevent compiler warnings */
rulesynpred25_belle_sdpEx: ;

}
// $ANTLR end synpred25_belle_sdp
/* End of parsing rules
 * ==============================================
 */

/* ==============================================
 * Syntactic predicates
 */
static ANTLR3_BOOLEAN synpred25_belle_sdp(pbelle_sdpParser ctx)
{
    ANTLR3_MARKER   start;
    ANTLR3_BOOLEAN  success;

    BACKTRACKING++;
    start	= MARK();
    synpred25_belle_sdp_fragment(ctx);	    // can never throw exception
    success	= !(FAILEDFLAG);
    REWIND(start);
    BACKTRACKING--;
    FAILEDFLAG	= ANTLR3_FALSE;
    return success;
}
static ANTLR3_BOOLEAN synpred12_belle_sdp(pbelle_sdpParser ctx)
{
    ANTLR3_MARKER   start;
    ANTLR3_BOOLEAN  success;

    BACKTRACKING++;
    start	= MARK();
    synpred12_belle_sdp_fragment(ctx);	    // can never throw exception
    success	= !(FAILEDFLAG);
    REWIND(start);
    BACKTRACKING--;
    FAILEDFLAG	= ANTLR3_FALSE;
    return success;
}
static ANTLR3_BOOLEAN synpred9_belle_sdp(pbelle_sdpParser ctx)
{
    ANTLR3_MARKER   start;
    ANTLR3_BOOLEAN  success;

    BACKTRACKING++;
    start	= MARK();
    synpred9_belle_sdp_fragment(ctx);	    // can never throw exception
    success	= !(FAILEDFLAG);
    REWIND(start);
    BACKTRACKING--;
    FAILEDFLAG	= ANTLR3_FALSE;
    return success;
}
static ANTLR3_BOOLEAN synpred23_belle_sdp(pbelle_sdpParser ctx)
{
    ANTLR3_MARKER   start;
    ANTLR3_BOOLEAN  success;

    BACKTRACKING++;
    start	= MARK();
    synpred23_belle_sdp_fragment(ctx);	    // can never throw exception
    success	= !(FAILEDFLAG);
    REWIND(start);
    BACKTRACKING--;
    FAILEDFLAG	= ANTLR3_FALSE;
    return success;
}
static ANTLR3_BOOLEAN synpred5_belle_sdp(pbelle_sdpParser ctx)
{
    ANTLR3_MARKER   start;
    ANTLR3_BOOLEAN  success;

    BACKTRACKING++;
    start	= MARK();
    synpred5_belle_sdp_fragment(ctx);	    // can never throw exception
    success	= !(FAILEDFLAG);
    REWIND(start);
    BACKTRACKING--;
    FAILEDFLAG	= ANTLR3_FALSE;
    return success;
}
static ANTLR3_BOOLEAN synpred10_belle_sdp(pbelle_sdpParser ctx)
{
    ANTLR3_MARKER   start;
    ANTLR3_BOOLEAN  success;

    BACKTRACKING++;
    start	= MARK();
    synpred10_belle_sdp_fragment(ctx);	    // can never throw exception
    success	= !(FAILEDFLAG);
    REWIND(start);
    BACKTRACKING--;
    FAILEDFLAG	= ANTLR3_FALSE;
    return success;
}
static ANTLR3_BOOLEAN synpred4_belle_sdp(pbelle_sdpParser ctx)
{
    ANTLR3_MARKER   start;
    ANTLR3_BOOLEAN  success;

    BACKTRACKING++;
    start	= MARK();
    synpred4_belle_sdp_fragment(ctx);	    // can never throw exception
    success	= !(FAILEDFLAG);
    REWIND(start);
    BACKTRACKING--;
    FAILEDFLAG	= ANTLR3_FALSE;
    return success;
}
static ANTLR3_BOOLEAN synpred17_belle_sdp(pbelle_sdpParser ctx)
{
    ANTLR3_MARKER   start;
    ANTLR3_BOOLEAN  success;

    BACKTRACKING++;
    start	= MARK();
    synpred17_belle_sdp_fragment(ctx);	    // can never throw exception
    success	= !(FAILEDFLAG);
    REWIND(start);
    BACKTRACKING--;
    FAILEDFLAG	= ANTLR3_FALSE;
    return success;
}
static ANTLR3_BOOLEAN synpred14_belle_sdp(pbelle_sdpParser ctx)
{
    ANTLR3_MARKER   start;
    ANTLR3_BOOLEAN  success;

    BACKTRACKING++;
    start	= MARK();
    synpred14_belle_sdp_fragment(ctx);	    // can never throw exception
    success	= !(FAILEDFLAG);
    REWIND(start);
    BACKTRACKING--;
    FAILEDFLAG	= ANTLR3_FALSE;
    return success;
}
static ANTLR3_BOOLEAN synpred2_belle_sdp(pbelle_sdpParser ctx)
{
    ANTLR3_MARKER   start;
    ANTLR3_BOOLEAN  success;

    BACKTRACKING++;
    start	= MARK();
    synpred2_belle_sdp_fragment(ctx);	    // can never throw exception
    success	= !(FAILEDFLAG);
    REWIND(start);
    BACKTRACKING--;
    FAILEDFLAG	= ANTLR3_FALSE;
    return success;
}
static ANTLR3_BOOLEAN synpred19_belle_sdp(pbelle_sdpParser ctx)
{
    ANTLR3_MARKER   start;
    ANTLR3_BOOLEAN  success;

    BACKTRACKING++;
    start	= MARK();
    synpred19_belle_sdp_fragment(ctx);	    // can never throw exception
    success	= !(FAILEDFLAG);
    REWIND(start);
    BACKTRACKING--;
    FAILEDFLAG	= ANTLR3_FALSE;
    return success;
}
static ANTLR3_BOOLEAN synpred7_belle_sdp(pbelle_sdpParser ctx)
{
    ANTLR3_MARKER   start;
    ANTLR3_BOOLEAN  success;

    BACKTRACKING++;
    start	= MARK();
    synpred7_belle_sdp_fragment(ctx);	    // can never throw exception
    success	= !(FAILEDFLAG);
    REWIND(start);
    BACKTRACKING--;
    FAILEDFLAG	= ANTLR3_FALSE;
    return success;
}
static ANTLR3_BOOLEAN synpred20_belle_sdp(pbelle_sdpParser ctx)
{
    ANTLR3_MARKER   start;
    ANTLR3_BOOLEAN  success;

    BACKTRACKING++;
    start	= MARK();
    synpred20_belle_sdp_fragment(ctx);	    // can never throw exception
    success	= !(FAILEDFLAG);
    REWIND(start);
    BACKTRACKING--;
    FAILEDFLAG	= ANTLR3_FALSE;
    return success;
}
static ANTLR3_BOOLEAN synpred8_belle_sdp(pbelle_sdpParser ctx)
{
    ANTLR3_MARKER   start;
    ANTLR3_BOOLEAN  success;

    BACKTRACKING++;
    start	= MARK();
    synpred8_belle_sdp_fragment(ctx);	    // can never throw exception
    success	= !(FAILEDFLAG);
    REWIND(start);
    BACKTRACKING--;
    FAILEDFLAG	= ANTLR3_FALSE;
    return success;
}
static ANTLR3_BOOLEAN synpred24_belle_sdp(pbelle_sdpParser ctx)
{
    ANTLR3_MARKER   start;
    ANTLR3_BOOLEAN  success;

    BACKTRACKING++;
    start	= MARK();
    synpred24_belle_sdp_fragment(ctx);	    // can never throw exception
    success	= !(FAILEDFLAG);
    REWIND(start);
    BACKTRACKING--;
    FAILEDFLAG	= ANTLR3_FALSE;
    return success;
}
static ANTLR3_BOOLEAN synpred11_belle_sdp(pbelle_sdpParser ctx)
{
    ANTLR3_MARKER   start;
    ANTLR3_BOOLEAN  success;

    BACKTRACKING++;
    start	= MARK();
    synpred11_belle_sdp_fragment(ctx);	    // can never throw exception
    success	= !(FAILEDFLAG);
    REWIND(start);
    BACKTRACKING--;
    FAILEDFLAG	= ANTLR3_FALSE;
    return success;
}
static ANTLR3_BOOLEAN synpred22_belle_sdp(pbelle_sdpParser ctx)
{
    ANTLR3_MARKER   start;
    ANTLR3_BOOLEAN  success;

    BACKTRACKING++;
    start	= MARK();
    synpred22_belle_sdp_fragment(ctx);	    // can never throw exception
    success	= !(FAILEDFLAG);
    REWIND(start);
    BACKTRACKING--;
    FAILEDFLAG	= ANTLR3_FALSE;
    return success;
}
static ANTLR3_BOOLEAN synpred15_belle_sdp(pbelle_sdpParser ctx)
{
    ANTLR3_MARKER   start;
    ANTLR3_BOOLEAN  success;

    BACKTRACKING++;
    start	= MARK();
    synpred15_belle_sdp_fragment(ctx);	    // can never throw exception
    success	= !(FAILEDFLAG);
    REWIND(start);
    BACKTRACKING--;
    FAILEDFLAG	= ANTLR3_FALSE;
    return success;
}
static ANTLR3_BOOLEAN synpred16_belle_sdp(pbelle_sdpParser ctx)
{
    ANTLR3_MARKER   start;
    ANTLR3_BOOLEAN  success;

    BACKTRACKING++;
    start	= MARK();
    synpred16_belle_sdp_fragment(ctx);	    // can never throw exception
    success	= !(FAILEDFLAG);
    REWIND(start);
    BACKTRACKING--;
    FAILEDFLAG	= ANTLR3_FALSE;
    return success;
}
static ANTLR3_BOOLEAN synpred21_belle_sdp(pbelle_sdpParser ctx)
{
    ANTLR3_MARKER   start;
    ANTLR3_BOOLEAN  success;

    BACKTRACKING++;
    start	= MARK();
    synpred21_belle_sdp_fragment(ctx);	    // can never throw exception
    success	= !(FAILEDFLAG);
    REWIND(start);
    BACKTRACKING--;
    FAILEDFLAG	= ANTLR3_FALSE;
    return success;
}
static ANTLR3_BOOLEAN synpred3_belle_sdp(pbelle_sdpParser ctx)
{
    ANTLR3_MARKER   start;
    ANTLR3_BOOLEAN  success;

    BACKTRACKING++;
    start	= MARK();
    synpred3_belle_sdp_fragment(ctx);	    // can never throw exception
    success	= !(FAILEDFLAG);
    REWIND(start);
    BACKTRACKING--;
    FAILEDFLAG	= ANTLR3_FALSE;
    return success;
}
static ANTLR3_BOOLEAN synpred6_belle_sdp(pbelle_sdpParser ctx)
{
    ANTLR3_MARKER   start;
    ANTLR3_BOOLEAN  success;

    BACKTRACKING++;
    start	= MARK();
    synpred6_belle_sdp_fragment(ctx);	    // can never throw exception
    success	= !(FAILEDFLAG);
    REWIND(start);
    BACKTRACKING--;
    FAILEDFLAG	= ANTLR3_FALSE;
    return success;
}
static ANTLR3_BOOLEAN synpred18_belle_sdp(pbelle_sdpParser ctx)
{
    ANTLR3_MARKER   start;
    ANTLR3_BOOLEAN  success;

    BACKTRACKING++;
    start	= MARK();
    synpred18_belle_sdp_fragment(ctx);	    // can never throw exception
    success	= !(FAILEDFLAG);
    REWIND(start);
    BACKTRACKING--;
    FAILEDFLAG	= ANTLR3_FALSE;
    return success;
}
static ANTLR3_BOOLEAN synpred1_belle_sdp(pbelle_sdpParser ctx)
{
    ANTLR3_MARKER   start;
    ANTLR3_BOOLEAN  success;

    BACKTRACKING++;
    start	= MARK();
    synpred1_belle_sdp_fragment(ctx);	    // can never throw exception
    success	= !(FAILEDFLAG);
    REWIND(start);
    BACKTRACKING--;
    FAILEDFLAG	= ANTLR3_FALSE;
    return success;
}
static ANTLR3_BOOLEAN synpred13_belle_sdp(pbelle_sdpParser ctx)
{
    ANTLR3_MARKER   start;
    ANTLR3_BOOLEAN  success;

    BACKTRACKING++;
    start	= MARK();
    synpred13_belle_sdp_fragment(ctx);	    // can never throw exception
    success	= !(FAILEDFLAG);
    REWIND(start);
    BACKTRACKING--;
    FAILEDFLAG	= ANTLR3_FALSE;
    return success;
}

/* End of syntactic predicates
 * ==============================================
 */






/* End of code
 * =============================================================================
 */
