Read the next record.

@return the next record from the input stream or {@code null} if none.
@throws IOException in case of error.
@see #readNextAttributeProvider()
439194
public DBaseFileRecord readNextDBFRecord() throws IOException {
		if (this.recordCount == -1) {
			throw new MustCallReadHeaderFunctionException();
		}
		if (this.readingPosition >= this.recordCount) {
			return null;
		}

		try {
			// Update the readingPosition attribute AFTER the call to the
			// reading function to avoid invalid usage of its value
			// by this function.
			final DBaseFileRecord record = readDBFRecord(this.readingPosition);
			++this.readingPosition;
			return record;
		} catch (EOFException e) {
			this.finished = true;
			return null;
		}
	}
1273078
private function readNextRecord()
    {
        if ($this->isEOF) {
            $this->isValidPosition = false;
        }

        $isInRecord = false;
        $recording = '';

        while (false !== ($line = fgets($this->handle))) {
            $isNewArrayStart = strpos($line, '-') === 0;

            if ($isInRecord && $isNewArrayStart) {
                fseek($this->handle, -strlen($line), SEEK_CUR);
                break;
            }

            if (!$isInRecord && $isNewArrayStart) {
                $isInRecord = true;
            }

            if ($isInRecord) {
                $recording .= $line;
            }
        }

        if ($line == false) {
            $this->isEOF = true;
        }

        return $recording;
    }
875913
public Object next() {
        try {
            if (!_primed) {
                _primed = _rs.next();
                if (!_primed) {
                    throw new NoSuchElementException();
                }
            }
            // reset upon consumption
            _primed = false;
            return _rowMapper.mapRowToReturnType();
        } catch (SQLException e) {
            // Since Iterator interface is locked, all we can do
            // is put the real exception inside an expected one.
            NoSuchElementException xNoSuch = new NoSuchElementException("ResultSet exception: " + e);
            xNoSuch.initCause(e);
            throw xNoSuch;
        }
    }
619496
public Object next() throws java.util.NoSuchElementException {
        Object element = null;
        if (nextElement != null) {
            element = nextElement;
            nextElement = null;
        } else {
            element = getNextElement();
            if (element == null) {
                throw new java.util.NoSuchElementException();
            }
        }
        return element;
    }
1163219
protected Val nextSimpleValue() throws IOException {
      switch (currentValue.getKey()) {
         case NULL:
         case STRING:
         case BOOLEAN:
         case NUMBER:
            Val object = currentValue.v2;
            consume();
            return object;
         default:
            throw new IOException("Expecting VALUE, but found " + jsonTokenToStructuredElement(null));
      }
   }
833566
public boolean next() throws IOException {
		boolean hasNext = true;
		try {
			pageId = stream.readInt();
			pageNamespace = stream.readInt();
			pageTitle = stream.readUTFAsArray();
			pageIsRedirect = stream.readBoolean();
		} catch (EOFException e) {
			hasNext = false;
		}
		return hasNext;
	}
363470
@Override
    public Record nextRecord() {
        Record next = sequenceRecordReader.nextRecord();
        next.setRecord(transformProcess.execute(next.getRecord()));
        return next;
    }
1014644
private boolean next() throws IOException {
    if (valuesRead >= endOfPageValueCount) {
      if (valuesRead >= totalValueCount) {
        // How do we get here? Throw end of stream exception?
        return false;
      }
      readPage();
    }
    ++valuesRead;
    // TODO: Don't read for flat schemas
    //repetitionLevel = repetitionLevelColumn.nextInt();
    return definitionLevelColumn.nextInt() == maxDefLevel;
  }
827840
public LogRecord readNext()
                    throws ObjectManagerException
    {
        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.entry(this,
                        cclass,
                        "readNext");

        java.io.DataInputStream logRecordDataInputStream;
        int type; // Of the Log Record.
        // Supress log Records until we see Checkpoint Start. Just build up the 
        // parts of any log Records.
        do {
            logRecordDataInputStream = readNextLogRecord();
            // We now have a java.io.DataInputStream containg a complete logRecord.       
            try {
                type = logRecordDataInputStream.readInt();
            } catch (java.io.IOException exception) {
                // No FFDC Code Needed.
                ObjectManager.ffdc.processException(cclass, "readNext", exception, "1:160:1.13");

                if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
                    trace.exit(this,
                               cclass,
                               "readNext",
                               exception);
                throw new PermanentIOException(this,
                                               exception);
            } // catch java.io.IOException.
            if (type == LogRecord.TYPE_CHECKPOINT_START)
                checkpointStartSeen = true;
        } while (!checkpointStartSeen);

        LogRecord logRecordRead = null; // The log record read from the log. 
        switch (type) {
            case LogRecord.TYPE_USER_DEFINED:
                logRecordRead = LogRecord.getUserLogRecord(logRecordDataInputStream, objectManagerState);
                break;
            case LogRecord.TYPE_ADD:
                logRecordRead = new TransactionAddLogRecord(logRecordDataInputStream
                                                            , objectManagerState
                                );
                break;
            case LogRecord.TYPE_REPLACE:
                logRecordRead = new TransactionReplaceLogRecord(logRecordDataInputStream
                                                                , objectManagerState
                                );
                break;
            case LogRecord.TYPE_OPTIMISTIC_REPLACE:
                logRecordRead = new TransactionOptimisticReplaceLogRecord(logRecordDataInputStream
                                                                          , objectManagerState
                                );
                break;
            case LogRecord.TYPE_DELETE:
                logRecordRead = new TransactionDeleteLogRecord(logRecordDataInputStream
                                                               , objectManagerState
                                );
                break;
            case LogRecord.TYPE_PREPARE:
                logRecordRead = new TransactionPrepareLogRecord(logRecordDataInputStream
                                );
                break;
            case LogRecord.TYPE_COMMIT:
                logRecordRead = new TransactionCommitLogRecord(logRecordDataInputStream);
                break;
            case LogRecord.TYPE_BACKOUT:
                logRecordRead = new TransactionBackoutLogRecord(logRecordDataInputStream);
                break;
            case LogRecord.TYPE_CHECKPOINT_START:
                logRecordRead = new CheckpointStartLogRecord(logRecordDataInputStream
                                                             , objectManagerState
                                );
                break;
            case LogRecord.TYPE_CHECKPOINT_END:
                logRecordRead = new CheckpointEndLogRecord(logRecordDataInputStream);
                break;
            case LogRecord.TYPE_CHECKPOINT_TRANSACTION:
                logRecordRead = new TransactionCheckpointLogRecord(logRecordDataInputStream
                                                                   , objectManagerState
                                );
                break;
            case LogRecord.TYPE_PADDING:
                logRecordRead = new PaddingLogRecord(logRecordDataInputStream);
                break;
            default:
                InvalidLogRecordTypeException invalidLogRecordTypeException = new InvalidLogRecordTypeException(this
                                                                                                                , type
                                );
                ObjectManager.ffdc.processException(cclass, "readNext", invalidLogRecordTypeException, "1:229:1.13");

                if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
                    trace.exit(this, cclass
                               , "readNext"
                               , new Object[] { invalidLogRecordTypeException, logRecordDataInputStream, new Integer(type) }
                                    );
                throw invalidLogRecordTypeException;
        } // switch (type).

        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.exit(this,
                       cclass,
                       "readNext",
                       new Object[] { logRecordRead });
        return logRecordRead;
    }
