// $ANTLR 2.7.1: "expandedsip_messageParser.g" -> "sip_messageParser.java"$

/*******************************************************************************
* Product of NIST/ITL Advanced Networking Technologies Division (ANTD)         *
* See ../../../../doc/uncopyright.html for conditions of use                   *
* Author: M. Ranganathan (mranga@nist.gov)                                     *
* Questions/Comments: nist-sip-dev@antd.nist.gov                               *
*******************************************************************************/
/**
* Revisions Since v0.9  release:
*
* 1. addes support for also header 
*
* 2. Fixed a bug that would report the wrong line for error if 
*	error occured in the address rule (parserMain.newline() is called
*	only when consuming a RETURN token)
*
* 3. Added error recovery mechanism for dealing with Malformed headers.
*     i.e. headers where you cant even tell what the type is.
*    (non-terminals request_body and repy_body have an additional case)
*
* 4. Made changes in the from and to rules in accordance with the following:
*    The Contact, From and To header fields contain a URL. If the URL
*    contains a comma, question mark or semicolon, the URL MUST be
*    enclosed in angle brackets (< and >). Any URL parameters are
*    contained within these brackets. If the URL is not enclosed in angle
*    brackets, any semicolon-delimited parameters are header-parameters,
*    not URL parameters.
*
* 5. added error_info
*
* 6. Revisions to reflect new (regularized) classes for sip headers.
*/

package gov.nist.sip.msgparser;
import gov.nist.sip.net.*;
import java.lang.reflect.*;
import gov.nist.sip.*;
import gov.nist.sip.sipheaders.*;

import antlr.TokenBuffer;
import antlr.TokenStreamException;
import antlr.TokenStreamIOException;
import antlr.ANTLRException;
import antlr.LLkParser;
import antlr.Token;
import antlr.TokenStream;
import antlr.RecognitionException;
import antlr.NoViableAltException;
import antlr.MismatchedTokenException;
import antlr.SemanticException;
import antlr.ParserSharedInputState;
import antlr.collections.impl.BitSet;
import antlr.collections.AST;
import antlr.ASTPair;
import antlr.collections.impl.ASTArray;

