Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /* Generated By:JavaCC: Do not edit this line. FeatureParser.java */
   /*
   
       ngs-feature  Features.
       Copyright (c) 2014-2015 National Marrow Donor Program (NMDP)
   
       This library is free software; you can redistribute it and/or modify it
       under the terms of the GNU Lesser General Public License as published
       by the Free Software Foundation; either version 3 of the License, or (at
      your option) any later version.
  
      This library is distributed in the hope that it will be useful, but WITHOUT
      ANY WARRANTY; with out even the implied warranty of MERCHANTABILITY or
      FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
      License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with this library;  if not, write to the Free Software Foundation,
      Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA.
  
      > http://www.gnu.org/licenses/lgpl.html
  
  */
  package org.nmdp.ngs.feature.parser;
  
  
  
  import java.util.List;
  import java.util.Map;
  import java.util.TreeMap;
  
  
  
  
  
  
  
Feature parser.
  
  public final class FeatureParser implements FeatureParserConstants {
  
      public static SimpleGFFRecord parseOneRecord(final String fieldsthrows ParseException {
          FeatureParser featureParser = new FeatureParser(new StringReader(fields));
          return featureParser.parse();
      }
  
      public static Double parseNumber(final String fieldthrows ParseException {
          return (new FeatureParser(new StringReader(field))).parseNumber();
      }
  
      public static Double parseNumberField(final String fieldthrows ParseException {
          return (new FeatureParser(new StringReader(field))).parseNumberField();
      }
  
      public static List<DoubleparseNumbers(final String fieldsthrows ParseException {
          return (new FeatureParser(new StringReader(fields))).parseNumbers();
      }
  
      public static SimpleAnnotation parseAnnotations(final String fieldsthrows ParseException {
          return (new FeatureParser(new StringReader(fields))).parseAnnotations();
      }
  
      public static BigInteger parseLocation(final String fieldthrows ParseException {
          return (new FeatureParser(new StringReader(field))).parseLocation();
      }
  
      public static RangeLocation parseRangeLocation(final String fieldthrows ParseException {
          return (new FeatureParser(new StringReader(field))).parseRangeLocation();
      }
  
      public static Locus parseLocus(final String fieldthrows ParseException {
          return (new FeatureParser(new StringReader(field))).parseLocus();
      }
  
      public static VcfRecord parseVcfRecord(final String fieldfinal long lineNumberthrows ParseException {
          return (new FeatureParser(new StringReader(field))).parseVcfRecord(lineNumber);
     }
 
     public static List<SampleparseVcfSamples(final String fieldfinal VcfFile.Header headerthrows ParseException {
         return (new FeatureParser(new StringReader(field))).parseVcfSamples(header);
     }
 
     public static String parseVcfVersion(final String fieldthrows ParseException {
         return (new FeatureParser(new StringReader(field))).parseVcfVersion();
     }
 
     public static VcfFile.Header parseVcfHeader(final String fieldthrows ParseException {
         return (new FeatureParser(new StringReader(field))).parseVcfHeader();
     }
 
     public static VcfFile.Metadata parseVcfMetadata(final String fieldthrows ParseException {
         return (new FeatureParser(new StringReader(field.replace(","";")))).parseVcfMetadata();
     }
 
     public static Sequence parseDnaSequence(final String fieldthrows ParseException {
         return parseDnaSequence(field"");
     }
 
     public static Sequence parseDnaSequence(final String fieldfinal String namethrows ParseException {
         return (new FeatureParser(new StringReader(field))).parseDna(name);
     }
 
     public static String parseDnas(final String fieldsthrows ParseException {
         // stub
         return null;
     }
 
     public static String parseSequence(final String fieldthrows ParseException {
         // stub
         return null;
     }
 
     public static String parseSequence(final String fieldfinal String urifinal String namefinal Annotation annotationthrows ParseException {
         // stub
         return null;
     }
 
     public static String parseSequences(final String fieldthrows ParseException {
         // stub
         return null;
     }
 
     public static StrandedFeature.Strand parseGffStrand(final String fieldthrows ParseException {
         FeatureParser featureParser = new FeatureParser(new StringReader(field));
         return featureParser.parseGffStrand();
     }
 
   final public SimpleGFFRecord parse() throws ParseException {
   String sequenceName;
   String source;
   String feature;
   BigInteger start;
   BigInteger end;
   //Double score;
   StrandedFeature.Strand strand;
   Integer frame;
   String comment;
   Map<StringObjectattributes;
     //sequenceName = "" <TAB>
         //source = "" <TAB>
         //feature = "" <TAB>
         start = parseInteger();
     end = parseInteger();
     //score = 0 <TAB>
         strand = parseGffStrand();
     jj_consume_token(0);
     {if (truereturn new SimpleGFFRecord(""""""start.intValue(), end.intValue(), 0, strand, 0, ""null);}
     throw new Error("Missing return statement in function");
   }
 
   final private String parseString() throws ParseException {
   Token token;
   //System.out.println("INSIDE parseString()");
   String string;
     if (jj_2_1(2)) {
       token = jj_consume_token();
     } else if (jj_2_2(2)) {
       token = jj_consume_token();
     } else if (jj_2_3(2)) {
       token = jj_consume_token();
     } else {
       jj_consume_token(-1);
       throw new ParseException();
     }
     {if (truereturn token.image;}
     throw new Error("Missing return statement in function");
   }
 
   final private String parseStringSkip(long nsthrows ParseException {
   Token token;
   //System.out.println("parseStringSkip(" + ns + ")");
   String string;
     token = jj_consume_token();
     {if (truereturn token.image;}
     throw new Error("Missing return statement in function");
   }
 
   final private List<StringparseStrings() throws ParseException {
   String string;
   List<Stringstrings = new ArrayList<String>();
     if (jj_2_5(2)) {
       string = parseString();
     strings.add(string);
       label_1:
       while (true) {
         if (jj_2_4(2)) {
           ;
         } else {
           break label_1;
         }
         jj_consume_token();
         string = parseString();
     strings.add(string);
       }
     } else {
       ;
     }
     {if (truereturn strings;}
     throw new Error("Missing return statement in function");
   }
 
   final private BigInteger parseInteger() throws ParseException {
   Token token;
     token = jj_consume_token();
     {if (truereturn new BigInteger(token.image);}
     throw new Error("Missing return statement in function");
   }
 
   final public Double parseNumber() throws ParseException {
   Token token;
     if (jj_2_6(2)) {
       token = jj_consume_token();
     } else if (jj_2_7(2)) {
       token = jj_consume_token();
     } else {
       jj_consume_token(-1);
       throw new ParseException();
     }
     {if (truereturn new Double(token.image);}
     throw new Error("Missing return statement in function");
   }
 
   final private Double parseNumberField() throws ParseException {
   Double number;
     number = parseNumber();
     jj_consume_token(0);
     {if (truereturn number;}
     throw new Error("Missing return statement in function");
   }
 
   final private List<DoubleparseNumbers() throws ParseException {
   Double number;
   List<Doublenumbers = new ArrayList<Double>();
     if (jj_2_9(2)) {
       number = parseNumber();
     numbers.add(number);
       label_2:
       while (true) {
         if (jj_2_8(2)) {
           ;
         } else {
           break label_2;
         }
         jj_consume_token();
         number = parseNumber();
     numbers.add(number);
       }
     } else {
       ;
     }
     {if (truereturn numbers;}
     throw new Error("Missing return statement in function");
   }
 
   final private Object parseObject() throws ParseException {
   Object object;
     if (jj_2_10(2)) {
       object = parseNumber();
     } else if (jj_2_11(2)) {
       object = parseString();
     } else if (jj_2_12(2)) {
       object = parseDna("");
     } else {
       jj_consume_token(-1);
       throw new ParseException();
     }
     {if (truereturn object;}
     throw new Error("Missing return statement in function");
   }
 
   final private List<ObjectparseObjects() throws ParseException {
   Object object;
   List<Objectobjects = new ArrayList<Object>();
     object = parseObject();
     objects.add(object);
     label_3:
     while (true) {
       if (jj_2_13(2)) {
         ;
       } else {
         break label_3;
       }
       jj_consume_token();
       object = parseObject();
     objects.add(object);
     }
     {if (truereturn objects;}
     throw new Error("Missing return statement in function");
   }
 
   final private SimpleAnnotation parseAnnotations() throws ParseException {
   String key;
   List<Objectvalues = new ArrayList<Object>();
   Map<StringList<Object>> map = new TreeMap<StringList<Object>>();
     key = parseString();
     if (jj_2_14(2)) {
       jj_consume_token();
       values = parseObjects();
     } else {
       ;
     }
     map.put(keyvalues);
     //System.out.println("map.put(" + key + ", " + values + ")");
 
     label_4:
     while (true) {
       if (jj_2_15(2)) {
         ;
       } else {
         break label_4;
       }
       key = parseString();
     values = new ArrayList<Object>();
       if (jj_2_16(2)) {
         jj_consume_token();
         values = parseObjects();
       } else {
         ;
       }
     map.put(keyvalues);
     //System.out.println("map.put(" + key + ", " + values + ")");
 
     }
     {if (truereturn new SimpleAnnotation(map);}
     throw new Error("Missing return statement in function");
   }
 
   final private BigInteger parseLocation() throws ParseException {
   Token token;
   BigInteger location;
     if (jj_2_17(2)) {
       location = parseInteger();
     {if (truereturn location;}
     } else if (jj_2_18(2)) {
       token = jj_consume_token();
     {if (truereturn new BigInteger(token.image.replace(","""));}
     } else {
       jj_consume_token(-1);
       throw new ParseException();
     }
     throw new Error("Missing return statement in function");
   }
 
   final private RangeLocation parseRangeLocation() throws ParseException {
   BigInteger lower = null , upper = null;
   char sign = '?';
     lower = parseLocation();
     if (jj_2_22(2)) {
       if (jj_2_21(2)) {
         if (jj_2_19(2)) {
           jj_consume_token();
         } else if (jj_2_20(2)) {
           jj_consume_token();
           jj_consume_token();
         } else {
           jj_consume_token(-1);
           throw new ParseException();
         }
       } else {
         ;
       }
       upper = parseLocation();
     // System.out.println("tab or .. : lower = " + lower + " upper = " + upper + " negated = " + upper.negate());
     if (lower.compareTo(.) == 1 && upper.compareTo(.) == -1) {
       upper = upper.negate();
     }
     } else if (jj_2_23(2)) {
       upper = parseLocation();
       //System.out.println("plus : lower = " + lower);
       //System.out.println("     : upper = " + upper);
       upper = ..add(lower.add(upper));
       //System.out.println("plus : lower = " + lower + " upper = " + upper);
 
     } else {
       jj_consume_token(-1);
       throw new ParseException();
     }
     if (upper == null) {
       {if (truethrow new ParseException("cannot parse upper coordinate");}
     }
 
     try {
       // System.out.println("new RangeLocation(" + lower.intValue() + ", " + upper.intValue() + ")");
       {if (truereturn new RangeLocation(lower.intValue(), upper.intValue());}
     }
     catch (IndexOutOfBoundsException exception) {
       {if (truethrow new ParseException(exception.getMessage());}
     }
     throw new Error("Missing return statement in function");
   }
 
   final private Locus parseLocus() throws ParseException {
   String contig;
   BigInteger integer;
   RangeLocation range;
     if (jj_2_24(2)) {
       contig = parseString();
     } else if (jj_2_25(2)) {
       integer = parseInteger();
     contig = integer.toString();
     } else {
       jj_consume_token(-1);
       throw new ParseException();
     }
     range = parseRangeLocation();
     {if (truereturn new Locus(contigrange);}
     throw new Error("Missing return statement in function");
   }
 
   final private List<ObjectparseVcfGenotypes() throws ParseException {
   BigInteger index;
   List<Objectindexes = new ArrayList<Object>();
     index = parseInteger();
     indexes.add(index);
     label_5:
     while (true) {
       if (jj_2_26(2)) {
         ;
       } else {
         break label_5;
       }
       if (jj_2_27(2)) {
         jj_consume_token();
       } else if (jj_2_28(2)) {
         jj_consume_token();
       } else {
         jj_consume_token(-1);
         throw new ParseException();
       }
       index = parseInteger();
     indexes.add(index);
     }
     {if (truereturn indexes;}
     throw new Error("Missing return statement in function");
   }
 
   final private List<StringparseVcfFormat() throws ParseException {
   String tag;
   List<Stringtags = new ArrayList<String>();
     tag = parseString();
     tags.add(tag);
     label_6:
     while (true) {
       if (jj_2_29(2)) {
         ;
       } else {
         break label_6;
       }
       jj_consume_token();
       tag = parseString();
     tags.add(tag);
     }
     {if (truereturn tags;}
     throw new Error("Missing return statement in function");
   }
 
   final private List<SampleparseVcfSamples(VcfFile.Header headerthrows ParseException {
   int formatIndex;
   int sampleIndex;
   String tag;
   List<Stringtags;
   List<Objectgenotypes;
   List<Objectvalues = new ArrayList<Object>();
   Map<StringList<Object>> map = new TreeMap<StringList<Object>>();
   Sample sample;
   List<Samplesamples = new ArrayList<Sample>();
     tags = parseVcfFormat();
     sampleIndex = 0;
     //System.out.println("tags = " + tags);
 
     try {
       tag = tags.get(0);
 
       if(!tag.equals("GT")) {
         {if (truethrow new ParseException("genotype field 'GT' must be first in format");}
       }
     } catch(IndexOutOfBoundsException exception) {
       {if (truethrow new ParseException("missing required genotype field 'GT' in format");}
     }
     label_7:
     while (true) {
       if (jj_2_30(2)) {
         ;
       } else {
         break label_7;
       }
       jj_consume_token();
       genotypes = parseVcfGenotypes();
     // System.out.println("genotypes = " + genotypes);
     formatIndex = 0;
 
     map.put(tags.get(formatIndex), genotypes);
       label_8:
       while (true) {
         if (jj_2_31(2)) {
           ;
         } else {
           break label_8;
         }
         jj_consume_token();
         values = parseObjects();
     try {
       map.put(tags.get(++formatIndex), values);
     } catch(IndexOutOfBoundsException exception) {
       {if (truethrow new ParseException("format field index out of bounds");}
     }
       }
     try {
       sample = new Sample(header.names.get(sampleIndex++), new SimpleAnnotation(map));
       samples.add(sample);
     } catch(IndexOutOfBoundsException exception) {
       {if (truethrow new ParseException("not enough names for observed samples");}
     }
 
     map.clear();
     }
     {if (truereturn samples;}
     throw new Error("Missing return statement in function");
   }
 
   final private VcfRecord parseVcfRecord(long lineNumberthrows ParseException {
   String contig;
   BigInteger position;
   Double quality;
   List<Stringidentifiers = new ArrayList<String>();
   Sequence ref;
   String filter;
   List<Stringfilters = new ArrayList<String>();
   List<Sequencealternates = new ArrayList<Sequence>();
   String uri;
   String name;
   SimpleAnnotation annotation;
     contig = parseString();
 
     position = parseInteger();
 
     identifiers = parseStrings();
 
     ref = parseDna("");
 
     alternates = parseDnas();
 
     quality = parseNumber();
 
     filter = parseString();
       filters.add(filter);
       //System.out.println("filter = " + filter);
 
     label_9:
     while (true) {
       if (jj_2_32(2)) {
         ;
       } else {
         break label_9;
       }
       filter = parseString();
       filters.add(filter);
     }
 
     annotation = parseAnnotations();
       List<Stringalts = new ArrayList<String>();
       for(Sequence alternate : alternates) {
         alts.add(alternate.seqString());
       }
 
       // todo:  this needs more thinkin'
       ListMultimap<StringStringinfo = ArrayListMultimap.create();
       // ...and untyped map coming from annotation is ugly
       for (Object e : annotation.asMap().entrySet()) {
           Map.Entry entry = (Map.Entrye;
           String key = (Stringentry.getKey();
           List<Objectvalues = (List<Object>) entry.getValue();
           for (Object value : values) {
               info.put(keyvalue == null ? "null" : value.toString());
           }
       }
 
       {if (truereturn VcfRecord.builder()
           .withLineNumber(lineNumber)
           .withChrom(contig)
           .withPos(position.longValue())
           .withId(identifiers.toArray(new String[identifiers.size()]))
           .withRef(ref.seqString())
           .withAlt(alts.toArray(new String[alts.size()]))
           .withQual(quality)
           .withFilter(filters.toArray(new String[filters.size()]))
           .withInfo(info)
           .build();}
     throw new Error("Missing return statement in function");
   }
 
   final private String parseVcfVersion() throws ParseException {
   SimpleAnnotation annotation;
     annotation = parseAnnotations();
     try {
       {if (truereturn (Stringannotation.getProperty("fileformat");}
     } catch(NoSuchElementException exception) {
       {if (truethrow new ParseException("expected \u005c"fileformat\u005c"");}
     }
     throw new Error("Missing return statement in function");
   }
 
   final private VcfFile.Metadata parseVcfMetadata() throws ParseException {
   String namedescription;
   SimpleAnnotation annotation;
     name = parseString();
     if (jj_2_33(2)) {
       description = parseString();
       {if (truereturn new VcfFile.Metadata(namedescription);}
     } else if (jj_2_34(2)) {
       annotation = parseAnnotations();
     } else {
       jj_consume_token(-1);
       throw new ParseException();
     }
       if(name.equals(.)) {
         try {
           {if (truereturn new VcfFile.Info(annotation);}
         } catch(VcfFileException exception) {
           {if (truethrow new ParseException(exception.getMessage());}
         }
       }
       else if(name.equals(.)) {
         try {
           {if (truereturn new VcfFile.Filter(annotation);}
         } catch(VcfFileException exception) {
           {if (truethrow new ParseException(exception.getMessage());}
         }
       }
       else if(name.equals(.)) {
         try {
           {if (truereturn new VcfFile.Format(annotation);}
         } catch(VcfFileException exception) {
           {if (truethrow new ParseException(exception.getMessage());}
         }
       }
     throw new Error("Missing return statement in function");
   }
 
   final private VcfFile.Header parseVcfHeader() throws ParseException {
   String field;
   List<Stringfields = new ArrayList<String>();
     field = parseString();
     fields.add(field);
     label_10:
     while (true) {
       if (jj_2_35(2)) {
         ;
       } else {
         break label_10;
       }
       jj_consume_token();
       field = parseString();
     fields.add(field);
     }
     try {
       {if (truereturn new VcfFile.Header(fields.subList(9, fields.size()));}
     } catch (IndexOutOfBoundsException exception) {
       {if (truethrow new ParseException("header is improperly formed");}
     }
     throw new Error("Missing return statement in function");
   }
 
   final private Sequence parseDna(String namethrows ParseException {
   Token token;
     token = jj_consume_token();
     try {
       //System.out.println("parseDna() : " + token.image);
       {if (truereturn DNATools.createDNASequence(token.imagename);}
     }
     catch(IllegalSymbolException exception) {
       {if (truethrow new ParseException(exception.getMessage());}
     }
     throw new Error("Missing return statement in function");
   }
 
   final private List<SequenceparseDnas() throws ParseException {
   Sequence sequence;
   List<Sequencesequences = new ArrayList<Sequence>();
     sequence = parseDna("");
     sequences.add(sequence);
     label_11:
     while (true) {
       if (jj_2_36(2)) {
         ;
       } else {
         break label_11;
       }
       jj_consume_token();
       sequence = parseDna("");
     sequences.add(sequence);
     }
     {if (truereturn sequences;}
     throw new Error("Missing return statement in function");
   }
 
   final public StrandedFeature.Strand parseGffStrand() throws ParseException {
   Token token;
     if (jj_2_37(2)) {
       token = jj_consume_token();
     {if (truereturn .;}
     } else if (jj_2_38(2)) {
       token = jj_consume_token();
     {if (truereturn .;}
     } else if (jj_2_39(2)) {
       token = jj_consume_token();
     {if (truereturn .;}
     } else {
       jj_consume_token(-1);
       throw new ParseException();
     }
     throw new Error("Missing return statement in function");
   }
 
   private boolean jj_2_1(int xla) {
      = xla =  = ;
     try { return !jj_3_1(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(0, xla); }
   }
 
   private boolean jj_2_2(int xla) {
      = xla =  = ;
     try { return !jj_3_2(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(1, xla); }
   }
 
   private boolean jj_2_3(int xla) {
      = xla =  = ;
     try { return !jj_3_3(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(2, xla); }
   }
 
   private boolean jj_2_4(int xla) {
      = xla =  = ;
     try { return !jj_3_4(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(3, xla); }
   }
 
   private boolean jj_2_5(int xla) {
      = xla =  = ;
     try { return !jj_3_5(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(4, xla); }
   }
 
   private boolean jj_2_6(int xla) {
      = xla =  = ;
     try { return !jj_3_6(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(5, xla); }
   }
 
   private boolean jj_2_7(int xla) {
      = xla =  = ;
     try { return !jj_3_7(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(6, xla); }
   }
 
   private boolean jj_2_8(int xla) {
      = xla =  = ;
     try { return !jj_3_8(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(7, xla); }
   }
 
   private boolean jj_2_9(int xla) {
      = xla =  = ;
     try { return !jj_3_9(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(8, xla); }
   }
 
   private boolean jj_2_10(int xla) {
      = xla =  = ;
     try { return !jj_3_10(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(9, xla); }
   }
 
   private boolean jj_2_11(int xla) {
      = xla =  = ;
     try { return !jj_3_11(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(10, xla); }
   }
 
   private boolean jj_2_12(int xla) {
      = xla =  = ;
     try { return !jj_3_12(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(11, xla); }
   }
 
   private boolean jj_2_13(int xla) {
      = xla =  = ;
     try { return !jj_3_13(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(12, xla); }
   }
 
   private boolean jj_2_14(int xla) {
      = xla =  = ;
     try { return !jj_3_14(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(13, xla); }
   }
 
   private boolean jj_2_15(int xla) {
      = xla =  = ;
     try { return !jj_3_15(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(14, xla); }
   }
 
   private boolean jj_2_16(int xla) {
      = xla =  = ;
     try { return !jj_3_16(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(15, xla); }
   }
 
   private boolean jj_2_17(int xla) {
      = xla =  = ;
     try { return !jj_3_17(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(16, xla); }
   }
 
   private boolean jj_2_18(int xla) {
      = xla =  = ;
     try { return !jj_3_18(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(17, xla); }
   }
 
   private boolean jj_2_19(int xla) {
      = xla =  = ;
     try { return !jj_3_19(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(18, xla); }
   }
 
   private boolean jj_2_20(int xla) {
      = xla =  = ;
     try { return !jj_3_20(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(19, xla); }
   }
 
   private boolean jj_2_21(int xla) {
      = xla =  = ;
     try { return !jj_3_21(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(20, xla); }
   }
 
   private boolean jj_2_22(int xla) {
      = xla =  = ;
     try { return !jj_3_22(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(21, xla); }
   }
 
   private boolean jj_2_23(int xla) {
      = xla =  = ;
     try { return !jj_3_23(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(22, xla); }
   }
 
   private boolean jj_2_24(int xla) {
      = xla =  = ;
     try { return !jj_3_24(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(23, xla); }
   }
 
   private boolean jj_2_25(int xla) {
      = xla =  = ;
     try { return !jj_3_25(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(24, xla); }
   }
 
   private boolean jj_2_26(int xla) {
      = xla =  = ;
     try { return !jj_3_26(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(25, xla); }
   }
 
   private boolean jj_2_27(int xla) {
      = xla =  = ;
     try { return !jj_3_27(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(26, xla); }
   }
 
   private boolean jj_2_28(int xla) {
      = xla =  = ;
     try { return !jj_3_28(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(27, xla); }
   }
 
   private boolean jj_2_29(int xla) {
      = xla =  = ;
     try { return !jj_3_29(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(28, xla); }
   }
 
   private boolean jj_2_30(int xla) {
      = xla =  = ;
     try { return !jj_3_30(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(29, xla); }
   }
 
   private boolean jj_2_31(int xla) {
      = xla =  = ;
     try { return !jj_3_31(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(30, xla); }
   }
 
   private boolean jj_2_32(int xla) {
      = xla =  = ;
     try { return !jj_3_32(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(31, xla); }
   }
 
   private boolean jj_2_33(int xla) {
      = xla =  = ;
     try { return !jj_3_33(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(32, xla); }
   }
 
   private boolean jj_2_34(int xla) {
      = xla =  = ;
     try { return !jj_3_34(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(33, xla); }
   }
 
   private boolean jj_2_35(int xla) {
      = xla =  = ;
     try { return !jj_3_35(); }
     catch(LookaheadSuccess ls) { return true; }
     finally { jj_save(34, xla); }
   }
  private boolean jj_2_36(int xla) {
     = xla =  = ;
    try { return !jj_3_36(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(35, xla); }
  }
  private boolean jj_2_37(int xla) {
     = xla =  = ;
    try { return !jj_3_37(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(36, xla); }
  }
  private boolean jj_2_38(int xla) {
     = xla =  = ;
    try { return !jj_3_38(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(37, xla); }
  }
  private boolean jj_2_39(int xla) {
     = xla =  = ;
    try { return !jj_3_39(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(38, xla); }
  }
  private boolean jj_3_12() {
    if (jj_3R_14()) return true;
    return false;
  }
  private boolean jj_3_14() {
    if (jj_scan_token()) return true;
    if (jj_3R_16()) return true;
    return false;
  }
  private boolean jj_3_18() {
    if (jj_scan_token()) return true;
    return false;
  }
  private boolean jj_3_4() {
    if (jj_scan_token()) return true;
    if (jj_3R_12()) return true;
    return false;
  }
  private boolean jj_3R_18() {
    Token xsp;
    xsp = ;
    if (jj_3_17()) {
     = xsp;
    if (jj_3_18()) return true;
    }
    return false;
  }
  private boolean jj_3_5() {
    if (jj_3R_12()) return true;
    Token xsp