166638
private boolean readNextRecord() throws IOException {
		boolean recordFound = false;
		while (!recordFound) {
			// no more records left
			if (numReadRecords >= numTotalRecords) {
				return false;
			}

			try {
				if (numReadRecords == numRecordsUpToCurrentBlock) {
					// advance to next block
					PageReadStore pages = reader.readNextRowGroup();
					recordReader = createRecordReader(pages);
					numRecordsUpToPreviousBlock = numRecordsUpToCurrentBlock;
					numRecordsUpToCurrentBlock += pages.getRowCount();
					currentBlock++;
				}

				numReadRecords++;
				try {
					readRecord = recordReader.read();
					readRecordReturned = false;
				} catch (RecordMaterializationException e) {
					String errorMessage = String.format(
						"skipping a corrupt record in block number [%d] record number [%s] of file %s",
						currentBlock, numReadRecords - numRecordsUpToPreviousBlock, reader.getFile());

					if (!skipCorruptedRecord) {
						LOG.error(errorMessage);
						throw e;
					} else {
						LOG.warn(errorMessage);
					}
					continue;
				}

				if (readRecord == null) {
					readRecordReturned = true;
					numReadRecords = numRecordsUpToCurrentBlock;
					LOG.debug("filtered record reader reached end of block");
					continue;
				}

				recordFound = true;
				LOG.debug("read value: {}", readRecord);
			} catch (RecordMaterializationException e) {
				LOG.error(String.format("Can not read value at %d in block %d in file %s",
					numReadRecords - numRecordsUpToPreviousBlock, currentBlock, reader.getFile()), e);
				if (!skipCorruptedRecord) {
					throw e;
				}
				return false;
			}
		}

		return true;
	}