public class sip_messageParser extends antlr.LLkParser
       implements sip_messageParserTokenTypes
 {


MsgParser parserMain;

/**
* This code is to track the portion of the input that
* matches non-terminals.
*/

private java.util.Vector   vbuf = new java.util.Vector(10,10);
private int 	 topOfStack = 0;
private java.util.Vector   currentRule = new java.util.Vector(10,10);
private int 	 traceTopOfStack = 0;
private boolean traceEnabled;
private final int HEADER_PARSE_EXCEPTION = 1;
private final int ILLEGAL_REQUEST_LINE_EXCEPTION = 2;
private final int ILLEGAL_STATUS_LINE_EXCEPTION = 3;
private final int SDP_PARSE_EXCEPTION = 4;
private final int UNRECOGNIZED_EXTENSION_EXCEPTION = 5;
private final int UNEXPECTED_HEADER_EXCEPTION = 6;
private final int INVALID_HEADER_EXCEPTION = 7;

   public void match(int t) throws  MismatchedTokenException,
    TokenStreamException {
         if ( parserMain.trackInput && inputState.guessing == 0 ) {
	    for (int i = 0; i < topOfStack; i ++) {
	        StringBuffer rbuf = (StringBuffer) vbuf.elementAt(i);
	        rbuf.append(LT(1).getText());
	    }
           }
           super.match(t);
    }
   public void traceIn(String rname) 
	throws TokenStreamException 
	{
		traceEnabled = true;
		currentRule.add(rname);
		super.traceIn(rname);
	}

   public void traceOut(String rname)
	throws TokenStreamException 
	{
		traceEnabled = true;
		Object lastElement = currentRule.lastElement();
		currentRule.remove(lastElement);
		super.traceOut(rname);
	}
	

   public void match(BitSet b) throws  MismatchedTokenException,
       TokenStreamException {
       if ( parserMain.trackInput  && (inputState.guessing == 0) ) {
	    for (int i = 0; i < topOfStack; i ++) {
	        StringBuffer rbuf = (StringBuffer) vbuf.elementAt(i);
	        rbuf.append(LT(1).getText());
	    }
       }
       super.match(b);
  }

  private void track ( String str)  {
      if ( parserMain.trackInput && (inputState.guessing == 0) ) {
	    for (int i = 0; i < topOfStack; i ++) {
	        StringBuffer rbuf = (StringBuffer) vbuf.elementAt(i);
	        rbuf.append(str);
           }
      }
  }
		
  private void startTracking() { 
      
      if ( parserMain.trackInput  && inputState.guessing == 0 ) {
	 if (parserMain.debugFlag == 1 && traceEnabled ) {
	    String cur = (String) currentRule.lastElement();
	    String dbgStr = "startTracking{ " + "(" + cur + "/" +  
				topOfStack + ")";
	    Debug.print(dbgStr);
	 }
         vbuf.add(new StringBuffer());
         topOfStack++;
       }
  }

  public void consume() {
	try {
	  if (LA(1) == RETURN) {
		parserMain.newLine(); 
	  }
	} catch ( TokenStreamException ex) {}
	super.consume();
  }

  private String stopTracking() {
     if ( parserMain.trackInput  && inputState.guessing == 0 ) {
        if (topOfStack - 1  < 0) {
	   InternalError.handleException("Fatal error tracking stack!");
        }
        StringBuffer rbuf = (StringBuffer) vbuf.elementAt(topOfStack - 1 );
        vbuf.remove(topOfStack -1 );
        topOfStack --;
	
	if (parserMain.debugFlag == 1 && traceEnabled ) {
	    String cur = (String) currentRule.lastElement();
	    String dbgStr = "}stopTracking " + "(" + cur + "/" + 
				topOfStack + ")" ;
	    Debug.print(dbgStr);
	}
        return rbuf.toString();
     } else return null;
 }

 private boolean isDigit( char ch) {
	if (ch == '0' || ch == '1' || ch == '2' || ch == '3' || ch == '4' ||
	    ch == '5' || ch == '6' || ch == '7' || ch == '8' || ch == '9')
	    return true;
	else return false;
 }

 
 private void selectLexer( String lname ) {
	parserMain.select(lname);
 }

 private void selectLexer( String lname, int state  ) {
	parserMain.select(lname, state);
 }

 private void pushLexer( String lname ) {
	parserMain.push(lname);
 }

 private void popLexer() {
	parserMain.pop();
	if (parserMain.enclosingLexer != null) {
		parserMain.select(parserMain.enclosingLexer);
		parserMain.enclosingLexer = null;
	}
 }

 private String getCurrentLexerName() {
	return parserMain.current_lexer_name;
 }

 /**
 * Set the lexer to switch to when hitting end of line.
 */
 private void setEOLLexer( String lname) {
	parserMain.setEOLLexer(lname);
 }

 /**
 * Arrest the line counter from progressing (when we are looking ahead)
 */
 private void arrestLineCounter() {
	parserMain.arrestLineCounter();
 }
 
 /**
 * Allow the line counter to proceed again.
 */
 private void releaseLineCounter() {
	parserMain.releaseLineCounter();
 }

 private void resetLineCounter() {
	parserMain.resetLineCounter();
 }


/**
* Handle a parse error by calling the registered error handler.
*
* If the error handler throws an exception, then this is passed back
* to the parser. This should be called only from the exception handler of the
* parser (note that stopTracking() is called).
*/
private GenericObject  handleParseException(
		RecognitionException ex, 
		int exceptionType, 
		GenericObject h,
		String headerName,  
		boolean trackFlag) 
	throws RecognitionException {
	String currentHeader = parserMain.getCurrentHeader();
	String input_text = null;
	selectLexer("charLexer");
	while (true) {
		Token tok;
		try {
			tok = LT(1);
		} catch (TokenStreamException tse) {
			if (trackFlag) {
				input_text = stopTracking();
			}
			ex.fillInStackTrace();
			throw ex;
		}
		if (tok.getType() == Token.EOF_TYPE) {
			 if ( trackFlag) stopTracking();
			 break;
		}
		consume();
		if (tok.getType() == RETURN ) break;
	}
	if (trackFlag)  {
		input_text = stopTracking();
	}
	try {
        	SIPParseException e = null;
 		if (exceptionType == UNRECOGNIZED_EXTENSION_EXCEPTION )  {
			e = new SIPUnrecognizedExtensionException(ex);
			selectLexer("command_keywordLexer");
		} else if (exceptionType == HEADER_PARSE_EXCEPTION)  {
			e = new SIPHeaderParseException(ex);
			selectLexer("command_keywordLexer");
        	} else if (exceptionType == SDP_PARSE_EXCEPTION) {
			e = new SDPParseException(ex);
			selectLexer("sdpLexer");
  		} else if (exceptionType == ILLEGAL_REQUEST_LINE_EXCEPTION) {
			e = new SIPIllegalRequestLineException(ex);
			selectLexer("command_keywordLexer");
        	} else if (exceptionType == ILLEGAL_STATUS_LINE_EXCEPTION) {
	       		e = new SIPIllegalStatusLineException(ex);
	       		selectLexer("command_keywordLexer");
  		}  else {
			InternalError.handleException(ex);
		}
		e.setErrorObject(h);
		e.fillInStackTrace();
		e.setErrorObjectName(headerName);
        	e.setText(currentHeader);
	   	parserMain.handleParseException(e);
	   	return e.getErrorObject();
	} catch (SIPParseException pex) {
		ex.fillInStackTrace();
		throw  ex;
	}
}

/**
* Handle a parse error by calling the registered error handler.
*
* If the error handler throws an exception, then this is passed back
* to the parser. This should be called only from the exception handler of the
* parser.
*/
private GenericObject  handleParseException(TokenStreamException ex, 
		int exceptionType, 
		GenericObject h, 
		String headerName, 
		boolean trackFlag ) throws TokenStreamException  {
	String input_text = null;
	String currentHeader = parserMain.getCurrentHeader();
	selectLexer("charLexer");
        while (true) {
		Token tok;
		try {
			tok = LT(1);
		} catch (TokenStreamException tse) {
			if (trackFlag) {
				input_text = stopTracking();
			}
			ex.fillInStackTrace();
			throw ex;
		}
		consume();
		if (tok.getType() == RETURN ) break;
        }

	if (trackFlag) {
		input_text =  stopTracking();
	}
	try {
		// If we are not at EOL, then advance to the end of line
	 	SIPParseException e = null;
         	if (exceptionType == HEADER_PARSE_EXCEPTION)  {
			e = new SIPHeaderParseException(ex);
			selectLexer("command_keywordLexer");
         	} else if (exceptionType == SDP_PARSE_EXCEPTION) {
			e = new SDPParseException(ex);
			selectLexer("sdpLexer");
         	} else if (exceptionType == ILLEGAL_REQUEST_LINE_EXCEPTION) {
			e = new SIPIllegalRequestLineException(ex);
			e.fillInStackTrace();
			selectLexer("command_keywordLexer");
        	} else if (exceptionType == ILLEGAL_STATUS_LINE_EXCEPTION) {
	       		e = new SIPIllegalStatusLineException(ex);
	       		selectLexer("command_keywordLexer");
        	}  else {
			InternalError.handleException(ex);
        	}
		e.fillInStackTrace();
		e.setErrorObjectName(headerName);
		e.setText(currentHeader);
		e.setErrorObject(h);
	   	parserMain.handleParseException(e);
	   	return e.getErrorObject();
	} catch (SIPParseException pex) {
		 ex.fillInStackTrace(); 
		 throw ex;
	}
}

/**
* Handle a parse error by calling the registered error handler.
*
* If the error handler throws an exception, then this is passed back
* to the parser. This should be called only from the exception handler of the
* parser.
*/
private GenericObject  handleParseException(NoViableAltException ex, 
		int exceptionType, 
		GenericObject h, 
		String headerName, 
		boolean trackFlag ) throws NoViableAltException {
	String input_text = null;
	String currentHeader = parserMain.getCurrentHeader();
	selectLexer("charLexer");
        while (true) {
		Token tok;
		try {
			tok = LT(1);
		} catch (TokenStreamException tse) {
			if (trackFlag) {
				input_text = stopTracking();
			}
			ex.fillInStackTrace();
			throw ex;
		}
		consume();
		if (tok.getType() == RETURN ) break;
        }

	if (trackFlag) {
		input_text =  stopTracking();
	}
	try {
		// If we are not at EOL, then advance to the end of line
	 	SIPParseException e = null;
 		if (exceptionType == INVALID_HEADER_EXCEPTION )  {
	       		e = new SIPInvalidHeaderException(ex);
	       		selectLexer("command_keywordLexer");
        	}  else {
			InternalError.handleException(ex);
        	}
		e.fillInStackTrace();
		e.setErrorObjectName(headerName);
		e.setText(currentHeader);
		e.setErrorObject(h);
	   	parserMain.handleParseException(e);
	   	return e.getErrorObject();
	} catch (SIPParseException pex) {
		 ex.fillInStackTrace(); 
		 throw ex;
	}
}

 private void Assert( boolean condition) {
	if ( ! condition ) {
		InternalError.handleException ("Assertion Failure");
	}
 }

 private void Assert( boolean condition, String msg ) {
	if ( ! condition ) {
		System.err.println("Current lexer is " 
				+ parserMain.current_lexer_name );
		InternalError.handleException ("Assertion Failure " + msg);
	}
 }

 

protected sip_messageParser(TokenBuffer tokenBuf, int k) {
  super(tokenBuf,k);
  tokenNames = _tokenNames;
}

public sip_messageParser(TokenBuffer tokenBuf) {
  this(tokenBuf,1);
}

protected sip_messageParser(TokenStream lexer, int k) {
  super(lexer,k);
  tokenNames = _tokenNames;
}

public sip_messageParser(TokenStream lexer) {
  this(lexer,1);
}

public sip_messageParser(ParserSharedInputState state) {
  super(state,1);
  tokenNames = _tokenNames;
}

	public final  String  sip_version() throws RecognitionException, TokenStreamException {
		 String v ;
		
		Token  t1 = null;
		Token  t2 = null;
		Token  t3 = null;
		Token  t4 = null;
		Token  t5 = null;
		Token  t6 = null;
		
			String s = "";
			v = null;
		
		
		t1 = LT(1);
		match(SIP);
		if ( inputState.guessing==0 ) {
			s += t1.getText();
		}
		t2 = LT(1);
		match(SLASH);
		if ( inputState.guessing==0 ) {
			s += t2.getText();
		}
		{
		switch ( LA(1)) {
		case DIGIT:
		{
			{
			t3 = LT(1);
			match(DIGIT);
			if ( inputState.guessing==0 ) {
				s += t3.getText();
			}
			t4 = LT(1);
			match(DOT);
			if ( inputState.guessing==0 ) {
				s += t4.getText();
			}
			t5 = LT(1);
			match(DIGIT);
			if ( inputState.guessing==0 ) {
				s += t5.getText();
			}
			}
			break;
		}
		case ID:
		{
			{
			t6 = LT(1);
			match(ID);
			if ( inputState.guessing==0 ) {
					
				if (t6.getText().length() != 3) {
					throw new RecognitionException("Invalid Version String");
				} else {
					s += t6.getText(); 
				}
				
			}
			}
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			
				v = s.toUpperCase(); // Return in canonical form.
			
		}
		return v ;
	}
	
	public final  SIPMessage  sip_message() throws RecognitionException, TokenStreamException {
		 SIPMessage m ;
		
		
			m = null;
			selectLexer("method_keywordLexer");
			setEOLLexer("method_keywordLexer");
			while (true) {
			   try {
			      // Strange token in the input stream.
			      if (LT(1).getText() == null) return null;
			      // Consume leading RETURNs 
			      else if (LT(1).getText().equals("\n")) consume();
			      // Reached the end of file.
			      else if (LA(1) == Token.EOF_TYPE) return null;
			      else break;
			   } catch ( TokenStreamException ex ) {
			 	return null;
			   }
			}
			// Select the lexical analyser to pick when hitting EOL.
			setEOLLexer("command_keywordLexer");
			// Reset the line counter here (otherwise we will report errors
			// on the wrong line).
			// Enable line folding support in the pre-processor.
			parserMain.setHandleContinuations(true);
			// Set the content length to some arbitrary number.
			startTracking();
		
		
		try {      // for error handling
			switch ( LA(1)) {
			case NULL:
			{
				match(NULL);
				if ( inputState.guessing==0 ) {
					stopTracking(); m = null;
				}
				break;
			}
			case ID:
			case SIP:
			case REGISTER:
			case ACK:
			case OPTIONS:
			case BYE:
			case INVITE:
			case CANCEL:
			{
				{
				switch ( LA(1)) {
				case SIP:
				{
					{
					m=response();
					}
					break;
				}
				case ID:
				case REGISTER:
				case ACK:
				case OPTIONS:
				case BYE:
				case INVITE:
				case CANCEL:
				{
					{
					m=request();
					}
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				}
				}
				if ( inputState.guessing==0 ) {
					m.setInputText(stopTracking());
				}
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
		}
		catch ( RecognitionException ex ) {
			if (inputState.guessing==0) {
				
					// Enable if debugging is on...
					ex.fillInStackTrace();
					parserMain.dbgprint("RecognitionException :" + ex.getMessage());
					parserMain.dbgprint(ex);
					// Eat all tokens until the blank line.
					selectLexer("skipLexer");
					try {
				while(LA(1) != Token.EOF_TYPE && LA(2) != Token.EOF_TYPE) {
					     if (LA(1) == RETURN && LA(2) == RETURN) break;
					     else consume();
				}
					} catch (ANTLRException e) { /* IGNORE  */ } 
				throw ex;
				
			} else {
				throw ex ;
			}
		}
		catch ( TokenStreamException ex ) {
			if (inputState.guessing==0) {
				
					// added v 1.0
					// Enable if debugging is on...
					ex.fillInStackTrace();
					parserMain.dbgprint("TokenStreamException :" + ex.getMessage());
					parserMain.dbgprint(ex);
					// Eat all tokens until the blank line.
					selectLexer("skipLexer");
					try {
					  while(LA(1) != Token.EOF_TYPE && LA(2) != Token.EOF_TYPE) {
					    if (LA(1) == RETURN && LA(2) == RETURN) break;
					    else consume();
				}
					} catch (ANTLRException e) { /* IGNORE  */ }
					throw ex;
				
			} else {
				throw ex ;
			}
		}
		return m ;
	}
	
	public final  SIPResponse  response() throws RecognitionException, TokenStreamException {
		 SIPResponse m ;
		
		
		m = new SIPResponse();
		StatusLine s;
			SIPHeader hdr;
			resetLineCounter();
		startTracking();
		
		
		s=status_line();
		{
		if ((LA(1)==RETURN)) {
			{
			match(RETURN);
			match(RETURN);
			}
		}
		else if ((_tokenSet_0.member(LA(1)))) {
			{
			int _cnt15=0;
			_loop15:
			do {
				if ((_tokenSet_0.member(LA(1)))) {
					hdr=response_body();
					if ( inputState.guessing==0 ) {
						
						// store a direct ptr in the header for efficient processing later.
							   try {
						if (hdr != null) m.attachHeader(hdr, false,false); 
							   } catch (SIPDuplicateHeaderException ex) {
								ex.fillInStackTrace();
								try {
							            parserMain.handleParseException (ex);
								    // user wants to reject message.
								    if (ex.getHeader() != null) {
									 m.attachHeader(hdr,true,false);
								    }
								} catch (SIPParseException e ) {
									RecognitionException rex = 
									 new RecognitionException(e.getMessage());
									rex.fillInStackTrace();
									throw rex;
								}
							   }
							
					}
				}
				else {
					if ( _cnt15>=1 ) { break _loop15; } else {throw new NoViableAltException(LT(1), getFilename());}
				}
				
				_cnt15++;
			} while (true);
			}
			match(RETURN);
		}
		else {
			throw new NoViableAltException(LT(1), getFilename());
		}
		
		}
		if ( inputState.guessing==0 ) {
			
				  m.statusLine = s;
				  try {
				       // if (parserMain.checkURI) m.checkURI();
					m.checkHeaders();
				  } catch ( SIPParseException ex) {
				     ex.fillInStackTrace();
				     try {
				    	parserMain.handleParseException(ex);
				     } catch ( SIPParseException e ) {
					RecognitionException rex = 
					   new RecognitionException(e.getMessage());
					rex.fillInStackTrace();
					throw rex;
				     }
				 }
			m.setInputText(stopTracking());
				  m.messageContent = null;
				  // Disable line folding support in the preprocessor.
				  parserMain.setHandleContinuations(false);
			// Deal with the message payload.
			if ( m.contentLengthHeader != null  &&
					m.contentLengthHeader.getContentLength() > 0 ) {
			match(RETURN);
			selectLexer("skipLexer");
				    setEOLLexer("skipLexer");
				    m.messageContent = "";
			for ( int i = 2 ; 
					i < m.contentLengthHeader.getContentLength(); ) {
					Token tok = LT(1);
					if (tok == null) break;
				        String nexttok = tok.getText();
					if (nexttok == null) break;
				        // Carriage return is counted as 2 chars because it is
				        // carriage return + line feed.
					// changed v1.0
			consume();
				        if (nexttok.equals("\n") ) {
					  i ++;
				        }
					i += nexttok.length();
			m.messageContent += nexttok;
				    }
			} else if ( m.contentLengthHeader == null && 
				   parserMain.getClass().getName().compareTo(
					PackageNames.MSGPARSER_PACKAGE + ".StringMsgParser") == 0 ) {
					// This is a UDP packet - need to snarf up input 
					// even though the contentLength is  not specified.
					// Content length not specified - snarf up input to 
					// the next RETURN.
					match(RETURN);
					selectLexer("skipLexer");
					m.messageContent = "";
					int i = 0;
					while (true) {
						Token tok = LT(1);
						if (tok == null) break;
				        	String nexttok = tok.getText();
						if (nexttok == null) break;
				        	// Carriage return is counted as 2 chars because it is
				        	// carriage return + line feed (default behavior).
						// changed v1.0
				        	if (nexttok.equals("\n") && 
							parserMain.lineFeedTranslation) {
					  		i ++;
				        	}
				m.messageContent += nexttok;
						i += nexttok.length();
				consume();
					}
					m.contentLengthHeader = new ContentLength();
					m.contentLengthHeader.setContentLength(i);
				}
				parserMain.messageDone(m);
			
		}
		return m ;
	}
	
	public final  SIPRequest  request() throws RecognitionException, TokenStreamException {
		 SIPRequest m ;
		
		
		m = new SIPRequest ();
		String mtag;
		RequestLine rl = null;
		SIPHeader hdr = null;
		resetLineCounter();
		startTracking();
		
		
		rl=request_line();
		{
		if ((LA(1)==RETURN)) {
			{
			match(RETURN);
			match(RETURN);
			}
		}
		else if ((_tokenSet_0.member(LA(1)))) {
			{
			int _cnt20=0;
			_loop20:
			do {
				if ((_tokenSet_0.member(LA(1)))) {
					hdr=request_body();
					if ( inputState.guessing==0 ) {
						
							  try {
							     if (hdr != null) m.attachHeader(hdr,false,false);  
							   } catch ( SIPDuplicateHeaderException ex) {
								ex.fillInStackTrace();
								try {
							       		parserMain.handleParseException(ex);
									// User returned null --  discard the duplicate
							     		if (ex.getHeader() != null) {
										 m.attachHeader(hdr,true,false);  
									}
								} catch ( SIPParseException e ) {
									RecognitionException rex = 
									    new RecognitionException(e.getMessage());
									rex.fillInStackTrace();
									throw rex;
								}
							   }
							
					}
				}
				else {
					if ( _cnt20>=1 ) { break _loop20; } else {throw new NoViableAltException(LT(1), getFilename());}
				}
				
				_cnt20++;
			} while (true);
			}
			match(RETURN);
		}
		else {
			throw new NoViableAltException(LT(1), getFilename());
		}
		
		}
		if ( inputState.guessing==0 ) {
			
				m.requestLine = rl;
				m.setDefaults();
				try {
				        // if (parserMain.checkURI) m.checkURI();
					m.checkHeaders();
				} catch ( SIPParseException ex) {
				     ex.fillInStackTrace();
				     try {
				    	parserMain.handleParseException(ex);
				     } catch ( SIPParseException e ) {
					RecognitionException rex = 
					   new RecognitionException(e.getMessage());
					rex.fillInStackTrace();
					throw rex;
				     }
				 }
			
			m.setInputText(stopTracking());
				m.messageContent = null;
				parserMain.setHandleContinuations(false);
			if (m.contentLengthHeader != null && 
				     m.contentLengthHeader.getContentLength() > 0 ) {
			match(RETURN);
			selectLexer("skipLexer");
				    setEOLLexer("skipLexer");
				    m.messageContent = "";
				    // Ignoring the last CRLF, consume the rest.
			for ( int i = 2 ; 
					i < m.contentLengthHeader.getContentLength(); ) {
					Token tok = LT(1);
					if (tok == null) {
						 break;
					}
				        String nexttok = tok.getText();
					if (nexttok == null)  {
						break;
					}
				        // Carriage return is counted as 2 chars because it is
				        // carriage return + line feed.
			m.messageContent += nexttok;
			consume();
					i += nexttok.length();
				        if (nexttok.equals("\n")) {
					    i ++;
				        }
				    }
			} else if ( m.contentLengthHeader == null && 
					parserMain instanceof StringMsgParser ) {
					// Content length not specified - snarf up 
					// input to the next RETURN.
					match(RETURN);
					selectLexer("skipLexer");
					m.messageContent = "";
					int i = 0;
					while (true) {
						Token tok = LT(1);
						if (tok == null) break;
				        	String nexttok = tok.getText();
				        	// Carriage return is counted as 2 chars because it is
				        	// carriage return + line feed (default behavior).
						if (nexttok == null) break;
				        	if (nexttok.equals("\n") && 
							parserMain.lineFeedTranslation ) {
					  		i ++;
				        	}
				m.messageContent += nexttok;
						i += nexttok.length();
				consume();
					}
					m.contentLengthHeader = new ContentLength();
					m.contentLengthHeader.setContentLength(i);
				}
				// For string msg parser.
				parserMain.messageDone(m);
			
			
		}
		return m ;
	}
	
	public final  StatusLine  status_line() throws RecognitionException, TokenStreamException {
		 StatusLine s ;
		
		
		s = new StatusLine();
		String v = null;
		int    scode = 0;
		String rp = null ;
		startTracking();
		
		
		try {      // for error handling
			v=sip_version();
			match(SP);
			if ( inputState.guessing==0 ) {
				s.setSipVersion(v);
			}
			scode=status_code();
			match(SP);
			if ( inputState.guessing==0 ) {
				s.setStatusCode(scode);
			}
			rp=reason_phrase();
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
				s.setReasonPhrase(rp); 
				s.setInputText(stopTracking()); // Gather the match portion.
				selectLexer("command_keywordLexer"); 
				
			}
		}
		catch ( TokenStreamException ex ) {
			if (inputState.guessing==0) {
				
					 s = (StatusLine) 
					 handleParseException(ex, ILLEGAL_STATUS_LINE_EXCEPTION,
							s, SIPHeaderNames.STATUS_LINE, true);
				
			} else {
				throw ex ;
			}
		}
		catch ( RecognitionException ex ) {
			if (inputState.guessing==0) {
				
					 s = (StatusLine) 
					 handleParseException(ex, ILLEGAL_STATUS_LINE_EXCEPTION,
							s, SIPHeaderNames.STATUS_LINE, true);
				
			} else {
				throw ex ;
			}
		}
		return s ;
	}
	
	public final  SIPHeader  response_body() throws RecognitionException, TokenStreamException {
		 SIPHeader m ;
		
		m = null;  String msg = null;
		
		boolean synPredMatched35 = false;
		if ((((LA(1) >= SUPPORTED_COLON && LA(1) <= CONTACT_COLON)))) {
			int _m35 = mark();
			synPredMatched35 = true;
			inputState.guessing++;
			try {
				{
				switch ( LA(1)) {
				case SUPPORTED_COLON:
				{
					match(SUPPORTED_COLON);
					break;
				}
				case CALL_INFO_COLON:
				{
					match(CALL_INFO_COLON);
					break;
				}
				case ACCEPT_ENCODING_COLON:
				{
					match(ACCEPT_ENCODING_COLON);
					break;
				}
				case ACCEPT_LANGUAGE_COLON:
				{
					match(ACCEPT_LANGUAGE_COLON);
					break;
				}
				case CALL_ID_COLON:
				{
					match(CALL_ID_COLON);
					break;
				}
				case MIME_VERSION_COLON:
				{
					match(MIME_VERSION_COLON);
					break;
				}
				case CSEQ_COLON:
				{
					match(CSEQ_COLON);
					break;
				}
				case DATE_COLON:
				{
					match(DATE_COLON);
					break;
				}
				case ENCRYPTION_COLON:
				{
					match(ENCRYPTION_COLON);
					break;
				}
				case FROM_COLON:
				{
					match(FROM_COLON);
					break;
				}
				case RECORD_ROUTE_COLON:
				{
					match(RECORD_ROUTE_COLON);
					break;
				}
				case TIMESTAMP_COLON:
				{
					match(TIMESTAMP_COLON);
					break;
				}
				case TO_COLON:
				{
					match(TO_COLON);
					break;
				}
				case ACCEPT_COLON:
				{
					match(ACCEPT_COLON);
					break;
				}
				case VIA_COLON:
				{
					match(VIA_COLON);
					break;
				}
				case ORGANIZATION_COLON:
				{
					match(ORGANIZATION_COLON);
					break;
				}
				case REQUIRE_COLON:
				{
					match(REQUIRE_COLON);
					break;
				}
				case USER_AGENT_COLON:
				{
					match(USER_AGENT_COLON);
					break;
				}
				case CONTACT_COLON:
				{
					match(CONTACT_COLON);
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				}
				}
			}
			catch (RecognitionException pe) {
				synPredMatched35 = false;
			}
			rewind(_m35);
			inputState.guessing--;
		}
		if ( synPredMatched35 ) {
			m=general_header();
		}
		else {
			boolean synPredMatched37 = false;
			if ((((LA(1) >= ERROR_INFO_COLON && LA(1) <= WWW_AUTHENTICATE_COLON)))) {
				int _m37 = mark();
				synPredMatched37 = true;
				inputState.guessing++;
				try {
					{
					switch ( LA(1)) {
					case ERROR_INFO_COLON:
					{
						match(ERROR_INFO_COLON);
						break;
					}
					case PROXY_AUTHENTICATE_COLON:
					{
						match(PROXY_AUTHENTICATE_COLON);
						break;
					}
					case SERVER_COLON:
					{
						match(SERVER_COLON);
						break;
					}
					case UNSUPPORTED_COLON:
					{
						match(UNSUPPORTED_COLON);
						break;
					}
					case RETRY_AFTER_COLON:
					{
						match(RETRY_AFTER_COLON);
						break;
					}
					case WARNING_COLON:
					{
						match(WARNING_COLON);
						break;
					}
					case WWW_AUTHENTICATE_COLON:
					{
						match(WWW_AUTHENTICATE_COLON);
						break;
					}
					default:
					{
						throw new NoViableAltException(LT(1), getFilename());
					}
					}
					}
				}
				catch (RecognitionException pe) {
					synPredMatched37 = false;
				}
				rewind(_m37);
				inputState.guessing--;
			}
			if ( synPredMatched37 ) {
				m=response_header();
			}
			else {
				boolean synPredMatched39 = false;
				if ((((LA(1) >= CONTENT_DISPOSITION_COLON && LA(1) <= CONTENT_LENGTH_COLON)))) {
					int _m39 = mark();
					synPredMatched39 = true;
					inputState.guessing++;
					try {
						{
						switch ( LA(1)) {
						case CONTENT_DISPOSITION_COLON:
						{
							match(CONTENT_DISPOSITION_COLON);
							break;
						}
						case CONTENT_LANGUAGE_COLON:
						{
							match(CONTENT_LANGUAGE_COLON);
							break;
						}
						case EXPIRES_COLON:
						{
							match(EXPIRES_COLON);
							break;
						}
						case ALLOW_COLON:
						{
							match(ALLOW_COLON);
							break;
						}
						case CONTENT_TYPE_COLON:
						{
							match(CONTENT_TYPE_COLON);
							break;
						}
						case CONTENT_ENCODING_COLON:
						{
							match(CONTENT_ENCODING_COLON);
							break;
						}
						case CONTENT_LENGTH_COLON:
						{
							match(CONTENT_LENGTH_COLON);
							break;
						}
						default:
						{
							throw new NoViableAltException(LT(1), getFilename());
						}
						}
						}
					}
					catch (RecognitionException pe) {
						synPredMatched39 = false;
					}
					rewind(_m39);
					inputState.guessing--;
				}
				if ( synPredMatched39 ) {
					m=entity_header();
				}
				else {
					boolean synPredMatched41 = false;
					if ((((LA(1) >= ALERT_INFO_COLON && LA(1) <= SUBJECT_COLON)))) {
						int _m41 = mark();
						synPredMatched41 = true;
						inputState.guessing++;
						try {
							{
							switch ( LA(1)) {
							case ALERT_INFO_COLON:
							{
								match(ALERT_INFO_COLON);
								break;
							}
							case ALSO_COLON:
							{
								match(ALSO_COLON);
								break;
							}
							case IN_REPLY_TO_COLON:
							{
								match(IN_REPLY_TO_COLON);
								break;
							}
							case AUTHORIZATION_COLON:
							{
								match(AUTHORIZATION_COLON);
								break;
							}
							case HIDE_COLON:
							{
								match(HIDE_COLON);
								break;
							}
							case MAX_FORWARDS_COLON:
							{
								match(MAX_FORWARDS_COLON);
								break;
							}
							case PRIORITY_COLON:
							{
								match(PRIORITY_COLON);
								break;
							}
							case PROXY_AUTHORIZATION_COLON:
							{
								match(PROXY_AUTHORIZATION_COLON);
								break;
							}
							case PROXY_REQUIRE_COLON:
							{
								match(PROXY_REQUIRE_COLON);
								break;
							}
							case ROUTE_COLON:
							{
								match(ROUTE_COLON);
								break;
							}
							case RESPONSE_KEY_COLON:
							{
								match(RESPONSE_KEY_COLON);
								break;
							}
							case SUBJECT_COLON:
							{
								match(SUBJECT_COLON);
								break;
							}
							default:
							{
								throw new NoViableAltException(LT(1), getFilename());
							}
							}
							}
						}
						catch (RecognitionException pe) {
							synPredMatched41 = false;
						}
						rewind(_m41);
						inputState.guessing--;
					}
					if ( synPredMatched41 ) {
						m=request_header();
						if ( inputState.guessing==0 ) {
							
								// It may look a bit strange to have request_header here
								// but the idea is to allow the stack to forgive the mistake.
								SIPUnexpectedHeaderException e =
									new SIPUnexpectedHeaderException(m.getInputText());
								e.setHeaderName(m.getHeaderName());
								e.setText(m.getTrimmedInputText());
								e.setErrorObject(m);
								try {
								   parserMain.handleParseException(e);
								   m = (SIPHeader) e.getHeader();
								} catch (SIPParseException ex) {
									throw new RecognitionException("Unexpected Header : " +
										m.getInputText());
								}
							
							
						}
					}
					else {
						boolean synPredMatched43 = false;
						if (((LA(1)==HEADER_NAME_COLON))) {
							int _m43 = mark();
							synPredMatched43 = true;
							inputState.guessing++;
							try {
								{
								match(HEADER_NAME_COLON);
								}
							}
							catch (RecognitionException pe) {
								synPredMatched43 = false;
							}
							rewind(_m43);
							inputState.guessing--;
						}
						if ( synPredMatched43 ) {
							m=extension_header();
						}
						else if ((_tokenSet_0.member(LA(1)))) {
							msg=byte_string();
							match(RETURN);
							if ( inputState.guessing==0 ) {
								
								// Added v1.0
								// No colon or other delimiter found before the EOL cannot be a valid header
								// This is an error condition -- we try to let the application recover
								// by giving him the error text.
								selectLexer("command_keywordLexer"); 
								SIPInvalidHeaderException e = new SIPInvalidHeaderException(msg);
								e.setHeaderText(msg);
								try {
								parserMain.handleParseException(e);
								m = (SIPHeader) e.getHeader();
								} catch (SIPParseException ex) {
									throw new RecognitionException("Invalid Header " + msg);
								}
								
							}
						}
						else {
							throw new NoViableAltException(LT(1), getFilename());
						}
						}}}}
						return m ;
					}
					
	public final  RequestLine  request_line() throws RecognitionException, TokenStreamException {
		 RequestLine req_line ;
		
		
			URI u;
			req_line = new RequestLine();
			String m;
			String v;
			startTracking();
		
		
		try {      // for error handling
			m=method();
			match(SP);
			if ( inputState.guessing==0 ) {
				selectLexer("sip_urlLexer", sip_urlLexer.INIT_STATE);
			}
			u=request_uri();
			match(SP);
			if ( inputState.guessing==0 ) {
				
						req_line.setMethod(m);
						req_line.setUri(u);
						// Note the RETURN is below as we can throw an exception here!
						try {
							CheckConstraints.checkRequestURI(u,m);
						} catch (IllegalArgumentException ex) {
							throw new RecognitionException(ex.getMessage());
						}
						// Check for request line restrictions on URI
						selectLexer("method_keywordLexer"); 
					
			}
			v=sip_version();
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
					req_line.setSipVersion(v);
					req_line.setInputText(stopTracking());
				selectLexer("command_keywordLexer"); 
				
			}
		}
		catch ( TokenStreamException ex ) {
			if (inputState.guessing==0) {
				
					req_line = (RequestLine)
					handleParseException(ex,ILLEGAL_REQUEST_LINE_EXCEPTION, 
						req_line,SIPHeaderNames.REQUEST_LINE, true);
				
			} else {
				throw ex ;
			}
		}
		catch ( RecognitionException ex ) {
			if (inputState.guessing==0) {
				
					req_line = (RequestLine)
					handleParseException(ex,ILLEGAL_REQUEST_LINE_EXCEPTION, 
						req_line,SIPHeaderNames.REQUEST_LINE, true);
				
			} else {
				throw ex ;
			}
		}
		return req_line ;
	}
	
	public final  SIPHeader  request_body() throws RecognitionException, TokenStreamException {
		 SIPHeader rb ;
		
		
		String msg = null;
		rb = null; 
		
		
		boolean synPredMatched23 = false;
		if ((((LA(1) >= SUPPORTED_COLON && LA(1) <= CONTACT_COLON)))) {
			int _m23 = mark();
			synPredMatched23 = true;
			inputState.guessing++;
			try {
				{
				switch ( LA(1)) {
				case SUPPORTED_COLON:
				{
					match(SUPPORTED_COLON);
					break;
				}
				case CALL_INFO_COLON:
				{
					match(CALL_INFO_COLON);
					break;
				}
				case ACCEPT_ENCODING_COLON:
				{
					match(ACCEPT_ENCODING_COLON);
					break;
				}
				case ACCEPT_LANGUAGE_COLON:
				{
					match(ACCEPT_LANGUAGE_COLON);
					break;
				}
				case CALL_ID_COLON:
				{
					match(CALL_ID_COLON);
					break;
				}
				case MIME_VERSION_COLON:
				{
					match(MIME_VERSION_COLON);
					break;
				}
				case CSEQ_COLON:
				{
					match(CSEQ_COLON);
					break;
				}
				case DATE_COLON:
				{
					match(DATE_COLON);
					break;
				}
				case ENCRYPTION_COLON:
				{
					match(ENCRYPTION_COLON);
					break;
				}
				case FROM_COLON:
				{
					match(FROM_COLON);
					break;
				}
				case RECORD_ROUTE_COLON:
				{
					match(RECORD_ROUTE_COLON);
					break;
				}
				case TIMESTAMP_COLON:
				{
					match(TIMESTAMP_COLON);
					break;
				}
				case TO_COLON:
				{
					match(TO_COLON);
					break;
				}
				case ACCEPT_COLON:
				{
					match(ACCEPT_COLON);
					break;
				}
				case VIA_COLON:
				{
					match(VIA_COLON);
					break;
				}
				case ORGANIZATION_COLON:
				{
					match(ORGANIZATION_COLON);
					break;
				}
				case REQUIRE_COLON:
				{
					match(REQUIRE_COLON);
					break;
				}
				case USER_AGENT_COLON:
				{
					match(USER_AGENT_COLON);
					break;
				}
				case CONTACT_COLON:
				{
					match(CONTACT_COLON);
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				}
				}
			}
			catch (RecognitionException pe) {
				synPredMatched23 = false;
			}
			rewind(_m23);
			inputState.guessing--;
		}
		if ( synPredMatched23 ) {
			rb=general_header();
		}
		else {
			boolean synPredMatched25 = false;
			if ((((LA(1) >= ALERT_INFO_COLON && LA(1) <= SUBJECT_COLON)))) {
				int _m25 = mark();
				synPredMatched25 = true;
				inputState.guessing++;
				try {
					{
					switch ( LA(1)) {
					case ALERT_INFO_COLON:
					{
						match(ALERT_INFO_COLON);
						break;
					}
					case ALSO_COLON:
					{
						match(ALSO_COLON);
						break;
					}
					case IN_REPLY_TO_COLON:
					{
						match(IN_REPLY_TO_COLON);
						break;
					}
					case AUTHORIZATION_COLON:
					{
						match(AUTHORIZATION_COLON);
						break;
					}
					case HIDE_COLON:
					{
						match(HIDE_COLON);
						break;
					}
					case MAX_FORWARDS_COLON:
					{
						match(MAX_FORWARDS_COLON);
						break;
					}
					case PRIORITY_COLON:
					{
						match(PRIORITY_COLON);
						break;
					}
					case PROXY_AUTHORIZATION_COLON:
					{
						match(PROXY_AUTHORIZATION_COLON);
						break;
					}
					case PROXY_REQUIRE_COLON:
					{
						match(PROXY_REQUIRE_COLON);
						break;
					}
					case ROUTE_COLON:
					{
						match(ROUTE_COLON);
						break;
					}
					case RESPONSE_KEY_COLON:
					{
						match(RESPONSE_KEY_COLON);
						break;
					}
					case SUBJECT_COLON:
					{
						match(SUBJECT_COLON);
						break;
					}
					default:
					{
						throw new NoViableAltException(LT(1), getFilename());
					}
					}
					}
				}
				catch (RecognitionException pe) {
					synPredMatched25 = false;
				}
				rewind(_m25);
				inputState.guessing--;
			}
			if ( synPredMatched25 ) {
				rb=request_header();
			}
			else {
				boolean synPredMatched27 = false;
				if ((((LA(1) >= CONTENT_DISPOSITION_COLON && LA(1) <= CONTENT_LENGTH_COLON)))) {
					int _m27 = mark();
					synPredMatched27 = true;
					inputState.guessing++;
					try {
						{
						switch ( LA(1)) {
						case CONTENT_DISPOSITION_COLON:
						{
							match(CONTENT_DISPOSITION_COLON);
							break;
						}
						case CONTENT_LANGUAGE_COLON:
						{
							match(CONTENT_LANGUAGE_COLON);
							break;
						}
						case EXPIRES_COLON:
						{
							match(EXPIRES_COLON);
							break;
						}
						case ALLOW_COLON:
						{
							match(ALLOW_COLON);
							break;
						}
						case CONTENT_TYPE_COLON:
						{
							match(CONTENT_TYPE_COLON);
							break;
						}
						case CONTENT_ENCODING_COLON:
						{
							match(CONTENT_ENCODING_COLON);
							break;
						}
						case CONTENT_LENGTH_COLON:
						{
							match(CONTENT_LENGTH_COLON);
							break;
						}
						default:
						{
							throw new NoViableAltException(LT(1), getFilename());
						}
						}
						}
					}
					catch (RecognitionException pe) {
						synPredMatched27 = false;
					}
					rewind(_m27);
					inputState.guessing--;
				}
				if ( synPredMatched27 ) {
					rb=entity_header();
				}
				else {
					boolean synPredMatched29 = false;
					if ((((LA(1) >= ERROR_INFO_COLON && LA(1) <= WWW_AUTHENTICATE_COLON)))) {
						int _m29 = mark();
						synPredMatched29 = true;
						inputState.guessing++;
						try {
							{
							switch ( LA(1)) {
							case ERROR_INFO_COLON:
							{
								match(ERROR_INFO_COLON);
								break;
							}
							case PROXY_AUTHENTICATE_COLON:
							{
								match(PROXY_AUTHENTICATE_COLON);
								break;
							}
							case SERVER_COLON:
							{
								match(SERVER_COLON);
								break;
							}
							case UNSUPPORTED_COLON:
							{
								match(UNSUPPORTED_COLON);
								break;
							}
							case RETRY_AFTER_COLON:
							{
								match(RETRY_AFTER_COLON);
								break;
							}
							case WARNING_COLON:
							{
								match(WARNING_COLON);
								break;
							}
							case WWW_AUTHENTICATE_COLON:
							{
								match(WWW_AUTHENTICATE_COLON);
								break;
							}
							default:
							{
								throw new NoViableAltException(LT(1), getFilename());
							}
							}
							}
						}
						catch (RecognitionException pe) {
							synPredMatched29 = false;
						}
						rewind(_m29);
						inputState.guessing--;
					}
					if ( synPredMatched29 ) {
						rb=response_header();
						if ( inputState.guessing==0 ) {
							
								// It may look a bit strange to have response_header as an alternative
								//  here but the idea is to allow the stack to forgive the mistake.
								SIPUnexpectedHeaderException e =
									new SIPUnexpectedHeaderException(rb.getInputText());
								e.setHeaderName(rb.getHeaderName());
								e.setText(rb.getTrimmedInputText());
								e.setErrorObject(rb);
								try {
								   parserMain.handleParseException(e);
								   rb = (SIPHeader) e.getHeader();
								} catch (SIPParseException ex) {
									throw new RecognitionException("Unexpected Header : " +
										rb.getInputText());
								}
							
							
						}
					}
					else {
						boolean synPredMatched31 = false;
						if (((LA(1)==HEADER_NAME_COLON))) {
							int _m31 = mark();
							synPredMatched31 = true;
							inputState.guessing++;
							try {
								{
								match(HEADER_NAME_COLON);
								}
							}
							catch (RecognitionException pe) {
								synPredMatched31 = false;
							}
							rewind(_m31);
							inputState.guessing--;
						}
						if ( synPredMatched31 ) {
							rb=extension_header();
						}
						else if ((_tokenSet_0.member(LA(1)))) {
							msg=byte_string();
							match(RETURN);
							if ( inputState.guessing==0 ) {
								
								// Added v1.0
								// No colon or other delimiter found before the EOL cannot be a valid header
								// This is an error condition -- we try to let the application recover
								// by giving him the error text (He always has the option of 
								// re-throwing the exception).
								selectLexer("command_keywordLexer"); 
								SIPInvalidHeaderException e = new SIPInvalidHeaderException(msg);
								e.setHeaderText(msg);
								try {
								parserMain.handleParseException(e);
								rb = (SIPHeader) e.getHeader();
								} catch (SIPParseException ex) {
									throw new RecognitionException("Invalid Header " + msg);
								}
								
							}
						}
						else {
							throw new NoViableAltException(LT(1), getFilename());
						}
						}}}}
						return rb ;
					}
					
	public final  SIPHeader  general_header() throws RecognitionException, TokenStreamException {
		 SIPHeader r ;
		
		
			r = null;
		
		
		{
		switch ( LA(1)) {
		case ACCEPT_COLON:
		{
			r=accept();
			break;
		}
		case ACCEPT_ENCODING_COLON:
		{
			r=accept_encoding();
			break;
		}
		case ACCEPT_LANGUAGE_COLON:
		{
			r=accept_language();
			break;
		}
		case REQUIRE_COLON:
		{
			r=require();
			break;
		}
		case CALL_ID_COLON:
		{
			r=call_id();
			break;
		}
		case CONTACT_COLON:
		{
			r=contact();
			break;
		}
		case CSEQ_COLON:
		{
			r=cseq();
			break;
		}
		case DATE_COLON:
		{
			r=date();
			break;
		}
		case ENCRYPTION_COLON:
		{
			r=encryption();
			break;
		}
		case FROM_COLON:
		{
			r=from();
			break;
		}
		case TO_COLON:
		{
			r=to();
			break;
		}
		case RECORD_ROUTE_COLON:
		{
			r=record_route();
			break;
		}
		case TIMESTAMP_COLON:
		{
			r=timestamp();
			break;
		}
		case ORGANIZATION_COLON:
		{
			r=organization();
			break;
		}
		case CALL_INFO_COLON:
		{
			r=call_info();
			break;
		}
		case USER_AGENT_COLON:
		{
			r=user_agent();
			break;
		}
		case VIA_COLON:
		{
			r=via();
			break;
		}
		case MIME_VERSION_COLON:
		{
			r=mime_version();
			break;
		}
		case SUPPORTED_COLON:
		{
			r=supported();
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		return r ;
	}
	
	public final  SIPHeader  request_header() throws RecognitionException, TokenStreamException {
		 SIPHeader m ;
		
		
			m = null;
		
		
		{
		switch ( LA(1)) {
		case AUTHORIZATION_COLON:
		{
			m=authorization();
			break;
		}
		case HIDE_COLON:
		{
			m=hide();
			break;
		}
		case MAX_FORWARDS_COLON:
		{
			m=max_forwards();
			break;
		}
		case PRIORITY_COLON:
		{
			m=priority();
			break;
		}
		case PROXY_AUTHORIZATION_COLON:
		{
			m=proxy_authorization();
			break;
		}
		case PROXY_REQUIRE_COLON:
		{
			m=proxy_require();
			break;
		}
		case ALERT_INFO_COLON:
		{
			m=alert_info();
			break;
		}
		case ROUTE_COLON:
		{
			m=route();
			break;
		}
		case RESPONSE_KEY_COLON:
		{
			m=response_key();
			break;
		}
		case SUBJECT_COLON:
		{
			m=subject();
			break;
		}
		case IN_REPLY_TO_COLON:
		{
			m=in_reply_to();
			break;
		}
		case ALSO_COLON:
		{
			m=also();
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		return m ;
	}
	
	public final  SIPHeader  entity_header() throws RecognitionException, TokenStreamException {
		 SIPHeader r ;
		
		
			r = null;
		
		
		{
		switch ( LA(1)) {
		case CONTENT_ENCODING_COLON:
		{
			r=content_encoding();
			break;
		}
		case ALLOW_COLON:
		{
			r=allow();
			break;
		}
		case CONTENT_LENGTH_COLON:
		{
			r=content_length();
			break;
		}
		case EXPIRES_COLON:
		{
			r=expires();
			break;
		}
		case CONTENT_TYPE_COLON:
		{
			r=content_type();
			break;
		}
		case CONTENT_LANGUAGE_COLON:
		{
			r=content_language();
			break;
		}
		case CONTENT_DISPOSITION_COLON:
		{
			r=content_disposition();
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		return r ;
	}
	
	public final  SIPHeader  response_header() throws RecognitionException, TokenStreamException {
		 SIPHeader b ;
		
		
			b = null;
		
		
		{
		switch ( LA(1)) {
		case PROXY_AUTHENTICATE_COLON:
		{
			b=proxy_authenticate();
			break;
		}
		case RETRY_AFTER_COLON:
		{
			b=retry_after();
			break;
		}
		case SERVER_COLON:
		{
			b=server();
			break;
		}
		case UNSUPPORTED_COLON:
		{
			b=unsupported();
			break;
		}
		case WARNING_COLON:
		{
			b=warning();
			break;
		}
		case WWW_AUTHENTICATE_COLON:
		{
			b=www_authenticate();
			break;
		}
		case ERROR_INFO_COLON:
		{
			b=error_info();
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		return b ;
	}
	
	public final  SIPHeader  extension_header() throws RecognitionException, TokenStreamException {
		 SIPHeader rb ;
		
		Token  t = null;
		
			startTracking();
			rb = null;
			String s = null;
		
		
		t = LT(1);
		match(HEADER_NAME_COLON);
		s=byte_string();
		match(RETURN);
		if ( inputState.guessing==0 ) {
			
				String inputText = stopTracking();
				selectLexer("command_keywordLexer"); 
				SIPUnrecognizedExtensionException e = 
					new SIPUnrecognizedExtensionException(t.getText());
				e.setHeader(null);
			e.fillInStackTrace();
				String hname = t.getText();
			e.setExtensionName(hname.substring(0,hname.lastIndexOf(":")));
				e.setHeaderText(t.getText() + s );
				try {
			parserMain.handleParseException(e);
				   rb =  (SIPHeader) e.getHeader();
				} catch (SIPParseException ex) {
				   throw new RecognitionException("Unrecognized extension " +
						t.getText());
				}
			
		}
		return rb ;
	}
	
	public final  String  byte_string() throws RecognitionException, TokenStreamException {
		 String s ;
		
		Token  d = null;
		
			s = "";
		
		
		d = LT(1);
		matchNot(RETURN);
		if ( inputState.guessing==0 ) {
			
			pushLexer("charLexer");
			while ( true ) {
				s += d.getText();
				d = LT(1);
				if (d == null || d.getType() == Token.EOF_TYPE) {
					throw new RecognitionException("Premature EOF");
				}	
				if (d.getType() == RETURN ) break;
				consume();
			}
			track(s);
			popLexer();
			
		}
		return s ;
	}
	
	public final  SIPHeader  message_header() throws RecognitionException, TokenStreamException {
		 SIPHeader m ;
		
		
			 m = null;
		
		
		{
		switch ( LA(1)) {
		case CONTENT_TYPE_COLON:
		{
			m=content_type();
			break;
		}
		case FROM_COLON:
		{
			m=from();
			break;
		}
		case CONTACT_COLON:
		{
			m=contact();
			break;
		}
		case VIA_COLON:
		{
			m=via();
			break;
		}
		case CSEQ_COLON:
		{
			m=cseq();
			break;
		}
		case AUTHORIZATION_COLON:
		{
			m=authorization();
			break;
		}
		case HIDE_COLON:
		{
			m=hide();
			break;
		}
		case MAX_FORWARDS_COLON:
		{
			m=max_forwards();
			break;
		}
		case ORGANIZATION_COLON:
		{
			m=organization();
			break;
		}
		case PRIORITY_COLON:
		{
			m=priority();
			break;
		}
		case PROXY_AUTHORIZATION_COLON:
		{
			m=proxy_authorization();
			break;
		}
		case PROXY_REQUIRE_COLON:
		{
			m=proxy_require();
			break;
		}
		case ROUTE_COLON:
		{
			m=route();
			break;
		}
		case REQUIRE_COLON:
		{
			m=require();
			break;
		}
		case RESPONSE_KEY_COLON:
		{
			m=response_key();
			break;
		}
		case SUBJECT_COLON:
		{
			m=subject();
			break;
		}
		case USER_AGENT_COLON:
		{
			m=user_agent();
			break;
		}
		case WWW_AUTHENTICATE_COLON:
		{
			m=www_authenticate();
			break;
		}
		case ACCEPT_COLON:
		{
			m=accept();
			break;
		}
		case ACCEPT_ENCODING_COLON:
		{
			m=accept_encoding();
			break;
		}
		case ACCEPT_LANGUAGE_COLON:
		{
			m=accept_language();
			break;
		}
		case CALL_ID_COLON:
		{
			m=call_id();
			break;
		}
		case DATE_COLON:
		{
			m=date();
			break;
		}
		case ENCRYPTION_COLON:
		{
			m=encryption();
			break;
		}
		case EXPIRES_COLON:
		{
			m=expires();
			break;
		}
		case RECORD_ROUTE_COLON:
		{
			m=record_route();
			break;
		}
		case TIMESTAMP_COLON:
		{
			m=timestamp();
			break;
		}
		case TO_COLON:
		{
			m=to();
			break;
		}
		case CONTENT_LENGTH_COLON:
		{
			m=content_length();
			break;
		}
		case PROXY_AUTHENTICATE_COLON:
		{
			m=proxy_authenticate();
			break;
		}
		case ALLOW_COLON:
		{
			m=allow();
			break;
		}
		case RETRY_AFTER_COLON:
		{
			m=retry_after();
			break;
		}
		case SERVER_COLON:
		{
			m=server();
			break;
		}
		case WARNING_COLON:
		{
			m=warning();
			break;
		}
		case UNSUPPORTED_COLON:
		{
			m=unsupported();
			break;
		}
		case ALERT_INFO_COLON:
		{
			m=alert_info();
			break;
		}
		case CALL_INFO_COLON:
		{
			m=call_info();
			break;
		}
		case CONTENT_LANGUAGE_COLON:
		{
			m=content_language();
			break;
		}
		case IN_REPLY_TO_COLON:
		{
			m=in_reply_to();
			break;
		}
		case MIME_VERSION_COLON:
		{
			m=mime_version();
			break;
		}
		case ALSO_COLON:
		{
			m=also();
			break;
		}
		case ERROR_INFO_COLON:
		{
			m=error_info();
			break;
		}
		case SUPPORTED_COLON:
		{
			m=supported();
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		return m ;
	}
	
	public final  ContentType  content_type() throws RecognitionException, TokenStreamException {
		 ContentType ct ;
		
		
			ct = new ContentType();
			MediaRange r = null;
			startTracking();
		
		
		try {      // for error handling
			match(CONTENT_TYPE_COLON);
			r=media_type();
			{
			_loop586:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop586;
				}
				}
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
					ct.setInputText(stopTracking());
					ct.setMediaRange(r);
					selectLexer("command_keywordLexer"); 
				
			}
		}
		catch ( TokenStreamException ex ) {
			if (inputState.guessing==0) {
				
					ct = (ContentType)
					handleParseException(ex,HEADER_PARSE_EXCEPTION, 
						ct,SIPHeaderNames.CONTENT_TYPE, true);
				
			} else {
				throw ex ;
			}
		}
		catch ( RecognitionException ex ) {
			if (inputState.guessing==0) {
				
					ct = (ContentType)
					handleParseException(ex,HEADER_PARSE_EXCEPTION, 
						ct,SIPHeaderNames.CONTENT_TYPE, true);
				
			} else {
				throw ex ;
			}
		}
		return ct ;
	}
	
	public final  From  from() throws RecognitionException, TokenStreamException {
		 From t ;
		
		
			t = new From();
			Address a = null;
			startTracking();
			NameValue ae;
			String tag;
			
		
		
		try {      // for error handling
			match(FROM_COLON);
			a=address();
			if ( inputState.guessing==0 ) {
				selectLexer("addr_parmsLexer");
			}
			{
			_loop255:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop255;
				}
				}
			} while (true);
			}
			{
			_loop264:
			do {
				if ((LA(1)==SEMICOLON)) {
					match(SEMICOLON);
					{
					_loop258:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop258;
						}
						}
					} while (true);
					}
					{
					switch ( LA(1)) {
					case TAG:
					{
						tag=tag_param();
						if ( inputState.guessing==0 ) {
							t.setTag(tag);
						}
						break;
					}
					case ALPHA:
					case DIGIT:
					case UNDERSCORE:
					case PLUS:
					case MINUS:
					case QUOTE:
					case EXCLAMATION:
					case PERCENT:
					case TILDE:
					case BACK_QUOTE:
					case STAR:
					case DOT:
					{
						ae=addr_extension();
						break;
					}
					default:
					{
						throw new NoViableAltException(LT(1), getFilename());
					}
					}
					}
					{
					_loop263:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop263;
						}
						}
					} while (true);
					}
				}
				else {
					break _loop264;
				}
				
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
				// If this is an address spec then the parameters belong to me (and not
				// to the url.
				t.setAddress(a);
				t.setInputText(stopTracking());
				//
				// The Contact, From and To header fields contain a URL. If the URL
				// contains a comma, question mark or semicolon, the URL MUST be
				// enclosed in angle brackets (< and >). Any URL parameters are
				// contained within these brackets. If the URL is not enclosed in angle
				// brackets, any semicolon-delimited parameters are header-parameters,
				// not URL parameters.
				//
				if (a.getAddressType() == Address.ADDRESS_SPEC) {
					t.getParms().concatenate(a.getAddrSpec().getUriParms());
					a.getAddrSpec().clearUriParms();
				}
				selectLexer("command_keywordLexer"); 
				try {
				CheckConstraints.check(t);
				} catch ( IllegalArgumentException ex) {
					throw new RecognitionException(ex.getMessage());
				}
				
			}
		}
		catch ( RecognitionException ex) {
			if (inputState.guessing==0) {
				
					t = (From)
						handleParseException(ex,HEADER_PARSE_EXCEPTION,
						t, SIPHeaderNames.FROM, true);
				
			} else {
				throw ex;
			}
		}
		catch ( TokenStreamException ex) {
			if (inputState.guessing==0) {
				
					t = (From)
						handleParseException(ex,HEADER_PARSE_EXCEPTION,
						t,SIPHeaderNames.FROM, true);
				
			} else {
				throw ex;
			}
		}
		return t ;
	}
	
	public final  ContactList  contact() throws RecognitionException, TokenStreamException {
		 ContactList cl ;
		
		
			cl = null;
			startTracking();
		
		
		try {      // for error handling
			match(CONTACT_COLON);
			cl=contact_body();
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
					cl.setInputText(stopTracking());
					selectLexer("command_keywordLexer");
				
			}
		}
		catch ( TokenStreamException ex ) {
			if (inputState.guessing==0) {
				
					cl = (ContactList ) 
						handleParseException(ex,HEADER_PARSE_EXCEPTION, 
						cl,SIPHeaderNames.CONTACT, true);
				
			} else {
				throw ex ;
			}
		}
		catch ( RecognitionException ex ) {
			if (inputState.guessing==0) {
				
					cl = (ContactList) 
						handleParseException(ex,HEADER_PARSE_EXCEPTION, 
						cl,SIPHeaderNames.CONTACT, true);
				
			} else {
				throw ex ;
			}
		}
		return cl ;
	}
	
	public final  ViaList  via() throws RecognitionException, TokenStreamException {
		 ViaList vl ;
		
		
		
			vl = new ViaList();
			Via v = null;
			startTracking();
		
		
		try {      // for error handling
			match(VIA_COLON);
			v=via_body();
			if ( inputState.guessing==0 ) {
				vl.add(v);
			}
			{
			_loop363:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop363;
				}
				}
			} while (true);
			}
			{
			_loop369:
			do {
				if ((LA(1)==COMMA)) {
					match(COMMA);
					{
					_loop366:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop366;
						}
						}
					} while (true);
					}
					v=via_body();
					if ( inputState.guessing==0 ) {
						vl.add(v);
					}
					{
					_loop368:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop368;
						}
						}
					} while (true);
					}
				}
				else {
					break _loop369;
				}
				
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
					vl.setInputText(stopTracking());
					selectLexer("command_keywordLexer"); 
				
			}
		}
		catch ( RecognitionException ex) {
			if (inputState.guessing==0) {
				
					vl = (ViaList)
					handleParseException(ex,HEADER_PARSE_EXCEPTION,
						vl,SIPHeaderNames.VIA, true);
				
			} else {
				throw ex;
			}
		}
		catch ( TokenStreamException ex) {
			if (inputState.guessing==0) {
				
					vl = (ViaList)
					handleParseException(ex,HEADER_PARSE_EXCEPTION,
						vl,SIPHeaderNames.VIA, true);
				
			} else {
				throw ex;
			}
		}
		return vl ;
	}
	
	public final  CSeq  cseq() throws RecognitionException, TokenStreamException {
		 CSeq cs ;
		
		Token  d = null;
		
			long sno = 0;
			String s = "";
			String m;
		cs = new CSeq();
			startTracking();
		
		
		try {      // for error handling
			match(CSEQ_COLON);
			{
			int _cnt224=0;
			_loop224:
			do {
				if ((LA(1)==DIGIT)) {
					d = LT(1);
					match(DIGIT);
					if ( inputState.guessing==0 ) {
						s += d.getText();
					}
				}
				else {
					if ( _cnt224>=1 ) { break _loop224; } else {throw new NoViableAltException(LT(1), getFilename());}
				}
				
				_cnt224++;
			} while (true);
			}
			if ( inputState.guessing==0 ) {
				selectLexer("method_keywordLexer");
			}
			{
			int _cnt226=0;
			_loop226:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					if ( _cnt226>=1 ) { break _loop226; } else {throw new NoViableAltException(LT(1), getFilename());}
				}
				}
				_cnt226++;
			} while (true);
			}
			m=method();
			{
			_loop228:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop228;
				}
				}
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
				sno = Long.parseLong(s);
				cs.setMethod(m);
				cs.setSeqno(sno);
				cs.setInputText(stopTracking());
				selectLexer("command_keywordLexer"); 
				
			}
		}
		catch ( RecognitionException ex) {
			if (inputState.guessing==0) {
				
					cs = (CSeq)
					handleParseException(ex,HEADER_PARSE_EXCEPTION,
						cs,SIPHeaderNames.CSEQ, true);
				
			} else {
				throw ex;
			}
		}
		catch ( TokenStreamException ex) {
			if (inputState.guessing==0) {
				
					cs = (CSeq)
					handleParseException(ex,HEADER_PARSE_EXCEPTION,
						cs,SIPHeaderNames.CSEQ, true);
				
			} else {
				throw ex;
			}
		}
		return cs ;
	}
	
	public final  Authorization  authorization() throws RecognitionException, TokenStreamException {
		 Authorization auth ;
		
		
			auth = null;
			startTracking();
		
		
		try {      // for error handling
			match(AUTHORIZATION_COLON);
			auth=auth_body();
			{
			_loop433:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop433;
				}
				}
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
				auth.setInputText(stopTracking());
				selectLexer("command_keywordLexer"); 
				
			}
		}
		catch ( RecognitionException ex) {
			if (inputState.guessing==0) {
				
					auth = (Authorization)
					handleParseException(ex, HEADER_PARSE_EXCEPTION,
							auth,SIPHeaderNames.AUTHORIZATION, true);
				
			} else {
				throw ex;
			}
		}
		catch ( TokenStreamException ex) {
			if (inputState.guessing==0) {
				
					auth = (Authorization)
					handleParseException(ex, HEADER_PARSE_EXCEPTION,
							auth,SIPHeaderNames.AUTHORIZATION, true);
				
			} else {
				throw ex;
			}
		}
		return auth ;
	}
	
	public final  Hide  hide() throws RecognitionException, TokenStreamException {
		 Hide h ;
		
		
			h = new Hide();
			String flag = null;
			startTracking();
		
		
		try {      // for error handling
			match(HIDE_COLON);
			{
			switch ( LA(1)) {
			case ROUTE:
			{
				match(ROUTE);
				if ( inputState.guessing==0 ) {
					h.setHide(SIPKeywords.ROUTE);
				}
				break;
			}
			case HOP:
			{
				match(HOP);
				if ( inputState.guessing==0 ) {
					h.setHide(SIPKeywords.HOP);
				}
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			{
			_loop616:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop616;
				}
				}
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
					h.setInputText(stopTracking());
					selectLexer("command_keywordLexer"); 
				
			}
		}
		catch ( TokenStreamException ex ) {
			if (inputState.guessing==0) {
				
					h = (Hide)
					handleParseException(ex,HEADER_PARSE_EXCEPTION, 
						h,SIPHeaderNames.HIDE, true);
				
			} else {
				throw ex ;
			}
		}
		catch ( RecognitionException ex ) {
			if (inputState.guessing==0) {
				
					h = (Hide)
					handleParseException(ex,HEADER_PARSE_EXCEPTION, 
							h,SIPHeaderNames.HIDE, true);
				
			} else {
				throw ex ;
			}
		}
		return h ;
	}
	
	public final  MaxForwards  max_forwards() throws RecognitionException, TokenStreamException {
		 MaxForwards mf ;
		
		Token  d = null;
		
			mf = new MaxForwards();
			startTracking();
			String s = "";
			int m = 0;
		
		
		try {      // for error handling
			match(MAX_FORWARDS_COLON);
			{
			int _cnt619=0;
			_loop619:
			do {
				if ((LA(1)==DIGIT)) {
					d = LT(1);
					match(DIGIT);
					if ( inputState.guessing==0 ) {
						s += d.getText();
					}
				}
				else {
					if ( _cnt619>=1 ) { break _loop619; } else {throw new NoViableAltException(LT(1), getFilename());}
				}
				
				_cnt619++;
			} while (true);
			}
			{
			_loop621:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop621;
				}
				}
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
				m = Integer.parseInt(s);
				mf.setMaxForwards(m);
				mf.setInputText(stopTracking());
				selectLexer("command_keywordLexer"); 
				
			}
		}
		catch ( TokenStreamException ex ) {
			if (inputState.guessing==0) {
				
					mf = (MaxForwards)
					handleParseException(ex,HEADER_PARSE_EXCEPTION, 
							mf,SIPHeaderNames.MAX_FORWARDS, true);
				
			} else {
				throw ex ;
			}
		}
		catch ( RecognitionException ex ) {
			if (inputState.guessing==0) {
				
					mf = (MaxForwards)
					handleParseException(ex,HEADER_PARSE_EXCEPTION, 
							mf,SIPHeaderNames.MAX_FORWARDS, true);
				
			} else {
				throw ex ;
			}
		}
		return mf ;
	}
	
	public final  Organization  organization() throws RecognitionException, TokenStreamException {
		 Organization s ;
		
		
			String r = null;
			s = new Organization();
			startTracking();
		
		
		try {      // for error handling
			match(ORGANIZATION_COLON);
			r=textUTF8();
			{
			_loop624:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop624;
				}
				}
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
					s.setOrganization(r);
					s.setInputText(stopTracking());
					selectLexer("command_keywordLexer"); 
				
			}
		}
		catch ( TokenStreamException ex ) {
			if (inputState.guessing==0) {
				
					s = (Organization)
					handleParseException(ex,HEADER_PARSE_EXCEPTION, 
							s,SIPHeaderNames.ORGANIZATION, true);
				
			} else {
				throw ex ;
			}
		}
		catch ( RecognitionException ex ) {
			if (inputState.guessing==0) {
				
					s = (Organization)
					handleParseException(ex,HEADER_PARSE_EXCEPTION, 
							s,SIPHeaderNames.ORGANIZATION, true);
				
			} else {
				throw ex ;
			}
		}
		return s ;
	}
	
	public final  Priority  priority() throws RecognitionException, TokenStreamException {
		 Priority pri ;
		
		
			pri = new Priority();
			String p;
			startTracking();
		
		
		try {      // for error handling
			match(PRIORITY_COLON);
			p=priority_value();
			{
			_loop627:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop627;
				}
				}
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
					pri.setPriority(p);
					pri.setInputText(stopTracking());
					selectLexer("command_keywordLexer"); 
				
			}
		}
		catch ( TokenStreamException ex ) {
			if (inputState.guessing==0) {
				
					pri = (Priority)
					handleParseException(ex,HEADER_PARSE_EXCEPTION, 
							pri,SIPHeaderNames.PRIORITY, true);
				
			} else {
				throw ex ;
			}
		}
		catch ( RecognitionException ex ) {
			if (inputState.guessing==0) {
				
					pri = (Priority)
					handleParseException(ex,HEADER_PARSE_EXCEPTION, 
						pri,SIPHeaderNames.PRIORITY, true);
				
			} else {
				throw ex ;
			}
		}
		return pri ;
	}
	
	public final  ProxyAuthorization  proxy_authorization() throws RecognitionException, TokenStreamException {
		 ProxyAuthorization pa ;
		
		
			pa = new ProxyAuthorization();
			Credentials cr;
			startTracking();
		
		
		try {      // for error handling
			match(PROXY_AUTHORIZATION_COLON);
			cr=credentials();
			{
			_loop631:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop631;
				}
				}
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
					pa.setScheme(cr.getScheme());
					pa.setCredentials(cr.getCredentials());
					pa.setInputText(stopTracking());
					selectLexer("command_keywordLexer"); 
				
			}
		}
		catch ( TokenStreamException ex ) {
			if (inputState.guessing==0) {
				
					pa = (ProxyAuthorization) 
					handleParseException
						(ex,HEADER_PARSE_EXCEPTION, 
						pa,SIPHeaderNames.PROXY_AUTHORIZATION, true);
				
			} else {
				throw ex ;
			}
		}
		catch ( RecognitionException ex ) {
			if (inputState.guessing==0) {
				
					pa = (ProxyAuthorization) 
					handleParseException(ex,HEADER_PARSE_EXCEPTION, 
							pa,SIPHeaderNames.PROXY_AUTHORIZATION, true);
				
			} else {
				throw ex ;
			}
		}
		return pa ;
	}
	
	public final  ProxyRequireList  proxy_require() throws RecognitionException, TokenStreamException {
		 ProxyRequireList pr ;
		
		
			pr = new ProxyRequireList ();
			startTracking();
			String op ;
		
		
		try {      // for error handling
			match(PROXY_REQUIRE_COLON);
			{
			op=option_tag();
			}
			{
			_loop635:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop635;
				}
				}
			} while (true);
			}
			if ( inputState.guessing==0 ) {
				pr.add( new ProxyRequire(op));
			}
			{
			_loop641:
			do {
				if ((LA(1)==COMMA)) {
					match(COMMA);
					{
					_loop638:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop638;
						}
						}
					} while (true);
					}
					op=option_tag();
					{
					_loop640:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop640;
						}
						}
					} while (true);
					}
					if ( inputState.guessing==0 ) {
						pr.add(new ProxyRequire(op));
					}
				}
				else {
					break _loop641;
				}
				
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
					pr.setInputText(stopTracking());
					selectLexer("command_keywordLexer"); 
					
			}
		}
		catch ( TokenStreamException ex ) {
			if (inputState.guessing==0) {
				
					pr = (ProxyRequireList) 
						handleParseException(ex,HEADER_PARSE_EXCEPTION, 
							pr,SIPHeaderNames.PROXY_REQUIRE, true);
				
			} else {
				throw ex ;
			}
		}
		catch ( RecognitionException ex ) {
			if (inputState.guessing==0) {
				
					pr = (ProxyRequireList) 
						handleParseException(ex,HEADER_PARSE_EXCEPTION, 
							pr,SIPHeaderNames.PROXY_REQUIRE, true);
				
			} else {
				throw ex ;
			}
		}
		return pr ;
	}
	
	public final  RouteList  route() throws RecognitionException, TokenStreamException {
		 RouteList al ;
		
		
			al = new RouteList();
			startTracking();
			Address a;
			Route r = null;
			NameValue nv = null;
		
		
		try {      // for error handling
			match(ROUTE_COLON);
			a=name_addr();
			{
			_loop644:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop644;
				}
				}
			} while (true);
			}
			if ( inputState.guessing==0 ) {
				
					   r = new Route(); 
					   r.setAddress(a); 
					   al.add(r);    
				
			}
			{
			_loop650:
			do {
				if ((LA(1)==SEMICOLON)) {
					match(SEMICOLON);
					{
					_loop647:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop647;
						}
						}
					} while (true);
					}
					nv=generic_param();
					{
					_loop649:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop649;
						}
						}
					} while (true);
					}
					if ( inputState.guessing==0 ) {
						
							    r.addParam(nv);
							    nv = null;
							
					}
				}
				else {
					break _loop650;
				}
				
			} while (true);
			}
			{
			_loop662:
			do {
				if ((LA(1)==COMMA)) {
					match(COMMA);
					{
					_loop653:
					do {
						if ((LA(1)==SP)) {
							match(SP);
						}
						else if ((LA(1)==HT)) {
							match(HT);
						}
						else {
							break _loop653;
						}
						
					} while (true);
					}
					a=name_addr();
					{
					_loop655:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop655;
						}
						}
					} while (true);
					}
					if ( inputState.guessing==0 ) {
						
								r = new Route(); 
								r.setAddress(a); 
								al.add(r); 
							
					}
					{
					_loop661:
					do {
						if ((LA(1)==SEMICOLON)) {
							match(SEMICOLON);
							{
							_loop658:
							do {
								switch ( LA(1)) {
								case SP:
								{
									match(SP);
									break;
								}
								case HT:
								{
									match(HT);
									break;
								}
								default:
								{
									break _loop658;
								}
								}
							} while (true);
							}
							nv=generic_param();
							{
							_loop660:
							do {
								switch ( LA(1)) {
								case SP:
								{
									match(SP);
									break;
								}
								case HT:
								{
									match(HT);
									break;
								}
								default:
								{
									break _loop660;
								}
								}
							} while (true);
							}
							if ( inputState.guessing==0 ) {
								
									        r.addParam(nv);
										nv = null;
									
							}
						}
						else {
							break _loop661;
						}
						
					} while (true);
					}
				}
				else {
					break _loop662;
				}
				
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
					  al.setInputText(stopTracking());
					  selectLexer("command_keywordLexer"); 
					
			}
		}
		catch ( TokenStreamException ex ) {
			if (inputState.guessing==0) {
				
					 al = (RouteList) 
						handleParseException(ex, HEADER_PARSE_EXCEPTION, 
							al,SIPHeaderNames.ROUTE, true);
					
				
			} else {
				throw ex ;
			}
		}
		catch ( RecognitionException ex ) {
			if (inputState.guessing==0) {
				
				
					 al = (RouteList) 
					handleParseException(ex, HEADER_PARSE_EXCEPTION, 
							al,SIPHeaderNames.ROUTE, true);
				
			} else {
				throw ex ;
			}
		}
		return al ;
	}
	
	public final  RequireList  require() throws RecognitionException, TokenStreamException {
		 RequireList req ;
		
		
			req = new RequireList ();
			String op;
			startTracking();
		
		
		try {      // for error handling
			match(REQUIRE_COLON);
			op=option_tag();
			{
			_loop665:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop665;
				}
				}
			} while (true);
			}
			if ( inputState.guessing==0 ) {
				req.add(new Require(op));
			}
			{
			_loop671:
			do {
				if ((LA(1)==COMMA)) {
					match(COMMA);
					{
					_loop668:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop668;
						}
						}
					} while (true);
					}
					op=option_tag();
					{
					_loop670:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop670;
						}
						}
					} while (true);
					}
					if ( inputState.guessing==0 ) {
						req.add(new Require(op));
					}
				}
				else {
					break _loop671;
				}
				
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
					req.setInputText(stopTracking());
					selectLexer("command_keywordLexer"); 
				
			}
		}
		catch ( TokenStreamException ex ) {
			if (inputState.guessing==0) {
				
					req = (RequireList) 
					handleParseException(ex,HEADER_PARSE_EXCEPTION, 
							req,SIPHeaderNames.REQUIRE, true);
				
			} else {
				throw ex ;
			}
		}
		catch ( RecognitionException ex ) {
			if (inputState.guessing==0) {
				
					req = (RequireList) 
					handleParseException(ex,HEADER_PARSE_EXCEPTION, 
							req,SIPHeaderNames.REQUIRE, true);
				
			} else {
				throw ex ;
			}
		}
		return req ;
	}
	
	public final  ResponseKey  response_key() throws RecognitionException, TokenStreamException {
		 ResponseKey k ;
		
		
			k = new ResponseKey();
			NameValue nv = null ; 
			String s;
			startTracking();
		
		
		try {      // for error handling
			match(RESPONSE_KEY_COLON);
			s=key_scheme();
			{
			switch ( LA(1)) {
			case SP:
			case HT:
			{
				{
				int _cnt675=0;
				_loop675:
				do {
					switch ( LA(1)) {
					case SP:
					{
						match(SP);
						break;
					}
					case HT:
					{
						match(HT);
						break;
					}
					default:
					{
						if ( _cnt675>=1 ) { break _loop675; } else {throw new NoViableAltException(LT(1), getFilename());}
					}
					}
					_cnt675++;
				} while (true);
				}
				nv=key_param();
				{
				_loop677:
				do {
					switch ( LA(1)) {
					case SP:
					{
						match(SP);
						break;
					}
					case HT:
					{
						match(HT);
						break;
					}
					default:
					{
						break _loop677;
					}
					}
				} while (true);
				}
				if ( inputState.guessing==0 ) {
					k.getKeyParam().add(nv);
				}
				{
				_loop683:
				do {
					if ((LA(1)==COMMA)) {
						match(COMMA);
						{
						_loop680:
						do {
							switch ( LA(1)) {
							case SP:
							{
								match(SP);
								break;
							}
							case HT:
							{
								match(HT);
								break;
							}
							default:
							{
								break _loop680;
							}
							}
						} while (true);
						}
						nv=key_param();
						if ( inputState.guessing==0 ) {
							k.getKeyParam().add(nv);
						}
						{
						_loop682:
						do {
							switch ( LA(1)) {
							case SP:
							{
								match(SP);
								break;
							}
							case HT:
							{
								match(HT);
								break;
							}
							default:
							{
								break _loop682;
							}
							}
						} while (true);
						}
					}
					else {
						break _loop683;
					}
					
				} while (true);
				}
				break;
			}
			case RETURN:
			{
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
				k.setKeyScheme(s);
				k.setInputText(stopTracking());
				selectLexer("command_keywordLexer"); 
				
			}
		}
		catch ( TokenStreamException ex ) {
			if (inputState.guessing==0) {
				
					k = (ResponseKey) 
						handleParseException(ex,HEADER_PARSE_EXCEPTION, 
						k,SIPHeaderNames.RESPONSE_KEY, true);
				
			} else {
				throw ex ;
			}
		}
		catch ( RecognitionException ex ) {
			if (inputState.guessing==0) {
				
					k = (ResponseKey) 
						handleParseException(ex,HEADER_PARSE_EXCEPTION, 
							k,SIPHeaderNames.RESPONSE_KEY, true);
				
			} else {
				throw ex ;
			}
		}
		return k ;
	}
	
	public final  Subject  subject() throws RecognitionException, TokenStreamException {
		 Subject s ;
		
		
			s = new Subject();
			startTracking();
			String r;
		
		
		try {      // for error handling
			match(SUBJECT_COLON);
			r=textUTF8();
			{
			_loop691:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop691;
				}
				}
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
					
					s.setSubject(r);
					s.setInputText(stopTracking());
					selectLexer("command_keywordLexer"); 
				
			}
		}
		catch ( TokenStreamException ex ) {
			if (inputState.guessing==0) {
				
					s = (Subject) 
						handleParseException(ex,HEADER_PARSE_EXCEPTION, 
						s,SIPHeaderNames.SUBJECT, true);
				
			} else {
				throw ex ;
			}
		}
		catch ( RecognitionException ex ) {
			if (inputState.guessing==0) {
				
					s = (Subject) 
						handleParseException(ex,HEADER_PARSE_EXCEPTION, 
						s,SIPHeaderNames.SUBJECT, true);
				
			} else {
				throw ex ;
			}
		}
		return s ;
	}
	
	public final  UserAgent  user_agent() throws RecognitionException, TokenStreamException {
		 UserAgent ua ;
		
		
			ua  = null;
		String s = null;
			Product p;
			startTracking();
			
		
		
		try {      // for error handling
			match(USER_AGENT_COLON);
			{
			boolean synPredMatched695 = false;
			if (((LA(1)==LPAREN))) {
				int _m695 = mark();
				synPredMatched695 = true;
				inputState.guessing++;
				try {
					{
					match(LPAREN);
					}
				}
				catch (RecognitionException pe) {
					synPredMatched695 = false;
				}
				rewind(_m695);
				inputState.guessing--;
			}
			if ( synPredMatched695 ) {
				s=comment();
				if ( inputState.guessing==0 ) {
					ua = new UserAgent(); ua.setComment(s);
				}
			}
			else if ((_tokenSet_0.member(LA(1)))) {
				p=product();
				if ( inputState.guessing==0 ) {
					ua = new UserAgent(); ua.setProduct(p);
				}
			}
			else {
				throw new NoViableAltException(LT(1), getFilename());
			}
			
			}
			{
			_loop697:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop697;
				}
				}
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
				ua.setInputText(stopTracking());
				selectLexer("command_keywordLexer");  
				
			}
		}
		catch ( TokenStreamException ex ) {
			if (inputState.guessing==0) {
				
					ua = (UserAgent) 
						handleParseException(ex,HEADER_PARSE_EXCEPTION, 
						ua,SIPHeaderNames.USER_AGENT, true);
				
			} else {
				throw ex ;
			}
		}
		catch ( RecognitionException ex ) {
			if (inputState.guessing==0) {
				
					ua = (UserAgent) 
						handleParseException(ex,HEADER_PARSE_EXCEPTION, 
						ua,SIPHeaderNames.USER_AGENT, true);
				
			} else {
				throw ex ;
			}
		}
		return ua ;
	}
	
	public final  WWWAuthenticateList  www_authenticate() throws RecognitionException, TokenStreamException {
		 WWWAuthenticateList cl ;
		
		Token  t = null;
		
			cl = new WWWAuthenticateList();
			Challenge c;
			startTracking();
		
		
		try {      // for error handling
			match(WWW_AUTHENTICATE_COLON);
			{
			switch ( LA(1)) {
			case PGP:
			{
				match(PGP);
				{
				int _cnt793=0;
				_loop793:
				do {
					switch ( LA(1)) {
					case SP:
					{
						match(SP);
						break;
					}
					case HT:
					{
						match(HT);
						break;
					}
					default:
					{
						if ( _cnt793>=1 ) { break _loop793; } else {throw new NoViableAltException(LT(1), getFilename());}
					}
					}
					_cnt793++;
				} while (true);
				}
				c=pgp_challenge();
				if ( inputState.guessing==0 ) {
					cl.add(new WWWAuthenticate(c));
				}
				break;
			}
			case BASIC:
			{
				match(BASIC);
				{
				int _cnt795=0;
				_loop795:
				do {
					switch ( LA(1)) {
					case SP:
					{
						match(SP);
						break;
					}
					case HT:
					{
						match(HT);
						break;
					}
					default:
					{
						if ( _cnt795>=1 ) { break _loop795; } else {throw new NoViableAltException(LT(1), getFilename());}
					}
					}
					_cnt795++;
				} while (true);
				}
				c=basic_challenge();
				if ( inputState.guessing==0 ) {
					cl.add(new WWWAuthenticate(c));
				}
				break;
			}
			case DIGEST:
			{
				match(DIGEST);
				{
				int _cnt797=0;
				_loop797:
				do {
					switch ( LA(1)) {
					case SP:
					{
						match(SP);
						break;
					}
					case HT:
					{
						match(HT);
						break;
					}
					default:
					{
						if ( _cnt797>=1 ) { break _loop797; } else {throw new NoViableAltException(LT(1), getFilename());}
					}
					}
					_cnt797++;
				} while (true);
				}
				c=digest_challenge();
				if ( inputState.guessing==0 ) {
					cl.add(new WWWAuthenticate(c));
				}
				break;
			}
			case ID:
			{
				t = LT(1);
				match(ID);
				{
				int _cnt799=0;
				_loop799:
				do {
					switch ( LA(1)) {
					case SP:
					{
						match(SP);
						break;
					}
					case HT:
					{
						match(HT);
						break;
					}
					default:
					{
						if ( _cnt799>=1 ) { break _loop799; } else {throw new NoViableAltException(LT(1), getFilename());}
					}
					}
					_cnt799++;
				} while (true);
				}
				c=challenge();
				if ( inputState.guessing==0 ) {
					c.setScheme(t.getText()); cl.add (new WWWAuthenticate(c));
				}
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			{
			_loop801:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop801;
				}
				}
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
				cl.setInputText(stopTracking());
				selectLexer("command_keywordLexer"); 
				
			}
		}
		catch ( TokenStreamException ex ) {
			if (inputState.guessing==0) {
				
					cl = (WWWAuthenticateList) 
						handleParseException(ex, HEADER_PARSE_EXCEPTION, 
						cl,SIPHeaderNames.WWW_AUTHENTICATE, true);
				
			} else {
				throw ex ;
			}
		}
		catch ( RecognitionException ex ) {
			if (inputState.guessing==0) {
				
					cl = (WWWAuthenticateList) 
						handleParseException(ex, HEADER_PARSE_EXCEPTION, 
							cl,SIPHeaderNames.WWW_AUTHENTICATE, true);
				
			} else {
				throw ex ;
			}
		}
		return cl ;
	}
	
	public final  AcceptList  accept() throws RecognitionException, TokenStreamException {
		 AcceptList al ;
		
		
			al = new AcceptList();
			Accept a;
			startTracking();
		
		
		try {      // for error handling
			match(ACCEPT_COLON);
			if ( inputState.guessing==0 ) {
				selectLexer("charLexer");
			}
			a=accept_args();
			if ( inputState.guessing==0 ) {
				al.add(a);
			}
			{
			_loop319:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop319;
				}
				}
			} while (true);
			}
			{
			_loop325:
			do {
				if ((LA(1)==COMMA)) {
					match(COMMA);
					{
					_loop322:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop322;
						}
						}
					} while (true);
					}
					a=accept_args();
					if ( inputState.guessing==0 ) {
						al.add(a);
					}
					{
					_loop324:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop324;
						}
						}
					} while (true);
					}
				}
				else {
					break _loop325;
				}
				
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
					al.setInputText(stopTracking());
					selectLexer("command_keywordLexer"); 
				
			}
		}
		catch ( RecognitionException ex) {
			if (inputState.guessing==0) {
				
					al = (AcceptList)
					handleParseException(ex,HEADER_PARSE_EXCEPTION,
						al,SIPHeaderNames.ACCEPT, true);
				
			} else {
				throw ex;
			}
		}
		catch ( TokenStreamException ex) {
			if (inputState.guessing==0) {
				
					al = (AcceptList)
					handleParseException(ex,HEADER_PARSE_EXCEPTION,
						al,SIPHeaderNames.ACCEPT, true);
				
			} else {
				throw ex;
			}
		}
		return al ;
	}
	
	public final  AcceptEncodingList  accept_encoding() throws RecognitionException, TokenStreamException {
		 AcceptEncodingList clist ;
		
		
			clist = new AcceptEncodingList ();
			startTracking();
			AcceptEncoding c;
			
		
		
		try {      // for error handling
			match(ACCEPT_ENCODING_COLON);
			c=content_preference();
			if ( inputState.guessing==0 ) {
				clist.add(c);
			}
			{
			_loop151:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop151;
				}
				}
			} while (true);
			}
			{
			_loop157:
			do {
				if ((LA(1)==COMMA)) {
					match(COMMA);
					{
					_loop154:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop154;
						}
						}
					} while (true);
					}
					c=content_preference();
					if ( inputState.guessing==0 ) {
						clist.add(c);
					}
					{
					_loop156:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop156;
						}
						}
					} while (true);
					}
				}
				else {
					break _loop157;
				}
				
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
					clist.setInputText(stopTracking());
					selectLexer("command_keywordLexer"); 
				
			}
		}
		catch ( RecognitionException ex) {
			if (inputState.guessing==0) {
				
					clist = (AcceptEncodingList) 
						handleParseException(ex,HEADER_PARSE_EXCEPTION,
					   	clist,SIPHeaderNames.ACCEPT_ENCODING, true);
				
			} else {
				throw ex;
			}
		}
		catch ( TokenStreamException ex) {
			if (inputState.guessing==0) {
				
					clist = (AcceptEncodingList) 
						handleParseException(ex,HEADER_PARSE_EXCEPTION,
						clist,SIPHeaderNames.ACCEPT_ENCODING,true);
				
			} else {
				throw ex;
			}
		}
		return clist ;
	}
	
	public final  AcceptLanguageList  accept_language() throws RecognitionException, TokenStreamException {
		 AcceptLanguageList a ;
		
		
			a = new AcceptLanguageList();
			String s;
			double qv;
			AcceptLanguage al;
			startTracking();
			
		
		
		try {      // for error handling
			match(ACCEPT_LANGUAGE_COLON);
			al=accept_language_body();
			{
			_loop173:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop173;
				}
				}
			} while (true);
			}
			if ( inputState.guessing==0 ) {
				a.add(al);
			}
			{
			_loop179:
			do {
				if ((LA(1)==COMMA)) {
					match(COMMA);
					{
					_loop176:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop176;
						}
						}
					} while (true);
					}
					al=accept_language_body();
					{
					_loop178:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop178;
						}
						}
					} while (true);
					}
					if ( inputState.guessing==0 ) {
						a.add(al);
					}
				}
				else {
					break _loop179;
				}
				
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
				a.setInputText(stopTracking());
				selectLexer("command_keywordLexer"); 
				
			}
		}
		catch ( RecognitionException ex) {
			if (inputState.guessing==0) {
				
					a = (AcceptLanguageList) 
					handleParseException(ex,HEADER_PARSE_EXCEPTION,
						a,SIPHeaderNames.ACCEPT_LANGUAGE, true);
				
			} else {
				throw ex;
			}
		}
		catch ( TokenStreamException ex) {
			if (inputState.guessing==0) {
				
					a = (AcceptLanguageList) 
						handleParseException(ex,HEADER_PARSE_EXCEPTION,
						a, SIPHeaderNames.ACCEPT_LANGUAGE, true);
				
			} else {
				throw ex;
			}
		}
		return a ;
	}
	
	public final  CallID  call_id() throws RecognitionException, TokenStreamException {
		 CallID c ;
		
		
			c = new CallID();
			String h = null;
			String s;
			CallIdentifier cid = null;
			startTracking();
		
		
		try {      // for error handling
			match(CALL_ID_COLON);
			cid=call_identifier();
			{
			_loop196:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop196;
				}
				}
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
					c.setCallIdentifier(cid);
					c.setInputText(stopTracking());
					selectLexer("command_keywordLexer"); 
				
			}
		}
		catch ( RecognitionException ex) {
			if (inputState.guessing==0) {
				
					c = (CallID)
						handleParseException(ex,HEADER_PARSE_EXCEPTION,
						c, SIPHeaderNames.CALL_ID, true);
				
			} else {
				throw ex;
			}
		}
		catch ( TokenStreamException ex) {
			if (inputState.guessing==0) {
				
					c = (CallID)
						handleParseException(ex,HEADER_PARSE_EXCEPTION,
						c, SIPHeaderNames.CALL_ID, true);
				
			} else {
				throw ex;
			}
		}
		return c ;
	}
	
	public final  SIPDateHeader  date() throws RecognitionException, TokenStreamException {
		 SIPDateHeader dt ;
		
		
			dt = new SIPDateHeader();
			SIPDate d;
			startTracking();
		
		
		try {      // for error handling
			match(DATE_COLON);
			d=sip_date();
			{
			_loop231:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop231;
				}
				}
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
				dt.setDate(d);
				dt.setInputText(stopTracking());
				selectLexer("command_keywordLexer"); 
				
			}
		}
		catch ( RecognitionException ex) {
			if (inputState.guessing==0) {
				
					dt = (SIPDateHeader )
					handleParseException(ex,HEADER_PARSE_EXCEPTION,
						dt,SIPHeaderNames.DATE, true);
				
			} else {
				throw ex;
			}
		}
		catch ( TokenStreamException ex) {
			if (inputState.guessing==0) {
				
					dt = (SIPDateHeader )
					handleParseException(ex,HEADER_PARSE_EXCEPTION,
						dt,SIPHeaderNames.DATE, true);
				
			} else {
				throw ex;
			}
		}
		return dt ;
	}
	
	public final  Encryption  encryption() throws RecognitionException, TokenStreamException {
		 Encryption e ;
		
		
			e = new Encryption();
			String s;
			NameValue p;
			startTracking();
		
		
		
		try {      // for error handling
			match(ENCRYPTION_COLON);
			s=encryption_scheme();
			{
			int _cnt234=0;
			_loop234:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					if ( _cnt234>=1 ) { break _loop234; } else {throw new NoViableAltException(LT(1), getFilename());}
				}
				}
				_cnt234++;
			} while (true);
			}
			if ( inputState.guessing==0 ) {
				e.setEncryptionScheme(s);
			}
			p=encryption_params();
			{
			_loop236:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop236;
				}
				}
			} while (true);
			}
			if ( inputState.guessing==0 ) {
				e.getEncryptionParms().add(p);
			}
			{
			_loop242:
			do {
				if ((LA(1)==COMMA)) {
					match(COMMA);
					{
					_loop239:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop239;
						}
						}
					} while (true);
					}
					p=encryption_params();
					{
					_loop241:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop241;
						}
						}
					} while (true);
					}
					if ( inputState.guessing==0 ) {
						e.getEncryptionParms().add(p);
					}
				}
				else {
					break _loop242;
				}
				
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
					e.setInputText(stopTracking());
					selectLexer("command_keywordLexer"); 
				
			}
		}
		catch ( RecognitionException ex) {
			if (inputState.guessing==0) {
				
					e = (Encryption)
					handleParseException(ex,HEADER_PARSE_EXCEPTION,
						e, SIPHeaderNames.ENCRYPTION, true);
				
			} else {
				throw ex;
			}
		}
		catch ( TokenStreamException ex) {
			if (inputState.guessing==0) {
				
					e = (Encryption)
					handleParseException(ex,HEADER_PARSE_EXCEPTION,
						e,SIPHeaderNames.ENCRYPTION,true);
				
			} else {
				throw ex;
			}
		}
		return e ;
	}
	
	public final  Expires  expires() throws RecognitionException, TokenStreamException {
		 Expires exp ;
		
		
			exp = new Expires();
			SIPDateOrDeltaSeconds e; 
			startTracking();
		
		
		try {      // for error handling
			match(EXPIRES_COLON);
			e=date_or_delta_seconds();
			{
			_loop252:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop252;
				}
				}
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
				exp.setExpiryTime(e);
				exp.setInputText(stopTracking()); 
				selectLexer("command_keywordLexer"); 
				
			}
		}
		catch ( RecognitionException ex) {
			if (inputState.guessing==0) {
				
					exp = (Expires)
					handleParseException(ex,HEADER_PARSE_EXCEPTION,
						exp,SIPHeaderNames.EXPIRES, true);
				
			} else {
				throw ex;
			}
		}
		catch ( TokenStreamException ex) {
			if (inputState.guessing==0) {
				
					exp = (Expires)
					handleParseException(ex,HEADER_PARSE_EXCEPTION,
						exp,SIPHeaderNames.EXPIRES, true);
				
			} else {
				throw ex;
			}
		}
		return exp ;
	}
	
	public final  RecordRouteList  record_route() throws RecognitionException, TokenStreamException {
		 RecordRouteList al ;
		
		
			Address a = null;
			al = new RecordRouteList();
			startTracking();
			NameValue nv = null;
			RecordRoute rr = null;
		
		
		try {      // for error handling
			match(RECORD_ROUTE_COLON);
			a=name_addr();
			{
			_loop274:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop274;
				}
				}
			} while (true);
			}
			if ( inputState.guessing==0 ) {
				
						rr = new RecordRoute(a);
						al.add(rr);  
					
			}
			{
			_loop280:
			do {
				if ((LA(1)==SEMICOLON)) {
					match(SEMICOLON);
					{
					_loop277:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop277;
						}
						}
					} while (true);
					}
					nv=generic_param();
					{
					_loop279:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop279;
						}
						}
					} while (true);
					}
					if ( inputState.guessing==0 ) {
						
								rr.addParam(nv);
							
					}
				}
				else {
					break _loop280;
				}
				
			} while (true);
			}
			{
			_loop292:
			do {
				if ((LA(1)==COMMA)) {
					match(COMMA);
					{
					_loop283:
					do {
						if ((LA(1)==SP)) {
							match(SP);
						}
						else if ((LA(1)==HT)) {
							match(HT);
						}
						else {
							break _loop283;
						}
						
					} while (true);
					}
					a=name_addr();
					{
					_loop285:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop285;
						}
						}
					} while (true);
					}
					if ( inputState.guessing==0 ) {
						
							     rr = new RecordRoute(a); 
							     al.add(rr) ; 
							
					}
					{
					_loop291:
					do {
						if ((LA(1)==SEMICOLON)) {
							match(SEMICOLON);
							{
							_loop288:
							do {
								switch ( LA(1)) {
								case SP:
								{
									match(SP);
									break;
								}
								case HT:
								{
									match(HT);
									break;
								}
								default:
								{
									break _loop288;
								}
								}
							} while (true);
							}
							nv=generic_param();
							{
							_loop290:
							do {
								switch ( LA(1)) {
								case SP:
								{
									match(SP);
									break;
								}
								case HT:
								{
									match(HT);
									break;
								}
								default:
								{
									break _loop290;
								}
								}
							} while (true);
							}
							if ( inputState.guessing==0 ) {
								
									       rr.addParam(nv);
									       nv = null;
									
							}
						}
						else {
							break _loop291;
						}
						
					} while (true);
					}
				}
				else {
					break _loop292;
				}
				
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
				al.setInputText(stopTracking());
				selectLexer("command_keywordLexer"); 
				
			}
		}
		catch ( RecognitionException ex) {
			if (inputState.guessing==0) {
				
					al = (RecordRouteList)
						handleParseException(ex,HEADER_PARSE_EXCEPTION,
						al,SIPHeaderNames.RECORD_ROUTE, true);
				
			} else {
				throw ex;
			}
		}
		catch ( TokenStreamException ex) {
			if (inputState.guessing==0) {
				
					al = (RecordRouteList)
						handleParseException(ex,HEADER_PARSE_EXCEPTION,
						al,SIPHeaderNames.RECORD_ROUTE, true);
				
			} else {
				throw ex;
			}
		}
		return al ;
	}
	
	public final  TimeStamp  timestamp() throws RecognitionException, TokenStreamException {
		 TimeStamp ts ;
		
		
			double f = 0;
			ts = new TimeStamp();
			startTracking();
		
		
		
		try {      // for error handling
			match(TIMESTAMP_COLON);
			if ( inputState.guessing==0 ) {
				selectLexer ("charLexer");
			}
			f=delay();
			{
			_loop295:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop295;
				}
				}
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
					float fdelay = new Double(f).floatValue();
					ts.setTimeStamp(fdelay);
					ts.setInputText(stopTracking());
					selectLexer("command_keywordLexer"); 
				
			}
		}
		catch ( RecognitionException ex) {
			if (inputState.guessing==0) {
				
					ts = (TimeStamp)
					handleParseException(ex,HEADER_PARSE_EXCEPTION,
						ts,SIPHeaderNames.TIMESTAMP, true);
				
			} else {
				throw ex;
			}
		}
		catch ( TokenStreamException ex) {
			if (inputState.guessing==0) {
				
					ts = (TimeStamp)
					handleParseException(ex,HEADER_PARSE_EXCEPTION,
						ts,SIPHeaderNames.TIMESTAMP, true);
				
			} else {
				throw ex;
			}
		}
		return ts ;
	}
	
	public final  To  to() throws RecognitionException, TokenStreamException {
		 To t ;
		
		
			t = new To();
			Address a = null;
			startTracking();
			NameValue ae;
			String tag;
			boolean semicolonSeen = false;
			
		
		
		try {      // for error handling
			match(TO_COLON);
			a=address();
			if ( inputState.guessing==0 ) {
				selectLexer("addr_parmsLexer");
			}
			{
			_loop299:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop299;
				}
				}
			} while (true);
			}
			{
			_loop308:
			do {
				if ((LA(1)==SEMICOLON)) {
					match(SEMICOLON);
					{
					_loop302:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop302;
						}
						}
					} while (true);
					}
					{
					switch ( LA(1)) {
					case TAG:
					{
						tag=tag_param();
						if ( inputState.guessing==0 ) {
							t.setTag(tag);
						}
						break;
					}
					case ALPHA:
					case DIGIT:
					case UNDERSCORE:
					case PLUS:
					case MINUS:
					case QUOTE:
					case EXCLAMATION:
					case PERCENT:
					case TILDE:
					case BACK_QUOTE:
					case STAR:
					case DOT:
					{
						ae=addr_extension();
						break;
					}
					default:
					{
						throw new NoViableAltException(LT(1), getFilename());
					}
					}
					}
					{
					_loop307:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop307;
						}
						}
					} while (true);
					}
				}
				else {
					break _loop308;
				}
				
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
				// If this is an address spec then the parameters belong to me (and not
				// to the url.
				t.setAddress(a);
				t.setInputText(stopTracking());
				//
				// The Contact, From and To header fields contain a URL. If the URL
				// contains a comma, question mark or semicolon, the URL MUST be
				// enclosed in angle brackets (< and >). Any URL parameters are
				// contained within these brackets. If the URL is not enclosed in angle
				// brackets, any semicolon-delimited parameters are header-parameters,
				// not URL parameters.
				//
				if (a.getAddressType() == Address.ADDRESS_SPEC) {
					t.getParms().concatenate(a.getAddrSpec().getUriParms());
					a.getAddrSpec().clearUriParms();
				}
				try {
				CheckConstraints.check(t);
				} catch ( IllegalArgumentException ex) {
					throw new RecognitionException(ex.getMessage());
				}
				selectLexer("command_keywordLexer"); 
				
			}
		}
		catch ( RecognitionException ex) {
			if (inputState.guessing==0) {
				
					t = (To)
					handleParseException(ex,HEADER_PARSE_EXCEPTION,
						t, SIPHeaderNames.TO, true);
				
			} else {
				throw ex;
			}
		}
		catch ( TokenStreamException ex) {
			if (inputState.guessing==0) {
				
					t = (To)
					handleParseException(ex,HEADER_PARSE_EXCEPTION,
						t,SIPHeaderNames.TO, true);
				
			} else {
				throw ex;
			}
		}
		return t ;
	}
	
	public final  ContentLength  content_length() throws RecognitionException, TokenStreamException {
		 ContentLength cl ;
		
		Token  d = null;
		
			cl = new ContentLength();
			String s = "";
			int i = 0;
			startTracking();
		
		
		try {      // for error handling
			match(CONTENT_LENGTH_COLON);
			{
			int _cnt610=0;
			_loop610:
			do {
				if ((LA(1)==DIGIT)) {
					d = LT(1);
					match(DIGIT);
					if ( inputState.guessing==0 ) {
						s += d.getText();
					}
				}
				else {
					if ( _cnt610>=1 ) { break _loop610; } else {throw new NoViableAltException(LT(1), getFilename());}
				}
				
				_cnt610++;
			} while (true);
			}
			{
			_loop612:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop612;
				}
				}
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
					i = Integer.parseInt(s);
					cl.setContentLength(i);
					cl.setInputText(stopTracking());
				selectLexer("command_keywordLexer"); 
				
			}
		}
		catch ( TokenStreamException ex ) {
			if (inputState.guessing==0) {
				
					cl = (ContentLength)
						handleParseException(ex,HEADER_PARSE_EXCEPTION, 
							cl,SIPHeaderNames.CONTENT_LENGTH, true);
				
			} else {
				throw ex ;
			}
		}
		catch ( RecognitionException ex ) {
			if (inputState.guessing==0) {
				
					cl = (ContentLength)
						handleParseException(ex,HEADER_PARSE_EXCEPTION, 
							cl,SIPHeaderNames.CONTENT_LENGTH, true);
				
			} else {
				throw ex ;
			}
		}
		return cl ;
	}
	
	public final  ProxyAuthenticateList  proxy_authenticate() throws RecognitionException, TokenStreamException {
		 ProxyAuthenticateList cl ;
		
		Token  t = null;
		
			cl = new ProxyAuthenticateList();
			Challenge c;
			startTracking();
		
		
		try {      // for error handling
			match(PROXY_AUTHENTICATE_COLON);
			{
			switch ( LA(1)) {
			case PGP:
			{
				match(PGP);
				{
				int _cnt526=0;
				_loop526:
				do {
					switch ( LA(1)) {
					case SP:
					{
						match(SP);
						break;
					}
					case HT:
					{
						match(HT);
						break;
					}
					default:
					{
						if ( _cnt526>=1 ) { break _loop526; } else {throw new NoViableAltException(LT(1), getFilename());}
					}
					}
					_cnt526++;
				} while (true);
				}
				c=pgp_challenge();
				if ( inputState.guessing==0 ) {
					cl.add(new ProxyAuthenticate(c));
				}
				break;
			}
			case BASIC:
			{
				match(BASIC);
				{
				int _cnt528=0;
				_loop528:
				do {
					switch ( LA(1)) {
					case SP:
					{
						match(SP);
						break;
					}
					case HT:
					{
						match(HT);
						break;
					}
					default:
					{
						if ( _cnt528>=1 ) { break _loop528; } else {throw new NoViableAltException(LT(1), getFilename());}
					}
					}
					_cnt528++;
				} while (true);
				}
				c=basic_challenge();
				if ( inputState.guessing==0 ) {
					cl.add(new ProxyAuthenticate(c));
				}
				break;
			}
			case DIGEST:
			{
				match(DIGEST);
				{
				int _cnt530=0;
				_loop530:
				do {
					switch ( LA(1)) {
					case SP:
					{
						match(SP);
						break;
					}
					case HT:
					{
						match(HT);
						break;
					}
					default:
					{
						if ( _cnt530>=1 ) { break _loop530; } else {throw new NoViableAltException(LT(1), getFilename());}
					}
					}
					_cnt530++;
				} while (true);
				}
				c=digest_challenge();
				if ( inputState.guessing==0 ) {
					cl.add(new ProxyAuthenticate(c));
				}
				break;
			}
			case ID:
			{
				t = LT(1);
				match(ID);
				{
				int _cnt532=0;
				_loop532:
				do {
					switch ( LA(1)) {
					case SP:
					{
						match(SP);
						break;
					}
					case HT:
					{
						match(HT);
						break;
					}
					default:
					{
						if ( _cnt532>=1 ) { break _loop532; } else {throw new NoViableAltException(LT(1), getFilename());}
					}
					}
					_cnt532++;
				} while (true);
				}
				c=challenge();
				if ( inputState.guessing==0 ) {
					c.setScheme(t.getText()); cl.add (new ProxyAuthenticate(c));
				}
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			{
			_loop534:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop534;
				}
				}
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
				cl.setInputText(stopTracking());
				selectLexer("command_keywordLexer"); 
				
			}
		}
		catch ( RecognitionException ex) {
			if (inputState.guessing==0) {
				
					cl = (ProxyAuthenticateList)
						handleParseException(ex,HEADER_PARSE_EXCEPTION,
						cl,SIPHeaderNames.PROXY_AUTHENTICATE,true);
				
			} else {
				throw ex;
			}
		}
		catch ( TokenStreamException ex) {
			if (inputState.guessing==0) {
				
					cl = (ProxyAuthenticateList)
						handleParseException(ex,HEADER_PARSE_EXCEPTION,
						cl,SIPHeaderNames.PROXY_AUTHENTICATE,true);
				
			} else {
				throw ex;
			}
		}
		return cl ;
	}
	
	public final  AllowList  allow() throws RecognitionException, TokenStreamException {
		 AllowList m ;
		
		
			m = new AllowList();
			String meth;
			startTracking();
		
		
		try {      // for error handling
			match(ALLOW_COLON);
			meth=method();
			if ( inputState.guessing==0 ) {
				
						m.add(new  Allow(meth));
					
			}
			{
			_loop424:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop424;
				}
				}
			} while (true);
			}
			{
			_loop430:
			do {
				if ((LA(1)==COMMA)) {
					match(COMMA);
					{
					_loop427:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop427;
						}
						}
					} while (true);
					}
					meth=method();
					if ( inputState.guessing==0 ) {
						
								m.add(new Allow(meth)); 
							
					}
					{
					_loop429:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop429;
						}
						}
					} while (true);
					}
				}
				else {
					break _loop430;
				}
				
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
					  m.setInputText(stopTracking());
					  selectLexer("command_keywordLexer"); 
					
			}
		}
		catch ( RecognitionException ex) {
			if (inputState.guessing==0) {
				
					m = (AllowList)
					handleParseException(ex, HEADER_PARSE_EXCEPTION,
								m,SIPHeaderNames.ALLOW, true);
				
			} else {
				throw ex;
			}
		}
		catch ( TokenStreamException ex) {
			if (inputState.guessing==0) {
				
					m = (AllowList)
					handleParseException(ex, HEADER_PARSE_EXCEPTION,
								m,SIPHeaderNames.ALLOW, true);
				
			} else {
				throw ex;
			}
		}
		return m ;
	}
	
	public final  RetryAfter  retry_after() throws RecognitionException, TokenStreamException {
		 RetryAfter r ;
		
		
			r = new RetryAfter();
			SIPDateOrDeltaSeconds d ;
			String c = null;
			DeltaSeconds  du = null;
			startTracking();
		
		
		try {      // for error handling
			match(RETRY_AFTER_COLON);
			d=date_or_delta_seconds();
			if ( inputState.guessing==0 ) {
				r.setExpiryDate(d);
			}
			{
			switch ( LA(1)) {
			case LPAREN:
			{
				c=comment();
				if ( inputState.guessing==0 ) {
					r.setComment(c);
				}
				break;
			}
			case SP:
			case HT:
			case RETURN:
			case SEMICOLON:
			{
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			{
			switch ( LA(1)) {
			case SEMICOLON:
			{
				match(SEMICOLON);
				if ( inputState.guessing==0 ) {
					selectLexer("retry_afterLexer");
				}
				match(DURATION);
				{
				_loop559:
				do {
					switch ( LA(1)) {
					case SP:
					{
						match(SP);
						break;
					}
					case HT:
					{
						match(HT);
						break;
					}
					default:
					{
						break _loop559;
					}
					}
				} while (true);
				}
				match(EQUALS);
				{
				_loop561:
				do {
					switch ( LA(1)) {
					case SP:
					{
						match(SP);
						break;
					}
					case HT:
					{
						match(HT);
						break;
					}
					default:
					{
						break _loop561;
					}
					}
				} while (true);
				}
				du=delta_seconds();
				break;
			}
			case SP:
			case HT:
			case RETURN:
			{
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			{
			_loop563:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop563;
				}
				}
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
					r.setDuration(du);
					r.setInputText(stopTracking());
					selectLexer("command_keywordLexer"); 
				
			}
		}
		catch ( RecognitionException ex) {
			if (inputState.guessing==0) {
				
					r = (RetryAfter)
					handleParseException(ex,HEADER_PARSE_EXCEPTION,
						r,SIPHeaderNames.RETRY_AFTER, true);
				
			} else {
				throw ex;
			}
		}
		catch ( TokenStreamException ex) {
			if (inputState.guessing==0) {
				
					r = (RetryAfter)
					handleParseException(ex,HEADER_PARSE_EXCEPTION,
						r,SIPHeaderNames.RETRY_AFTER, true);
				
			} else {
				throw ex;
			}
		}
		return r ;
	}
	
	public final  Server  server() throws RecognitionException, TokenStreamException {
		 Server s ;
		
		
		s = null;
		startTracking();
		
		
		try {      // for error handling
			match(SERVER_COLON);
			{
			_loop537:
			do {
				if ((LA(1)==SP)) {
					match(SP);
				}
				else if ((LA(1)==HT)) {
					match(HT);
				}
				else {
					break _loop537;
				}
				
			} while (true);
			}
			s=server_body();
			{
			_loop539:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop539;
				}
				}
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
				s.setInputText(stopTracking());
				selectLexer("command_keywordLexer"); 
				
			}
		}
		catch ( RecognitionException ex) {
			if (inputState.guessing==0) {
				
					s = (Server)
					handleParseException(ex,HEADER_PARSE_EXCEPTION,
						s,SIPHeaderNames.SERVER, true);
				
			} else {
				throw ex;
			}
		}
		catch ( TokenStreamException ex) {
			if (inputState.guessing==0) {
				
					s = (Server)
					handleParseException(ex,HEADER_PARSE_EXCEPTION,
						s,SIPHeaderNames.SERVER, true);
				
			} else {
				throw ex;
			}
		}
		return s ;
	}
	
	public final  WarningList  warning() throws RecognitionException, TokenStreamException {
		 WarningList wvlist ;
		
		
			wvlist = new WarningList();
			Warning wv = null;
			startTracking();
		
		
		try {      // for error handling
			match(WARNING_COLON);
			wv=warning_value();
			if ( inputState.guessing==0 ) {
				wvlist.add(wv);
			}
			{
			_loop756:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop756;
				}
				}
			} while (true);
			}
			{
			_loop760:
			do {
				if ((LA(1)==COMMA)) {
					match(COMMA);
					{
					_loop759:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop759;
						}
						}
					} while (true);
					}
					wv=warning_value();
					if ( inputState.guessing==0 ) {
						wvlist.add(wv);
					}
				}
				else {
					break _loop760;
				}
				
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
				wvlist.setInputText(stopTracking()); 
				
			}
		}
		catch ( TokenStreamException ex ) {
			if (inputState.guessing==0) {
				
					wvlist = (WarningList) 
						handleParseException(ex,HEADER_PARSE_EXCEPTION, 
							wvlist,SIPHeaderNames.WARNING, true);
				
			} else {
				throw ex ;
			}
		}
		catch ( RecognitionException ex ) {
			if (inputState.guessing==0) {
				
					wvlist = (WarningList) 
						handleParseException(ex,HEADER_PARSE_EXCEPTION, 
							wvlist,SIPHeaderNames.WARNING, true);
				
			} else {
				throw ex ;
			}
		}
		return wvlist ;
	}
	
	public final  UnsupportedList  unsupported() throws RecognitionException, TokenStreamException {
		 UnsupportedList ot ;
		
		
			String opt = null;
			ot = new UnsupportedList();
			startTracking();
		
		
		try {      // for error handling
			match(UNSUPPORTED_COLON);
			opt=option_tag();
			if ( inputState.guessing==0 ) {
				ot.add(new Unsupported(opt));
			}
			{
			_loop548:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop548;
				}
				}
			} while (true);
			}
			{
			_loop554:
			do {
				if ((LA(1)==COMMA)) {
					match(COMMA);
					{
					_loop551:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop551;
						}
						}
					} while (true);
					}
					opt=option_tag();
					if ( inputState.guessing==0 ) {
						ot.add( new Unsupported(opt));
					}
					{
					_loop553:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop553;
						}
						}
					} while (true);
					}
				}
				else {
					break _loop554;
				}
				
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
				ot.setInputText(stopTracking());
				selectLexer("command_keywordLexer"); 
				
			}
		}
		catch ( RecognitionException ex) {
			if (inputState.guessing==0) {
				
					ot = (UnsupportedList)
					handleParseException(ex,HEADER_PARSE_EXCEPTION,
						ot,SIPHeaderNames.UNSUPPORTED, true);
				
			} else {
				throw ex;
			}
		}
		catch ( TokenStreamException ex) {
			if (inputState.guessing==0) {
				
					ot = (UnsupportedList)
					handleParseException(ex,HEADER_PARSE_EXCEPTION,
						ot,SIPHeaderNames.UNSUPPORTED, true);
				
			} else {
				throw ex;
			}
		}
		return ot ;
	}
	
	public final  AlertInfoList  alert_info() throws RecognitionException, TokenStreamException {
		 AlertInfoList hl ;
		
		
			hl = new AlertInfoList();
			URI u = null;
			NameValue gp = null;
			startTracking();
			AlertInfo ai = null;
		
		
		try {      // for error handling
			match(ALERT_INFO_COLON);
			{
			int _cnt146=0;
			_loop146:
			do {
				if ((LA(1)==LESS_THAN)) {
					if ( inputState.guessing==0 ) {
						ai = new AlertInfo();
					}
					match(LESS_THAN);
					u=uri_reference();
					if ( inputState.guessing==0 ) {
						ai.setUri(u);
					}
					match(GREATER_THAN);
					{
					_loop145:
					do {
						if ((LA(1)==SEMICOLON)) {
							match(SEMICOLON);
							gp=generic_param();
							if ( inputState.guessing==0 ) {
								ai.getParms().add(gp);
							}
						}
						else {
							break _loop145;
						}
						
					} while (true);
					}
					if ( inputState.guessing==0 ) {
						hl.add(ai);
					}
				}
				else {
					if ( _cnt146>=1 ) { break _loop146; } else {throw new NoViableAltException(LT(1), getFilename());}
				}
				
				_cnt146++;
			} while (true);
			}
			{
			_loop148:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop148;
				}
				}
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
					hl.setInputText(stopTracking());
					selectLexer("command_keywordLexer");
				
			}
		}
		catch ( RecognitionException ex) {
			if (inputState.guessing==0) {
				
					hl = (AlertInfoList) 
					handleParseException(ex,HEADER_PARSE_EXCEPTION,
						hl, SIPHeaderNames.ALERT_INFO, true);
				
			} else {
				throw ex;
			}
		}
		catch ( TokenStreamException ex) {
			if (inputState.guessing==0) {
				
					hl = (AlertInfoList) 
					handleParseException(ex,HEADER_PARSE_EXCEPTION,
						hl,SIPHeaderNames.ALERT_INFO, true);
				
			} else {
				throw ex;
			}
		}
		return hl ;
	}
	
	public final  CallInfoList  call_info() throws RecognitionException, TokenStreamException {
		 CallInfoList ci ;
		
		
			startTracking();
			ci = new CallInfoList();
			CallInfo cinfo;
		
		
		
		try {      // for error handling
			match(CALL_INFO_COLON);
			cinfo=call_info_body();
			if ( inputState.guessing==0 ) {
				ci.add(cinfo);
			}
			{
			_loop118:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop118;
				}
				}
			} while (true);
			}
			{
			_loop124:
			do {
				if ((LA(1)==COMMA)) {
					match(COMMA);
					{
					_loop121:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop121;
						}
						}
					} while (true);
					}
					cinfo=call_info_body();
					{
					_loop123:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop123;
						}
						}
					} while (true);
					}
					if ( inputState.guessing==0 ) {
						ci.add(cinfo);
					}
				}
				else {
					break _loop124;
				}
				
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
					ci.setInputText(stopTracking());
					selectLexer("command_keywordLexer");
				
			}
		}
		catch ( RecognitionException ex) {
			if (inputState.guessing==0) {
				
					ci = (CallInfoList) 
					handleParseException(ex,HEADER_PARSE_EXCEPTION,
						ci,SIPHeaderNames.CALL_INFO, true);
				
			} else {
				throw ex;
			}
		}
		catch ( TokenStreamException ex) {
			if (inputState.guessing==0) {
				
					ci = (CallInfoList) 
					handleParseException(ex,HEADER_PARSE_EXCEPTION,
						ci, SIPHeaderNames.CALL_INFO, true);
				
			} else {
				throw ex;
			}
		}
		return ci ;
	}
	
	public final  ContentLanguageList  content_language() throws RecognitionException, TokenStreamException {
		 ContentLanguageList cl ;
		
		
			startTracking();
			cl = new ContentLanguageList();
			ContentLanguage la = null;
			
		
		
		try {      // for error handling
			match(CONTENT_LANGUAGE_COLON);
			la=language_tag();
			if ( inputState.guessing==0 ) {
				cl.add(la);
			}
			{
			_loop88:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop88;
				}
				}
			} while (true);
			}
			{
			_loop94:
			do {
				if ((LA(1)==COMMA)) {
					match(COMMA);
					{
					_loop91:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop91;
						}
						}
					} while (true);
					}
					la=language_tag();
					if ( inputState.guessing==0 ) {
						cl.add(la);
					}
					{
					_loop93:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop93;
						}
						}
					} while (true);
					}
				}
				else {
					break _loop94;
				}
				
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
					selectLexer("command_keywordLexer");
					cl.setInputText(stopTracking());
				
			}
		}
		catch ( RecognitionException ex ) {
			if (inputState.guessing==0) {
				
					cl = (ContentLanguageList) 
					handleParseException(ex,HEADER_PARSE_EXCEPTION,
						cl, SIPHeaderNames.CONTENT_LANGUAGE, true);
				
			} else {
				throw ex ;
			}
		}
		catch ( TokenStreamException ex ) {
			if (inputState.guessing==0) {
				
					cl = (ContentLanguageList) 
				handleParseException(ex,HEADER_PARSE_EXCEPTION,
						cl,SIPHeaderNames.CONTENT_LANGUAGE, true);
				
			} else {
				throw ex ;
			}
		}
		return cl ;
	}
	
	public final  InReplyToList  in_reply_to() throws RecognitionException, TokenStreamException {
		 InReplyToList inreply ;
		
		
		
			inreply = new InReplyToList();
			CallIdentifier cid;
			startTracking();
			
		
		
		try {      // for error handling
			match(IN_REPLY_TO_COLON);
			cid=call_identifier();
			if ( inputState.guessing==0 ) {
				inreply.add(cid);
			}
			{
			_loop212:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop212;
				}
				}
			} while (true);
			}
			{
			_loop218:
			do {
				if ((LA(1)==COMMA)) {
					match(COMMA);
					{
					_loop215:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop215;
						}
						}
					} while (true);
					}
					cid=call_identifier();
					{
					_loop217:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop217;
						}
						}
					} while (true);
					}
					if ( inputState.guessing==0 ) {
						inreply.add(new InReplyTo(cid));
					}
				}
				else {
					break _loop218;
				}
				
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
					inreply.setInputText(stopTracking()); 
					selectLexer("command_keywordLexer"); 
				
				
			}
		}
		catch ( RecognitionException ex) {
			if (inputState.guessing==0) {
				
					inreply = (InReplyToList )
						handleParseException(ex,HEADER_PARSE_EXCEPTION,
						inreply, SIPHeaderNames.IN_REPLY_TO, true);
				
			} else {
				throw ex;
			}
		}
		catch ( TokenStreamException ex) {
			if (inputState.guessing==0) {
				
					inreply = (InReplyToList)
						handleParseException(ex,HEADER_PARSE_EXCEPTION,
						inreply, SIPHeaderNames.IN_REPLY_TO, true);
				
			} else {
				throw ex;
			}
		}
		return inreply ;
	}
	
	public final  MimeVersion  mime_version() throws RecognitionException, TokenStreamException {
		 MimeVersion mv ;
		
		
			mv = new MimeVersion();
			int major;
			int minor;
			startTracking();
		
		
		try {      // for error handling
			match(MIME_VERSION_COLON);
			major=intnumber();
			match(DOT);
			minor=intnumber();
			{
			_loop221:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop221;
				}
				}
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
					mv.setMajorNumber(major);
					mv.setMinorNumber(minor);
					mv.setInputText(stopTracking());
					selectLexer("command_keywordLexer"); 
				
			}
		}
		catch ( RecognitionException ex) {
			if (inputState.guessing==0) {
				
					mv  = (MimeVersion )
						handleParseException(ex,HEADER_PARSE_EXCEPTION,
						mv, SIPHeaderNames.MIME_VERSION, true);
				
			} else {
				throw ex;
			}
		}
		catch ( TokenStreamException ex) {
			if (inputState.guessing==0) {
				
					mv = (MimeVersion)
						handleParseException(ex,HEADER_PARSE_EXCEPTION,
						mv, SIPHeaderNames.MIME_VERSION, true);
				
			} else {
				throw ex;
			}
		}
		return mv ;
	}
	
	public final  AlsoList  also() throws RecognitionException, TokenStreamException {
		 AlsoList a ;
		
		
			a = new AlsoList();
			Address addr;
			startTracking();
		
		
		try {      // for error handling
			match(ALSO_COLON);
			addr=address();
			if ( inputState.guessing==0 ) {
				a.add( new Also(addr));
			}
			{
			_loop203:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop203;
				}
				}
			} while (true);
			}
			{
			_loop209:
			do {
				if ((LA(1)==COMMA)) {
					match(COMMA);
					{
					_loop206:
					do {
						if ((LA(1)==SP)) {
							match(SP);
						}
						else if ((LA(1)==HT)) {
							match(HT);
						}
						else {
							break _loop206;
						}
						
					} while (true);
					}
					addr=address();
					if ( inputState.guessing==0 ) {
						a.add(new Also(addr));
					}
					{
					_loop208:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop208;
						}
						}
					} while (true);
					}
				}
				else {
					break _loop209;
				}
				
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
					a.setInputText(stopTracking());
					selectLexer("command_keywordLexer");
				
			}
		}
		catch ( RecognitionException ex) {
			if (inputState.guessing==0) {
				
					a  = (AlsoList )
						handleParseException(ex,HEADER_PARSE_EXCEPTION,
						a, SIPHeaderNames.ALSO, true);
				
			} else {
				throw ex;
			}
		}
		catch ( TokenStreamException ex) {
			if (inputState.guessing==0) {
				
					a  = (AlsoList)
						handleParseException(ex,HEADER_PARSE_EXCEPTION,
						a, SIPHeaderNames.ALSO, true);
				
			} else {
				throw ex;
			}
		}
		return a ;
	}
	
	public final  ErrorInfoList  error_info() throws RecognitionException, TokenStreamException {
		 ErrorInfoList eil ;
		
			
			eil = new ErrorInfoList();
			ErrorInfo ei;
			startTracking();
		
		
		try {      // for error handling
			match(ERROR_INFO_COLON);
			ei=error_infobody();
			if ( inputState.guessing==0 ) {
				eil.add(ei);
			}
			{
			_loop98:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop98;
				}
				}
			} while (true);
			}
			{
			_loop104:
			do {
				if ((LA(1)==COMMA)) {
					match(COMMA);
					{
					_loop101:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop101;
						}
						}
					} while (true);
					}
					ei=error_infobody();
					if ( inputState.guessing==0 ) {
						eil.add(ei);
					}
					{
					_loop103:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop103;
						}
						}
					} while (true);
					}
				}
				else {
					break _loop104;
				}
				
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
					eil.setInputText(stopTracking());
				
			}
		}
		catch ( RecognitionException ex ) {
			if (inputState.guessing==0) {
				
					eil = (ErrorInfoList) 
					handleParseException(ex,HEADER_PARSE_EXCEPTION,
						eil, SIPHeaderNames.ERROR_INFO, true);
				
			} else {
				throw ex ;
			}
		}
		catch ( TokenStreamException ex ) {
			if (inputState.guessing==0) {
				
					eil = (ErrorInfoList) 
				handleParseException(ex,HEADER_PARSE_EXCEPTION,
						eil,SIPHeaderNames.ERROR_INFO, true);
				
			} else {
				throw ex ;
			}
		}
		return eil ;
	}
	
	public final  SupportedList  supported() throws RecognitionException, TokenStreamException {
		 SupportedList sl ;
		
		
			sl = new SupportedList();
			Supported sp = null;
			String ot  = null;
		
		
		try {      // for error handling
			match(SUPPORTED_COLON);
			ot=option_tag();
			if ( inputState.guessing==0 ) {
				sp = new Supported(ot);  sl.add(sp);
			}
			{
			_loop79:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop79;
				}
				}
			} while (true);
			}
			{
			_loop85:
			do {
				if ((LA(1)==COMMA)) {
					match(COMMA);
					{
					_loop82:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop82;
						}
						}
					} while (true);
					}
					ot=option_tag();
					if ( inputState.guessing==0 ) {
						sp = new Supported(ot);  sl.add(sp);
					}
					{
					_loop84:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop84;
						}
						}
					} while (true);
					}
				}
				else {
					break _loop85;
				}
				
			} while (true);
			}
			match(RETURN);
		}
		catch ( RecognitionException ex ) {
			if (inputState.guessing==0) {
				
					sl = (SupportedList) 
					handleParseException(ex,HEADER_PARSE_EXCEPTION,
						sl, SIPHeaderNames.SUPPORTED, true);
				
			} else {
				throw ex ;
			}
		}
		catch ( TokenStreamException ex ) {
			if (inputState.guessing==0) {
				
					sl = (SupportedList) 
				handleParseException(ex,HEADER_PARSE_EXCEPTION,
						sl,SIPHeaderNames.SUPPORTED, true);
				
			} else {
				throw ex ;
			}
		}
		return sl ;
	}
	
	public final  ContentEncodingList  content_encoding() throws RecognitionException, TokenStreamException {
		 ContentEncodingList c ;
		
		
			c = new ContentEncodingList ();
			startTracking();
			String enc;
		
		
		try {      // for error handling
			match(CONTENT_ENCODING_COLON);
			enc=content_coding();
			if ( inputState.guessing==0 ) {
				c.add(new ContentEncoding(enc));
			}
			{
			_loop601:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop601;
				}
				}
			} while (true);
			}
			{
			_loop607:
			do {
				if ((LA(1)==COMMA)) {
					match(COMMA);
					{
					_loop604:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop604;
						}
						}
					} while (true);
					}
					enc=content_coding();
					if ( inputState.guessing==0 ) {
						c.add(new ContentEncoding(enc));
					}
					{
					_loop606:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop606;
						}
						}
					} while (true);
					}
				}
				else {
					break _loop607;
				}
				
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
					c.setInputText(stopTracking());
					selectLexer("command_keywordLexer"); 
				
			}
		}
		catch ( TokenStreamException ex ) {
			if (inputState.guessing==0) {
				
					c = (ContentEncodingList)
					handleParseException(ex, HEADER_PARSE_EXCEPTION, 
						c,SIPHeaderNames.CONTENT_ENCODING, true);
				
				
			} else {
				throw ex ;
			}
		}
		catch ( RecognitionException ex ) {
			if (inputState.guessing==0) {
				
					c = (ContentEncodingList)
					handleParseException(ex, HEADER_PARSE_EXCEPTION, 
							c,SIPHeaderNames.CONTENT_ENCODING, true);
				
			} else {
				throw ex ;
			}
		}
		return c ;
	}
	
	public final  ContentDisposition  content_disposition() throws RecognitionException, TokenStreamException {
		 ContentDisposition disp ;
		
		
			startTracking();
			disp = new ContentDisposition();
			NameValue dp;
			String dt;
			
		
		
		try {      // for error handling
			match(CONTENT_DISPOSITION_COLON);
			dt=disposition_type();
			if ( inputState.guessing==0 ) {
				disp.setDispositionType(dt);
			}
			{
			_loop62:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop62;
				}
				}
			} while (true);
			}
			{
			_loop68:
			do {
				if ((LA(1)==SEMICOLON)) {
					match(SEMICOLON);
					{
					_loop65:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop65;
						}
						}
					} while (true);
					}
					dp=disposition_param();
					{
					_loop67:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop67;
						}
						}
					} while (true);
					}
					if ( inputState.guessing==0 ) {
						disp.addDispositionParam(dp);
					}
				}
				else {
					break _loop68;
				}
				
			} while (true);
			}
			match(RETURN);
			if ( inputState.guessing==0 ) {
				
					selectLexer("command_keywordLexer");
					disp.setInputText(stopTracking());
				
			}
		}
		catch ( RecognitionException ex) {
			if (inputState.guessing==0) {
				
					disp = (ContentDisposition) 
					handleParseException(ex,HEADER_PARSE_EXCEPTION,
						disp, SIPHeaderNames.CONTENT_DISPOSITION, true);
				
			} else {
				throw ex;
			}
		}
		catch ( TokenStreamException ex) {
			if (inputState.guessing==0) {
				
					disp = (ContentDisposition) 
				handleParseException(ex,HEADER_PARSE_EXCEPTION,
						disp,SIPHeaderNames.CONTENT_DISPOSITION, true);
				
			} else {
				throw ex;
			}
		}
		return disp ;
	}
	
	public final  int  status_code() throws RecognitionException, TokenStreamException {
		 int sc ;
		
		Token  d1 = null;
		Token  d2 = null;
		Token  d3 = null;
		Token  t = null;
		
			sc = 0;
		
		
		switch ( LA(1)) {
		case DIGIT:
		{
			d1 = LT(1);
			match(DIGIT);
			d2 = LT(1);
			match(DIGIT);
			d3 = LT(1);
			match(DIGIT);
			if ( inputState.guessing==0 ) {
				
					String s = d1.getText() + d2.getText() + d3.getText();
					sc = Integer.parseInt(s);
				
			}
			break;
		}
		case ID:
		{
			t = LT(1);
			match(ID);
			if ( inputState.guessing==0 ) {
				
					String s = t.getText() ;
					sc = Integer.parseInt(s);
					selectLexer("charLexer");
				
			}
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		return sc ;
	}
	
	public final  String  reason_phrase() throws RecognitionException, TokenStreamException {
		 String s ;
		
		Token  d = null;
		
			s = "";
			Assert( getCurrentLexerName().compareTo("charLexer") == 0 );
		
		
		{
		int _cnt59=0;
		_loop59:
		do {
			if ((_tokenSet_0.member(LA(1)))) {
				{
				d = LT(1);
				match(_tokenSet_0);
				}
				if ( inputState.guessing==0 ) {
					s += d.getText();
				}
			}
			else {
				if ( _cnt59>=1 ) { break _loop59; } else {throw new NoViableAltException(LT(1), getFilename());}
			}
			
			_cnt59++;
		} while (true);
		}
		return s ;
	}
	
	public final  String  disposition_type() throws RecognitionException, TokenStreamException {
		 String dt ;
		
		Token  t = null;
		
			dt = null;
		
		
		switch ( LA(1)) {
		case RENDER:
		{
			match(RENDER);
			if ( inputState.guessing==0 ) {
				dt = ContentDisposition.RENDER;
			}
			break;
		}
		case SESSION:
		{
			match(SESSION);
			if ( inputState.guessing==0 ) {
				dt = ContentDisposition.SESSION;
			}
			break;
		}
		case ICON:
		{
			match(ICON);
			if ( inputState.guessing==0 ) {
				dt = ContentDisposition.ICON;
			}
			break;
		}
		case ALERT:
		{
			match(ALERT);
			if ( inputState.guessing==0 ) {
				dt = ContentDisposition.ALERT;
			}
			break;
		}
		case ID:
		{
			t = LT(1);
			match(ID);
			if ( inputState.guessing==0 ) {
				dt = t.getText();
			}
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		return dt ;
	}
	
	public final  NameValue  disposition_param() throws RecognitionException, TokenStreamException {
		 NameValue dp ;
		
		
			dp = null;
			startTracking();
		
		
		switch ( LA(1)) {
		case HANDLING:
		{
			{
			match(HANDLING);
			{
			_loop73:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop73;
				}
				}
			} while (true);
			}
			match(EQUALS);
			{
			_loop75:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop75;
				}
				}
			} while (true);
			}
			{
			switch ( LA(1)) {
			case OPTIONAL:
			{
				match(OPTIONAL);
				if ( inputState.guessing==0 ) {
					dp = new NameValue( ContentDisposition.HANDLING,
								 ContentDisposition.OPTIONAL) ; 
					dp.setInputText(stopTracking());
					
				}
				break;
			}
			case REQUIRED:
			{
				match(REQUIRED);
				if ( inputState.guessing==0 ) {
					dp = new NameValue( ContentDisposition.HANDLING,
							 	 ContentDisposition.REQUIRED) ; 
					dp.setInputText(stopTracking());
					
				}
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			}
			break;
		}
		case ALPHA:
		case DIGIT:
		case UNDERSCORE:
		case PLUS:
		case MINUS:
		case QUOTE:
		case EXCLAMATION:
		case PERCENT:
		case TILDE:
		case BACK_QUOTE:
		case STAR:
		case DOT:
		{
			dp=generic_param();
			if ( inputState.guessing==0 ) {
				dp.setInputText(stopTracking());
			}
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		return dp ;
	}
	
	public final  NameValue  generic_param() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		
			nv = null;
			String n = null;
			String v = null;
			startTracking();
		
		
		
		n=ttoken();
		{
		_loop872:
		do {
			if ((LA(1)==SP)) {
				match(SP);
			}
			else if ((LA(1)==HT)) {
				match(HT);
			}
			else {
				break _loop872;
			}
			
		} while (true);
		}
		{
		switch ( LA(1)) {
		case EQUALS:
		{
			match(EQUALS);
			{
			_loop877:
			do {
				if ((LA(1)==SP)) {
					match(SP);
				}
				else if ((LA(1)==HT)) {
					match(HT);
				}
				else {
					break _loop877;
				}
				
			} while (true);
			}
			{
			switch ( LA(1)) {
			case DOUBLEQUOTE:
			{
				v=quoted_string();
				break;
			}
			case ALPHA:
			case DIGIT:
			case UNDERSCORE:
			case PLUS:
			case MINUS:
			case QUOTE:
			case EXCLAMATION:
			case PERCENT:
			case TILDE:
			case BACK_QUOTE:
			case STAR:
			case DOT:
			case SP:
			case HT:
			{
				{
				_loop882:
				do {
					switch ( LA(1)) {
					case SP:
					{
						match(SP);
						break;
					}
					case HT:
					{
						match(HT);
						break;
					}
					default:
					{
						break _loop882;
					}
					}
				} while (true);
				}
				v=ttoken();
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			break;
		}
		case SP:
		case HT:
		case RETURN:
		case SEMICOLON:
		case COMMA:
		case LESS_THAN:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			
				nv = new NameValue();
				nv.setName(n);
				nv.setValue(v);
				nv.setInputText(stopTracking());
			
		}
		return nv ;
	}
	
	public final  String  option_tag() throws RecognitionException, TokenStreamException {
		 String op ;
		
		
			op = null;
		
		
		op=ttoken();
		return op ;
	}
	
	public final  ContentLanguage  language_tag() throws RecognitionException, TokenStreamException {
		 ContentLanguage la ;
		
		
			la = null;
			String s = null;
		
		
		s=ttoken();
		if ( inputState.guessing==0 ) {
			
				la = new ContentLanguage(s);
			
		}
		return la ;
	}
	
	public final  String  ttoken() throws RecognitionException, TokenStreamException {
		 String s ;
		
		Token  t1 = null;
		Token  t2 = null;
		Token  t3 = null;
		Token  t4 = null;
		Token  t5 = null;
		Token  t6 = null;
		Token  t7 = null;
		Token  t8 = null;
		Token  t9 = null;
		Token  t10 = null;
		Token  t11 = null;
		Token  t12 = null;
		
		s = "";
		
		
		{
		switch ( LA(1)) {
		case ALPHA:
		{
			t1 = LT(1);
			match(ALPHA);
			if ( inputState.guessing==0 ) {
				s = t1.getText();
			}
			break;
		}
		case DIGIT:
		{
			t2 = LT(1);
			match(DIGIT);
			if ( inputState.guessing==0 ) {
				s = t2.getText();
			}
			break;
		}
		case UNDERSCORE:
		{
			t3 = LT(1);
			match(UNDERSCORE);
			if ( inputState.guessing==0 ) {
				s = t3.getText();
			}
			break;
		}
		case PLUS:
		{
			t4 = LT(1);
			match(PLUS);
			if ( inputState.guessing==0 ) {
				s = t4.getText();
			}
			break;
		}
		case MINUS:
		{
			t5 = LT(1);
			match(MINUS);
			if ( inputState.guessing==0 ) {
				s = t5.getText();
			}
			break;
		}
		case QUOTE:
		{
			t6 = LT(1);
			match(QUOTE);
			if ( inputState.guessing==0 ) {
				s = t6.getText();
			}
			break;
		}
		case EXCLAMATION:
		{
			t7 = LT(1);
			match(EXCLAMATION);
			if ( inputState.guessing==0 ) {
				s = t7.getText();
			}
			break;
		}
		case PERCENT:
		{
			t8 = LT(1);
			match(PERCENT);
			if ( inputState.guessing==0 ) {
				s = t8.getText();
			}
			break;
		}
		case TILDE:
		{
			t9 = LT(1);
			match(TILDE);
			if ( inputState.guessing==0 ) {
				s = t9.getText();
			}
			break;
		}
		case BACK_QUOTE:
		{
			t10 = LT(1);
			match(BACK_QUOTE);
			if ( inputState.guessing==0 ) {
				s = t10.getText();
			}
			break;
		}
		case STAR:
		{
			t11 = LT(1);
			match(STAR);
			if ( inputState.guessing==0 ) {
				s = t11.getText();
			}
			break;
		}
		case DOT:
		{
			t12 = LT(1);
			match(DOT);
			if ( inputState.guessing==0 ) {
				s = t12.getText();
			}
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			
			pushLexer("charLexer");
				String r = "";
				while(true) {
					Token d = LT(1);
					if (d == null || d.getType() == Token.EOF_TYPE ) {
						throw new RecognitionException("Premature EOF");
					}		
					int ttype = d.getType();
			
					if (  ttype == ALPHA   || ttype == DIGIT || ttype == UNDERSCORE
					   || ttype == PLUS    || ttype == QUOTE || ttype == EXCLAMATION
					   || ttype == PERCENT || ttype == TILDE || ttype == BACK_QUOTE 
					   || ttype == DOT     || ttype == MINUS || ttype == STAR ) {
						r += d.getText();
						consume();
					} else {
						track(r);
						break;
					}
			}
			s += r;
			popLexer();
			
		}
		return s ;
	}
	
	public final  ErrorInfo  error_infobody() throws RecognitionException, TokenStreamException {
		 ErrorInfo ei ;
		
		
		startTracking();
		ei = new ErrorInfo();
		NameValue gp;
		URI u;
		
		
		match(LESS_THAN);
		u=uri_reference();
		if ( inputState.guessing==0 ) {
			ei.setURI(u);
		}
		match(GREATER_THAN);
		if ( inputState.guessing==0 ) {
			selectLexer("charLexer");
		}
		{
		_loop107:
		do {
			if ((LA(1)==SP)) {
				match(SP);
			}
			else if ((LA(1)==HT)) {
				match(HT);
			}
			else {
				break _loop107;
			}
			
		} while (true);
		}
		{
		_loop115:
		do {
			boolean synPredMatched110 = false;
			if (((LA(1)==SEMICOLON))) {
				int _m110 = mark();
				synPredMatched110 = true;
				inputState.guessing++;
				try {
					{
					match(SEMICOLON);
					}
				}
				catch (RecognitionException pe) {
					synPredMatched110 = false;
				}
				rewind(_m110);
				inputState.guessing--;
			}
			if ( synPredMatched110 ) {
				match(SEMICOLON);
				{
				_loop112:
				do {
					switch ( LA(1)) {
					case SP:
					{
						match(SP);
						break;
					}
					case HT:
					{
						match(HT);
						break;
					}
					default:
					{
						break _loop112;
					}
					}
				} while (true);
				}
				gp=generic_param();
				if ( inputState.guessing==0 ) {
					ei.addParam(gp);
				}
				{
				_loop114:
				do {
					if ((LA(1)==SP)) {
						match(SP);
					}
					else if ((LA(1)==HT)) {
						match(HT);
					}
					else {
						break _loop114;
					}
					
				} while (true);
				}
			}
			else {
				break _loop115;
			}
			
		} while (true);
		}
		if ( inputState.guessing==0 ) {
			
				ei.setInputText(stopTracking());
			
		}
		return ei ;
	}
	
	public final  URI  uri_reference() throws RecognitionException, TokenStreamException {
		 URI uri_ptr ;
		
		
		{
		switch ( LA(1)) {
		case SIP:
		{
			uri_ptr=sip_url();
			break;
		}
		case ALPHA:
		case DIGIT:
		case UNDERSCORE:
		case PLUS:
		case MINUS:
		case QUOTE:
		case EXCLAMATION:
		case PERCENT:
		case TILDE:
		case BACK_QUOTE:
		case STAR:
		case DOT:
		case EQUALS:
		case LPAREN:
		case RPAREN:
		case SEMICOLON:
		case ID:
		case SLASH:
		case AT:
		case AND:
		case DOLLAR:
		case COMMA:
		{
			uri_ptr=uri();
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		return uri_ptr ;
	}
	
	public final  CallInfo  call_info_body() throws RecognitionException, TokenStreamException {
		 CallInfo ci ;
		
		
			ci =  new CallInfo();
			URI u;
			String p;
			NameValue gp;
			startTracking();
		
		
		match(LESS_THAN);
		{
		_loop127:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop127;
			}
			}
		} while (true);
		}
		u=uri_reference();
		if ( inputState.guessing==0 ) {
			ci.setUri(u);
		}
		{
		_loop129:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop129;
			}
			}
		} while (true);
		}
		match(GREATER_THAN);
		if ( inputState.guessing==0 ) {
			selectLexer("call_infoLexer", call_infoLexer.PARMS_LHS_STATE );
		}
		{
		_loop131:
		do {
			if ((LA(1)==SP)) {
				match(SP);
			}
			else if ((LA(1)==HT)) {
				match(HT);
			}
			else {
				break _loop131;
			}
			
		} while (true);
		}
		{
		switch ( LA(1)) {
		case SEMICOLON:
		{
			match(SEMICOLON);
			if ( inputState.guessing==0 ) {
				selectLexer("call_infoLexer", call_infoLexer.PARMS_LHS_STATE );
			}
			{
			_loop136:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop136;
				}
				}
			} while (true);
			}
			match(PURPOSE);
			{
			_loop138:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop138;
				}
				}
			} while (true);
			}
			match(EQUALS);
			{
			_loop140:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop140;
				}
				}
			} while (true);
			}
			p=purpose();
			if ( inputState.guessing==0 ) {
				ci.setPurpose(p);
			}
			break;
		}
		case SP:
		case HT:
		case RETURN:
		case COMMA:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			
				ci.setInputText(stopTracking());
			
		}
		return ci ;
	}
	
	public final  String  purpose() throws RecognitionException, TokenStreamException {
		 String p ;
		
		Token  t = null;
		
			p = null;
		
		
		switch ( LA(1)) {
		case ICON:
		{
			match(ICON);
			if ( inputState.guessing==0 ) {
				p = CallInfoKeywords.ICON;
			}
			break;
		}
		case INFO:
		{
			match(INFO);
			if ( inputState.guessing==0 ) {
				p = CallInfoKeywords.INFO;
			}
			break;
		}
		case CARD:
		{
			match(CARD);
			if ( inputState.guessing==0 ) {
				p = CallInfoKeywords.CARD;
			}
			break;
		}
		case ID:
		{
			t = LT(1);
			match(ID);
			if ( inputState.guessing==0 ) {
				p = t.getText();
			}
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		return p ;
	}
	
	public final  AcceptEncoding  content_preference() throws RecognitionException, TokenStreamException {
		 AcceptEncoding cc ;
		
		
			cc = new AcceptEncoding();
			String c;
			double qv = 1.0;
			startTracking();
		
		
		c=content_coding();
		if ( inputState.guessing==0 ) {
			cc.setContentCoding(c);
		}
		{
		_loop160:
		do {
			if ((LA(1)==SP)) {
				match(SP);
			}
			else if ((LA(1)==HT)) {
				match(HT);
			}
			else {
				break _loop160;
			}
			
		} while (true);
		}
		{
		switch ( LA(1)) {
		case SEMICOLON:
		{
			match(SEMICOLON);
			if ( inputState.guessing==0 ) {
				selectLexer("accept_languageLexer");
			}
			{
			_loop165:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop165;
				}
				}
			} while (true);
			}
			match(Q);
			{
			_loop167:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop167;
				}
				}
			} while (true);
			}
			match(EQUALS);
			{
			_loop169:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop169;
				}
				}
			} while (true);
			}
			qv=qvalue();
			if ( inputState.guessing==0 ) {
				
				cc.setQvalue(qv); 
				selectLexer("charLexer"); 
				
			}
			break;
		}
		case SP:
		case HT:
		case RETURN:
		case COMMA:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			cc.setInputText(stopTracking());
		}
		return cc ;
	}
	
	public final  String  content_coding() throws RecognitionException, TokenStreamException {
		 String c ;
		
		
		c=ttoken();
		return c ;
	}
	
	public final  double  qvalue() throws RecognitionException, TokenStreamException {
		 double f ;
		
		
		f=fpnum();
		return f ;
	}
	
	public final  AcceptLanguage  accept_language_body() throws RecognitionException, TokenStreamException {
		 AcceptLanguage a ;
		
		
			a = new AcceptLanguage();
			String s  = null;
			startTracking();
			double qv;
		
		
		s=language_range();
		if ( inputState.guessing==0 ) {
			a.setLanguageRange(s);
		}
		{
		switch ( LA(1)) {
		case SEMICOLON:
		{
			match(SEMICOLON);
			if ( inputState.guessing==0 ) {
				selectLexer("accept_languageLexer");
			}
			match(Q);
			{
			_loop183:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop183;
				}
				}
			} while (true);
			}
			match(EQUALS);
			{
			_loop185:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop185;
				}
				}
			} while (true);
			}
			qv=qvalue();
			if ( inputState.guessing==0 ) {
				a.setQValue(qv);  selectLexer("charLexer");
			}
			break;
		}
		case SP:
		case HT:
		case RETURN:
		case COMMA:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			
				a.setInputText(stopTracking());
			
		}
		return a ;
	}
	
	public final  String  language_range() throws RecognitionException, TokenStreamException {
		 String s ;
		
		Token  d1 = null;
		Token  d2 = null;
		Token  d3 = null;
		
			s = "";
		
		
		switch ( LA(1)) {
		case ALPHA:
		{
			{
			int _cnt188=0;
			_loop188:
			do {
				if ((LA(1)==ALPHA)) {
					d1 = LT(1);
					match(ALPHA);
					if ( inputState.guessing==0 ) {
						s += d1.getText();
					}
				}
				else {
					if ( _cnt188>=1 ) { break _loop188; } else {throw new NoViableAltException(LT(1), getFilename());}
				}
				
				_cnt188++;
			} while (true);
			}
			{
			_loop192:
			do {
				if ((LA(1)==MINUS)) {
					d2 = LT(1);
					match(MINUS);
					if ( inputState.guessing==0 ) {
						s += d2.getText();
					}
					{
					int _cnt191=0;
					_loop191:
					do {
						if ((LA(1)==ALPHA)) {
							d3 = LT(1);
							match(ALPHA);
							if ( inputState.guessing==0 ) {
								s += d3.getText();
							}
						}
						else {
							if ( _cnt191>=1 ) { break _loop191; } else {throw new NoViableAltException(LT(1), getFilename());}
						}
						
						_cnt191++;
					} while (true);
					}
				}
				else {
					break _loop192;
				}
				
			} while (true);
			}
			break;
		}
		case STAR:
		{
			match(STAR);
			if ( inputState.guessing==0 ) {
				s = "*";
			}
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		return s ;
	}
	
	public final  double  fpnum() throws RecognitionException, TokenStreamException {
		 double f ;
		
		Token  a = null;
		Token  b = null;
		
			String s = "";
			f = 1.0;
		
		
		a = LT(1);
		match(DIGIT);
		if ( inputState.guessing==0 ) {
			s = a.getText();
		}
		{
		switch ( LA(1)) {
		case DOT:
		{
			match(DOT);
			if ( inputState.guessing==0 ) {
				s += ".";
			}
			{
			int _cnt1067=0;
			_loop1067:
			do {
				if ((LA(1)==DIGIT)) {
					b = LT(1);
					match(DIGIT);
					if ( inputState.guessing==0 ) {
						s += b.getText();
					}
				}
				else {
					if ( _cnt1067>=1 ) { break _loop1067; } else {throw new NoViableAltException(LT(1), getFilename());}
				}
				
				_cnt1067++;
			} while (true);
			}
			break;
		}
		case SP:
		case HT:
		case RETURN:
		case LPAREN:
		case SEMICOLON:
		case COMMA:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			
				f = Double.parseDouble(s);
			
		}
		return f ;
	}
	
	public final  CallIdentifier  call_identifier() throws RecognitionException, TokenStreamException {
		 CallIdentifier cid ;
		
		
			startTracking();
			 cid = new CallIdentifier();
			String s = null;
			String h = null;
		
		
		
		s=ttoken();
		{
		switch ( LA(1)) {
		case AT:
		{
			match(AT);
			h=ttoken();
			break;
		}
		case SP:
		case HT:
		case RETURN:
		case COMMA:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			
			
				cid.setLocalId(s);
				if (h != null) cid.setHost(h);
				cid.setInputText(stopTracking());
			
		}
		return cid ;
	}
	
	public final  Address  address() throws RecognitionException, TokenStreamException {
		 Address a ;
		
		
		URI  u ;
		a = null;
		int k = 1;
		String prefix = "";
		startTracking();
		while( LA(k) != RETURN ) {
			String n = LT(k).getText();
			prefix += n;
			if ( LA(k) ==  LESS_THAN ) {
			  	break;
			} else if ( LA(k) == DOUBLEQUOTE) {
				break; 
			} else if ( LA(k) == COLON ) {
			  	break;
			} else if (LA(k) == SLASH) {
				break;
			}
		k++;
		}
		
		
		{
		if (((_tokenSet_1.member(LA(1))))&&( LA(k) == LESS_THAN || LA(k) == DOUBLEQUOTE )) {
			a=name_addr();
		}
		else if (((_tokenSet_2.member(LA(1))))&&(LA(k) == COLON || LA(k) == SLASH )) {
			u=addr_spec();
			if ( inputState.guessing==0 ) {
				
					// This is a relative uri or an absolute uri.
					a = new Address();
					a.setAddressType(Address.ADDRESS_SPEC);
					a.setAddrSpec(u);
				
			}
		}
		else {
			throw new NoViableAltException(LT(1), getFilename());
		}
		
		}
		if ( inputState.guessing==0 ) {
			
				a.setInputText(stopTracking());  
			
		}
		return a ;
	}
	
	public final  int  intnumber() throws RecognitionException, TokenStreamException {
		 int i ;
		
		Token  d = null;
		Token  d1 = null;
		
			String s = "";
			i = 0;
		
		
		switch ( LA(1)) {
		case DIGIT:
		{
			{
			int _cnt1056=0;
			_loop1056:
			do {
				if ((LA(1)==DIGIT)) {
					d = LT(1);
					match(DIGIT);
					if ( inputState.guessing==0 ) {
						s += d.getText();
					}
				}
				else {
					if ( _cnt1056>=1 ) { break _loop1056; } else {throw new NoViableAltException(LT(1), getFilename());}
				}
				
				_cnt1056++;
			} while (true);
			}
			if ( inputState.guessing==0 ) {
				
					i = Integer.parseInt(s);
				
			}
			break;
		}
		case NUMBER:
		{
			d1 = LT(1);
			match(NUMBER);
			if ( inputState.guessing==0 ) {
				
					// This alternative is necessary because of non-determinism in
					// the parser.
					i = Integer.parseInt(d1.getText());
				
			}
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		return i ;
	}
	
	public final  String  method() throws RecognitionException, TokenStreamException {
		 String m ;
		
		
			pushLexer("method_keywordLexer");
			m = null;
		
		
		{
		switch ( LA(1)) {
		case REGISTER:
		{
			match(REGISTER);
			if ( inputState.guessing==0 ) {
				m = SIPKeywords.REGISTER;
			}
			break;
		}
		case ACK:
		{
			match(ACK);
			if ( inputState.guessing==0 ) {
				m = SIPKeywords.ACK;
			}
			break;
		}
		case OPTIONS:
		{
			match(OPTIONS);
			if ( inputState.guessing==0 ) {
				m = SIPKeywords.OPTIONS;
			}
			break;
		}
		case BYE:
		{
			match(BYE);
			if ( inputState.guessing==0 ) {
				m = SIPKeywords.BYE;
			}
			break;
		}
		case INVITE:
		{
			match(INVITE);
			if ( inputState.guessing==0 ) {
				m = SIPKeywords.INVITE;
			}
			break;
		}
		case CANCEL:
		{
			match(CANCEL);
			if ( inputState.guessing==0 ) {
				m = SIPKeywords.CANCEL;
			}
			break;
		}
		case ID:
		{
			m=extension_method();
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			
				popLexer();
			
		}
		return m ;
	}
	
	public final  SIPDate  sip_date() throws RecognitionException, TokenStreamException {
		 SIPDate d ;
		
		
		d=rfc1123date();
		return d ;
	}
	
	public final  String  encryption_scheme() throws RecognitionException, TokenStreamException {
		 String s ;
		
		
		s=ttoken();
		return s ;
	}
	
	public final  NameValue  encryption_params() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		
			nv = new NameValue();
			String n;
			String v;
			startTracking();
		
		
		n=ttoken();
		{
		_loop246:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop246;
			}
			}
		} while (true);
		}
		match(EQUALS);
		{
		_loop248:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop248;
			}
			}
		} while (true);
		}
		v=quoted_string_or_ttoken();
		if ( inputState.guessing==0 ) {
			
				nv.setName(n);
				nv.setValue(v);
				nv.setInputText(stopTracking());
			
		}
		return nv ;
	}
	
	public final  String  quoted_string_or_ttoken() throws RecognitionException, TokenStreamException {
		 String s ;
		
		
		switch ( LA(1)) {
		case DOUBLEQUOTE:
		{
			s=quoted_string();
			break;
		}
		case ALPHA:
		case DIGIT:
		case UNDERSCORE:
		case PLUS:
		case MINUS:
		case QUOTE:
		case EXCLAMATION:
		case PERCENT:
		case TILDE:
		case BACK_QUOTE:
		case STAR:
		case DOT:
		{
			s=ttoken();
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		return s ;
	}
	
	public final  String  quoted_string() throws RecognitionException, TokenStreamException {
		 String qs ;
		
		
			qs = "";
		
		
		match(DOUBLEQUOTE);
		if ( inputState.guessing==0 ) {
			
				pushLexer("charLexer");
				Token tok = null;
				while(true) {
					tok = LT(1);
					consume();
					if (tok == null) throw 
						new TokenStreamException("Invalid quoted string");
					if (tok.getType() == charLexerTokenTypes.BACKSLASH) {
						// Skip over escape sequences.
						qs += tok.getText();
						tok = LT(1); 
						consume();
						qs += tok.getText();
					} else if (tok.getType() == DOUBLEQUOTE) {
						break;
					} else {
						qs += tok.getText();
					}
				}
				// If tracking is enabled, then track the input string.
				track(qs + tok.getText());
				popLexer();
			
		}
		return qs ;
	}
	
	public final  SIPDateOrDeltaSeconds   date_or_delta_seconds() throws RecognitionException, TokenStreamException {
		 SIPDateOrDeltaSeconds  e ;
		
		
		{
		switch ( LA(1)) {
		case MON:
		case TUE:
		case WED:
		case THU:
		case FRI:
		case SAT:
		case SUN:
		{
			e=sip_date();
			break;
		}
		case DIGIT:
		{
			e=delta_seconds();
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		return e ;
	}
	
	public final  String   tag_param() throws RecognitionException, TokenStreamException {
		 String  s ;
		
		
		match(TAG);
		if ( inputState.guessing==0 ) {
			selectLexer("charLexer");
		}
		{
		_loop312:
		do {
			if ((LA(1)==SP)) {
				match(SP);
			}
			else if ((LA(1)==HT)) {
				match(HT);
			}
			else {
				break _loop312;
			}
			
		} while (true);
		}
		{
		_loop314:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop314;
			}
			}
		} while (true);
		}
		match(EQUALS);
		{
		_loop316:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop316;
			}
			}
		} while (true);
		}
		s=ttoken();
		return s ;
	}
	
	public final  NameValue  addr_extension() throws RecognitionException, TokenStreamException {
		 NameValue ae ;
		
		
		ae=generic_param();
		return ae ;
	}
	
	public final  NameValue  extension_params() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		Token  t = null;
		
			nv = new NameValue();
			String n;
			String v = null;
			startTracking();
		
		
		t = LT(1);
		match(ID);
		{
		switch ( LA(1)) {
		case SP:
		case HT:
		case EQUALS:
		{
			{
			_loop268:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop268;
				}
				}
			} while (true);
			}
			match(EQUALS);
			if ( inputState.guessing==0 ) {
				selectLexer("charLexer");
			}
			{
			_loop270:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop270;
				}
				}
			} while (true);
			}
			v=extension_value();
			break;
		}
		case EOF:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			
				nv.setName(t.getText());
				nv.setValue(v);
				nv.setInputText(stopTracking());
			
		}
		return nv ;
	}
	
	public final  String  extension_value() throws RecognitionException, TokenStreamException {
		 String v ;
		
		
		v=ttoken();
		return v ;
	}
	
	public final  Address  name_addr() throws RecognitionException, TokenStreamException {
		 Address a ;
		
		
			String d = null;
			URI    u;
		a = new Address();
			startTracking();
		
		
		{
		switch ( LA(1)) {
		case LESS_THAN:
		{
			match(LESS_THAN);
			if ( inputState.guessing==0 ) {
				selectLexer("sip_urlLexer", sip_urlLexer.INIT_STATE);
			}
			u=addr_spec();
			match(GREATER_THAN);
			break;
		}
		case SP:
		case HT:
		case DOUBLEQUOTE:
		case ID:
		case SIP:
		{
			d=display_name();
			{
			_loop749:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop749;
				}
				}
			} while (true);
			}
			match(LESS_THAN);
			if ( inputState.guessing==0 ) {
				selectLexer("sip_urlLexer", sip_urlLexer.INIT_STATE);
			}
			u=addr_spec();
			match(GREATER_THAN);
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			
			a.setDisplayName(d);
			a.setAddrSpec(u);
			a.setAddressType(Address.NAME_ADDR); 
			a.setInputText(stopTracking());
			
		}
		return a ;
	}
	
	public final  double  delay() throws RecognitionException, TokenStreamException {
		 double f ;
		
		
		f=fpnum();
		return f ;
	}
	
	public final  Accept  accept_args() throws RecognitionException, TokenStreamException {
		 Accept a ;
		
		
			a = new Accept();
			MediaRange m ;
			AcceptParams p = null;
			startTracking();
		
		
		m=media_range();
		{
		switch ( LA(1)) {
		case SEMICOLON:
		{
			match(SEMICOLON);
			if ( inputState.guessing==0 ) {
				selectLexer("accept_languageLexer");
			}
			p=accept_params();
			break;
		}
		case SP:
		case HT:
		case RETURN:
		case COMMA:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			
				a.setMediaRange(m);
				a.setAcceptParams(p);
				a.setInputText(stopTracking());
			
		}
		return a ;
	}
	
	public final  MediaRange  media_range() throws RecognitionException, TokenStreamException {
		 MediaRange r ;
		
		
			r = new MediaRange();
			NameValue nv;
			String t;
			String s;
			startTracking();
		
		
		t=type();
		match(SLASH);
		s=subtype();
		{
		_loop332:
		do {
			if ((LA(1)==SP)) {
				match(SP);
			}
			else if ((LA(1)==HT)) {
				match(HT);
			}
			else {
				break _loop332;
			}
			
		} while (true);
		}
		{
		if ((LA(1)==SEMICOLON)) {
			{
			int _cnt341=0;
			_loop341:
			do {
				boolean synPredMatched336 = false;
				if (((LA(1)==SEMICOLON))) {
					int _m336 = mark();
					synPredMatched336 = true;
					inputState.guessing++;
					try {
						{
						match(SEMICOLON);
						}
					}
					catch (RecognitionException pe) {
						synPredMatched336 = false;
					}
					rewind(_m336);
					inputState.guessing--;
				}
				if ( synPredMatched336 ) {
					match(SEMICOLON);
					{
					_loop338:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop338;
						}
						}
					} while (true);
					}
					nv=parameter();
					if ( inputState.guessing==0 ) {
						r.getParameter().add(nv);
					}
					{
					_loop340:
					do {
						if ((LA(1)==SP)) {
							match(SP);
						}
						else if ((LA(1)==HT)) {
							match(HT);
						}
						else {
							break _loop340;
						}
						
					} while (true);
					}
				}
				else {
					if ( _cnt341>=1 ) { break _loop341; } else {throw new NoViableAltException(LT(1), getFilename());}
				}
				
				_cnt341++;
			} while (true);
			}
		}
		else if ((_tokenSet_3.member(LA(1)))) {
		}
		else {
			throw new NoViableAltException(LT(1), getFilename());
		}
		
		}
		if ( inputState.guessing==0 ) {
			
			r.setType(t); 
			r.setSubtype(s);  
			r.setInputText(stopTracking()); 
			if (r.getType().compareTo("*") == 0  && 
					r.getSubtype().compareTo("*")  != 0) {
				throw new RecognitionException ("bad media range spec");
			}
			if (r.getSubtype().compareTo("*") == 0 &&  r.getParameter().isEmpty()) {
				throw new RecognitionException ("bad media range spec");
			}
			
		}
		return r ;
	}
	
	public final AcceptParams  accept_params() throws RecognitionException, TokenStreamException {
		AcceptParams p ;
		
		
			p = new AcceptParams();
			double qv;
			NameValue ex = null;
			startTracking();
		
		
		match(Q);
		match(EQUALS);
		qv=qvalue();
		{
		_loop352:
		do {
			boolean synPredMatched351 = false;
			if (((LA(1)==SEMICOLON))) {
				int _m351 = mark();
				synPredMatched351 = true;
				inputState.guessing++;
				try {
					{
					match(SEMICOLON);
					}
				}
				catch (RecognitionException pe) {
					synPredMatched351 = false;
				}
				rewind(_m351);
				inputState.guessing--;
			}
			if ( synPredMatched351 ) {
				match(SEMICOLON);
				ex=accept_extension();
				if ( inputState.guessing==0 ) {
					p.addExtension(ex);
				}
			}
			else {
				break _loop352;
			}
			
		} while (true);
		}
		if ( inputState.guessing==0 ) {
			
				p.setQValue(qv);
				p.setInputText(stopTracking());
			
		}
		return p ;
	}
	
	public final  String  type() throws RecognitionException, TokenStreamException {
		 String t ;
		
		
		t=ttoken();
		return t ;
	}
	
	public final  String  subtype() throws RecognitionException, TokenStreamException {
		 String s ;
		
		
		s=ttoken();
		return s ;
	}
	
	public final  NameValue  parameter() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		
			nv = new NameValue();
			startTracking();
			String n;
			String v;
			
		
		
		n=attribute();
		{
		_loop345:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop345;
			}
			}
		} while (true);
		}
		match(EQUALS);
		{
		_loop347:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop347;
			}
			}
		} while (true);
		}
		v=value();
		if ( inputState.guessing==0 ) {
			
				nv.setName(n);
				nv.setValue(v);
				nv.setInputText(stopTracking());
			
			
		}
		return nv ;
	}
	
	public final  String  attribute() throws RecognitionException, TokenStreamException {
		 String s ;
		
		
		s=ttoken();
		return s ;
	}
	
	public final  String  value() throws RecognitionException, TokenStreamException {
		 String s ;
		
		
		s=quoted_string_or_ttoken();
		return s ;
	}
	
	public final  NameValue  accept_extension() throws RecognitionException, TokenStreamException {
		 NameValue ex ;
		
		
			String n = null;
			String v = null;
			ex = null;
			startTracking();
		
		
		
		n=ttoken();
		{
		_loop355:
		do {
			if ((LA(1)==SP)) {
				match(SP);
			}
			else if ((LA(1)==HT)) {
				match(HT);
			}
			else {
				break _loop355;
			}
			
		} while (true);
		}
		{
		switch ( LA(1)) {
		case EQUALS:
		{
			match(EQUALS);
			{
			_loop360:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop360;
				}
				}
			} while (true);
			}
			v=quoted_string_or_ttoken();
			break;
		}
		case SP:
		case HT:
		case RETURN:
		case SEMICOLON:
		case COMMA:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			
				ex = new NameValue();
				ex.setName(n);
				ex.setValue(v);
				ex.setInputText(stopTracking());
			
		}
		return ex ;
	}
	
	public final  Via  via_body() throws RecognitionException, TokenStreamException {
		 Via v ;
		
		
			v = new Via();
			Protocol p;
			NameValue  vp;
			String comm;
			HostPort s ;
			startTracking();
		
		
		p=sent_protocol();
		{
		int _cnt372=0;
		_loop372:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				if ( _cnt372>=1 ) { break _loop372; } else {throw new NoViableAltException(LT(1), getFilename());}
			}
			}
			_cnt372++;
		} while (true);
		}
		s=sent_by();
		{
		_loop374:
		do {
			if ((LA(1)==SP)) {
				match(SP);
			}
			else if ((LA(1)==HT)) {
				match(HT);
			}
			else {
				break _loop374;
			}
			
		} while (true);
		}
		{
		_loop380:
		do {
			if ((LA(1)==SEMICOLON)) {
				match(SEMICOLON);
				if ( inputState.guessing==0 ) {
					selectLexer("via_parmsLexer"); parserMain.initLexer();
				}
				{
				_loop377:
				do {
					switch ( LA(1)) {
					case SP:
					{
						match(SP);
						break;
					}
					case HT:
					{
						match(HT);
						break;
					}
					default:
					{
						break _loop377;
					}
					}
				} while (true);
				}
				vp=via_params();
				if ( inputState.guessing==0 ) {
					v.getViaParms().add(vp);
				}
				{
				_loop379:
				do {
					if ((LA(1)==SP)) {
						match(SP);
					}
					else if ((LA(1)==HT)) {
						match(HT);
					}
					else {
						break _loop379;
					}
					
				} while (true);
				}
			}
			else {
				break _loop380;
			}
			
		} while (true);
		}
		{
		switch ( LA(1)) {
		case LPAREN:
		{
			comm=comment();
			if ( inputState.guessing==0 ) {
				v.setComment(comm);
			}
			{
			_loop383:
			do {
				if ((LA(1)==SP)) {
					match(SP);
				}
				else if ((LA(1)==HT)) {
					match(HT);
				}
				else {
					break _loop383;
				}
				
			} while (true);
			}
			break;
		}
		case SP:
		case HT:
		case RETURN:
		case COMMA:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			
				v.setSentProtocol(p);
				v.setSentBy(s);
				v.setInputText(stopTracking());
			
		}
		return v ;
	}
	
	public final  Protocol  sent_protocol() throws RecognitionException, TokenStreamException {
		 Protocol p ;
		
		
			String n;
			String v;
			String t;
			p  = new Protocol();
			startTracking();
		
		
		n=protocol_name();
		{
		_loop386:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop386;
			}
			}
		} while (true);
		}
		match(SLASH);
		{
		_loop388:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop388;
			}
			}
		} while (true);
		}
		v=protocol_version();
		{
		_loop390:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop390;
			}
			}
		} while (true);
		}
		match(SLASH);
		{
		_loop392:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop392;
			}
			}
		} while (true);
		}
		t=transport();
		if ( inputState.guessing==0 ) {
			
				p.setProtocolName(n);
				p.setProtocolVersion(v);
				p.setTransport(t);
				p.setInputText(stopTracking());
			
		}
		return p ;
	}
	
	public final  HostPort  sent_by() throws RecognitionException, TokenStreamException {
		 HostPort h ;
		
		
			h = null;
		
		
		h=host_port();
		return h ;
	}
	
	public final  NameValue  via_params() throws RecognitionException, TokenStreamException {
		 NameValue v ;
		
		
		switch ( LA(1)) {
		case HIDDEN:
		{
			v=via_hidden();
			break;
		}
		case TTL:
		{
			v=via_ttl();
			break;
		}
		case MADDR:
		{
			v=via_maddr();
			break;
		}
		case RECEIVED:
		{
			v=via_received();
			break;
		}
		case BRANCH:
		{
			v=via_branch();
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		return v ;
	}
	
	public final  String  comment() throws RecognitionException, TokenStreamException {
		 String c ;
		
		
			c = null;
		
		
		match(LPAREN);
		if ( inputState.guessing==0 ) {
			
				// Returns the comment string excluding the parenthesis at the ends.
				// nested comments are allowed.
				pushLexer("charLexer");
				int  counter = 1;
				c = "";
				Token tok = null;
				while(true) {
				  tok = LT(1);
				  if (tok == null) 
					throw new RecognitionException("Unterminated Comment");
				  consume();
				  if (tok.getType() == LPAREN) {
					c += tok.getText();
					counter++;
				  } else if (tok.getType() == charLexerTokenTypes.BACKSLASH) {
					c += tok.getText();
					tok = LT(1);
					consume();
					c += tok.getText();
				  } else if ( tok.getType() == RPAREN) {
					counter -- ;
					if (counter == 0 ) break;
					c += tok.getText();
				  }
				}
				track( c + tok.getText());
				popLexer();
			
		}
		return c ;
	}
	
	public final  String  protocol_name() throws RecognitionException, TokenStreamException {
		 String s ;
		
		
		s=ttoken();
		if ( inputState.guessing==0 ) {
			/* TODO "SIP" is a special case - need to handle in code */
		}
		return s ;
	}
	
	public final  String  protocol_version() throws RecognitionException, TokenStreamException {
		 String s ;
		
		
		s=ttoken();
		return s ;
	}
	
	public final  String  transport() throws RecognitionException, TokenStreamException {
		 String s ;
		
		
		s=ttoken();
		if ( inputState.guessing==0 ) {
			
			if (s.compareToIgnoreCase(SIPKeywords.TCP) != 0 
				&& s.compareToIgnoreCase(SIPKeywords.UDP) != 0 ) {
				throw new RecognitionException("Invalid Transport String " + s);
			}
			
		}
		return s ;
	}
	
	public final HostPort  host_port() throws RecognitionException, TokenStreamException {
		HostPort hostPort;
		
		
		
			hostPort = new HostPort();
			hostPort.setHost(null);
			Host h;
			int p =  0;
			startTracking();
		
		
		h=host();
		{
		switch ( LA(1)) {
		case COLON:
		{
			{
			match(COLON);
			p=port();
			}
			if ( inputState.guessing==0 ) {
				hostPort.setPort(p);
			}
			break;
		}
		case SP:
		case HT:
		case RETURN:
		case LPAREN:
		case POUND:
		case SEMICOLON:
		case SLASH:
		case QUESTION:
		case COMMA:
		case GREATER_THAN:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			
				hostPort.setHost(h);
				hostPort.setInputText(stopTracking());
			
		}
		return hostPort;
	}
	
	public final  NameValue  via_hidden() throws RecognitionException, TokenStreamException {
		 NameValue v ;
		
		
			v = null;
			startTracking();
		
		
		match(HIDDEN);
		if ( inputState.guessing==0 ) {
			
				v = new NameValue(ViaKeywords.HIDDEN, new Boolean(true));
				v.setInputText(stopTracking());
			
		}
		return v ;
	}
	
	public final  NameValue  via_ttl() throws RecognitionException, TokenStreamException {
		 NameValue v ;
		
		
			int t;
			v = null;
			startTracking();
		
		
		match(TTL);
		{
		_loop401:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop401;
			}
			}
		} while (true);
		}
		match(EQUALS);
		{
		_loop403:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop403;
			}
			}
		} while (true);
		}
		t=ttl_val();
		if ( inputState.guessing==0 ) {
			
				v = new NameValue(ViaKeywords.TTL, new Integer(t));
				v.setInputText(stopTracking());
			
		}
		return v ;
	}
	
	public final  NameValue  via_maddr() throws RecognitionException, TokenStreamException {
		 NameValue v ;
		
		
			v =  null;
			Host h;
			startTracking();
		
		
		match(MADDR);
		{
		_loop409:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop409;
			}
			}
		} while (true);
		}
		match(EQUALS);
		{
		_loop411:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop411;
			}
			}
		} while (true);
		}
		h=host();
		if ( inputState.guessing==0 ) {
			
				v = new NameValue(ViaKeywords.MADDR,h);
				v.setInputText(stopTracking());
			
		}
		return v ;
	}
	
	public final  NameValue  via_received() throws RecognitionException, TokenStreamException {
		 NameValue v ;
		
		
			v = null;
			String s;
			startTracking();
		
		
		match(RECEIVED);
		{
		_loop414:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop414;
			}
			}
		} while (true);
		}
		match(EQUALS);
		{
		_loop416:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop416;
			}
			}
		} while (true);
		}
		s=ttoken();
		if ( inputState.guessing==0 ) {
			
				v  = new NameValue(ViaKeywords.RECEIVED, s);
				v.setInputText(stopTracking());
			
		}
		return v ;
	}
	
	public final  NameValue  via_branch() throws RecognitionException, TokenStreamException {
		 NameValue v ;
		
		
			v = null;
			String s;
			startTracking();
		
		
		match(BRANCH);
		{
		_loop419:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop419;
			}
			}
		} while (true);
		}
		match(EQUALS);
		{
		_loop421:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop421;
			}
			}
		} while (true);
		}
		s=ttoken();
		if ( inputState.guessing==0 ) {
			
				v  = new NameValue(ViaKeywords.BRANCH,s);
				v.setInputText(stopTracking());
			
		}
		return v ;
	}
	
	public final  int  ttl_val() throws RecognitionException, TokenStreamException {
		 int ttl ;
		
		Token  d1 = null;
		
		ttl = 0;
		String result = "";
		
		
		{
		int _cnt406=0;
		_loop406:
		do {
			if ((LA(1)==DIGIT)) {
				d1 = LT(1);
				match(DIGIT);
				if ( inputState.guessing==0 ) {
					result += d1.getText();
				}
			}
			else {
				if ( _cnt406>=1 ) { break _loop406; } else {throw new NoViableAltException(LT(1), getFilename());}
			}
			
			_cnt406++;
		} while (true);
		}
		if ( inputState.guessing==0 ) {
			
				ttl = Integer.parseInt(result);
			
		}
		return ttl ;
	}
	
	public final  Host  host() throws RecognitionException, TokenStreamException {
		 Host hostID ;
		
		
			hostID = null;
			String hname;
			boolean isIPV4;
			startTracking();
			// scan ahead and see if this is an ipv4 address
			int nints = 0;
			int k = 1;
			while(LA(k) == DIGIT) {
			    if (LA(k + 1) == DIGIT) k++;
			    else if (LA(k+1) == DOT) {
				 k += 2; // skip over the dot.
				 nints ++;
			    } else {
				nints ++;
				break;
			    }
			}
			// should have seen 4 digits (eg. 129.6.55.62
			// If so set the semantic lookahed flag....
			if (nints == 4) isIPV4 = true;
			else isIPV4 = false;
			
		
		
		if (((LA(1)==DIGIT))&&( isIPV4 )) {
			{
			hname=ipv4_address();
			if ( inputState.guessing==0 ) {
				
				
				hostID = new Host(hname,HostAddrTypes.IPV4ADDRESS);
				hostID.setInputText(stopTracking());
				
			}
			}
		}
		else if ((LA(1)==ALPHA||LA(1)==DIGIT||LA(1)==MINUS)) {
			hname=hostname();
			if ( inputState.guessing==0 ) {
				
				hostID = new Host(hname,HostAddrTypes.HOSTNAME);
				hostID.setInputText(stopTracking());
				
			}
		}
		else {
			throw new NoViableAltException(LT(1), getFilename());
		}
		
		return hostID ;
	}
	
	public final  Authorization  auth_body() throws RecognitionException, TokenStreamException {
		 Authorization auth ;
		
		
			String cookie;
			auth  = new Authorization();
			startTracking();
			Credentials cr;
			NameValue nv;
		
		
		{
		switch ( LA(1)) {
		case BASIC:
		{
			match(BASIC);
			{
			int _cnt439=0;
			_loop439:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					if ( _cnt439>=1 ) { break _loop439; } else {throw new NoViableAltException(LT(1), getFilename());}
				}
				}
				_cnt439++;
			} while (true);
			}
			cookie=basic_cookie();
			if ( inputState.guessing==0 ) {
				
					auth.setScheme(AuthorizationKeywords.BASIC);
					nv = new NameValue();
					nv.setName(AuthorizationKeywords.PASSWORD);
					nv.setValue(cookie);
					nv.setInputText(SIPKeywords.PASSWORD + " = " + cookie);
					auth.getCredentials().add(nv);
				
				
			}
			break;
		}
		case PGP:
		{
			match(PGP);
			if ( inputState.guessing==0 ) {
				auth.setScheme(AuthorizationKeywords.PGP);
			}
			{
			int _cnt443=0;
			_loop443:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					if ( _cnt443>=1 ) { break _loop443; } else {throw new NoViableAltException(LT(1), getFilename());}
				}
				}
				_cnt443++;
			} while (true);
			}
			nv=pgp_response();
			if ( inputState.guessing==0 ) {
				auth.addParam(nv);
			}
			{
			_loop445:
			do {
				if ((LA(1)==SP)) {
					match(SP);
				}
				else if ((LA(1)==HT)) {
					match(HT);
				}
				else {
					break _loop445;
				}
				
			} while (true);
			}
			{
			_loop453:
			do {
				boolean synPredMatched448 = false;
				if (((LA(1)==COMMA))) {
					int _m448 = mark();
					synPredMatched448 = true;
					inputState.guessing++;
					try {
						{
						match(COMMA);
						}
					}
					catch (RecognitionException pe) {
						synPredMatched448 = false;
					}
					rewind(_m448);
					inputState.guessing--;
				}
				if ( synPredMatched448 ) {
					match(COMMA);
					{
					_loop450:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop450;
						}
						}
					} while (true);
					}
					nv=pgp_response();
					if ( inputState.guessing==0 ) {
						auth.addParam(nv);
					}
					{
					_loop452:
					do {
						if ((LA(1)==SP)) {
							match(SP);
						}
						else if ((LA(1)==HT)) {
							match(HT);
						}
						else {
							break _loop452;
						}
						
					} while (true);
					}
				}
				else {
					break _loop453;
				}
				
			} while (true);
			}
			break;
		}
		case DIGEST:
		{
			match(DIGEST);
			if ( inputState.guessing==0 ) {
				auth.setScheme(AuthorizationKeywords.DIGEST);
			}
			{
			int _cnt457=0;
			_loop457:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					if ( _cnt457>=1 ) { break _loop457; } else {throw new NoViableAltException(LT(1), getFilename());}
				}
				}
				_cnt457++;
			} while (true);
			}
			nv=digest_response();
			if ( inputState.guessing==0 ) {
				auth.addParam(nv);
			}
			{
			_loop459:
			do {
				if ((LA(1)==SP)) {
					match(SP);
				}
				else if ((LA(1)==HT)) {
					match(HT);
				}
				else {
					break _loop459;
				}
				
			} while (true);
			}
			{
			_loop467:
			do {
				boolean synPredMatched462 = false;
				if (((LA(1)==COMMA))) {
					int _m462 = mark();
					synPredMatched462 = true;
					inputState.guessing++;
					try {
						{
						match(COMMA);
						}
					}
					catch (RecognitionException pe) {
						synPredMatched462 = false;
					}
					rewind(_m462);
					inputState.guessing--;
				}
				if ( synPredMatched462 ) {
					match(COMMA);
					{
					_loop464:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop464;
						}
						}
					} while (true);
					}
					nv=digest_response();
					if ( inputState.guessing==0 ) {
						auth.addParam(nv);
					}
					{
					_loop466:
					do {
						if ((LA(1)==SP)) {
							match(SP);
						}
						else if ((LA(1)==HT)) {
							match(HT);
						}
						else {
							break _loop466;
						}
						
					} while (true);
					}
				}
				else {
					break _loop467;
				}
				
			} while (true);
			}
			break;
		}
		case ID:
		{
			cr=credentials();
			if ( inputState.guessing==0 ) {
				auth.setScheme(cr.getScheme()); auth.setCredentials(cr.getCredentials());
			}
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			
				auth.setInputText(stopTracking()); 
			
		}
		return auth ;
	}
	
	public final  String  basic_cookie() throws RecognitionException, TokenStreamException {
		 String s ;
		
		
		s=base64string();
		return s ;
	}
	
	public final  NameValue  pgp_response() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		nv = null;  startTracking();
		
		{
		switch ( LA(1)) {
		case REALM:
		{
			nv=realm();
			break;
		}
		case VERSION:
		{
			nv=pgp_version();
			break;
		}
		case SIGNATURE:
		{
			nv=pgp_signature();
			break;
		}
		case SIGNED_BY:
		{
			nv=signed_by();
			break;
		}
		case NONCE:
		{
			nv=nonce();
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			nv.setInputText(stopTracking());
		}
		return nv ;
	}
	
	public final  NameValue  digest_response() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		
		nv = null; 
		parserMain.setEnclosingLexer("digest_Lexer"); 
		
		
		switch ( LA(1)) {
		case USERNAME:
		{
			nv=username();
			break;
		}
		case URI:
		{
			nv=digest_uri();
			break;
		}
		case QOP:
		{
			nv=qop_value();
			break;
		}
		case STALE:
		{
			nv=stale();
			break;
		}
		case ALGORITHM:
		{
			nv=algorithm();
			break;
		}
		case DOMAIN:
		{
			nv=domain();
			break;
		}
		case RESPONSE:
		{
			nv=dresponse();
			break;
		}
		case NC:
		{
			nv=noncecount();
			break;
		}
		case NONCE:
		{
			nv=nonce();
			break;
		}
		case CNONCE:
		{
			nv=cnonce();
			break;
		}
		case REALM:
		{
			nv=realm();
			break;
		}
		case OPAQUE:
		{
			nv=opaque();
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		return nv ;
	}
	
	public final  Credentials  credentials() throws RecognitionException, TokenStreamException {
		 Credentials creds ;
		
		Token  t = null;
		
			creds = new Credentials();
			String s ;
			NameValue nv;
			startTracking();
		
		
		t = LT(1);
		match(ID);
		{
		if ((LA(1)==SP||LA(1)==HT)) {
			{
			int _cnt511=0;
			_loop511:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					if ( _cnt511>=1 ) { break _loop511; } else {throw new NoViableAltException(LT(1), getFilename());}
				}
				}
				_cnt511++;
			} while (true);
			}
			nv=auth_params();
			{
			_loop519:
			do {
				boolean synPredMatched514 = false;
				if (((LA(1)==COMMA))) {
					int _m514 = mark();
					synPredMatched514 = true;
					inputState.guessing++;
					try {
						{
						match(COMMA);
						}
					}
					catch (RecognitionException pe) {
						synPredMatched514 = false;
					}
					rewind(_m514);
					inputState.guessing--;
				}
				if ( synPredMatched514 ) {
					match(COMMA);
					{
					_loop516:
					do {
						switch ( LA(1)) {
						case SP:
						{
							match(SP);
							break;
						}
						case HT:
						{
							match(HT);
							break;
						}
						default:
						{
							break _loop516;
						}
						}
					} while (true);
					}
					nv=auth_params();
					{
					_loop518:
					do {
						if ((LA(1)==SP)) {
							match(SP);
						}
						else if ((LA(1)==HT)) {
							match(HT);
						}
						else {
							break _loop518;
						}
						
					} while (true);
					}
					if ( inputState.guessing==0 ) {
						creds.getCredentials().add(nv);
					}
				}
				else {
					break _loop519;
				}
				
			} while (true);
			}
		}
		else if ((LA(1)==SP||LA(1)==HT||LA(1)==RETURN)) {
		}
		else {
			throw new NoViableAltException(LT(1), getFilename());
		}
		
		}
		if ( inputState.guessing==0 ) {
			
			creds.setScheme(t.getText());
			creds.setInputText(stopTracking());
			
		}
		return creds ;
	}
	
	public final  NameValue  username() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		String u = null;  nv = null;
		
		match(USERNAME);
		{
		_loop476:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop476;
			}
			}
		} while (true);
		}
		match(EQUALS);
		{
		_loop478:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop478;
			}
			}
		} while (true);
		}
		u=quoted_string();
		if ( inputState.guessing==0 ) {
			nv = new NameValue(AuthorizationKeywords.USERNAME,u);
		}
		return nv ;
	}
	
	public final  NameValue  digest_uri() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		nv = null;  String u;
		
		match(URI);
		{
		_loop481:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop481;
			}
			}
		} while (true);
		}
		match(EQUALS);
		{
		_loop483:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop483;
			}
			}
		} while (true);
		}
		u=quoted_string();
		if ( inputState.guessing==0 ) {
			nv = new NameValue(AuthorizationKeywords.URI,u);
		}
		return nv ;
	}
	
	public final  NameValue  qop_value() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		
			startTracking();
			String t;
			nv = null;
		
		
		match(QOP);
		{
		_loop825:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop825;
			}
			}
		} while (true);
		}
		match(EQUALS);
		{
		_loop827:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop827;
			}
			}
		} while (true);
		}
		t=quoted_string();
		if ( inputState.guessing==0 ) {
			
				nv = new NameValue(SIPKeywords.QOP, t);
				nv.setInputText(stopTracking());
			
		}
		return nv ;
	}
	
	public final  NameValue  stale() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		
			startTracking();
			String t = null;
			nv = null;
		
		
		match(STALE);
		{
		_loop840:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop840;
			}
			}
		} while (true);
		}
		match(EQUALS);
		{
		_loop842:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop842;
			}
			}
		} while (true);
		}
		t=ttoken();
		if ( inputState.guessing==0 ) {
			
				if (t.toLowerCase().compareTo("true") != 0 &&
				    t.toLowerCase().compareTo("false") != 0 ) {
					throw new RecognitionException("Expecting true or false");
				}
				nv = new NameValue(SIPKeywords.STALE,t.toLowerCase());
				nv.setInputText(stopTracking());
			
		}
		return nv ;
	}
	
	public final  NameValue  algorithm() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		
			nv = new NameValue();
			startTracking();
			String s;
		
		
		match(ALGORITHM);
		{
		_loop777:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop777;
			}
			}
		} while (true);
		}
		match(EQUALS);
		{
		_loop779:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop779;
			}
			}
		} while (true);
		}
		s=ttoken();
		if ( inputState.guessing==0 ) {
			
				nv.setName(SIPKeywords.ALGORITHM);
				nv.setValue(s);
				nv.setInputText(stopTracking());
			
		}
		return nv ;
	}
	
	public final  NameValue  domain() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		
			startTracking(); 
			String t;
			nv = null;
		
		
		match(DOMAIN);
		{
		_loop835:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop835;
			}
			}
		} while (true);
		}
		match(EQUALS);
		{
		_loop837:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop837;
			}
			}
		} while (true);
		}
		t=quoted_string();
		if ( inputState.guessing==0 ) {
			
			nv  = new NameValue(SIPKeywords.DOMAIN, t); 
			nv.setInputText(stopTracking());
			
		}
		return nv ;
	}
	
	public final  NameValue  dresponse() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		nv = null;  String u;
		
		match(RESPONSE);
		{
		_loop486:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop486;
			}
			}
		} while (true);
		}
		match(EQUALS);
		{
		_loop488:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop488;
			}
			}
		} while (true);
		}
		u=quoted_string();
		if ( inputState.guessing==0 ) {
			nv = new NameValue(AuthorizationKeywords.RESPONSE,u);
		}
		return nv ;
	}
	
	public final  NameValue  noncecount() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		nv = null;  String u;  String nc = "";
		
		match(NC);
		{
		_loop491:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop491;
			}
			}
		} while (true);
		}
		match(EQUALS);
		{
		_loop493:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop493;
			}
			}
		} while (true);
		}
		{
		int _cnt495=0;
		_loop495:
		do {
			if ((LA(1)==ALPHA||LA(1)==DIGIT)) {
				u=hexdigit();
				if ( inputState.guessing==0 ) {
					nc += u;
				}
			}
			else {
				if ( _cnt495>=1 ) { break _loop495; } else {throw new NoViableAltException(LT(1), getFilename());}
			}
			
			_cnt495++;
		} while (true);
		}
		if ( inputState.guessing==0 ) {
			nv = new NameValue(AuthorizationKeywords.NC,nc);
		}
		return nv ;
	}
	
	public final  NameValue  nonce() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		
			nv = new NameValue();
			String s;
			startTracking();
		
		
		match(NONCE);
		{
		_loop782:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop782;
			}
			}
		} while (true);
		}
		match(EQUALS);
		{
		_loop784:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop784;
			}
			}
		} while (true);
		}
		s=quoted_string();
		if ( inputState.guessing==0 ) {
			
				nv.setName(SIPKeywords.NONCE);
				nv.setValue(s);
				nv.setInputText(stopTracking());
			
		}
		return nv ;
	}
	
	public final  NameValue  cnonce() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		String u = null;  nv = null;
		
		match(CNONCE);
		{
		_loop471:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop471;
			}
			}
		} while (true);
		}
		match(EQUALS);
		{
		_loop473:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop473;
			}
			}
		} while (true);
		}
		u=ttoken();
		if ( inputState.guessing==0 ) {
			nv = new NameValue(AuthorizationKeywords.CNONCE,u);
		}
		return nv ;
	}
	
	public final  NameValue  realm() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		
			nv = new NameValue();
			String rv;
		
		
		match(REALM);
		{
		_loop863:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop863;
			}
			}
		} while (true);
		}
		match(EQUALS);
		{
		_loop865:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop865;
			}
			}
		} while (true);
		}
		rv=realmvalue();
		if ( inputState.guessing==0 ) {
			
				nv.setName(SIPKeywords.REALM);
				nv.setValue(rv);
			
			
		}
		return nv ;
	}
	
	public final  NameValue  opaque() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		
			startTracking(); 
			String t;
			nv = null;
		
		
		match(OPAQUE);
		{
		_loop830:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop830;
			}
			}
		} while (true);
		}
		match(EQUALS);
		{
		_loop832:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop832;
			}
			}
		} while (true);
		}
		t=quoted_string();
		if ( inputState.guessing==0 ) {
			
			nv  = new NameValue(SIPKeywords.OPAQUE, t); 
			nv.setInputText(stopTracking());
			
		}
		return nv ;
	}
	
	public final  String  hexdigit() throws RecognitionException, TokenStreamException {
		 String s ;
		
		Token  d = null;
		Token  a = null;
		
			s = null;
		
		
		switch ( LA(1)) {
		case DIGIT:
		{
			d = LT(1);
			match(DIGIT);
			if ( inputState.guessing==0 ) {
				s = d.getText();
			}
			break;
		}
		case ALPHA:
		{
			a = LT(1);
			match(ALPHA);
			if ( inputState.guessing==0 ) {
				
					   String t = a.getText() ; 
					   String ttok = t.toUpperCase();
					   char   tok = ttok.charAt(0);
					   if ( tok != 'A' && tok != 'B' && tok != 'C' && tok != 'D' &&
					        tok != 'E' && tok != 'F'   &&
					        tok != 'a' && tok != 'b' && tok != 'c' && tok != 'd' &&
					        tok != 'e' && tok != 'f'   ) {
					         throw new RecognitionException("Bad Hex Number!");
					   }
					   s = a.getText();
					
			}
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		return s ;
	}
	
	public final  NameValue  pgp_version() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		
			startTracking();
			String s = "";
			nv = null;
		
		
		match(VERSION);
		{
		_loop772:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop772;
			}
			}
		} while (true);
		}
		match(EQUALS);
		{
		_loop774:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop774;
			}
			}
		} while (true);
		}
		s=quoted_string();
		if ( inputState.guessing==0 ) {
			
				nv = new NameValue( SIPKeywords.VERSION, s);
				nv.setInputText(stopTracking());
			
		}
		return nv ;
	}
	
	public final  NameValue  pgp_signature() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		
			nv  = new NameValue();
			String s = null;
		
		
		match(SIGNATURE);
		{
		_loop505:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop505;
			}
			}
		} while (true);
		}
		match(EQUALS);
		{
		_loop507:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop507;
			}
			}
		} while (true);
		}
		s=quoted_string();
		if ( inputState.guessing==0 ) {
			
				nv.setName(AuthorizationKeywords.SIGNATURE); 
				nv.setValue(s);
			
		}
		return nv ;
	}
	
	public final  NameValue  signed_by() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		
			String u;
			startTracking();
			nv = null;
		
		
		match(SIGNED_BY);
		{
		_loop500:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop500;
			}
			}
		} while (true);
		}
		match(EQUALS);
		{
		_loop502:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop502;
			}
			}
		} while (true);
		}
		u=quoted_string();
		if ( inputState.guessing==0 ) {
			
				nv = new NameValue(AuthorizationKeywords.SIGNED_BY,u);
				nv.setInputText(stopTracking());
			
		}
		return nv ;
	}
	
	public final  NameValue  auth_params() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		
		nv=generic_param();
		return nv ;
	}
	
	public final  String  base64string() throws RecognitionException, TokenStreamException {
		 String s ;
		
		Token  t = null;
		
			s = "";
			pushLexer("charLexer");
		
		
		s=ttoken();
		{
		_loop1050:
		do {
			if ((LA(1)==EQUALS)) {
				t = LT(1);
				match(EQUALS);
				if ( inputState.guessing==0 ) {
					s += t.getText();
				}
			}
			else {
				break _loop1050;
			}
			
		} while (true);
		}
		if ( inputState.guessing==0 ) {
			
				popLexer();
			
		}
		return s ;
	}
	
	public final  String  string() throws RecognitionException, TokenStreamException {
		 String s ;
		
		
		s=quoted_string_or_ttoken();
		return s ;
	}
	
	public final  Challenge  pgp_challenge() throws RecognitionException, TokenStreamException {
		 Challenge ch ;
		
		
		startTracking();
		ch = new Challenge();
		NameValue c = null;
		
		
		c=pgp_params();
		if ( inputState.guessing==0 ) {
			ch.getAuthParams().add(c);
		}
		{
		_loop851:
		do {
			boolean synPredMatched846 = false;
			if (((LA(1)==COMMA))) {
				int _m846 = mark();
				synPredMatched846 = true;
				inputState.guessing++;
				try {
					{
					match(COMMA);
					}
				}
				catch (RecognitionException pe) {
					synPredMatched846 = false;
				}
				rewind(_m846);
				inputState.guessing--;
			}
			if ( synPredMatched846 ) {
				match(COMMA);
				if ( inputState.guessing==0 ) {
					selectLexer("pgp_Lexer");
				}
				{
				_loop848:
				do {
					switch ( LA(1)) {
					case SP:
					{
						match(SP);
						break;
					}
					case HT:
					{
						match(HT);
						break;
					}
					default:
					{
						break _loop848;
					}
					}
				} while (true);
				}
				c=pgp_params();
				if ( inputState.guessing==0 ) {
					ch.getAuthParams().add(c);
				}
				{
				_loop850:
				do {
					if ((LA(1)==SP)) {
						match(SP);
					}
					else if ((LA(1)==HT)) {
						match(HT);
					}
					else {
						break _loop850;
					}
					
				} while (true);
				}
			}
			else {
				break _loop851;
			}
			
		} while (true);
		}
		if ( inputState.guessing==0 ) {
			
			ch.setScheme(SIPKeywords.PGP);
			ch.setInputText(stopTracking());
			
		}
		return ch ;
	}
	
	public final  Challenge  basic_challenge() throws RecognitionException, TokenStreamException {
		 Challenge ch ;
		
		
			startTracking();
			NameValue r = null;
			String t;
			ch = null;
		
		
		{
		switch ( LA(1)) {
		case REALM:
		{
			r=realm();
			{
			_loop807:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop807;
				}
				}
			} while (true);
			}
			match(COMMA);
			{
			_loop809:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop809;
				}
				}
			} while (true);
			}
			break;
		}
		case ALPHA:
		case DIGIT:
		case UNDERSCORE:
		case PLUS:
		case MINUS:
		case QUOTE:
		case EXCLAMATION:
		case PERCENT:
		case TILDE:
		case BACK_QUOTE:
		case STAR:
		case DOT:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		t=ttoken();
		if ( inputState.guessing==0 ) {
			
				ch = new Challenge();
				ch.setScheme(SIPKeywords.BASIC);
				if (r!= null) ch.setParam(r);
				ch.setParam(new NameValue(SIPKeywords.PASSWORD,t));
				ch.setInputText(stopTracking());
			
			
		}
		return ch ;
	}
	
	public final  Challenge  digest_challenge() throws RecognitionException, TokenStreamException {
		 Challenge ch ;
		
		
			ch = new Challenge() ;  
			ch.setScheme(SIPKeywords.DIGEST);
			NameValue nv; 
			startTracking();
		
		
		nv=digest_param();
		if ( inputState.guessing==0 ) {
			ch.setParam(nv);
		}
		{
		_loop812:
		do {
			if ((LA(1)==SP)) {
				match(SP);
			}
			else if ((LA(1)==HT)) {
				match(HT);
			}
			else {
				break _loop812;
			}
			
		} while (true);
		}
		{
		_loop820:
		do {
			boolean synPredMatched815 = false;
			if (((LA(1)==COMMA))) {
				int _m815 = mark();
				synPredMatched815 = true;
				inputState.guessing++;
				try {
					{
					match(COMMA);
					}
				}
				catch (RecognitionException pe) {
					synPredMatched815 = false;
				}
				rewind(_m815);
				inputState.guessing--;
			}
			if ( synPredMatched815 ) {
				match(COMMA);
				{
				_loop817:
				do {
					switch ( LA(1)) {
					case SP:
					{
						match(SP);
						break;
					}
					case HT:
					{
						match(HT);
						break;
					}
					default:
					{
						break _loop817;
					}
					}
				} while (true);
				}
				nv=digest_param();
				if ( inputState.guessing==0 ) {
					ch.setParam(nv);
				}
				{
				_loop819:
				do {
					if ((LA(1)==SP)) {
						match(SP);
					}
					else if ((LA(1)==HT)) {
						match(HT);
					}
					else {
						break _loop819;
					}
					
				} while (true);
				}
			}
			else {
				break _loop820;
			}
			
		} while (true);
		}
		if ( inputState.guessing==0 ) {
			ch.setInputText(stopTracking());
		}
		return ch ;
	}
	
	public final  Challenge  challenge() throws RecognitionException, TokenStreamException {
		 Challenge c ;
		
		
			c = new Challenge();
			NameValue r = null;
			NameValue ap = null;
			startTracking();
			selectLexer("charLexer");
		
		
		r=realm();
		if ( inputState.guessing==0 ) {
			c.getAuthParams().add(r);
		}
		{
		_loop854:
		do {
			if ((LA(1)==SP)) {
				match(SP);
			}
			else if ((LA(1)==HT)) {
				match(HT);
			}
			else {
				break _loop854;
			}
			
		} while (true);
		}
		{
		_loop860:
		do {
			if ((LA(1)==COMMA)) {
				match(COMMA);
				{
				_loop857:
				do {
					switch ( LA(1)) {
					case SP:
					{
						match(SP);
						break;
					}
					case HT:
					{
						match(HT);
						break;
					}
					default:
					{
						break _loop857;
					}
					}
				} while (true);
				}
				ap=auth_params();
				if ( inputState.guessing==0 ) {
					c.getAuthParams().add(ap);
				}
				{
				_loop859:
				do {
					if ((LA(1)==SP)) {
						match(SP);
					}
					else if ((LA(1)==HT)) {
						match(HT);
					}
					else {
						break _loop859;
					}
					
				} while (true);
				}
			}
			else {
				break _loop860;
			}
			
		} while (true);
		}
		if ( inputState.guessing==0 ) {
			
				c.setInputText(stopTracking());
			
		}
		return c ;
	}
	
	public final  Server  server_body() throws RecognitionException, TokenStreamException {
		 Server s ;
		
		
		startTracking();
		Product p;
		String com;
		s = null;
		
		
		boolean synPredMatched542 = false;
		if (((LA(1)==LPAREN))) {
			int _m542 = mark();
			synPredMatched542 = true;
			inputState.guessing++;
			try {
				{
				match(LPAREN);
				}
			}
			catch (RecognitionException pe) {
				synPredMatched542 = false;
			}
			rewind(_m542);
			inputState.guessing--;
		}
		if ( synPredMatched542 ) {
			com=comment();
			if ( inputState.guessing==0 ) {
				
				s = new Server(); 
				s.setComment(com);
				s.setInputText(stopTracking());
				
			}
		}
		else if ((_tokenSet_0.member(LA(1)))) {
			p=product();
			if ( inputState.guessing==0 ) {
				
				s = new Server();
				s.setProduct(p);
				s.setInputText(stopTracking());
				
			}
		}
		else {
			throw new NoViableAltException(LT(1), getFilename());
		}
		
		return s ;
	}
	
	public final  Product  product() throws RecognitionException, TokenStreamException {
		 Product p ;
		
		
			p = new Product();
			String pt = null;
		
		
		pt=product_token();
		if ( inputState.guessing==0 ) {
			p.setProductToken(pt);
		}
		return p ;
	}
	
	public final  String  product_token() throws RecognitionException, TokenStreamException {
		 String s ;
		
		
		s=byte_string_no_comma();
		return s ;
	}
	
	public final  String  byte_string_no_comma() throws RecognitionException, TokenStreamException {
		 String s ;
		
		Token  d = null;
		
			s = "";
		
		
		d = LT(1);
		matchNot(RETURN);
		if ( inputState.guessing==0 ) {
			
			pushLexer("charLexer");
			while ( true ) {
				s += d.getText();
				d = LT(1);
				if (d == null || d.getType() == Token.EOF_TYPE) {
					throw new RecognitionException("Premature EOF");
				}	
				if (d.getType() == RETURN ) break;
				else if (d.getType() == charLexerTokenTypes.COMMA) break;
				consume();
			}
			track(s);
			popLexer();
			
		}
		return s ;
	}
	
	public final  DeltaSeconds  delta_seconds() throws RecognitionException, TokenStreamException {
		 DeltaSeconds ds ;
		
		Token  d = null;
		
			String s = "";
			int i = 0;
			ds = null;
		
		
		{
		int _cnt869=0;
		_loop869:
		do {
			if ((LA(1)==DIGIT)) {
				d = LT(1);
				match(DIGIT);
				if ( inputState.guessing==0 ) {
					s += d.getText();
				}
			}
			else {
				if ( _cnt869>=1 ) { break _loop869; } else {throw new NoViableAltException(LT(1), getFilename());}
			}
			
			_cnt869++;
		} while (true);
		}
		if ( inputState.guessing==0 ) {
			
				i = Integer.parseInt(s);
				ds = new DeltaSeconds();
				ds.setInputText(s);
				ds.setDeltaSeconds(i);
			
		}
		return ds ;
	}
	
	public final  SIPDateOrDeltaSeconds  date_or_delta_seconds1() throws RecognitionException, TokenStreamException {
		 SIPDateOrDeltaSeconds e;
		
		
			// This is the same as the rule above but there is an extra
			// quote (for some strange reason, the RFC specifies contact
			// headers this way).
		
		
		{
		switch ( LA(1)) {
		case DOUBLEQUOTE:
		{
			match(DOUBLEQUOTE);
			if ( inputState.guessing==0 ) {
				selectLexer("dateLexer");
			}
			e=sip_date();
			match(DOUBLEQUOTE);
			break;
		}
		case DIGIT:
		{
			e=delta_seconds();
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		return e;
	}
	
	public final  SIPDate  rfc1123date() throws RecognitionException, TokenStreamException {
		 SIPDate d ;
		
		
			d = new SIPDate();
			String  w;
			MyDate  d1;
			MyTime  t;
			startTracking();
		
		
		w=wkday();
		match(COMMA);
		match(SP);
		d1=date1();
		match(SP);
		t=time();
		match(SP);
		match(GMT);
		if ( inputState.guessing==0 ) {
			
				d.setInputText(stopTracking());
				try {
					d.setWkday(w);
					d.setDay(d1.day);
					d.setMonth(d1.month);
					d.setYear(d1.year);
					d.setHour(t.hour);
					d.setMinute(t.minute);
					d.setSecond(t.second);
				} catch (IllegalArgumentException ex) {
					throw new RecognitionException("Illegal Date " 
							+ ex.getMessage());
				}
			
		}
		return d ;
	}
	
	public final  String  wkday() throws RecognitionException, TokenStreamException {
		 String w ;
		
		w = null ;
		
		switch ( LA(1)) {
		case MON:
		{
			match(MON);
			if ( inputState.guessing==0 ) {
				w = DateKeywords.MON;
			}
			break;
		}
		case TUE:
		{
			match(TUE);
			if ( inputState.guessing==0 ) {
				w = DateKeywords.TUE;
			}
			break;
		}
		case WED:
		{
			match(WED);
			if ( inputState.guessing==0 ) {
				w = DateKeywords.WED;
			}
			break;
		}
		case THU:
		{
			match(THU);
			if ( inputState.guessing==0 ) {
				w = DateKeywords.THU;
			}
			break;
		}
		case FRI:
		{
			match(FRI);
			if ( inputState.guessing==0 ) {
				w = DateKeywords.FRI;
			}
			break;
		}
		case SAT:
		{
			match(SAT);
			if ( inputState.guessing==0 ) {
				w = DateKeywords.SAT;
			}
			break;
		}
		case SUN:
		{
			match(SUN);
			if ( inputState.guessing==0 ) {
				w = DateKeywords.SUN;
			}
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		return w ;
	}
	
	public final  MyDate  date1() throws RecognitionException, TokenStreamException {
		 MyDate d ;
		
		Token  d1 = null;
		Token  d2 = null;
		Token  d3 = null;
		Token  d4 = null;
		Token  d5 = null;
		Token  d6 = null;
		
			d = new MyDate();
			int day = 0 ;
			int yr = 0;
			String mo;
		
		
		d1 = LT(1);
		match(DIGIT);
		d2 = LT(1);
		match(DIGIT);
		if ( inputState.guessing==0 ) {
			
				day = Integer.parseInt(d1.getText() + d2.getText()); 
			
		}
		match(SP);
		mo=month();
		match(SP);
		d3 = LT(1);
		match(DIGIT);
		d4 = LT(1);
		match(DIGIT);
		d5 = LT(1);
		match(DIGIT);
		d6 = LT(1);
		match(DIGIT);
		if ( inputState.guessing==0 ) {
				
				  yr = Integer.parseInt(d3.getText() + d4.getText() + d5.getText() +
							d6.getText()); 
				  d.day = day;
				  d.month = mo;
				  d.year = yr;
			
		}
		return d ;
	}
	
	public final  MyTime  time() throws RecognitionException, TokenStreamException {
		 MyTime t ;
		
		Token  d1 = null;
		Token  d2 = null;
		Token  d3 = null;
		
			int hr = 0;
			int min = 0;
			int sec = 0;
			t = new MyTime();
			String hr_string = "";
			String min_string = "";
			String sec_string = "";
		
		
		
		{
		int _cnt576=0;
		_loop576:
		do {
			if ((LA(1)==DIGIT)) {
				d1 = LT(1);
				match(DIGIT);
				if ( inputState.guessing==0 ) {
					hr_string += d1.getText();
				}
			}
			else {
				if ( _cnt576>=1 ) { break _loop576; } else {throw new NoViableAltException(LT(1), getFilename());}
			}
			
			_cnt576++;
		} while (true);
		}
		match(COLON);
		{
		int _cnt578=0;
		_loop578:
		do {
			if ((LA(1)==DIGIT)) {
				d2 = LT(1);
				match(DIGIT);
				if ( inputState.guessing==0 ) {
					min_string += d2.getText();
				}
			}
			else {
				if ( _cnt578>=1 ) { break _loop578; } else {throw new NoViableAltException(LT(1), getFilename());}
			}
			
			_cnt578++;
		} while (true);
		}
		match(COLON);
		{
		int _cnt580=0;
		_loop580:
		do {
			if ((LA(1)==DIGIT)) {
				d3 = LT(1);
				match(DIGIT);
				if ( inputState.guessing==0 ) {
					sec_string += d3.getText();
				}
			}
			else {
				if ( _cnt580>=1 ) { break _loop580; } else {throw new NoViableAltException(LT(1), getFilename());}
			}
			
			_cnt580++;
		} while (true);
		}
		if ( inputState.guessing==0 ) {
			
				hr  = Integer.parseInt(hr_string);
				min = Integer.parseInt(min_string);
				sec = Integer.parseInt(sec_string);
				t.hour = hr;
				t.minute = min;
				t.second = sec;
				
			
		}
		return t ;
	}
	
	public final  String   month() throws RecognitionException, TokenStreamException {
		 String  w ;
		
		
			w = null;
		
		
		{
		switch ( LA(1)) {
		case JAN:
		{
			match(JAN);
			if ( inputState.guessing==0 ) {
				w = DateKeywords.JAN;
			}
			break;
		}
		case FEB:
		{
			match(FEB);
			if ( inputState.guessing==0 ) {
				w = DateKeywords.FEB;
			}
			break;
		}
		case MAR:
		{
			match(MAR);
			if ( inputState.guessing==0 ) {
				w = DateKeywords.MAR;
			}
			break;
		}
		case APR:
		{
			match(APR);
			if ( inputState.guessing==0 ) {
				w = DateKeywords.APR;
			}
			break;
		}
		case MAY:
		{
			match(MAY);
			if ( inputState.guessing==0 ) {
				w = DateKeywords.MAY;
			}
			break;
		}
		case JUN:
		{
			match(JUN);
			if ( inputState.guessing==0 ) {
				w = DateKeywords.JUN;
			}
			break;
		}
		case JUL:
		{
			match(JUL);
			if ( inputState.guessing==0 ) {
				w = DateKeywords.JUL;
			}
			break;
		}
		case AUG:
		{
			match(AUG);
			if ( inputState.guessing==0 ) {
				w = DateKeywords.AUG;
			}
			break;
		}
		case SEP:
		{
			match(SEP);
			if ( inputState.guessing==0 ) {
				w = DateKeywords.SEP;
			}
			break;
		}
		case OCT:
		{
			match(OCT);
			if ( inputState.guessing==0 ) {
				w = DateKeywords.OCT;
			}
			break;
		}
		case NOV:
		{
			match(NOV);
			if ( inputState.guessing==0 ) {
				w = DateKeywords.NOV;
			}
			break;
		}
		case DEC:
		{
			match(DEC);
			if ( inputState.guessing==0 ) {
				w = DateKeywords.DEC;
			}
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		return w ;
	}
	
	public final  URI   request_uri() throws RecognitionException, TokenStreamException {
		 URI  u ;
		
		
			u = null;
		
		
		switch ( LA(1)) {
		case SIP:
		{
			u=sip_url();
			break;
		}
		case ALPHA:
		case DIGIT:
		case UNDERSCORE:
		case PLUS:
		case MINUS:
		case QUOTE:
		case EXCLAMATION:
		case PERCENT:
		case TILDE:
		case BACK_QUOTE:
		case STAR:
		case DOT:
		case ID:
		{
			u=absolute_uri();
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		return u ;
	}
	
	public final  URI  sip_url() throws RecognitionException, TokenStreamException {
		 URI uri ;
		
		
			uri =  null;
			startTracking();
		
		
		match(SIP);
		match(COLON);
		if ( inputState.guessing==0 ) {
			selectLexer("charLexer");
		}
		uri=sip_urlbody();
		if ( inputState.guessing==0 ) {
			
			uri.setUriType(URITypes.SIP_URL);
			uri.setScheme(SIPKeywords.SIP);  
			uri.setInputText(stopTracking());
			if (uri.isUserTelephoneSubscriber()) {
				  String usr = uri.getUser();
				  // This is a performance hit -- need a lightweight parser for this.
				  StringMsgParser smp = new StringMsgParser();
				  try {
				    TelephoneNumber tel = smp.parseTelephoneNumber(usr);
				    uri.setTelephoneSubscriber(tel);
				  } catch ( SIPParseException ex) {
				     throw new RecognitionException("Invalid Phone number spec "+ usr);
				  }
			}
			
		}
		return uri ;
	}
	
	public final  URI  absolute_uri() throws RecognitionException, TokenStreamException {
		 URI uri_ptr ;
		
		
			String s;
			String o;
			uri_ptr = null;
		
		
		s=scheme();
		match(COLON);
		{
		switch ( LA(1)) {
		case SLASH:
		{
			uri_ptr=hier_part();
			if ( inputState.guessing==0 ) {
				
					uri_ptr.setScheme(s);
				
			}
			break;
		}
		case ALPHA:
		case DIGIT:
		case UNDERSCORE:
		case PLUS:
		case MINUS:
		case QUOTE:
		case EXCLAMATION:
		case PERCENT:
		case TILDE:
		case STAR:
		case DOT:
		case LPAREN:
		case RPAREN:
		case SEMICOLON:
		case COLON:
		case QUESTION:
		case AT:
		case AND:
		case DOLLAR:
		case COMMA:
		{
			o=opaque_part();
			if ( inputState.guessing==0 ) {
				
					uri_ptr = new URI();
					uri_ptr.setUriType(URITypes.ABSOLUTE_URI);
					uri_ptr.setScheme(s);
					uri_ptr.setOpaquePart(o);
				
			}
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		return uri_ptr ;
	}
	
	public final  MediaRange   media_type() throws RecognitionException, TokenStreamException {
		 MediaRange  r ;
		
		
			String t;
			String s;
			NameValue p;
			r = new MediaRange();
			startTracking();
		
		
		t=type();
		match(SLASH);
		s=subtype();
		{
		_loop589:
		do {
			if ((LA(1)==SP)) {
				match(SP);
			}
			else if ((LA(1)==HT)) {
				match(HT);
			}
			else {
				break _loop589;
			}
			
		} while (true);
		}
		{
		_loop595:
		do {
			if ((LA(1)==SEMICOLON)) {
				match(SEMICOLON);
				{
				_loop592:
				do {
					switch ( LA(1)) {
					case SP:
					{
						match(SP);
						break;
					}
					case HT:
					{
						match(HT);
						break;
					}
					default:
					{
						break _loop592;
					}
					}
				} while (true);
				}
				p=parameter();
				if ( inputState.guessing==0 ) {
					r.getParameter().add(p);
				}
				{
				_loop594:
				do {
					if ((LA(1)==SP)) {
						match(SP);
					}
					else if ((LA(1)==HT)) {
						match(HT);
					}
					else {
						break _loop594;
					}
					
				} while (true);
				}
			}
			else {
				break _loop595;
			}
			
		} while (true);
		}
		if ( inputState.guessing==0 ) {
			
				r.setType(t);
				r.setSubtype(s);
				r.setInputText(stopTracking());
			
		}
		return r ;
	}
	
	public final  String  textUTF8() throws RecognitionException, TokenStreamException {
		 String s ;
		
		Token  d = null;
		
			s = null;
		
		
		if ((_tokenSet_0.member(LA(1)))) {
			{
			d = LT(1);
			matchNot(RETURN);
			if ( inputState.guessing==0 ) {
				
				pushLexer("charLexer");
				while ( true ) {
					if (s == null) s = d.getText();
					else s += d.getText();
					d = LT(1);
					if (d == null || d.getType() == Token.EOF_TYPE) {
						throw new RecognitionException("Premature EOF");
					}	
					if (d.getType() == RETURN ) break;
					consume();
				}
				track(s);
				popLexer();
				
			}
			}
		}
		else if ((LA(1)==SP||LA(1)==HT||LA(1)==RETURN)) {
		}
		else {
			throw new NoViableAltException(LT(1), getFilename());
		}
		
		return s ;
	}
	
	public final  String  priority_value() throws RecognitionException, TokenStreamException {
		 String p ;
		
		
			p = null;
		
		
		switch ( LA(1)) {
		case EMERGENCY:
		{
			match(EMERGENCY);
			if ( inputState.guessing==0 ) {
				p = PriorityKeywords.EMERGENCY ; 	
			}
			break;
		}
		case URGENT:
		{
			match(URGENT);
			if ( inputState.guessing==0 ) {
				p = PriorityKeywords.URGENT;  	
			}
			break;
		}
		case NORMAL:
		{
			match(NORMAL);
			if ( inputState.guessing==0 ) {
				p = PriorityKeywords.NORMAL; 	
			}
			break;
		}
		case NON_URGENT:
		{
			match(NON_URGENT);
			if ( inputState.guessing==0 ) {
				p = PriorityKeywords.NON_URGENT; 	
			}
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		return p ;
	}
	
	public final  String  key_scheme() throws RecognitionException, TokenStreamException {
		 String s ;
		
		
		s=ttoken();
		return s ;
	}
	
	public final  NameValue  key_param() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		
			nv = new NameValue();
			String n;
			String v;
			startTracking();
		
		
		n=ttoken();
		{
		_loop686:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop686;
			}
			}
		} while (true);
		}
		match(EQUALS);
		{
		_loop688:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop688;
			}
			}
		} while (true);
		}
		v=quoted_string_or_ttoken();
		if ( inputState.guessing==0 ) {
			
				nv.setName(n);
				nv.setValue(v);
				nv.setInputText(stopTracking());
			
		}
		return nv ;
	}
	
	public final  ContactList  contact_body() throws RecognitionException, TokenStreamException {
		 ContactList cl ;
		
		
			cl = new ContactList();
			Contact c ;
			startTracking();
		
		
		c=contact_item();
		if ( inputState.guessing==0 ) {
			
			try {
			cl.add(c);
			} catch (IllegalArgumentException ex) { 
				throw new RecognitionException(ex.getMessage());
			}  
			c.setContactList(cl); 
			
		}
		{
		_loop701:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop701;
			}
			}
		} while (true);
		}
		{
		_loop707:
		do {
			boolean synPredMatched704 = false;
			if (((LA(1)==COMMA))) {
				int _m704 = mark();
				synPredMatched704 = true;
				inputState.guessing++;
				try {
					{
					match(COMMA);
					}
				}
				catch (RecognitionException pe) {
					synPredMatched704 = false;
				}
				rewind(_m704);
				inputState.guessing--;
			}
			if ( synPredMatched704 ) {
				match(COMMA);
				if ( inputState.guessing==0 ) {
					selectLexer("sip_urlLexer", sip_urlLexer.INIT_STATE);
				}
				{
				_loop706:
				do {
					if ((LA(1)==SP)) {
						match(SP);
					}
					else if ((LA(1)==HT)) {
						match(HT);
					}
					else {
						break _loop706;
					}
					
				} while (true);
				}
				c=contact_item();
				if ( inputState.guessing==0 ) {
					
					try { 
						cl.add(c); 
					} catch (IllegalArgumentException ex) { 
						throw new RecognitionException(ex.getMessage());
					}  
					c.setContactList(cl);
					
				}
			}
			else {
				break _loop707;
			}
			
		} while (true);
		}
		if ( inputState.guessing==0 ) {
			
				cl.setInputText(stopTracking());
			
		}
		return cl ;
	}
	
	public final  Contact  contact_item() throws RecognitionException, TokenStreamException {
		 Contact c ;
		
		
		
			c = new Contact();
			Address a = null;
			String com = null;
			NameValue p;
			startTracking();
		
		
		{
		switch ( LA(1)) {
		case STAR_FLAG:
		{
			match(STAR_FLAG);
			if ( inputState.guessing==0 ) {
				c.setWildCardFlag(true);
			}
			break;
		}
		case ALPHA:
		case DIGIT:
		case UNDERSCORE:
		case PLUS:
		case MINUS:
		case QUOTE:
		case EXCLAMATION:
		case PERCENT:
		case TILDE:
		case BACK_QUOTE:
		case STAR:
		case DOT:
		case SP:
		case HT:
		case EQUALS:
		case DOUBLEQUOTE:
		case LPAREN:
		case RPAREN:
		case SEMICOLON:
		case ID:
		case SLASH:
		case AT:
		case AND:
		case DOLLAR:
		case COMMA:
		case SIP:
		case LESS_THAN:
		{
			{
			a=address();
			if ( inputState.guessing==0 ) {
				c.setAddress(a);
			}
			if ( inputState.guessing==0 ) {
				selectLexer("contact_parmsLexer");
			}
			{
			_loop712:
			do {
				if ((LA(1)==SP)) {
					match(SP);
				}
				else if ((LA(1)==HT)) {
					match(HT);
				}
				else {
					break _loop712;
				}
				
			} while (true);
			}
			{
			switch ( LA(1)) {
			case SEMICOLON:
			{
				{
				int _cnt721=0;
				_loop721:
				do {
					if ((LA(1)==SEMICOLON)) {
						match(SEMICOLON);
						if ( inputState.guessing==0 ) {
							selectLexer("contact_parmsLexer");
						}
						{
						_loop718:
						do {
							switch ( LA(1)) {
							case SP:
							{
								match(SP);
								break;
							}
							case HT:
							{
								match(HT);
								break;
							}
							default:
							{
								break _loop718;
							}
							}
						} while (true);
						}
						p=contact_parm();
						if ( inputState.guessing==0 ) {
							c.getContactParms().add(p);
						}
						{
						_loop720:
						do {
							if ((LA(1)==SP)) {
								match(SP);
							}
							else if ((LA(1)==HT)) {
								match(HT);
							}
							else {
								break _loop720;
							}
							
						} while (true);
						}
					}
					else {
						if ( _cnt721>=1 ) { break _loop721; } else {throw new NoViableAltException(LT(1), getFilename());}
					}
					
					_cnt721++;
				} while (true);
				}
				break;
			}
			case SP:
			case HT:
			case RETURN:
			case LPAREN:
			case COMMA:
			{
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			if ( inputState.guessing==0 ) {
				selectLexer("charLexer");
			}
			{
			switch ( LA(1)) {
			case LPAREN:
			{
				com=comment();
				if ( inputState.guessing==0 ) {
					c.setComment(com);
				}
				break;
			}
			case SP:
			case HT:
			case RETURN:
			case COMMA:
			{
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			}
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			
			c.setInputText(stopTracking());
			// Change made in accordance with the following...
			// The Contact, From and To header fields contain a URL. If the URL
			// contains a comma, question mark or semicolon, the URL MUST be
			// enclosed in angle brackets (< and >). Any URL parameters are
			// contained within these brackets. If the URL is not enclosed in angle
			// brackets, any semicolon-delimited parameters are header-parameters,
			// not URL parameters.
			//
			if (a != null && a.getAddressType() == Address.ADDRESS_SPEC) {
				c.getContactParms().concatenate(a.getAddrSpec().getUriParms());
				a.getAddrSpec().clearUriParms();
			}
			
		}
		return c ;
	}
	
	public final  NameValue  contact_parm() throws RecognitionException, TokenStreamException {
		 NameValue p ;
		
		
			p =  null;
			double qv = 0.0;
		String ac = null;
		SIPDateOrDeltaSeconds d = null;
			NameValue nv = null;
			startTracking();
			
		
		
		{
		switch ( LA(1)) {
		case Q:
		{
			match(Q);
			{
			_loop728:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop728;
				}
				}
			} while (true);
			}
			match(EQUALS);
			if ( inputState.guessing==0 ) {
				selectLexer("charLexer");
			}
			{
			_loop730:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop730;
				}
				}
			} while (true);
			}
			qv=qvalue();
			if ( inputState.guessing==0 ) {
				p = new NameValue(SIPKeywords.Q,new Double(qv));
			}
			break;
		}
		case ACTION:
		{
			match(ACTION);
			{
			_loop732:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop732;
				}
				}
			} while (true);
			}
			match(EQUALS);
			{
			_loop734:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop734;
				}
				}
			} while (true);
			}
			{
			switch ( LA(1)) {
			case PROXY:
			{
				match(PROXY);
				if ( inputState.guessing==0 ) {
					ac = SIPKeywords.PROXY;
				}
				break;
			}
			case REDIRECT:
			{
				match(REDIRECT);
				if ( inputState.guessing==0 ) {
					ac = SIPKeywords.REDIRECT;
				}
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			if ( inputState.guessing==0 ) {
				p = new NameValue (SIPKeywords.ACTION,ac) ;
			}
			break;
		}
		case EXPIRES:
		{
			match(EXPIRES);
			{
			_loop737:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop737;
				}
				}
			} while (true);
			}
			match(EQUALS);
			if ( inputState.guessing==0 ) {
				selectLexer("charLexer");
			}
			{
			_loop739:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop739;
				}
				}
			} while (true);
			}
			d=date_or_delta_seconds1();
			if ( inputState.guessing==0 ) {
				
					// For some strange reason the RFC specifies a quote around the date
					// so we have to make a new rule (sigh!).
					p = new NameValue(SIPKeywords.EXPIRES, d );
				
			}
			break;
		}
		case ID:
		{
			p=extension_attribute();
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			
				p.setInputText(stopTracking()); 
			
		}
		return p ;
	}
	
	public final  URI  addr_spec() throws RecognitionException, TokenStreamException {
		 URI u ;
		
		
		u=uri_reference();
		return u ;
	}
	
	public final  NameValue  extension_attribute() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		Token  t = null;
		
			nv = new NameValue();
			String n ;
			String val  = null;
			startTracking();
		
		
		t = LT(1);
		match(ID);
		{
		if (((LA(1) >= SP && LA(1) <= EQUALS))) {
			{
			_loop743:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop743;
				}
				}
			} while (true);
			}
			match(EQUALS);
			{
			_loop745:
			do {
				switch ( LA(1)) {
				case SP:
				{
					match(SP);
					break;
				}
				case HT:
				{
					match(HT);
					break;
				}
				default:
				{
					break _loop745;
				}
				}
			} while (true);
			}
			if ( inputState.guessing==0 ) {
				selectLexer("charLexer");
			}
			val=extension_value();
		}
		else if ((_tokenSet_4.member(LA(1)))) {
		}
		else {
			throw new NoViableAltException(LT(1), getFilename());
		}
		
		}
		if ( inputState.guessing==0 ) {
			
				nv.setName(t.getText());
				nv.setValue(val);
				nv.setInputText(stopTracking());
			
		}
		return nv ;
	}
	
	public final  String  display_name() throws RecognitionException, TokenStreamException {
		 String s ;
		
		Token  s13 = null;
		Token  s15 = null;
		Token  s2 = null;
		Token  s3 = null;
		
			s= null;
		
		
		switch ( LA(1)) {
		case DOUBLEQUOTE:
		{
			s=quoted_string();
			break;
		}
		case SP:
		case HT:
		case ID:
		case SIP:
		{
			{
			int _cnt752=0;
			_loop752:
			do {
				switch ( LA(1)) {
				case ID:
				{
					s13 = LT(1);
					match(ID);
					if ( inputState.guessing==0 ) {
						if ( s == null) s = s13.getText(); else s += s13.getText();
					}
					break;
				}
				case SIP:
				{
					s15 = LT(1);
					match(SIP);
					if ( inputState.guessing==0 ) {
						if ( s == null) s = s15.getText(); else s += s15.getText();
					}
					break;
				}
				default:
					if ((LA(1)==SP)) {
						s2 = LT(1);
						match(SP);
						if ( inputState.guessing==0 ) {
							if ( s == null) s = s2.getText(); else s += s2.getText();
						}
					}
					else if ((LA(1)==HT)) {
						s3 = LT(1);
						match(HT);
						if ( inputState.guessing==0 ) {
							if ( s == null) s = s3.getText(); else s += s3.getText();
						}
					}
				else {
					if ( _cnt752>=1 ) { break _loop752; } else {throw new NoViableAltException(LT(1), getFilename());}
				}
				}
				_cnt752++;
			} while (true);
			}
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		return s ;
	}
	
	public final  Warning  warning_value() throws RecognitionException, TokenStreamException {
		 Warning w ;
		
		
			int wc;
			WarnAgent wa;
			String wt;
			w = new Warning();
			startTracking();
		
		
		wc=warn_code();
		match(SP);
		wa=warn_agent();
		match(SP);
		wt=warn_text();
		if ( inputState.guessing==0 ) {
			
				w.setWarnCode(wc);
				w.setWarnAgent(wa);
				w.setWarnText(wt);
				w.setInputText(stopTracking());
			
		}
		return w ;
	}
	
	public final  int  warn_code() throws RecognitionException, TokenStreamException {
		 int wc ;
		
		Token  d1 = null;
		Token  d2 = null;
		Token  d3 = null;
		
			wc = -1;
			String s;
		
		
		d1 = LT(1);
		match(DIGIT);
		d2 = LT(1);
		match(DIGIT);
		d3 = LT(1);
		match(DIGIT);
		if ( inputState.guessing==0 ) {
			
				s = d1.getText() + d2.getText() + d3.getText();
				wc = Integer.parseInt(s);
			
		}
		return wc ;
	}
	
	public final  WarnAgent  warn_agent() throws RecognitionException, TokenStreamException {
		 WarnAgent wa ;
		
		
			wa = null;
			HostPort hp;
			String p;
			startTracking();
		
		
		{
		if ((LA(1)==ALPHA||LA(1)==DIGIT||LA(1)==MINUS)) {
			hp=host_port();
			if ( inputState.guessing==0 ) {
				wa = new WarnAgent(hp);
			}
		}
		else if (((LA(1) >= ALPHA && LA(1) <= DOT))) {
			p=pseudonym();
			if ( inputState.guessing==0 ) {
				wa = new WarnAgent(p);
			}
		}
		else {
			throw new NoViableAltException(LT(1), getFilename());
		}
		
		}
		if ( inputState.guessing==0 ) {
			
			wa.setInputText(stopTracking());
			
		}
		return wa ;
	}
	
	public final  String  warn_text() throws RecognitionException, TokenStreamException {
		 String t ;
		
		
		t=quoted_string();
		return t ;
	}
	
	public final  String  pseudonym() throws RecognitionException, TokenStreamException {
		 String p ;
		
		
		p=ttoken();
		return p ;
	}
	
	public final  NameValue  pgp_params() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		
			nv = null;
			parserMain.setEnclosingLexer("pgp_Lexer");
		
		
		{
		switch ( LA(1)) {
		case REALM:
		{
			nv=realm();
			break;
		}
		case VERSION:
		{
			nv=pgp_version();
			break;
		}
		case ALGORITHM:
		{
			nv=algorithm();
			break;
		}
		case PUBKEY:
		{
			nv=pgp_pubalgorithm();
			break;
		}
		case NONCE:
		{
			nv=nonce();
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		return nv ;
	}
	
	public final  NameValue  pgp_pubalgorithm() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		
			nv = new NameValue();
			String s;
			startTracking();
		
		
		match(PUBKEY);
		{
		_loop787:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop787;
			}
			}
		} while (true);
		}
		match(EQUALS);
		{
		_loop789:
		do {
			switch ( LA(1)) {
			case SP:
			{
				match(SP);
				break;
			}
			case HT:
			{
				match(HT);
				break;
			}
			default:
			{
				break _loop789;
			}
			}
		} while (true);
		}
		s=ttoken();
		if ( inputState.guessing==0 ) {
			
				nv.setName(SIPKeywords.PUBKEY);
				nv.setValue(s);
				nv.setInputText(stopTracking());
			
		}
		return nv ;
	}
	
	public final  NameValue  digest_param() throws RecognitionException, TokenStreamException {
		 NameValue r ;
		
		
			r = null;
			startTracking();
			parserMain.setEnclosingLexer("digest_Lexer"); 
		
		
		{
		switch ( LA(1)) {
		case REALM:
		{
			r=realm();
			break;
		}
		case DOMAIN:
		{
			r=domain();
			break;
		}
		case NONCE:
		{
			r=nonce();
			break;
		}
		case OPAQUE:
		{
			r=opaque();
			break;
		}
		case STALE:
		{
			r=stale();
			break;
		}
		case ALGORITHM:
		{
			r=algorithm();
			break;
		}
		case QOP:
		{
			r=qop_value();
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			r.setInputText(stopTracking());
		}
		return r ;
	}
	
	public final  String  realmvalue() throws RecognitionException, TokenStreamException {
		 String rv ;
		
		
		rv=quoted_string();
		return rv ;
	}
	
	public final  String  unreserved() throws RecognitionException, TokenStreamException {
		 String s ;
		
		Token  a = null;
		Token  d = null;
		s  = null ;
		
		{
		switch ( LA(1)) {
		case ALPHA:
		{
			a = LT(1);
			match(ALPHA);
			if ( inputState.guessing==0 ) {
				s = a.getText();
			}
			break;
		}
		case DIGIT:
		{
			d = LT(1);
			match(DIGIT);
			if ( inputState.guessing==0 ) {
				s = d.getText();
			}
			break;
		}
		case UNDERSCORE:
		case MINUS:
		case QUOTE:
		case EXCLAMATION:
		case TILDE:
		case STAR:
		case DOT:
		case LPAREN:
		case RPAREN:
		{
			s=mark_();
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		return s ;
	}
	
	public final  String  mark_() throws RecognitionException, TokenStreamException {
		 String s ;
		
		Token  m = null;
		Token  u = null;
		Token  d = null;
		Token  e = null;
		Token  t = null;
		Token  v = null;
		Token  q = null;
		Token  l = null;
		Token  r = null;
		
			s = null;
		
		
		{
		switch ( LA(1)) {
		case MINUS:
		{
			m = LT(1);
			match(MINUS);
			if ( inputState.guessing==0 ) {
				s = m.getText();
			}
			break;
		}
		case UNDERSCORE:
		{
			u = LT(1);
			match(UNDERSCORE);
			if ( inputState.guessing==0 ) {
				s = u.getText();
			}
			break;
		}
		case DOT:
		{
			d = LT(1);
			match(DOT);
			if ( inputState.guessing==0 ) {
				s = d.getText();
			}
			break;
		}
		case EXCLAMATION:
		{
			e = LT(1);
			match(EXCLAMATION);
			if ( inputState.guessing==0 ) {
				s = e.getText();
			}
			break;
		}
		case TILDE:
		{
			t = LT(1);
			match(TILDE);
			if ( inputState.guessing==0 ) {
				s = t.getText();
			}
			break;
		}
		case STAR:
		{
			v = LT(1);
			match(STAR);
			if ( inputState.guessing==0 ) {
				s = v.getText();
			}
			break;
		}
		case QUOTE:
		{
			q = LT(1);
			match(QUOTE);
			if ( inputState.guessing==0 ) {
				s = q.getText();
			}
			break;
		}
		case LPAREN:
		{
			l = LT(1);
			match(LPAREN);
			if ( inputState.guessing==0 ) {
				s = l.getText();
			}
			break;
		}
		case RPAREN:
		{
			r = LT(1);
			match(RPAREN);
			if ( inputState.guessing==0 ) {
				s = r.getText();
			}
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		return s ;
	}
	
	public final  String  reserved() throws RecognitionException, TokenStreamException {
		 String s ;
		
		Token  a = null;
		Token  b = null;
		Token  c = null;
		Token  d = null;
		Token  e = null;
		Token  f = null;
		Token  g = null;
		Token  h = null;
		Token  i = null;
		
			s = null;
		
		
		{
		switch ( LA(1)) {
		case SEMICOLON:
		{
			a = LT(1);
			match(SEMICOLON);
			if ( inputState.guessing==0 ) {
				s = a.getText();
			}
			break;
		}
		case SLASH:
		{
			b = LT(1);
			match(SLASH);
			if ( inputState.guessing==0 ) {
				s = b.getText();
			}
			break;
		}
		case QUESTION:
		{
			c = LT(1);
			match(QUESTION);
			if ( inputState.guessing==0 ) {
				s = c.getText();
			}
			break;
		}
		case COLON:
		{
			d = LT(1);
			match(COLON);
			if ( inputState.guessing==0 ) {
				s = d.getText();
			}
			break;
		}
		case AT:
		{
			e = LT(1);
			match(AT);
			if ( inputState.guessing==0 ) {
				s = e.getText();
			}
			break;
		}
		case AND:
		{
			f = LT(1);
			match(AND);
			if ( inputState.guessing==0 ) {
				s = f.getText();
			}
			break;
		}
		case PLUS:
		{
			g = LT(1);
			match(PLUS);
			if ( inputState.guessing==0 ) {
				s = g.getText();
			}
			break;
		}
		case DOLLAR:
		{
			h = LT(1);
			match(DOLLAR);
			if ( inputState.guessing==0 ) {
				s = h.getText();
			}
			break;
		}
		case COMMA:
		{
			i = LT(1);
			match(COMMA);
			if ( inputState.guessing==0 ) {
				s = i.getText();
			}
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		return s ;
	}
	
	public final  String  escaped() throws RecognitionException, TokenStreamException {
		 String s ;
		
		
			s = null;
			String a ;
			String b ;
		
		
		{
		match(PERCENT);
		a=hexdigit();
		b=hexdigit();
		if ( inputState.guessing==0 ) {
			s = "%" + a + b ;
		}
		}
		return s ;
	}
	
	public final  String  uric() throws RecognitionException, TokenStreamException {
		 String s ;
		
		
		{
		switch ( LA(1)) {
		case ALPHA:
		case DIGIT:
		case UNDERSCORE:
		case MINUS:
		case QUOTE:
		case EXCLAMATION:
		case TILDE:
		case STAR:
		case DOT:
		case LPAREN:
		case RPAREN:
		{
			s=unreserved();
			break;
		}
		case PLUS:
		case SEMICOLON:
		case COLON:
		case SLASH:
		case QUESTION:
		case AT:
		case AND:
		case DOLLAR:
		case COMMA:
		{
			s=reserved();
			break;
		}
		case PERCENT:
		{
			s=escaped();
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		return s ;
	}
	
	public final  String  uric_no_slash() throws RecognitionException, TokenStreamException {
		 String s ;
		
		Token  a = null;
		Token  b = null;
		Token  c = null;
		Token  d = null;
		Token  e = null;
		Token  f = null;
		Token  g = null;
		Token  h = null;
		
			s = null;
		
		
		{
		switch ( LA(1)) {
		case ALPHA:
		case DIGIT:
		case UNDERSCORE:
		case MINUS:
		case QUOTE:
		case EXCLAMATION:
		case TILDE:
		case STAR:
		case DOT:
		case LPAREN:
		case RPAREN:
		{
			s=unreserved();
			break;
		}
		case PERCENT:
		{
			s=escaped();
			break;
		}
		case SEMICOLON:
		{
			a = LT(1);
			match(SEMICOLON);
			if ( inputState.guessing==0 ) {
				s = a.getText();
			}
			break;
		}
		case QUESTION:
		{
			b = LT(1);
			match(QUESTION);
			if ( inputState.guessing==0 ) {
				s = b.getText();
			}
			break;
		}
		case COLON:
		{
			c = LT(1);
			match(COLON);
			if ( inputState.guessing==0 ) {
				s = c.getText();
			}
			break;
		}
		case AT:
		{
			d = LT(1);
			match(AT);
			if ( inputState.guessing==0 ) {
				s = d.getText();
			}
			break;
		}
		case AND:
		{
			e = LT(1);
			match(AND);
			if ( inputState.guessing==0 ) {
				s = e.getText();
			}
			break;
		}
		case PLUS:
		{
			f = LT(1);
			match(PLUS);
			if ( inputState.guessing==0 ) {
				s = f.getText();
			}
			break;
		}
		case DOLLAR:
		{
			g = LT(1);
			match(DOLLAR);
			if ( inputState.guessing==0 ) {
				s = g.getText();
			}
			break;
		}
		case COMMA:
		{
			h = LT(1);
			match(COMMA);
			if ( inputState.guessing==0 ) {
				s = h.getText();
			}
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		return s ;
	}
	
	public final  String  alphanum() throws RecognitionException, TokenStreamException {
		 String t ;
		
		Token  a = null;
		Token  d = null;
		
			t = null;
		
		
		{
		switch ( LA(1)) {
		case ALPHA:
		{
			a = LT(1);
			match(ALPHA);
			if ( inputState.guessing==0 ) {
				t = a.getText();
			}
			break;
		}
		case DIGIT:
		{
			d = LT(1);
			match(DIGIT);
			if ( inputState.guessing==0 ) {
				t = d.getText();
			}
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		return t ;
	}
	
	public final  String  h_name() throws RecognitionException, TokenStreamException {
		 String s ;
		
		
			s = "";
			String v;
		
		
		{
		int _cnt900=0;
		_loop900:
		do {
			if ((_tokenSet_5.member(LA(1)))) {
				v=uric();
				if ( inputState.guessing==0 ) {
					s += v;
				}
			}
			else {
				if ( _cnt900>=1 ) { break _loop900; } else {throw new NoViableAltException(LT(1), getFilename());}
			}
			
			_cnt900++;
		} while (true);
		}
		return s ;
	}
	
	public final  String  hvalue() throws RecognitionException, TokenStreamException {
		 String s ;
		
		
			s = "";
			String v;
		
		
		{
		_loop903:
		do {
			if ((_tokenSet_5.member(LA(1)))) {
				v=uric();
				if ( inputState.guessing==0 ) {
					s += v;
				}
			}
			else {
				break _loop903;
			}
			
		} while (true);
		}
		return s ;
	}
	
	public final  URI  uri() throws RecognitionException, TokenStreamException {
		 URI uri_ptr ;
		
		
		startTracking(); 
		String frag = null;
		
		
		{
		if (((_tokenSet_6.member(LA(1))))&&(LA(1) == ID && LA(2) == COLON )) {
			uri_ptr=absolute_uri();
		}
		else if ((_tokenSet_7.member(LA(1)))) {
			uri_ptr=relative_uri();
		}
		else {
			throw new NoViableAltException(LT(1), getFilename());
		}
		
		}
		{
		switch ( LA(1)) {
		case POUND:
		{
			match(POUND);
			frag=fragment();
			break;
		}
		case SP:
		case HT:
		case RETURN:
		case LPAREN:
		case SEMICOLON:
		case COMMA:
		case GREATER_THAN:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			
			uri_ptr.setFragment(frag);
			uri_ptr.setInputText(stopTracking()); 
			
		}
		return uri_ptr ;
	}
	
	public final  URI  relative_uri() throws RecognitionException, TokenStreamException {
		 URI u ;
		
		
			u = new URI();
			u.setUriType(URITypes.RELATIVE_URI);
			NetPath n = null;
			AbsPath s = null;
			RelPath r = null;
			String  q = null;
		
		
		{
		if ((LA(1)==SLASH)) {
			{
			if (!( LA(1) == SLASH && LA(2) == SLASH))
			  throw new SemanticException(" LA(1) == SLASH && LA(2) == SLASH");
			n=net_path();
			if ( inputState.guessing==0 ) {
				
				u.setAuthority(n.getAuthority());
				u.setPath((Path) n);
				
			}
			}
		}
		else if ((LA(1)==SLASH)) {
			{
			if (!( LA(1) == SLASH && LA(2) != SLASH ))
			  throw new SemanticException(" LA(1) == SLASH && LA(2) != SLASH ");
			s=abs_path();
			}
			if ( inputState.guessing==0 ) {
				
				u.setAuthority(null);
				u.setPath((Path) s);
				
			}
		}
		else if ((_tokenSet_8.member(LA(1)))) {
			r=rel_path();
			if ( inputState.guessing==0 ) {
				
				u.setAuthority(null);	
				u.setPath((Path) r);
				
			}
		}
		else {
			throw new NoViableAltException(LT(1), getFilename());
		}
		
		}
		{
		switch ( LA(1)) {
		case QUESTION:
		{
			match(QUESTION);
			q=query();
			break;
		}
		case SP:
		case HT:
		case RETURN:
		case LPAREN:
		case POUND:
		case SEMICOLON:
		case COMMA:
		case GREATER_THAN:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			
			u.setQuery(q);
			
		}
		return u ;
	}
	
	public final  String  fragment() throws RecognitionException, TokenStreamException {
		 String s ;
		
		
			s = "";
			String r;
		
		
		{
		int _cnt977=0;
		_loop977:
		do {
			if ((_tokenSet_5.member(LA(1)))) {
				r=uric();
				if ( inputState.guessing==0 ) {
					s += r;
				}
			}
			else {
				if ( _cnt977>=1 ) { break _loop977; } else {throw new NoViableAltException(LT(1), getFilename());}
			}
			
			_cnt977++;
		} while (true);
		}
		return s ;
	}
	
	public final  String  scheme() throws RecognitionException, TokenStreamException {
		 String s ;
		
		Token  t = null;
		
			s = "";
			String r;
		
		
		{
		switch ( LA(1)) {
		case ID:
		{
			t = LT(1);
			match(ID);
			if ( inputState.guessing==0 ) {
				// check for validity of scheme.
				s = t.getText();
				
			}
			break;
		}
		case ALPHA:
		case DIGIT:
		case UNDERSCORE:
		case PLUS:
		case MINUS:
		case QUOTE:
		case EXCLAMATION:
		case PERCENT:
		case TILDE:
		case BACK_QUOTE:
		case STAR:
		case DOT:
		{
			s=ttoken();
			{
			}
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			
				if  ( ! Character.isLetter(s.charAt(0))) {
					throw new RecognitionException 
						("URI scheme must start with letter");
				} 
				for (int k = 1; k < s.length(); k++) {
					if ( ! Character.isLetter(s.charAt(k))
					     && !Character.isDigit(s.charAt(k))
					     && s.charAt(k) != '+'
					     && s.charAt(k) != '-'
					     && s.charAt(k) != '.')  {
					     throw new RecognitionException 
						( "Bad URI scheme character " + s.charAt(k));
					}
			
				}
			
		}
		return s ;
	}
	
	public final  URI  hier_part() throws RecognitionException, TokenStreamException {
		 URI u ;
		
		
			u = new URI();
			NetPath n;
			AbsPath a;
			String q = null;
		
		
		{
		if (((LA(1)==SLASH))&&( LA(1) == SLASH && LA(2) == SLASH )) {
			n=net_path();
			if ( inputState.guessing==0 ) {
				
					u.setAuthority(n.getAuthority());
					u.setPath(n);
				
			}
		}
		else if ((LA(1)==SLASH)) {
			a=abs_path();
			if ( inputState.guessing==0 ) {
				
					u.setPath(a);
				
			}
		}
		else {
			throw new NoViableAltException(LT(1), getFilename());
		}
		
		}
		{
		switch ( LA(1)) {
		case QUESTION:
		{
			match(QUESTION);
			q=query();
			break;
		}
		case SP:
		case HT:
		case RETURN:
		case LPAREN:
		case POUND:
		case SEMICOLON:
		case COMMA:
		case GREATER_THAN:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			
				u.setQuery(q);
			
		}
		return u ;
	}
	
	public final  String  opaque_part() throws RecognitionException, TokenStreamException {
		 String s ;
		
		
			s = "";
			String v;
		
		
		s=uric_no_slash();
		{
		_loop962:
		do {
			if ((_tokenSet_5.member(LA(1)))) {
				v=uric();
				if ( inputState.guessing==0 ) {
					s += v;
				}
			}
			else {
				break _loop962;
			}
			
		} while (true);
		}
		return s ;
	}
	
	public final  NetPath  net_path() throws RecognitionException, TokenStreamException {
		 NetPath netpath ;
		
		
			Authority auth;
			AbsPath a = null;
			netpath = new NetPath();
			startTracking();
			
		
		
		match(SLASH);
		match(SLASH);
		auth=authority();
		{
		switch ( LA(1)) {
		case SLASH:
		{
			a=abs_path();
			break;
		}
		case SP:
		case HT:
		case RETURN:
		case LPAREN:
		case POUND:
		case SEMICOLON:
		case QUESTION:
		case COMMA:
		case GREATER_THAN:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			
				netpath.setAuthority(auth);
				netpath.setAbsPath(a);
				netpath.setInputText(stopTracking());
			
		}
		return netpath ;
	}
	
	public final  AbsPath  abs_path() throws RecognitionException, TokenStreamException {
		 AbsPath a ;
		
		
			a = new AbsPath();
			PathSegments s;
			startTracking();
		
		
		match(SLASH);
		s=path_segments();
		if ( inputState.guessing==0 ) {
			
				a.setPathSegments(s);
				a.setInputText(stopTracking());
			
		}
		return a ;
	}
	
	public final  String  query() throws RecognitionException, TokenStreamException {
		 String s ;
		
		
			s = "";
			String r;
		
		
		{
		int _cnt957=0;
		_loop957:
		do {
			if ((_tokenSet_5.member(LA(1)))) {
				r=uric();
				if ( inputState.guessing==0 ) {
					s += r;
				}
			}
			else {
				if ( _cnt957>=1 ) { break _loop957; } else {throw new NoViableAltException(LT(1), getFilename());}
			}
			
			_cnt957++;
		} while (true);
		}
		return s ;
	}
	
	public final  Authority  authority() throws RecognitionException, TokenStreamException {
		 Authority a ;
		
		
			String  r = null;
			a = null;
			startTracking();
		
		
		{
		boolean synPredMatched926 = false;
		if (((_tokenSet_9.member(LA(1))))) {
			int _m926 = mark();
			synPredMatched926 = true;
			inputState.guessing++;
			try {
				{
				server_h();
				}
			}
			catch (RecognitionException pe) {
				synPredMatched926 = false;
			}
			rewind(_m926);
			inputState.guessing--;
		}
		if ( synPredMatched926 ) {
			a=server_h();
		}
		else if ((_tokenSet_10.member(LA(1)))) {
			a=reg_name();
		}
		else {
			throw new NoViableAltException(LT(1), getFilename());
		}
		
		}
		if ( inputState.guessing==0 ) {
			
				a.setInputText(stopTracking());
			
		}
		return a ;
	}
	
	public final  AuthorityServer  server_h() throws RecognitionException, TokenStreamException {
		 AuthorityServer h ;
		
		
			h = new AuthorityServer();
			String s = null;
		HostPort p;
			UserInfo u = null;
			pushLexer("charLexer");
			startTracking();
		
		
		{
		boolean synPredMatched933 = false;
		if (((_tokenSet_9.member(LA(1))))) {
			int _m933 = mark();
			synPredMatched933 = true;
			inputState.guessing++;
			try {
				{
				userinfo();
				match(AT);
				}
			}
			catch (RecognitionException pe) {
				synPredMatched933 = false;
			}
			rewind(_m933);
			inputState.guessing--;
		}
		if ( synPredMatched933 ) {
			{
			u=userinfo();
			match(AT);
			}
		}
		else if ((LA(1)==ALPHA||LA(1)==DIGIT||LA(1)==MINUS)) {
		}
		else {
			throw new NoViableAltException(LT(1), getFilename());
		}
		
		}
		p=host_port();
		if ( inputState.guessing==0 ) {
			
				h.setUserInfo(u);
				h.setHostPort(p);
				h.setInputText(stopTracking());
				popLexer();
			
		}
		return h ;
	}
	
	public final  AuthorityRegname   reg_name() throws RecognitionException, TokenStreamException {
		 AuthorityRegname  a ;
		
		Token  t = null;
		Token  b = null;
		Token  c = null;
		Token  d = null;
		Token  e = null;
		Token  f = null;
		Token  g = null;
		Token  h = null;
		
		a = null;
		String s = "";
		String r;
		startTracking();
		
		
		{
		int _cnt929=0;
		_loop929:
		do {
			switch ( LA(1)) {
			case PERCENT:
			{
				r=escaped();
				if ( inputState.guessing==0 ) {
					s += r; 		
				}
				break;
			}
			case DOLLAR:
			{
				t = LT(1);
				match(DOLLAR);
				if ( inputState.guessing==0 ) {
					s += t.getText();
				}
				break;
			}
			case COLON:
			{
				d = LT(1);
				match(COLON);
				if ( inputState.guessing==0 ) {
					s += d.getText();
				}
				break;
			}
			case AT:
			{
				e = LT(1);
				match(AT);
				if ( inputState.guessing==0 ) {
					s += e.getText();
				}
				break;
			}
			case AND:
			{
				f = LT(1);
				match(AND);
				if ( inputState.guessing==0 ) {
					s += f.getText();
				}
				break;
			}
			case EQUALS:
			{
				g = LT(1);
				match(EQUALS);
				if ( inputState.guessing==0 ) {
					s += g.getText();
				}
				break;
			}
			case PLUS:
			{
				h = LT(1);
				match(PLUS);
				if ( inputState.guessing==0 ) {
					s += h.getText();
				}
				break;
			}
			default:
				if ((_tokenSet_11.member(LA(1)))) {
					r=unreserved();
					if ( inputState.guessing==0 ) {
						s += r; 		
					}
				}
				else if ((LA(1)==COMMA)) {
					b = LT(1);
					match(COMMA);
					if ( inputState.guessing==0 ) {
						s += b.getText();
					}
				}
				else if ((LA(1)==SEMICOLON)) {
					c = LT(1);
					match(SEMICOLON);
					if ( inputState.guessing==0 ) {
						s += c.getText();
					}
				}
			else {
				if ( _cnt929>=1 ) { break _loop929; } else {throw new NoViableAltException(LT(1), getFilename());}
			}
			}
			_cnt929++;
		} while (true);
		}
		if ( inputState.guessing==0 ) {
			
				a = new AuthorityRegname();
				a.setRegName(s);
				a.setInputText(stopTracking());
			
		}
		return a ;
	}
	
	public final  UserInfo  userinfo() throws RecognitionException, TokenStreamException {
		 UserInfo uinfo ;
		
		
			String u;
			String p = null ; // Default is no password
			uinfo = new UserInfo();
			startTracking();
		
		
		u=user();
		{
		switch ( LA(1)) {
		case COLON:
		{
			match(COLON);
			p=password();
			break;
		}
		case AT:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			
				uinfo.setUser(u);
				uinfo.setPassword(p);
				uinfo.setInputText(stopTracking());
				if (u.indexOf(Separators.POUND) >= 0  || 
					u.indexOf(Separators.SEMICOLON) >= 0) {
					uinfo.setUserType(UserInfo.TELEPHONE_SUBSCRIBER);
				} else uinfo.setUserType(UserInfo.USER);
			
			
		}
		return uinfo ;
	}
	
	public final  String  userinfo_h() throws RecognitionException, TokenStreamException {
		 String s ;
		
		Token  a = null;
		Token  b = null;
		Token  c = null;
		Token  d = null;
		Token  e = null;
		Token  f = null;
		Token  h = null;
		Token  g = null;
		
		s = "";
		String r;
		
		
		{
		_loop937:
		do {
			switch ( LA(1)) {
			case ALPHA:
			case DIGIT:
			case UNDERSCORE:
			case MINUS:
			case QUOTE:
			case EXCLAMATION:
			case TILDE:
			case STAR:
			case DOT:
			case LPAREN:
			case RPAREN:
			{
				r=unreserved();
				if ( inputState.guessing==0 ) {
					s += r; 		
				}
				break;
			}
			case PERCENT:
			{
				r=escaped();
				if ( inputState.guessing==0 ) {
					s += r; 		
				}
				break;
			}
			case SEMICOLON:
			{
				a = LT(1);
				match(SEMICOLON);
				if ( inputState.guessing==0 ) {
					s += a.getText();
				}
				break;
			}
			case COLON:
			{
				b = LT(1);
				match(COLON);
				if ( inputState.guessing==0 ) {
					s += b.getText();
				}
				break;
			}
			case AND:
			{
				c = LT(1);
				match(AND);
				if ( inputState.guessing==0 ) {
					s += c.getText();
				}
				break;
			}
			case EQUALS:
			{
				d = LT(1);
				match(EQUALS);
				if ( inputState.guessing==0 ) {
					s += d.getText();
				}
				break;
			}
			case PLUS:
			{
				e = LT(1);
				match(PLUS);
				if ( inputState.guessing==0 ) {
					s += e.getText();
				}
				break;
			}
			case DOLLAR:
			{
				f = LT(1);
				match(DOLLAR);
				if ( inputState.guessing==0 ) {
					s += f.getText();
				}
				break;
			}
			case SLASH:
			{
				h = LT(1);
				match(SLASH);
				if ( inputState.guessing==0 ) {
					s += h.getText();
				}
				break;
			}
			case COMMA:
			{
				g = LT(1);
				match(COMMA);
				if ( inputState.guessing==0 ) {
					s += g.getText();
				}
				break;
			}
			default:
			{
				break _loop937;
			}
			}
		} while (true);
		}
		return s ;
	}
	
	public final  PathSegments  path_segments() throws RecognitionException, TokenStreamException {
		 PathSegments s ;
		
		
			Segment p = null;
			s = new PathSegments();
			startTracking();
		
		
		p=segment();
		if ( inputState.guessing==0 ) {
			s.add(p);
		}
		{
		switch ( LA(1)) {
		case SLASH:
		{
			{
			int _cnt944=0;
			_loop944:
			do {
				if ((LA(1)==SLASH)) {
					match(SLASH);
					p=segment();
					if ( inputState.guessing==0 ) {
						s.add(p);
					}
				}
				else {
					if ( _cnt944>=1 ) { break _loop944; } else {throw new NoViableAltException(LT(1), getFilename());}
				}
				
				_cnt944++;
			} while (true);
			}
			break;
		}
		case SP:
		case HT:
		case RETURN:
		case LPAREN:
		case POUND:
		case SEMICOLON:
		case QUESTION:
		case COMMA:
		case GREATER_THAN:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			
				s.setInputText(stopTracking());
			
		}
		return s ;
	}
	
	public final  Segment  segment() throws RecognitionException, TokenStreamException {
		 Segment s ;
		
		
			s = new Segment() ; 
			String q = "";
			String p = null;
			String r ;
			startTracking();
		
		
		{
		_loop947:
		do {
			if ((_tokenSet_12.member(LA(1)))) {
				r=pchar();
				if ( inputState.guessing==0 ) {
					if (p == null) p = r ; else p += r ;
				}
			}
			else {
				break _loop947;
			}
			
		} while (true);
		}
		if ( inputState.guessing==0 ) {
			s.setPath(p);
		}
		{
		boolean synPredMatched950 = false;
		if (((LA(1)==SEMICOLON))) {
			int _m950 = mark();
			synPredMatched950 = true;
			inputState.guessing++;
			try {
				{
				match(SEMICOLON);
				}
			}
			catch (RecognitionException pe) {
				synPredMatched950 = false;
			}
			rewind(_m950);
			inputState.guessing--;
		}
		if ( synPredMatched950 ) {
			{
			int _cnt954=0;
			_loop954:
			do {
				if ((LA(1)==SEMICOLON)) {
					match(SEMICOLON);
					{
					int _cnt953=0;
					_loop953:
					do {
						if ((_tokenSet_12.member(LA(1)))) {
							r=pchar();
							if ( inputState.guessing==0 ) {
								q += r ;
							}
						}
						else {
							if ( _cnt953>=1 ) { break _loop953; } else {throw new NoViableAltException(LT(1), getFilename());}
						}
						
						_cnt953++;
					} while (true);
					}
					if ( inputState.guessing==0 ) {
						s.getParmList().add(q);
					}
				}
				else {
					if ( _cnt954>=1 ) { break _loop954; } else {throw new NoViableAltException(LT(1), getFilename());}
				}
				
				_cnt954++;
			} while (true);
			}
		}
		else if ((_tokenSet_13.member(LA(1)))) {
		}
		else {
			throw new NoViableAltException(LT(1), getFilename());
		}
		
		}
		if ( inputState.guessing==0 ) {
			
			s.setInputText(stopTracking());
			
		}
		return s ;
	}
	
	public final  String  pchar() throws RecognitionException, TokenStreamException {
		 String s ;
		
		Token  a = null;
		Token  b = null;
		Token  c = null;
		Token  d = null;
		Token  e = null;
		Token  f = null;
		Token  g = null;
		
			s = null;
			String r;
			
		
		
		{
		switch ( LA(1)) {
		case ALPHA:
		case DIGIT:
		case UNDERSCORE:
		case MINUS:
		case QUOTE:
		case EXCLAMATION:
		case TILDE:
		case STAR:
		case DOT:
		case LPAREN:
		case RPAREN:
		{
			r=unreserved();
			if ( inputState.guessing==0 ) {
				s = r; 		
			}
			break;
		}
		case PERCENT:
		{
			r=escaped();
			if ( inputState.guessing==0 ) {
				s = r; 		
			}
			break;
		}
		case COLON:
		{
			a = LT(1);
			match(COLON);
			if ( inputState.guessing==0 ) {
				s = a.getText(); 	
			}
			break;
		}
		case AT:
		{
			b = LT(1);
			match(AT);
			if ( inputState.guessing==0 ) {
				s = b.getText();
			}
			break;
		}
		case AND:
		{
			c = LT(1);
			match(AND);
			if ( inputState.guessing==0 ) {
				s = c.getText();	
			}
			break;
		}
		case EQUALS:
		{
			d = LT(1);
			match(EQUALS);
			if ( inputState.guessing==0 ) {
				s = d.getText(); 	
			}
			break;
		}
		case PLUS:
		{
			e = LT(1);
			match(PLUS);
			if ( inputState.guessing==0 ) {
				s = e.getText();
			}
			break;
		}
		case DOLLAR:
		{
			f = LT(1);
			match(DOLLAR);
			if ( inputState.guessing==0 ) {
				s = f.getText(); 	
			}
			break;
		}
		case COMMA:
		{
			g = LT(1);
			match(COMMA);
			if ( inputState.guessing==0 ) {
				s = g.getText(); 	
			}
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		return s ;
	}
	
	public final  RelPath  rel_path() throws RecognitionException, TokenStreamException {
		 RelPath s ;
		
		
			s = new RelPath();
			String r = null;
			AbsPath a = null;
			startTracking();
		
		
		r=rel_segment();
		{
		switch ( LA(1)) {
		case SLASH:
		{
			a=abs_path();
			break;
		}
		case SP:
		case HT:
		case RETURN:
		case LPAREN:
		case POUND:
		case SEMICOLON:
		case QUESTION:
		case COMMA:
		case GREATER_THAN:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			
				  s.setRelSegment(r);
				  s.setAbsPath(a);
				  s.setInputText(stopTracking());
				
		}
		return s ;
	}
	
	public final  String  rel_segment() throws RecognitionException, TokenStreamException {
		 String s ;
		
		Token  a = null;
		Token  b = null;
		Token  c = null;
		Token  d = null;
		Token  e = null;
		Token  f = null;
		Token  g = null;
		
			s  = "";
		String r = null;
		
		
		{
		int _cnt974=0;
		_loop974:
		do {
			// nongreedy exit test
			if ( _cnt974>=1 && (_tokenSet_13.member(LA(1)))) break _loop974;
			switch ( LA(1)) {
			case PERCENT:
			{
				r=escaped();
				if ( inputState.guessing==0 ) {
					s += r; 		
				}
				break;
			}
			case AT:
			{
				b = LT(1);
				match(AT);
				if ( inputState.guessing==0 ) {
					s += b.getText();	
				}
				break;
			}
			case AND:
			{
				c = LT(1);
				match(AND);
				if ( inputState.guessing==0 ) {
					s += c.getText(); 	
				}
				break;
			}
			case EQUALS:
			{
				d = LT(1);
				match(EQUALS);
				if ( inputState.guessing==0 ) {
					s += d.getText(); 	
				}
				break;
			}
			case PLUS:
			{
				e = LT(1);
				match(PLUS);
				if ( inputState.guessing==0 ) {
					s += e.getText(); 	
				}
				break;
			}
			case DOLLAR:
			{
				f = LT(1);
				match(DOLLAR);
				if ( inputState.guessing==0 ) {
					s += f.getText(); 	
				}
				break;
			}
			default:
				if ((_tokenSet_11.member(LA(1)))) {
					r=unreserved();
					if ( inputState.guessing==0 ) {
						s += r; 		
					}
				}
				else if ((LA(1)==SEMICOLON)) {
					a = LT(1);
					match(SEMICOLON);
					if ( inputState.guessing==0 ) {
						s += a.getText(); 	
					}
				}
				else if ((LA(1)==COMMA)) {
					g = LT(1);
					match(COMMA);
					if ( inputState.guessing==0 ) {
						s += g.getText(); 	
					}
				}
			else {
				if ( _cnt974>=1 ) { break _loop974; } else {throw new NoViableAltException(LT(1), getFilename());}
			}
			}
			_cnt974++;
		} while (true);
		}
		return s ;
	}
	
	public final  URI  sip_urlbody() throws RecognitionException, TokenStreamException {
		 URI uri ;
		
		
			uri =  new URI();
			NameValueList parms = null;
			NameValueList qhdrs = null;
			startTracking(); 
			Authority auth;
		
		
		auth=sip_authority();
		{
		if (((LA(1)==SEMICOLON))&&(  LA(1) == SEMICOLON &&  LT(2).getText().charAt(0)  != ' ' 
	  && LT(2).getText().charAt(0) != '\t' )) {
			match(SEMICOLON);
			if ( inputState.guessing==0 ) {
				selectLexer("sip_urlLexer",sip_urlLexer.PARMS_LHS_STATE);
			}
			parms=url_parms();
			if ( inputState.guessing==0 ) {
				uri.setUriParms(parms);
			}
		}
		else if ((_tokenSet_14.member(LA(1)))) {
		}
		else {
			throw new NoViableAltException(LT(1), getFilename());
		}
		
		}
		{
		switch ( LA(1)) {
		case QUESTION:
		{
			if ( inputState.guessing==0 ) {
				selectLexer("charLexer");
			}
			qhdrs=qheaders();
			if ( inputState.guessing==0 ) {
				uri.setQheaders(qhdrs);  uri.setQuery(qhdrs.getInputText());
			}
			break;
		}
		case SP:
		case HT:
		case RETURN:
		case LPAREN:
		case SEMICOLON:
		case COMMA:
		case GREATER_THAN:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			
				uri.setAuthority(auth);
				uri.setInputText(stopTracking());
			
		}
		return uri ;
	}
	
	public final  AuthorityServer  sip_authority() throws RecognitionException, TokenStreamException {
		 AuthorityServer auth ;
		
		
			startTracking();
		
		
		auth=server_h();
		if ( inputState.guessing==0 ) {
			
				if (auth.getHostPort().getPort() == 0) 
					auth.getHostPort().setPort(SIPDefaults.DEFAULT_PORT);
				auth.setInputText(stopTracking());
			
		}
		return auth ;
	}
	
	public final  NameValueList  url_parms() throws RecognitionException, TokenStreamException {
		 NameValueList nvlist ;
		
		
			nvlist = new NameValueList("url_parms");
			NameValue nv = null;
		
		
		nv=url_parameter();
		if ( inputState.guessing==0 ) {
			nvlist.add(nv);
		}
		{
		_loop998:
		do {
			if ((LA(1)==SEMICOLON)) {
				match(SEMICOLON);
				if ( inputState.guessing==0 ) {
					selectLexer("sip_urlLexer",sip_urlLexer.PARMS_LHS_STATE);
				}
				nv=url_parameter();
				if ( inputState.guessing==0 ) {
					nvlist.add(nv);
				}
			}
			else {
				break _loop998;
			}
			
		} while (true);
		}
		return nvlist ;
	}
	
	public final  NameValueList   qheaders() throws RecognitionException, TokenStreamException {
		 NameValueList  nv ;
		
		
			NameValue n = null ;
			nv = new NameValueList("qheaders");
			nv.setSeparator(Separators.AND);
		
		
		match(QUESTION);
		n=qheader();
		if ( inputState.guessing==0 ) {
			nv.add(n);
		}
		{
		_loop995:
		do {
			if ((LA(1)==AND)) {
				match(AND);
				n=qheader();
				if ( inputState.guessing==0 ) {
					nv.add(n);
				}
			}
			else {
				break _loop995;
			}
			
		} while (true);
		}
		return nv ;
	}
	
	public final  String  user() throws RecognitionException, TokenStreamException {
		 String s ;
		
		Token  a = null;
		Token  b = null;
		Token  c = null;
		Token  d = null;
		Token  q = null;
		Token  sl = null;
		Token  p = null;
		Token  sc = null;
		Token  e = null;
		
			s = "" ;
			String r;
		
		
		{
		int _cnt991=0;
		_loop991:
		do {
			switch ( LA(1)) {
			case ALPHA:
			case DIGIT:
			case UNDERSCORE:
			case MINUS:
			case QUOTE:
			case EXCLAMATION:
			case TILDE:
			case STAR:
			case DOT:
			case LPAREN:
			case RPAREN:
			{
				r=unreserved();
				if ( inputState.guessing==0 ) {
					s += r; 	
				}
				break;
			}
			case PERCENT:
			{
				r=escaped();
				if ( inputState.guessing==0 ) {
					s += r; 	
				}
				break;
			}
			case AND:
			{
				a = LT(1);
				match(AND);
				if ( inputState.guessing==0 ) {
					s += a.getText();
				}
				break;
			}
			case EQUALS:
			{
				b = LT(1);
				match(EQUALS);
				if ( inputState.guessing==0 ) {
					s += b.getText();
				}
				break;
			}
			case PLUS:
			{
				c = LT(1);
				match(PLUS);
				if ( inputState.guessing==0 ) {
					s += c.getText();
				}
				break;
			}
			case DOLLAR:
			{
				d = LT(1);
				match(DOLLAR);
				if ( inputState.guessing==0 ) {
					s += d.getText();
				}
				break;
			}
			case QUESTION:
			{
				q = LT(1);
				match(QUESTION);
				if ( inputState.guessing==0 ) {
					s += q.getText();
				}
				break;
			}
			case SLASH:
			{
				sl = LT(1);
				match(SLASH);
				if ( inputState.guessing==0 ) {
					s += sl.getText();
				}
				break;
			}
			case POUND:
			{
				p = LT(1);
				match(POUND);
				if ( inputState.guessing==0 ) {
					s += p.getText();
				}
				break;
			}
			case SEMICOLON:
			{
				sc = LT(1);
				match(SEMICOLON);
				if ( inputState.guessing==0 ) {
					s += sc.getText();
				}
				break;
			}
			case COMMA:
			{
				e = LT(1);
				match(COMMA);
				if ( inputState.guessing==0 ) {
					s += e.getText();
				}
				break;
			}
			default:
			{
				if ( _cnt991>=1 ) { break _loop991; } else {throw new NoViableAltException(LT(1), getFilename());}
			}
			}
			_cnt991++;
		} while (true);
		}
		return s ;
	}
	
	public final  String  password() throws RecognitionException, TokenStreamException {
		 String p ;
		
		Token  a = null;
		Token  b = null;
		Token  c = null;
		Token  d = null;
		Token  e = null;
		
		p = "";  
		String s;
		
		
		{
		_loop1017:
		do {
			switch ( LA(1)) {
			case ALPHA:
			case DIGIT:
			case UNDERSCORE:
			case MINUS:
			case QUOTE:
			case EXCLAMATION:
			case TILDE:
			case STAR:
			case DOT:
			case LPAREN:
			case RPAREN:
			{
				s=unreserved();
				if ( inputState.guessing==0 ) {
					p += s;
				}
				break;
			}
			case PERCENT:
			{
				s=escaped();
				if ( inputState.guessing==0 ) {
					p += s;
				}
				break;
			}
			case AND:
			{
				a = LT(1);
				match(AND);
				if ( inputState.guessing==0 ) {
					p += a.getText();
				}
				break;
			}
			case EQUALS:
			{
				b = LT(1);
				match(EQUALS);
				if ( inputState.guessing==0 ) {
					p += b.getText();
				}
				break;
			}
			case PLUS:
			{
				c = LT(1);
				match(PLUS);
				if ( inputState.guessing==0 ) {
					p += c.getText(); 	
				}
				break;
			}
			case DOLLAR:
			{
				d = LT(1);
				match(DOLLAR);
				if ( inputState.guessing==0 ) {
					p += d.getText() ;	
				}
				break;
			}
			case COMMA:
			{
				e = LT(1);
				match(COMMA);
				if ( inputState.guessing==0 ) {
					p += e.getText();
				}
				break;
			}
			default:
			{
				break _loop1017;
			}
			}
		} while (true);
		}
		return p ;
	}
	
	public final  NameValue  qheader() throws RecognitionException, TokenStreamException {
		 NameValue v ;
		
		
			String name;
			String value;
			v = new NameValue();
			int s;
			startTracking();
		
		
		name=h_name();
		match(EQUALS);
		value=hvalue();
		if ( inputState.guessing==0 ) {
			
				v.setName(name.toLowerCase());
				// Could be URL encoded values here.
				v.setValue(java.net.URLDecoder.decode(value));
				v.setInputText(stopTracking());
			
		}
		return v ;
	}
	
	public final  NameValue  url_parameter() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		
		{
		switch ( LA(1)) {
		case TRANSPORT:
		{
			nv=transport_param();
			break;
		}
		case USER:
		{
			nv=user_param();
			break;
		}
		case METHOD:
		{
			nv=method_param();
			break;
		}
		case TTL:
		{
			nv=ttl_param();
			break;
		}
		case MADDR:
		{
			nv=maddr_param();
			break;
		}
		case ALPHA:
		case DIGIT:
		case UNDERSCORE:
		case PLUS:
		case MINUS:
		case QUOTE:
		case EXCLAMATION:
		case PERCENT:
		case TILDE:
		case BACK_QUOTE:
		case STAR:
		case DOT:
		case ID:
		{
			nv=other_param();
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		return nv ;
	}
	
	public final  NameValue  transport_param() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		
			nv = new NameValue();
			nv.setName(URIKeywords.TRANSPORT);
			startTracking();
		
		
		match(TRANSPORT);
		match(EQUALS);
		if ( inputState.guessing==0 ) {
			selectLexer("transport_Lexer");
		}
		{
		switch ( LA(1)) {
		case UDP:
		{
			match(UDP);
			if ( inputState.guessing==0 ) {
				nv.setValue(URIKeywords.UDP);
			}
			break;
		}
		case TCP:
		{
			match(TCP);
			if ( inputState.guessing==0 ) {
				nv.setValue(URIKeywords.TCP);
			}
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			
				nv.setInputText(stopTracking());
			
		}
		return nv ;
	}
	
	public final  NameValue  user_param() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		
			nv = new NameValue();
			nv.setName(SIPKeywords.USER);
			startTracking();
		
		
		match(USER);
		match(EQUALS);
		if ( inputState.guessing==0 ) {
			selectLexer("transport_Lexer");
		}
		{
		switch ( LA(1)) {
		case PHONE:
		{
			match(PHONE);
			if ( inputState.guessing==0 ) {
				nv.setValue(URIKeywords.PHONE);
			}
			break;
		}
		case IP:
		{
			match(IP);
			if ( inputState.guessing==0 ) {
				nv.setValue(SIPKeywords.IP);
			}
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			
				nv.setInputText(stopTracking());
			
		}
		return nv ;
	}
	
	public final  NameValue  method_param() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		
			nv = new NameValue();
			nv.setName(SIPKeywords.METHOD);
			startTracking();
			String s;
		
		
		match(METHOD);
		match(EQUALS);
		s=method();
		if ( inputState.guessing==0 ) {
			
				nv.setValue(s);
				nv.setInputText(stopTracking());
			
		}
		return nv ;
	}
	
	public final  NameValue  ttl_param() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		
			nv = new NameValue();
			nv.setName(SIPKeywords.TTL);
			startTracking();
			Integer t;
		
		
		match(TTL);
		match(EQUALS);
		if ( inputState.guessing==0 ) {
			selectLexer ("charLexer");
		}
		t=ttlval();
		if ( inputState.guessing==0 ) {
			
				nv.setValue(t);
				nv.setInputText(stopTracking());
			
		}
		return nv ;
	}
	
	public final  NameValue  maddr_param() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		
			nv = new NameValue();
			nv.setName(SIPKeywords.MADDR);
			Host h;
			startTracking();
		
		
		match(MADDR);
		match(EQUALS);
		if ( inputState.guessing==0 ) {
			selectLexer("charLexer");
		}
		h=host();
		if ( inputState.guessing==0 ) {
			
				nv.setValue(h);
				nv.setInputText(stopTracking());
			
		}
		return nv ;
	}
	
	public final  NameValue  other_param() throws RecognitionException, TokenStreamException {
		 NameValue nv ;
		
		Token  t3 = null;
		Token  t4 = null;
		Token  t5 = null;
		
			nv = new NameValue();
			startTracking();
			String p;
		
		
		switch ( LA(1)) {
		case ID:
		{
			t3 = LT(1);
			match(ID);
			match(EQUALS);
			t4 = LT(1);
			match(ID);
			if ( inputState.guessing==0 ) {
				
					nv.setName(t3.getText());
					nv.setValue(java.net.URLDecoder.decode(t4.getText()));
					nv.setInputText(stopTracking());
				
			}
			break;
		}
		case ALPHA:
		case DIGIT:
		case UNDERSCORE:
		case PLUS:
		case MINUS:
		case QUOTE:
		case EXCLAMATION:
		case PERCENT:
		case TILDE:
		case BACK_QUOTE:
		case STAR:
		case DOT:
		{
			p=ttoken();
			match(EQUALS);
			t5 = LT(1);
			match(ID);
			if ( inputState.guessing==0 ) {
				
					nv.setName(p);
					nv.setValue(java.net.URLDecoder.decode(t5.getText()));
					nv.setInputText(stopTracking());
				
			}
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		return nv ;
	}
	
	public final  String  extension_method() throws RecognitionException, TokenStreamException {
		 String m ;
		
		Token  t = null;
		m = null ;
		
		t = LT(1);
		match(ID);
		if ( inputState.guessing==0 ) {
			m = t.getText();
		}
		return m ;
	}
	
	public final  Integer  ttlval() throws RecognitionException, TokenStreamException {
		 Integer val ;
		
		Token  d = null;
		
			val = null;
			String ttlval = "";
		
		
		
		{
		int _cnt1013=0;
		_loop1013:
		do {
			if ((LA(1)==DIGIT)) {
				d = LT(1);
				match(DIGIT);
				if ( inputState.guessing==0 ) {
					ttlval += d.getText();
				}
			}
			else {
				if ( _cnt1013>=1 ) { break _loop1013; } else {throw new NoViableAltException(LT(1), getFilename());}
			}
			
			_cnt1013++;
		} while (true);
		}
		if ( inputState.guessing==0 ) {
			
				val =  new Integer(ttlval);
			
		}
		return val ;
	}
	
	public final  int  port() throws RecognitionException, TokenStreamException {
		 int portNum ;
		
		Token  d1 = null;
		Token  d = null;
		
			portNum = -1;
			String portString = "";
		
		
		switch ( LA(1)) {
		case DIGIT:
		{
			{
			int _cnt1034=0;
			_loop1034:
			do {
				if ((LA(1)==DIGIT)) {
					d1 = LT(1);
					match(DIGIT);
					if ( inputState.guessing==0 ) {
						portString += d1.getText();
					}
				}
				else {
					if ( _cnt1034>=1 ) { break _loop1034; } else {throw new NoViableAltException(LT(1), getFilename());}
				}
				
				_cnt1034++;
			} while (true);
			}
			if ( inputState.guessing==0 ) {
				
					portNum = Integer.parseInt(portString);
				
			}
			break;
		}
		case NUMBER:
		{
			d = LT(1);
			match(NUMBER);
			if ( inputState.guessing==0 ) {
				
				// This alternative is necesasry because of nondeterminism in the 
				// parser.
					portNum = Integer.parseInt(d.getText()); 
				
			}
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		return portNum ;
	}
	
	public final  String  ipv4_address() throws RecognitionException, TokenStreamException {
		 String ipv4address ;
		
		Token  d1 = null;
		Token  d2 = null;
		Token  d3 = null;
		Token  d4 = null;
		
			ipv4address = "";
		
		
		{
		int _cnt1037=0;
		_loop1037:
		do {
			if ((LA(1)==DIGIT)) {
				d1 = LT(1);
				match(DIGIT);
				if ( inputState.guessing==0 ) {
					ipv4address += d1.getText();
				}
			}
			else {
				if ( _cnt1037>=1 ) { break _loop1037; } else {throw new NoViableAltException(LT(1), getFilename());}
			}
			
			_cnt1037++;
		} while (true);
		}
		match(DOT);
		if ( inputState.guessing==0 ) {
			ipv4address += ".";
		}
		{
		int _cnt1039=0;
		_loop1039:
		do {
			if ((LA(1)==DIGIT)) {
				d2 = LT(1);
				match(DIGIT);
				if ( inputState.guessing==0 ) {
					ipv4address += d2.getText();
				}
			}
			else {
				if ( _cnt1039>=1 ) { break _loop1039; } else {throw new NoViableAltException(LT(1), getFilename());}
			}
			
			_cnt1039++;
		} while (true);
		}
		match(DOT);
		if ( inputState.guessing==0 ) {
			ipv4address += ".";
		}
		{
		int _cnt1041=0;
		_loop1041:
		do {
			if ((LA(1)==DIGIT)) {
				d3 = LT(1);
				match(DIGIT);
				if ( inputState.guessing==0 ) {
					ipv4address += d3.getText();
				}
			}
			else {
				if ( _cnt1041>=1 ) { break _loop1041; } else {throw new NoViableAltException(LT(1), getFilename());}
			}
			
			_cnt1041++;
		} while (true);
		}
		match(DOT);
		if ( inputState.guessing==0 ) {
			ipv4address += ".";
		}
		{
		int _cnt1043=0;
		_loop1043:
		do {
			if ((LA(1)==DIGIT)) {
				d4 = LT(1);
				match(DIGIT);
				if ( inputState.guessing==0 ) {
					ipv4address += d4.getText();
				}
			}
			else {
				if ( _cnt1043>=1 ) { break _loop1043; } else {throw new NoViableAltException(LT(1), getFilename());}
			}
			
			_cnt1043++;
		} while (true);
		}
		return ipv4address ;
	}
	
	public final String  hostname() throws RecognitionException, TokenStreamException {
		String hname;
		
		
		hname = new String(""); 
		String s1 = null;
		String s2 = null;
		pushLexer("charLexer");
		
		
		s1=domainlabel();
		if ( inputState.guessing==0 ) {
			hname = s1 + hname;
		}
		{
		_loop1027:
		do {
			if (((LA(1)==DOT))&&( LA(1) ==  DOT && (LA(2) == ALPHA || LA(2) == DIGIT || LA(3) == MINUS)  )) {
				match(DOT);
				s2=domainlabel();
				if ( inputState.guessing==0 ) {
					hname += "." + s2;
				}
			}
			else {
				break _loop1027;
			}
			
		} while (true);
		}
		{
		switch ( LA(1)) {
		case DOT:
		{
			match(DOT);
			break;
		}
		case SP:
		case HT:
		case RETURN:
		case LPAREN:
		case POUND:
		case SEMICOLON:
		case COLON:
		case SLASH:
		case QUESTION:
		case COMMA:
		case GREATER_THAN:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			
			// check if the toplabel starts with a alpha else throw an exception...
			int lindex = hname.lastIndexOf('.');
			if (lindex == -1) {
				// only toplabel - make sure it starts with an alpha
				char ch1 = hname.charAt(0);
				if ( isDigit(ch1) || ch1 == '-' ) {
				   throw new RecognitionException("Invalid host name " + hname);
				}
			} else { 
				// s2 better not be null
			// s2 is the last piece of the segment - it had better start with
				// an alpha or it is not a domain name
				char ch1 = s2.charAt(0);
				if ( isDigit(ch1) || ch1  ==  '-' ) {
				   throw new RecognitionException("Invalid host name " + hname);
				}
			}
			// Hostnames are not case sensitive.
			hname = hname.toLowerCase();
			popLexer();
			
		}
		return hname;
	}
	
	public final  String  domainlabel() throws RecognitionException, TokenStreamException {
		 String dlabel ;
		
		Token  a = null;
		Token  d = null;
		Token  m = null;
		dlabel = new String("");
		
		{
		int _cnt1031=0;
		_loop1031:
		do {
			switch ( LA(1)) {
			case ALPHA:
			{
				a = LT(1);
				match(ALPHA);
				if ( inputState.guessing==0 ) {
					dlabel += a.getText();
				}
				break;
			}
			case DIGIT:
			{
				d = LT(1);
				match(DIGIT);
				if ( inputState.guessing==0 ) {
					dlabel += d.getText();
				}
				break;
			}
			case MINUS:
			{
				m = LT(1);
				match(MINUS);
				if ( inputState.guessing==0 ) {
					dlabel += m.getText();
				}
				break;
			}
			default:
			{
				if ( _cnt1031>=1 ) { break _loop1031; } else {throw new NoViableAltException(LT(1), getFilename());}
			}
			}
			_cnt1031++;
		} while (true);
		}
		if ( inputState.guessing==0 ) {
			
				     if ( dlabel.charAt(dlabel.length() -1 ) == '-')
				         throw new RecognitionException("Bad domain label!");
				     else if ( dlabel.charAt(0) == '-') 
				         throw new RecognitionException("Bad domain label!");
				
		}
		return dlabel ;
	}
	
	public final  String  ttoken_allow_space() throws RecognitionException, TokenStreamException {
		 String s ;
		
		Token  t1 = null;
		Token  t2 = null;
		Token  t3 = null;
		Token  t4 = null;
		Token  t5 = null;
		Token  t6 = null;
		Token  t7 = null;
		Token  t8 = null;
		Token  t9 = null;
		Token  t10 = null;
		Token  t11 = null;
		Token  t12 = null;
		Token  t13 = null;
		Token  t14 = null;
		
		s = "";
		
		
		{
		switch ( LA(1)) {
		case ALPHA:
		{
			t1 = LT(1);
			match(ALPHA);
			if ( inputState.guessing==0 ) {
				s = t1.getText();
			}
			break;
		}
		case DIGIT:
		{
			t2 = LT(1);
			match(DIGIT);
			if ( inputState.guessing==0 ) {
				s = t2.getText();
			}
			break;
		}
		case UNDERSCORE:
		{
			t3 = LT(1);
			match(UNDERSCORE);
			if ( inputState.guessing==0 ) {
				s = t3.getText();
			}
			break;
		}
		case PLUS:
		{
			t4 = LT(1);
			match(PLUS);
			if ( inputState.guessing==0 ) {
				s = t4.getText();
			}
			break;
		}
		case MINUS:
		{
			t5 = LT(1);
			match(MINUS);
			if ( inputState.guessing==0 ) {
				s = t5.getText();
			}
			break;
		}
		case QUOTE:
		{
			t6 = LT(1);
			match(QUOTE);
			if ( inputState.guessing==0 ) {
				s = t6.getText();
			}
			break;
		}
		case EXCLAMATION:
		{
			t7 = LT(1);
			match(EXCLAMATION);
			if ( inputState.guessing==0 ) {
				s = t7.getText();
			}
			break;
		}
		case PERCENT:
		{
			t8 = LT(1);
			match(PERCENT);
			if ( inputState.guessing==0 ) {
				s = t8.getText();
			}
			break;
		}
		case TILDE:
		{
			t9 = LT(1);
			match(TILDE);
			if ( inputState.guessing==0 ) {
				s = t9.getText();
			}
			break;
		}
		case BACK_QUOTE:
		{
			t10 = LT(1);
			match(BACK_QUOTE);
			if ( inputState.guessing==0 ) {
				s = t10.getText();
			}
			break;
		}
		case STAR:
		{
			t11 = LT(1);
			match(STAR);
			if ( inputState.guessing==0 ) {
				s = t11.getText();
			}
			break;
		}
		case DOT:
		{
			t12 = LT(1);
			match(DOT);
			if ( inputState.guessing==0 ) {
				s = t12.getText();
			}
			break;
		}
		case SP:
		{
			t13 = LT(1);
			match(SP);
			if ( inputState.guessing==0 ) {
				s = t13.getText();
			}
			break;
		}
		case HT:
		{
			t14 = LT(1);
			match(HT);
			if ( inputState.guessing==0 ) {
				s = t14.getText();
			}
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		if ( inputState.guessing==0 ) {
			
			pushLexer("charLexer");
				String r = "";
				while(true) {
					Token d = LT(1);
					if (d == null || d.getType() == Token.EOF_TYPE ) {
						throw new RecognitionException("Premature EOF");
					}		
					int ttype = d.getType();
			
					if (  ttype == ALPHA   || ttype == DIGIT || ttype == UNDERSCORE
					   || ttype == PLUS    || ttype == QUOTE || ttype == EXCLAMATION
					   || ttype == PERCENT || ttype == TILDE || ttype == BACK_QUOTE 
					   || ttype == DOT     || ttype == MINUS || ttype == STAR 
					   || ttype == HT	|| ttype == SP ) {
						r += d.getText();
						consume();
					} else {
						track(r);
						break;
					}
			}
			s += r;
			popLexer();
			
		}
		return s ;
	}
	
	public final  long  number() throws RecognitionException, TokenStreamException {
		 long i ;
		
		Token  t = null;
		Token  d = null;
		
			String s = "";
			i = 0;
		
		
		switch ( LA(1)) {
		case NUMBER:
		{
			t = LT(1);
			match(NUMBER);
			if ( inputState.guessing==0 ) {
				
					// This alternative is necessary because of non-determinism in
					// the parser.
					i = Long.parseLong(t.getText()); 
				
			}
			break;
		}
		case DIGIT:
		{
			{
			int _cnt1053=0;
			_loop1053:
			do {
				if ((LA(1)==DIGIT)) {
					d = LT(1);
					match(DIGIT);
					if ( inputState.guessing==0 ) {
						s += d.getText();
					}
				}
				else {
					if ( _cnt1053>=1 ) { break _loop1053; } else {throw new NoViableAltException(LT(1), getFilename());}
				}
				
				_cnt1053++;
			} while (true);
			}
			if ( inputState.guessing==0 ) {
				
					i = Long.parseLong(s);
				
			}
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		return i ;
	}
	
	public final  String  byte_string_no_semicolon() throws RecognitionException, TokenStreamException {
		 String s ;
		
		Token  d = null;
		
			s = "";
		
		
		d = LT(1);
		matchNot(RETURN);
		if ( inputState.guessing==0 ) {
			
			pushLexer("charLexer");
			while ( true ) {
				s += d.getText();
				d = LT(1);
				if (d == null || d.getType() == Token.EOF_TYPE) {
					throw new RecognitionException("Premature EOF");
				}	
				if (d.getType() == RETURN ) break;
				else if (d.getType() == charLexerTokenTypes.SEMICOLON) break;
				consume();
			}
			track(s);
			popLexer();
			
		}
		return s ;
	}
	
	
	public static final String[] _tokenNames = {
		"<0>",
		"EOF",
		"<2>",
		"NULL_TREE_LOOKAHEAD",
		"ALPHA",
		"DIGIT",
		"UNDERSCORE",
		"PLUS",
		"MINUS",
		"QUOTE",
		"EXCLAMATION",
		"PERCENT",
		"TILDE",
		"BACK_QUOTE",
		"STAR",
		"DOT",
		"SP",
		"HT",
		"EQUALS",
		"NUMBER",
		"RETURN",
		"DOUBLEQUOTE",
		"LPAREN",
		"RPAREN",
		"POUND",
		"SEMICOLON",
		"ISUB",
		"POSTDIAL",
		"PROVIDER_TAG",
		"PHONE_CONTEXT_TAG",
		"ID",
		"COLON",
		"SLASH",
		"QUESTION",
		"AT",
		"AND",
		"DOLLAR",
		"COMMA",
		"SIP",
		"TRANSPORT",
		"UDP",
		"TCP",
		"USER",
		"PHONE",
		"IP",
		"METHOD",
		"REGISTER",
		"ACK",
		"OPTIONS",
		"BYE",
		"INVITE",
		"CANCEL",
		"TTL",
		"MADDR",
		"NULL",
		"SUPPORTED_COLON",
		"CALL_INFO_COLON",
		"ACCEPT_ENCODING_COLON",
		"ACCEPT_LANGUAGE_COLON",
		"CALL_ID_COLON",
		"MIME_VERSION_COLON",
		"CSEQ_COLON",
		"DATE_COLON",
		"ENCRYPTION_COLON",
		"FROM_COLON",
		"RECORD_ROUTE_COLON",
		"TIMESTAMP_COLON",
		"TO_COLON",
		"ACCEPT_COLON",
		"VIA_COLON",
		"ORGANIZATION_COLON",
		"REQUIRE_COLON",
		"USER_AGENT_COLON",
		"CONTACT_COLON",
		"ALERT_INFO_COLON",
		"ALSO_COLON",
		"IN_REPLY_TO_COLON",
		"AUTHORIZATION_COLON",
		"HIDE_COLON",
		"MAX_FORWARDS_COLON",
		"PRIORITY_COLON",
		"PROXY_AUTHORIZATION_COLON",
		"PROXY_REQUIRE_COLON",
		"ROUTE_COLON",
		"RESPONSE_KEY_COLON",
		"SUBJECT_COLON",
		"CONTENT_DISPOSITION_COLON",
		"CONTENT_LANGUAGE_COLON",
		"EXPIRES_COLON",
		"ALLOW_COLON",
		"CONTENT_TYPE_COLON",
		"CONTENT_ENCODING_COLON",
		"CONTENT_LENGTH_COLON",
		"ERROR_INFO_COLON",
		"PROXY_AUTHENTICATE_COLON",
		"SERVER_COLON",
		"UNSUPPORTED_COLON",
		"RETRY_AFTER_COLON",
		"WARNING_COLON",
		"WWW_AUTHENTICATE_COLON",
		"HEADER_NAME_COLON",
		"RENDER",
		"SESSION",
		"ICON",
		"ALERT",
		"HANDLING",
		"OPTIONAL",
		"REQUIRED",
		"LESS_THAN",
		"GREATER_THAN",
		"PURPOSE",
		"INFO",
		"CARD",
		"Q",
		"TAG",
		"HIDDEN",
		"RECEIVED",
		"BRANCH",
		"BASIC",
		"PGP",
		"DIGEST",
		"CNONCE",
		"USERNAME",
		"URI",
		"RESPONSE",
		"NC",
		"SIGNED_BY",
		"SIGNATURE",
		"DURATION",
		"GMT",
		"MON",
		"TUE",
		"WED",
		"THU",
		"FRI",
		"SAT",
		"SUN",
		"JAN",
		"FEB",
		"MAR",
		"APR",
		"MAY",
		"JUN",
		"JUL",
		"AUG",
		"SEP",
		"OCT",
		"NOV",
		"DEC",
		"ROUTE",
		"HOP",
		"EMERGENCY",
		"URGENT",
		"NORMAL",
		"NON_URGENT",
		"STAR_FLAG",
		"ACTION",
		"PROXY",
		"REDIRECT",
		"EXPIRES",
		"VERSION",
		"ALGORITHM",
		"NONCE",
		"PUBKEY",
		"REALM",
		"QOP",
		"OPAQUE",
		"DOMAIN",
		"STALE"
	};
	
	private static final long _tokenSet_0_data_[] = { -1048592L, -1L, 2199023255551L, 0L, 0L, 0L };
	public static final BitSet _tokenSet_0 = new BitSet(_tokenSet_0_data_);
	private static final long _tokenSet_1_data_[] = { 275953942528L, 17592186044416L, 0L, 0L };
	public static final BitSet _tokenSet_1 = new BitSet(_tokenSet_1_data_);
	private static final long _tokenSet_2_data_[] = { 537991118832L, 0L, 0L };
	public static final BitSet _tokenSet_2 = new BitSet(_tokenSet_2_data_);
	private static final long _tokenSet_3_data_[] = { 137473753088L, 0L, 0L };
	public static final BitSet _tokenSet_3 = new BitSet(_tokenSet_3_data_);
	private static final long _tokenSet_4_data_[] = { 137477947392L, 0L, 0L };
	public static final BitSet _tokenSet_4 = new BitSet(_tokenSet_4_data_);
	private static final long _tokenSet_5_data_[] = { 272776617968L, 0L, 0L };
	public static final BitSet _tokenSet_5 = new BitSet(_tokenSet_5_data_);
	private static final long _tokenSet_6_data_[] = { 1073807344L, 0L, 0L };
	public static final BitSet _tokenSet_6 = new BitSet(_tokenSet_6_data_);
	private static final long _tokenSet_7_data_[] = { 262039461872L, 0L, 0L };
	public static final BitSet _tokenSet_7 = new BitSet(_tokenSet_7_data_);
	private static final long _tokenSet_8_data_[] = { 257744494576L, 0L, 0L };
	public static final BitSet _tokenSet_8 = new BitSet(_tokenSet_8_data_);
	private static final long _tokenSet_9_data_[] = { 253466304496L, 0L, 0L };
	public static final BitSet _tokenSet_9 = new BitSet(_tokenSet_9_data_);
	private static final long _tokenSet_10_data_[] = { 259891978224L, 0L, 0L };
	public static final BitSet _tokenSet_10 = new BitSet(_tokenSet_10_data_);
	private static final long _tokenSet_11_data_[] = { 12638064L, 0L, 0L };
	public static final BitSet _tokenSet_11 = new BitSet(_tokenSet_11_data_);
	private static final long _tokenSet_12_data_[] = { 259858423792L, 0L, 0L };
	public static final BitSet _tokenSet_12 = new BitSet(_tokenSet_12_data_);
	private static final long _tokenSet_13_data_[] = { 150379626496L, 35184372088832L, 0L, 0L };
	public static final BitSet _tokenSet_13 = new BitSet(_tokenSet_13_data_);
	private static final long _tokenSet_14_data_[] = { 146067881984L, 35184372088832L, 0L, 0L };
	public static final BitSet _tokenSet_14 = new BitSet(_tokenSet_14_data_);
	
	}