597417
public String next() throws java.io.IOException {
    int zzInput;
    int zzAction;

    // cached fields:
    int zzCurrentPosL;
    int zzMarkedPosL;
    int zzEndReadL = zzEndRead;
    char [] zzBufferL = zzBuffer;
    char [] zzCMapL = ZZ_CMAP;

    int [] zzTransL = ZZ_TRANS;
    int [] zzRowMapL = ZZ_ROWMAP;
    int [] zzAttrL = ZZ_ATTRIBUTE;

    while (true) {
      zzMarkedPosL = zzMarkedPos;

      zzAction = -1;

      zzCurrentPosL = zzCurrentPos = zzStartRead = zzMarkedPosL;
  
      zzState = ZZ_LEXSTATE[zzLexicalState];


      zzForAction: {
        while (true) {
    
          if (zzCurrentPosL < zzEndReadL)
            zzInput = zzBufferL[zzCurrentPosL++];
          else if (zzAtEOF) {
            zzInput = YYEOF;
            break zzForAction;
          }
          else {
            // store back cached positions
            zzCurrentPos  = zzCurrentPosL;
            zzMarkedPos   = zzMarkedPosL;
            boolean eof = zzRefill();
            // get translated positions and possibly new buffer
            zzCurrentPosL  = zzCurrentPos;
            zzMarkedPosL   = zzMarkedPos;
            zzBufferL      = zzBuffer;
            zzEndReadL     = zzEndRead;
            if (eof) {
              zzInput = YYEOF;
              break zzForAction;
            }
            else {
              zzInput = zzBufferL[zzCurrentPosL++];
            }
          }
          int zzNext = zzTransL[ zzRowMapL[zzState] + zzCMapL[zzInput] ];
          if (zzNext == -1) break zzForAction;
          zzState = zzNext;

          int zzAttributes = zzAttrL[zzState];
          if ( (zzAttributes & 1) == 1 ) {
            zzAction = zzState;
            zzMarkedPosL = zzCurrentPosL;
            if ( (zzAttributes & 8) == 8 ) break zzForAction;
          }

        }
      }

      // store back cached position
      zzMarkedPos = zzMarkedPosL;

      switch (zzAction < 0 ? zzAction : ZZ_ACTION[zzAction]) {
        case 180: 
          { return(stem(3,"te","ed"));
          }
        case 372: break;
        case 298: 
          { return(stem(1,"a","s"));
          }
        case 373: break;
        case 94: 
          { return(stem(3,"ide","ed"));
          }
        case 374: break;
        case 126: 
          { return(stem(2,"al","s"));
          }
        case 375: break;
        case 15: 
          { return(null_stem());
          }
        case 376: break;
        case 293: 
          { return(stem(2,"la","s"));
          }
        case 377: break;
        case 38: 
          { return(stem(3,"will",""));
          }
        case 378: break;
        case 8: 
          { yybegin(scan); if (option(tag_output)) return yytext();
          }
        case 379: break;
        case 11: 
          { return cnull_stem();
          }
        case 380: break;
        case 72: 
          { return(stem(3,"eel","ed"));
          }
        case 381: break;
        case 173: 
          { return(stem(3,"eal","ed"));
          }
        case 382: break;
        case 177: 
          { return(stem(4,"ake","en"));
          }
        case 383: break;
        case 134: 
          // lookahead expression with fixed base length
          zzMarkedPos = zzStartRead + 2;
          { return(stem(2,"I",""));
          }
        case 384: break;
        case 133: 
          // lookahead expression with fixed base length
          zzMarkedPos = zzStartRead + 2;
          { return(stem(1,"y",""));
          }
        case 385: break;
        case 259: 
          // lookahead expression with fixed base length
          zzMarkedPos = zzStartRead + 4;
          { return(stem(1,"y",""));
          }
        case 386: break;
        case 89: 
          { return(stem(3,"ay","ed"));
          }
        case 387: break;
        case 272: 
          { return(stem(3,"se","ed"));
          }
        case 388: break;
        case 95: 
          { return(stem(3,"ise","ed"));
          }
        case 389: break;
        case 236: 
          { return(stem(3,"ike","ed"));
          }
        case 390: break;
        case 29: 
          { return(ynull_stem());
          }
        case 391: break;
        case 111: 
          { return(stem(3,"ell","ed"));
          }
        case 392: break;
        case 10: 
          { return(stem(1,"us","s"));
          }
        case 393: break;
        case 1: 
          { return(common_noun_stem());
          }
        case 394: break;
        case 13: 
          // lookahead expression with fixed lookahead length
          yypushback(1);
          { return(common_noun_stem());
          }
        case 395: break;
        case 70: 
          { return(stem(3,"ly","ed"));
          }
        case 396: break;
        case 67: 
          { return(stem(3,"ive","ed"));
          }
        case 397: break;
        case 355: 
          { return(stem(3,"is","s"));
          }
        case 398: break;
        case 239: 
          { return(stem(5,"eek","ed"));
          }
        case 399: break;
        case 160: 
          { return(stem(3,"ar","ed"));
          }
        case 400: break;
        case 267: 
          { return(stem(4,"ame","ed"));
          }
        case 401: break;
        case 33: 
          { return(stem(3,"see","ed"));
          }
        case 402: break;
        case 151: 
          { return(stem(3,"epe","ed"));
          }
        case 403: break;
        case 21: 
          { return(stem(3,"get","ed"));
          }
        case 404: break;
        case 351: 
          { return(stem(8,"-de-sac","s"));
          }
        case 405: break;
        case 369: 
          { return(stem(12,"-in-the-box","s"));
          }
        case 406: break;
        case 266: 
          { return(stem(5,"ing","ed"));
          }
        case 407: break;
        case 182: 
          { return(stem(2,"i","s"));
          }
        case 408: break;
        case 162: 
          { return(stem(3,"an","ed"));
          }
        case 409: break;
        case 30: 
          { return(stem(3,"red","ed"));
          }
        case 410: break;
        case 51: 
          { return(stem(3,"e","ing"));
          }
        case 411: break;
        case 214: 
          { return(stem(3,"ass","ed"));
          }
        case 412: break;
        case 249: 
          { return(stem(2,"re","s"));
          }
        case 413: break;
        case 65: 
          { return(stem(2,"e","s"));
          }
        case 414: break;
        case 78: 
          { return(stem(3,"o","en"));
          }
        case 415: break;
        case 155: 
          { return(stem(5,"do","ed"));
          }
        case 416: break;
        case 71: 
          { return(stem(3,"all","ed"));
          }
        case 417: break;
        case 125: 
          { return(stem(2,"ra","s"));
          }
        case 418: break;
        case 212: 
          { return(stem(6,"clepe","ed"));
          }
        case 419: break;
        case 256: 
          // lookahead expression with fixed base length
          zzMarkedPos = zzStartRead + 4;
          { return(stem(1,"",""));
          }
        case 420: break;
        case 60: 
          { return(stem(3,"ear","ed"));
          }
        case 421: break;
        case 63: 
          { return(stem(3,"ome","ed"));
          }
        case 422: break;
        case 52: 
          { return(stem(1,"","ed"));
          }
        case 423: break;
        case 157: 
          { return(stem(3,"eeze","ed"));
          }
        case 424: break;
        case 27: 
          { return(stem(3,"light","ed"));
          }
        case 425: break;
        case 139: 
          { return(stem(3,"y","s"));
          }
        case 426: break;
        case 296: 
          { return(stem(2,"zo","s"));
          }
        case 427: break;
        case 31: 
          { return(stem(3,"run","ed"));
          }
        case 428: break;
        case 46: 
          { return(stem(2,"an","s"));
          }
        case 429: break;
        case 333: 
          { return(stem(3,"ix","ed"));
          }
        case 430: break;
        case 304: 
          { return(stem(4,"g","ing"));
          }
        case 431: break;
        case 57: 
          { return(stem(3,"end","ed"));
          }
        case 432: break;
        case 131: 
          // general lookahead, find correct zzMarkedPos
          { int zzFState = 5;
            int zzFPos = zzStartRead;
            if (zzFin.length <= zzBufferL.length) { zzFin = new boolean[zzBufferL.length+1]; }
            boolean zzFinL[] = zzFin;
            while (zzFState != -1 && zzFPos < zzMarkedPos) {
              if ((zzAttrL[zzFState] & 1) == 1) { zzFinL[zzFPos] = true; } 
              zzInput = zzBufferL[zzFPos++];
              zzFState = zzTransL[ zzRowMapL[zzFState] + zzCMapL[zzInput] ];
            }
            if (zzFState != -1 && (zzAttrL[zzFState] & 1) == 1) { zzFinL[zzFPos] = true; } 

            zzFState = 7;
            zzFPos = zzMarkedPos;
            while (!zzFinL[zzFPos] || (zzAttrL[zzFState] & 1) != 1) {
              zzInput = zzBufferL[--zzFPos];
              zzFState = zzTransL[ zzRowMapL[zzFState] + zzCMapL[zzInput] ];
            };
            zzMarkedPos = zzFPos;
          }
          { return(proper_name_stem());
          }
        case 433: break;
        case 50: 
          // lookahead expression with fixed base length
          zzMarkedPos = zzStartRead + 1;
          { return(proper_name_stem());
          }
        case 434: break;
        case 55: 
          { return(stem(3,"low","ed"));
          }
        case 435: break;
        case 193: 
          { return(stem(2,"ny","s"));
          }
        case 436: break;
        case 138: 
          { return(stem(3,"y","ed"));
          }
        case 437: break;
        case 104: 
          { return(stem(3,"mite","ed"));
          }
        case 438: break;
        case 305: 
          { return(stem(3,"d","en"));
          }
        case 439: break;
        case 14: 
          { return(stem(2,"e","ed"));
          }
        case 440: break;
        case 100: 
          { return(stem(3,"hoot","ed"));
          }
        case 441: break;
        case 185: 
          { return(stem(2,"so","s"));
          }
        case 442: break;
        case 341: 
          { return(stem(2,"r","s"));
          }
        case 443: break;
        case 231: 
          { return(stem(5,"elt","en"));
          }
        case 444: break;
        case 225: 
          { return(stem(4,"eeze","en"));
          }
        case 445: break;
        case 332: 
          { return(stem(4,"y","ing"));
          }
        case 446: break;
        case 130: 
          // general lookahead, find correct zzMarkedPos
          { int zzFState = 5;
            int zzFPos = zzStartRead;
            if (zzFin.length <= zzBufferL.length) { zzFin = new boolean[zzBufferL.length+1]; }
            boolean zzFinL[] = zzFin;
            while (zzFState != -1 && zzFPos < zzMarkedPos) {
              if ((zzAttrL[zzFState] & 1) == 1) { zzFinL[zzFPos] = true; } 
              zzInput = zzBufferL[zzFPos++];
              zzFState = zzTransL[ zzRowMapL[zzFState] + zzCMapL[zzInput] ];
            }
            if (zzFState != -1 && (zzAttrL[zzFState] & 1) == 1) { zzFinL[zzFPos] = true; } 

            zzFState = 6;
            zzFPos = zzMarkedPos;
            while (!zzFinL[zzFPos] || (zzAttrL[zzFState] & 1) != 1) {
              zzInput = zzBufferL[--zzFPos];
              zzFState = zzTransL[ zzRowMapL[zzFState] + zzCMapL[zzInput] ];
            };
            zzMarkedPos = zzFPos;
          }
          { yybegin(noun); yypushback(yylength()); return(next());
          }
        case 447: break;
        case 81: 
          { return(stem(3,"ew","en"));
          }
        case 448: break;
        case 113: 
          { return(stem(3,"aw","en"));
          }
        case 449: break;
        case 49: 
          // lookahead expression with fixed lookahead length
          yypushback(2);
          { yybegin(verb); yypushback(yylength()); return(next());
          }
        case 450: break;
        case 314: 
          { return(stem(3,"ship","ed"));
          }
        case 451: break;
        case 335: 
          { return(stem(1,"de","s"));
          }
        case 452: break;
        case 364: 
          { return(stem(9,"-mutuel","s"));
          }
        case 453: break;
        case 370: 
          { return(stem(14,"y-in-waiting","s"));
          }
        case 454: break;
        case 9: 
          { return(stem(2,"be",""));
          }
        case 455: break;
        case 206: 
          // lookahead expression with fixed base length
          zzMarkedPos = zzStartRead + 2;
          { return(stem(2,"be",""));
          }
        case 456: break;
        case 69: 
          { return(stem(3,"lee","ed"));
          }
        case 457: break;
        case 40: 
          { return(stem(1,"um","s"));
          }
        case 458: break;
        case 56: 
          { return(stem(3,"reed","ed"));
          }
        case 459: break;
        case 163: 
          { return(stem(3,"ap","ed"));
          }
        case 460: break;
        case 343: 
          { return(stem(2,"te","s"));
          }
        case 461: break;
        case 197: 
          { return(stem(3,"f","s"));
          }
        case 462: break;
        case 200: 
          // lookahead expression with fixed base length
          zzMarkedPos = zzStartRead + 2;
          { return(stem(2,"can",""));
          }
        case 463: break;
        case 300: 
          { return(stem(2,"lio","s"));
          }
        case 464: break;
        case 108: 
          { return(stem(3,"wim","en"));
          }
        case 465: break;
        case 91: 
          { return(stem(3,"ow","en"));
          }
        case 466: break;
        case 321: 
          { return(stem(2,"g","s"));
          }
        case 467: break;
        case 228: 
          { return(semi_reg_stem(1,""));
          }
        case 468: break;
        case 275: 
          { return(stem(2,"gue","s"));
          }
        case 469: break;
        case 143: 
          { return(stem(3,"ei","ed"));
          }
        case 470: break;
        case 37: 
          { return(stem(3,"eat","ed"));
          }
        case 471: break;
        case 17: 
          { return(stem(3,"bid","ed"));
          }
        case 472: break;
        case 217: 
          { return(stem(3,"","en"));
          }
        case 473: break;
        case 354: 
          { return(stem(10,"an-at-arms","s"));
          }
        case 474: break;
        case 132: 
          // lookahead expression with fixed base length
          zzMarkedPos = zzStartRead + 2;
          { return(stem(2,"we",""));
          }
        case 475: break;
        case 244: 
          { return(stem(2,"ron","s"));
          }
        case 476: break;
        case 338: 
          { return(stem(2,"non","s"));
          }
        case 477: break;
        case 196: 
          { return(stem(2,"uum","s"));
          }
        case 478: break;
        case 24: 
          { return(stem(3,"have","ed"));
          }
        case 479: break;
        case 344: 
          { return(stem(3,"ff","s"));
          }
        case 480: break;
        case 251: 
          { return(stem(2,"mum","s"));
          }
        case 481: break;
        case 242: 
          { return(stem(2,"ie","ed"));
          }
        case 482: break;
        case 273: 
          { return(stem(2,"ee","ed"));
          }
        case 483: break;
        case 334: 
          { return(stem(2,"do","s"));
          }
        case 484: break;
        case 262: 
          // lookahead expression with fixed base length
          zzMarkedPos = zzStartRead + 2;
          { return(stem(2,"do","s"));
          }
        case 485: break;
        case 360: 
          { return(stem(6,"-doux","s"));
          }
        case 486: break;
        case 299: 
          { return(stem(3,"ly","s"));
          }
        case 487: break;
        case 224: 
          { return(stem(4,"w","ed"));
          }
        case 488: break;
        case 237: 
          { return(stem(4,"eal","en"));
          }
        case 489: break;
        case 253: 
          { return(stem(6,"m.p.","s"));
          }
        case 490: break;
        case 45: 
          { return(stem(2,"","s"));
          }
        case 491: break;
        case 346: 
          { return(stem(9,"an-of-war","s"));
          }
        case 492: break;
        case 90: 
          { return(stem(3,"ie","en"));
          }
        case 493: break;
        case 121: 
          { return(stem(2,"tum","s"));
          }
        case 494: break;
        case 199: 
          { return(stem(5,"eyrir","s"));
          }
        case 495: break;
        case 110: 
          { return(stem(3,"ee","en"));
          }
        case 496: break;
        case 204: 
          // lookahead expression with fixed base length
          zzMarkedPos = zzStartRead + 2;
          { return(stem(2,"will",""));
          }
        case 497: break;
        case 250: 
          { return(stem(2,"ia","s"));
          }
        case 498: break;
        case 255: 
          { return(stem(3,"s","s"));
          }
        case 499: break;
        case 44: 
          { return(stem(2,"uo","s"));
          }
        case 500: break;
        case 226: 
          { return(stem(5,"ight","ed"));
          }
        case 501: break;
        case 124: 
          { return(stem(3,"ouse","s"));
          }
        case 502: break;
        case 358: 
          { return(stem(2,"t","s"));
          }
        case 503: break;
        case 7: 
          { return(stem(2,"be","s"));
          }
        case 504: break;
        case 260: 
          // lookahead expression with fixed base length
          zzMarkedPos = zzStartRead + 2;
          { return(stem(2,"be","s"));
          }
        case 505: break;
        case 53: 
          { return(semi_reg_stem(0,"e"));
          }
        case 506: break;
        case 356: 
          { return(stem(8,"-in-law","s"));
          }
        case 507: break;
        case 181: 
          { return(stem(4,".","s"));
          }
        case 508: break;
        case 169: 
          { return(stem(3,"ay","en"));
          }
        case 509: break;
        case 165: 
          { return(stem(3,"se","en"));
          }
        case 510: break;
        case 39: 
          { return(stem(3,"have",""));
          }
        case 511: break;
        case 166: 
          { return(stem(3,"ine","ed"));
          }
        case 512: break;
        case 278: 
          { return(stem(5,"ink","ed"));
          }
        case 513: break;
        case 326: 
          // lookahead expression with fixed base length
          zzMarkedPos = zzStartRead + 4;
          { return(stem(4,"be","ed"));
          }
        case 514: break;
        case 116: 
          { return(stem(4,"be","ed"));
          }
        case 515: break;
        case 359: 
          { return(stem(9,"-down","ing"));
          }
        case 516: break;
        case 297: 
          { return(stem(3,"en","s"));
          }
        case 517: break;
        case 148: 
          { return(stem(4,"ear","en"));
          }
        case 518: break;
        case 361: 
          { return(stem(8,"-de-lys","s"));
          }
        case 519: break;
        case 115: 
          { return(stem(4,"go","ed"));
          }
        case 520: break;
        case 309: 
          { return(stem(4,"y","ed"));
          }
        case 521: break;
        case 42: 
          { return(stem(2,"a","s"));
          }
        case 522: break;
        case 2: 
          { String str = yytext();
                                  int first = str.charAt(0);
	                          String msg = String.format("Untokenizable: %s (U+%s, decimal: %s) - this may be because your text isn't using _ as a tag delimiter", yytext(), Integer.toHexString(first).toUpperCase(), Integer.toString(first));
                  LOGGER.warning(msg);
          }
        case 523: break;
        case 189: 
          { return(stem(3,"x","s"));
          }
        case 524: break;
        case 61: 
          { return(stem(3,"id","ed"));
          }
        case 525: break;
        case 83: 
          { return(stem(4,"have","s"));
          }
        case 526: break;
        case 59: 
          { return(stem(3,"ear","en"));
          }
        case 527: break;
        case 96: 
          { return(stem(3,"eeve","ed"));
          }
        case 528: break;
        case 76: 
          { return(stem(3,"ild","ed"));
          }
        case 529: break;
        case 353: 
          { return(stem(10,"anservant","s"));
          }
        case 530: break;
        case 202: 
          // lookahead expression with fixed base length
          zzMarkedPos = zzStartRead + 3;
          { return(stem(3,"he",""));
          }
        case 531: break;
        case 254: 
          { return(stem(4,"ex","s"));
          }
        case 532: break;
        case 150: 
          { return(stem(3,"oose","ed"));
          }
        case 533: break;
        case 336: 
          { return(stem(4,"-in","s"));
          }
        case 534: break;
        case 285: 
          { return(stem(6,"ork","ed"));
          }
        case 535: break;
        case 144: 
          { return(stem(3,"eak","ed"));
          }
        case 536: break;
        case 112: 
          { return(stem(3,"ink","ed"));
          }
        case 537: break;
        case 241: 
          { return(stem(3,"a","ed"));
          }
        case 538: break;
        case 141: 
          { return(stem(3,"rn","ed"));
          }
        case 539: break;
        case 330: 
          { return(stem(6,"-up","ed"));
          }
        case 540: break;
        case 156: 
          { return(stem(3,"y","en"));
          }
        case 541: break;
        case 119: 
          { return(stem(2,"um","s"));
          }
        case 542: break;
        case 222: 
          { return(stem(4,"tch","ed"));
          }
        case 543: break;
        case 88: 
          { return(stem(3,"ose","ed"));
          }
        case 544: break;
        case 25: 
          { return(stem(3,"have","s"));
          }
        case 545: break;
        case 101: 
          { return(stem(3,"hit","ed"));
          }
        case 546: break;
        case 122: 
          { return(stem(3,"oot","s"));
          }
        case 547: break;
        case 68: 
          { return(stem(4,"do","s"));
          }
        case 548: break;
        case 97: 
          { return(stem(3,"ing","ed"));
          }
        case 549: break;
        case 246: 
          { return(stem(3,"denum","s"));
          }
        case 550: break;
        case 352: 
          { return(stem(6,"-over","s"));
          }
        case 551: break;
        case 191: 
          { return(stem(1,"s","s"));
          }
        case 552: break;
        case 34: 
          { return(stem(3,"win","ed"));
          }
        case 553: break;
        case 82: 
          { return(stem(3,"eave","ed"));
          }
        case 554: break;
        case 342: 
          { return(stem(7,"-up","ing"));
          }
        case 555: break;
        case 74: 
          { return(stem(3,"eld","ed"));
          }
        case 556: break;
        case 289: 
          { return(stem(4,"yatid","s"));
          }
        case 557: break;
        case 291: 
          { return(stem(1,"o","s"));
          }
        case 558: break;
        case 127: 
          { return(stem(2,"lo","s"));
          }
        case 559: break;
        case 103: 
          { return(stem(3,"lide","ed"));
          }
        case 560: break;
        case 41: 
          { return(stem(2,".","s"));
          }
        case 561: break;
        case 175: 
          { return(stem(3,"and","ed"));
          }
        case 562: break;
        case 223: 
          { return(stem(3,"am","ed"));
          }
        case 563: break;
        case 3: 
          { return common_noun_stem().concat(next());
          }
        case 564: break;
        case 114: 
          { return(stem(3,"read","ed"));
          }
        case 565: break;
        case 263: 
          // lookahead expression with fixed base length
          zzMarkedPos = zzStartRead + 2;
          { return(stem(2,"have","s"));
          }
        case 566: break;
        case 349: 
          { return(stem(8,"-down","ed"));
          }
        case 567: break;
        case 209: 
          // lookahead expression with fixed base length
          zzMarkedPos = zzStartRead + 2;
          { return(stem(2,"have","ed"));
          }
        case 568: break;
        case 137: 
          { return(stem(3,"","ing"));
          }
        case 569: break;
        case 146: 
          { return(stem(5,"be","ing"));
          }
        case 570: break;
        case 219: 
          { return(stem(4,"te","ing"));
          }
        case 571: break;
        case 322: 
          { return(stem(4,"isee","s"));
          }
        case 572: break;
        case 118: 
          { return(stem(1,"on","s"));
          }
        case 573: break;
        case 117: 
          { return(stem(2,"","ed"));
          }
        case 574: break;
        case 307: 
          { return(stem(4,"y","s"));
          }
        case 575: break;
        case 345: 
          { return(stem(4,"-on","s"));
          }
        case 576: break;
        case 337: 
          { return(stem(8,"onsieur","s"));
          }
        case 577: break;
        case 178: 
          { return(stem(4,"eave","en"));
          }
        case 578: break;
        case 248: 
          { return(stem(3,"us","s"));
          }
        case 579: break;
        case 365: 
          { return(stem(9,"-de-camp","s"));
          }
        case 580: break;
        case 201: 
          // lookahead expression with fixed base length
          zzMarkedPos = zzStartRead + 3;
          { return(stem(3,"she",""));
          }
        case 581: break;
        case 64: 
          { return(stem(3,"raw","ed"));
          }
        case 582: break;
        case 317: 
          { return(stem(2,"cio","s"));
          }
        case 583: break;
        case 371: 
          { return(stem(11,"y-general","s"));
          }
        case 584: break;
        case 320: 
          { return(stem(2,"eum","s"));
          }
        case 585: break;
        case 368: 
          { return(stem(9,"-at-arms","s"));
          }
        case 586: break;
        case 315: 
          { return(stem(2,"ion","s"));
          }
        case 587: break;
        case 367: 
          { return(stem(11,"erfamilias","s"));
          }
        case 588: break;
        case 328: 
          { return(stem(6,"-down","s"));
          }
        case 589: break;
        case 288: 
          { return(stem(1,"x","s"));
          }
        case 590: break;
        case 323: 
          { return(stem(2,"oan","s"));
          }
        case 591: break;
        case 306: 
          { return(stem(5,"eech","ed"));
          }
        case 592: break;
        case 73: 
          { return(stem(3,"row","ed"));
          }
        case 593: break;
        case 4: 
          { return yytext();
          }
        case 594: break;
        case 292: 
          { return(stem(2,"ro","s"));
          }
        case 595: break;
        case 252: 
          { return(stem(3,"ey","s"));
          }
        case 596: break;
        case 324: 
          { return(stem(2,"ton","s"));
          }
        case 597: break;
        case 5: 
          { return(stem(1,"","s"));
          }
        case 598: break;
        case 303: 
          // lookahead expression with fixed base length
          zzMarkedPos = zzStartRead + 3;
          { return(stem(3,"be",""));
          }
        case 599: break;
        case 36: 
          { return(stem(3,"be",""));
          }
        case 600: break;
        case 229: 
          { return(stem(5,"et","en"));
          }
        case 601: break;
        case 99: 
          { return(stem(3,"hoe","ed"));
          }
        case 602: break;
        case 164: 
          { return(stem(3,"de","en"));
          }
        case 603: break;
        case 43: 
          { return(xnull_stem());
          }
        case 604: break;
        case 362: 
          { return(stem(8,"-de-lis","s"));
          }
        case 605: break;
        case 207: 
          // lookahead expression with fixed base length
          zzMarkedPos = zzStartRead + 2;
          { return(stem(2,"have",""));
          }
        case 606: break;
        case 271: 
          { return(stem(5,"ivy","s"));
          }
        case 607: break;
        case 238: 
          { return(stem(3,"ge","ed"));
          }
        case 608: break;
        case 233: 
          { return(stem(3,"ce","ed"));
          }
        case 609: break;
        case 176: 
          { return(stem(3,"ke","en"));
          }
        case 610: break;
        case 105: 
          { return(stem(3,"pin","ed"));
          }
        case 611: break;
        case 287: 
          { return(stem(2,"no","s"));
          }
        case 612: break;
        case 312: 
          { return(semi_reg_stem(0,"ue"));
          }
        case 613: break;
        case 235: 
          { return(stem(3,"il","ed"));
          }
        case 614: break;
        case 350: 
          { return(stem(2,"l","s"));
          }
        case 615: break;
        case 167: 
          { return(semi_reg_stem(0,""));
          }
        case 616: break;
        case 159: 
          { return(stem(3,"ve","en"));
          }
        case 617: break;
        case 203: 
          // lookahead expression with fixed base length
          zzMarkedPos = zzStartRead + 3;
          { return(stem(2,"e",""));
          }
        case 618: break;
        case 234: 
          { return(stem(5,"ink","en"));
          }
        case 619: break;
        case 145: 
          { return(stem(3,"gin","ed"));
          }
        case 620: break;
        case 286: 
          { return(stem(5,"y","ed"));
          }
        case 621: break;
        case 205: 
          // lookahead expression with fixed base length
          zzMarkedPos = zzStartRead + 3;
          { return(stem(3,"we",""));
          }
        case 622: break;
        case 171: 
          { return(stem(3,"ill","ed"));
          }
        case 623: break;
        case 232: 
          { return(stem(3,"ue","ed"));
          }
        case 624: break;
        case 245: 
          { return(stem(1,"i","s"));
          }
        case 625: break;
        case 183: 
          { return(stem(2,"d","s"));
          }
        case 626: break;
        case 19: 
          { return(stem(3,"do","ed"));
          }
        case 627: break;
        case 58: 
          { return(stem(4,"be","en"));
          }
        case 628: break;
        case 270: 
          { return(stem(5,"ivy","ed"));
          }
        case 629: break;
        case 168: 
          { return(stem(3,"i","ed"));
          }
        case 630: break;
        case 187: 
          { return(stem(1,"e","s"));
          }
        case 631: break;
        case 340: 
          { return(stem(2,"le","s"));
          }
        case 632: break;
        case 280: 
          { return(stem(5,"ead","en"));
          }
        case 633: break;
        case 301: 
          // lookahead expression with fixed base length
          zzMarkedPos = zzStartRead + 5;
          { return(stem(2,"y",""));
          }
        case 634: break;
        case 149: 
          { return(stem(3,"rse","ed"));
          }
        case 635: break;
        case 66: 
          { return(stem(4,"do","en"));
          }
        case 636: break;
        case 170: 
          { return(stem(3,"ite","ed"));
          }
        case 637: break;
        case 227: 
          { return(stem(3,"l","en"));
          }
        case 638: break;
        case 128: 
          { return(stem(4,"ABC","s"));
          }
        case 639: break;
        case 106: 
          { return(stem(3,"peed","ed"));
          }
        case 640: break;
        case 215: 
          { return(stem(4,"eak","en"));
          }
        case 641: break;
        case 28: 
          { return(stem(3,"meet","ed"));
          }
        case 642: break;
        case 347: 
          { return(stem(4,"-by","s"));
          }
        case 643: break;
        case 135: 
          // lookahead expression with fixed base length
          zzMarkedPos = zzStartRead + 2;
          { return(stem(1, "", "n"));
          }
        case 644: break;
        case 325: 
          { return(stem(4,"s","s"));
          }
        case 645: break;
        case 318: 
          { return(stem(3,"esis","s"));
          }
        case 646: break;
        case 230: 
          { return(stem(3,"ey","ed"));
          }
        case 647: break;
        case 142: 
          { return(stem(3,"ess","ed"));
          }
        case 648: break;
        case 218: 
          { return(stem(3,"e","en"));
          }
        case 649: break;
        case 348: 
          { return(stem(4,"o","s"));
          }
        case 650: break;
        case 152: 
          { return(stem(4,"are","ed"));
          }
        case 651: break;
        case 147: 
          { return(stem(4,"ind","ed"));
          }
        case 652: break;
        case 172: 
          { return(stem(3,"ick","ed"));
          }
        case 653: break;
        case 153: 
          { return(stem(4,"ie","ing"));
          }
        case 654: break;
        case 107: 
          { return(stem(3,"pit","ed"));
          }
        case 655: break;
        case 184: 
          { return(stem(2,"u","s"));
          }
        case 656: break;
        case 129: 
          { return(stem(2,"to","s"));
          }
        case 657: break;
        case 268: 
          { return(stem(3,"ride","ed"));
          }
        case 658: break;
        case 186: 
          { return(stem(2,"denum","s"));
          }
        case 659: break;
        case 290: 
          { return(stem(4,"sbok","s"));
          }
        case 660: break;
        case 308: 
          { return(stem(6,"ivy","ing"));
          }
        case 661: break;
        case 366: 
          { return(stem(13,"ademoiselle","s"));
          }
        case 662: break;
        case 195: 
          { return(stem(4,"ooth","s"));
          }
        case 663: break;
        case 20: 
          { return(stem(3,"feed","ed"));
          }
        case 664: break;
        case 98: 
          { return(stem(3,"ink","en"));
          }
        case 665: break;
        case 92: 
          { return(stem(3,"ake","ed"));
          }
        case 666: break;
        case 62: 
          { return(stem(3,"lothe","ed"));
          }
        case 667: break;
        case 18: 
          { return(stem(3,"dig","ed"));
          }
        case 668: break;
        case 279: 
          { return(stem(4,"k","ed"));
          }
        case 669: break;
        case 194: 
          { return(stem(2,"po","s"));
          }
        case 670: break;
        case 221: 
          { return(stem(3,"ose","en"));
          }
        case 671: break;
        case 174: 
          { return(stem(3,"ave","ed"));
          }
        case 672: break;
        case 77: 
          { return(stem(3,"ird","ed"));
          }
        case 673: break;
        case 161: 
          { return(stem(3,"in","ed"));
          }
        case 674: break;
        case 210: 
          { return(stem(4,"","ing"));
          }
        case 675: break;
        case 85: 
          { return(stem(3,"en","ed"));
          }
        case 676: break;
        case 87: 
          { return(stem(3,"o","ed"));
          }
        case 677: break;
        case 281: 
          { return(stem(3,"mel","s"));
          }
        case 678: break;
        case 274: 
          { return(stem(4,"-up","s"));
          }
        case 679: break;
        case 12: 
          { return(stem(2,"is","s"));
          }
        case 680: break;
        case 23: 
          { return(stem(3,"hide","ed"));
          }
        case 681: break;
        case 93: 
          { return(stem(3,"ing","en"));
          }
        case 682: break;
        case 257: 
          // lookahead expression with fixed base length
          zzMarkedPos = zzStartRead + 3;
          { return(stem(3,"not",""));
          }
        case 683: break;
        case 283: 
          { return(stem(4,"i","ing"));
          }
        case 684: break;
        case 243: 
          { return(stem(4,"e","ing"));
          }
        case 685: break;
        case 284: 
          { return(stem(4,"a","ing"));
          }
        case 686: break;
        case 136: 
          // lookahead expression with fixed base length
          zzMarkedPos = zzStartRead + 2;
          { return(stem(2,"'s",""));
          }
        case 687: break;
        case 264: 
          { return(condub_stem(3,"","ing"));
          }
        case 688: break;
        case 120: 
          { return(stem(3,"a","s"));
          }
        case 689: break;
        case 327: 
          { return(stem(4,"l","ing"));
          }
        case 690: break;
        case 316: 
          { return(stem(2,"ne","s"));
          }
        case 691: break;
        case 247: 
          { return(stem(3,"ur","s"));
          }
        case 692: break;
        case 198: 
          { return(stem(2,"b","s"));
          }
        case 693: break;
        case 220: 
          { return(stem(5,"uy","ed"));
          }
        case 694: break;
        case 258: 
          // lookahead expression with fixed base length
          zzMarkedPos = zzStartRead + 3;
          { return(stem(3,"shall",""));
          }
        case 695: break;
        case 190: 
          { return(stem(3,"fe","s"));
          }
        case 696: break;
        case 216: 
          { return(stem(2,"","en"));
          }
        case 697: break;
        case 311: 
          { return(stem(5,"ify","s"));
          }
        case 698: break;
        case 313: 
          { return(stem(5,"k","ing"));
          }
        case 699: break;
        case 6: 
          { return(cnull_stem());
          }
        case 700: break;
        case 80: 
          { return(stem(3,"old","ed"));
          }
        case 701: break;
        case 339: 
          { return(stem(4,"ese","s"));
          }
        case 702: break;
        case 294: 
          { return(stem(2,"dum","s"));
          }
        case 703: break;
        case 47: 
          { return(stem(2,"s","s"));
          }
        case 704: break;
        case 329: 
          { return(stem(5,"y","ing"));
          }
        case 705: break;
        case 357: 
          { return(stem(6,"-lit","s"));
          }
        case 706: break;
        case 158: 
          { return(stem(3,"ip","ed"));
          }
        case 707: break;
        case 79: 
          { return(stem(3,"ang","ed"));
          }
        case 708: break;
        case 331: 
          { return(stem(6,"ify","ing"));
          }
        case 709: break;
        case 295: 
          { return(stem(4,"belly","s"));
          }
        case 710: break;
        case 188: 
          { return(stem(4,"oose","s"));
          }
        case 711: break;
        case 282: 
          { return(stem(4,"ge","ing"));
          }
        case 712: break;
        case 109: 
          { return(stem(3,"wim","ed"));
          }
        case 713: break;
        case 179: 
          { return(stem(3,"t","en"));
          }
        case 714: break;
        case 276: 
          { return(stem(4,"ue","ing"));
          }
        case 715: break;
        case 48: 
          { return(stem(2,"vum","s"));
          }
        case 716: break;
        case 123: 
          { return(stem(2,"rum","s"));
          }
        case 717: break;
        case 192: 
          { return(stem(2,"num","s"));
          }
        case 718: break;
        case 102: 
          { return(stem(3,"lay","ed"));
          }
        case 719: break;
        case 277: 
          { return(stem(5,"ell","en"));
          }
        case 720: break;
        case 140: 
          { return(stem(3,"","ed"));
          }
        case 721: break;
        case 261: 
          // lookahead expression with fixed base length
          zzMarkedPos = zzStartRead + 2;
          { return(stem(2,"as",""));
          }
        case 722: break;
        case 16: 
          { return(stem(3,"bite","ed"));
          }
        case 723: break;
        case 154: 
          { return(stem(3,"al","ed"));
          }
        case 724: break;
        case 213: 
          { return(stem(3,"","s"));
          }
        case 725: break;
        case 302: 
          // lookahead expression with fixed base length
          zzMarkedPos = zzStartRead + 3;
          { return(stem(3,"be","ed"));
          }
        case 726: break;
        case 35: 
          { return(stem(3,"be","ed"));
          }
        case 727: break;
        case 32: 
          { return(stem(3,"sit","ed"));
          }
        case 728: break;
        case 240: 
          { return(stem(5,"each","ed"));
          }
        case 729: break;
        case 363: 
          { return(stem(9,"-a-terre","s"));
          }
        case 730: break;
        case 84: 
          { return(stem(3,"now","ed"));
          }
        case 731: break;
        case 22: 
          { return(stem(3,"gin","en"));
          }
        case 732: break;
        case 269: 
          { return(stem(3,"ie","ed"));
          }
        case 733: break;
        case 75: 
          { return(stem(3,"ee","ed"));
          }
        case 734: break;
        case 86: 
          { return(stem(3,"eep","ed"));
          }
        case 735: break;
        case 208: 
          // lookahead expression with fixed base length
          zzMarkedPos = zzStartRead + 2;
          { return(stem(2,"would",""));
          }
        case 736: break;
        case 54: 
          { return(stem(3,"leed","ed"));
          }
        case 737: break;
        case 26: 
          { return(stem(3,"lead","ed"));
          }
        case 738: break;
        case 265: 
          { return(stem(7,"clepe","ed"));
          }
        case 739: break;
        case 319: 
          { return(stem(4,"eps","s"));
          }
        case 740: break;
        case 310: 
          { return(stem(5,"ify","ed"));
          }
        case 741: break;
        case 211: 
          { return(condub_stem(2,"","ed"));
          }
        case 742: break;
        default: 
          if (zzInput == YYEOF && zzStartRead == zzCurrentPos) {
            zzAtEOF = true;
              {
                return null;
              }
          } 
          else {
            zzScanError(ZZ_NO_MATCH);
          }
      }
    }
  }
893129
@Override
    public boolean next() {
        if (pointer < rows.size() && pointer + 1 != rows.size()) {
            pointer++;
            currentRecord = new RowRecord(rows.get(pointer), metaData, parser.isColumnNamesCaseSensitive(), pzConvertProps, strictNumericParse,
                    upperCase, lowerCase, parser.isNullEmptyStrings());
            return true;
        }
        currentRecord = null;
        return false;
    }
862781
public Object next()
  {
    if (tc.isEntryEnabled())
    {
      SibTr.entry(tc, "next");
    } 
    
    Object result;
    if (hasNext())
    {
      AnycastInputHandler aih = (AnycastInputHandler) anycastIHIterator.next();
      
      result = aih.getControlAdapter();
    }
    else
    {
      result = null;
    }
    
    if (tc.isEntryEnabled())
    {
      SibTr.exit(tc, "next", result);
    } 
    return result;
  }
1102033
public long next() {
        try {
            ByteBufferUtil.readWithShortLength(input);

            final long offset = input.readLong();

            // TODO: Because this is version ic > ia promotedIndex is true and we need to handle it. See C* Descriptor
            skipPromotedIndex(input);

            return offset;
        } catch (IOException e) {
            throw new IOError(e);
        }
    }
431641
public String next() throws IOException {
        if (done) {
            return null;
        }
        for (;;) {
            if (line == null) {
                line = reader.readLineSkippingComments();
                if (line == null) {
                    done = true;
                    return null;
                }
                pos = 0;
            }
            buf.setLength(0);
            lastpos = pos;
            pos = nextToken(pos);
            if (pos < 0) {
                line = null;
                continue;
            }
            return buf.toString();
        }
    }
1230919
public EventRecord getNext() {
    try {
	String line = reader.readLine();
	if (line != null) {
	    if (firstLine == null)
		firstLine = new String(line);
	    offset += line.length() + 1;
	    return parseLine(line);
	}
    } catch (IOException e) {
      e.printStackTrace();
    }
    return null;
  }
744130
@Override
  public int read () throws IOException
  {
    _ensureOpen ();
    while (true)
    {
      if (m_nNextCharIndex >= m_nChars)
      {
        _fill ();
        if (m_nNextCharIndex >= m_nChars)
          return -1;
      }
      if (m_bSkipLF)
      {
        m_bSkipLF = false;
        if (m_aBuf[m_nNextCharIndex] == '\n')
        {
          m_nNextCharIndex++;
          continue;
        }
      }
      return m_aBuf[m_nNextCharIndex++];
    }
  }