Input:
	protected void searchNext1(final int c1) {
		switch(c1) {
		case SourceParseInput.EOF:
			fFoundNum--;
			createFix(RTerminal.EOF);
			return;
		case '\r':
			if (fInput.get(2) == '\n') {
				fFoundNum++;
				handleNewLine(fInput.getIndex()+fInput.getLength(2));
				createLinebreakToken("\r\n");
				return;
			}
			handleNewLine(fInput.getIndex()+fInput.getLength(1));
			createLinebreakToken("\r");
			return;
		case '\n':
		case '\f':
			handleNewLine(fInput.getIndex()+fInput.getLength(1));
			createLinebreakToken("\n");
			return;
		case ' ':
		case '\t':
			LOOP: while (true) {
				switch (fInput.get(++fFoundNum)) {
				case ' ':
				case '\t':
					continue LOOP;
				default:
					fFoundNum--;
					createWhitespaceToken();
					return;
				}
			}
		case '!':
			if (fInput.get(2) == '=') {
				fFoundNum++;
				createFix(RTerminal.REL_NE);
				return;
			}
			createFix(RTerminal.NOT);
			return;
		case '\"':
			LOOP: while (true) {
				switch (fInput.get(++fFoundNum)) {
				case '\\':
					if (fInput.get(++fFoundNum) == SourceParseInput.EOF) {
						fFoundNum--;
					}
					continue LOOP;
				case '\"':
					createStringToken(RTerminal.STRING_D, STATUS_OK);
					return;
				case '\r':
					if (fInput.get(++fFoundNum) != '\n') {
						fFoundNum--;
					}
					handleNewLine(fInput.getIndex()+fInput.getLength(fFoundNum));
					continue LOOP;
				case '\n':
					handleNewLine(fInput.getIndex()+fInput.getLength(fFoundNum));
					continue LOOP;
				case SourceParseInput.EOF:
					fFoundNum--;
					createStringToken(RTerminal.STRING_D, STATUS2_SYNTAX_TOKEN_NOT_CLOSED);
					return;
				default:
					continue LOOP;
				}
			}
		case '#':
			final RTerminal type;
			if (fInput.get(2) == '\'') {
				type = RTerminal.ROXYGEN_COMMENT;
				fFoundNum++;
			}
			else {
				type = RTerminal.COMMENT;
			}
			LOOP: while (true) {
				switch (fInput.get(++fFoundNum)) {
				case SourceParseInput.EOF:
				case '\r':
				case '\n':
					fFoundNum--;
					createCommentToken(type);
					return;
				default:
					continue LOOP;
				}
			}
		case '$':
			createFix(RTerminal.SUB_NAMED_PART);
			return;
		case '%':
			LOOP: while (true) {
				switch (fInput.get(++fFoundNum)) {
				case '%':
					createSpecialToken(STATUS_OK);
					return;
				case '\n':
				case '\r':
				case SourceParseInput.EOF:
					fFoundNum--;
					createSpecialToken(STATUS2_SYNTAX_TOKEN_NOT_CLOSED);
					return;
				default:
					continue LOOP;
				}
			}
		case '&':
			if (fInput.get(2) == '&') {
				fFoundNum++;
				createFix(RTerminal.AND_D);
				return;
			}
			createFix(RTerminal.AND);
			return;
		case '\'':
			LOOP: while (true) {
				switch (fInput.get(++fFoundNum)) {
				case '\\':
					if (fInput.get(++fFoundNum) == SourceParseInput.EOF) {
						fFoundNum--;
					}
					continue LOOP;
				case '\'':
					createStringToken(RTerminal.STRING_S, STATUS_OK);
					return;
				case '\r':
					if (fInput.get(++fFoundNum) != '\n') {
						fFoundNum--;
					}
					handleNewLine(fInput.getIndex()+fInput.getLength(fFoundNum));
					continue LOOP;
				case '\n':
					handleNewLine(fInput.getIndex()+fInput.getLength(fFoundNum));
					continue LOOP;
				case SourceParseInput.EOF:
					fFoundNum--;
					createStringToken(RTerminal.STRING_S, STATUS2_SYNTAX_TOKEN_NOT_CLOSED);
					return;
				default:
					continue LOOP;
				}
			}
		case '(':
			createFix(RTerminal.GROUP_OPEN);
			return;
		case ')':
			createFix(RTerminal.GROUP_CLOSE);
			return;
		case '*':
			createFix(RTerminal.MULT);
			return;
		case '+':
			createFix(RTerminal.PLUS);
			return;
		case ',':
			createFix(RTerminal.COMMA);
			return;
		case '-':
			if (fInput.get(2) == '>') {
				fFoundNum++;
				if (fInput.get(3) == '>') {
					fFoundNum++;
					createFix(RTerminal.ARROW_RIGHT_D);
					return;
				}
				createFix(RTerminal.ARROW_RIGHT_S);
				return;
			}
			createFix(RTerminal.MINUS);
			return;
		case '.':
			switch (fInput.get(2)) {
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
				fFoundNum++;
				consumeNumberInFloat();
				return;
			default:
				scanIdentifier();
				createSymbolToken();
				return;
			}
		case '/':
			createFix(RTerminal.DIV);
			return;
		case '0':
			if (fInput.get(2) == 'x') {
				fFoundNum++;
				consumeNumberInHex();
				return;
			}
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
			consumeNumberInDec();
			return;
		case ':':
			if (fInput.get(2) == ':') {
				fFoundNum++;
				if (fInput.get(3) == ':') {
					fFoundNum++;
					createFix(RTerminal.NS_GET_INT);
					return;
				}
				createFix(RTerminal.NS_GET);
				return;
			}
			createFix(RTerminal.SEQ);
			return;
		case ';':
			createFix(RTerminal.SEMI);
			return;
		case '<':
			switch (fInput.get(2)) {
			case '=':
				fFoundNum++;
				createFix(RTerminal.REL_LE);
				return;
			case '-':
				fFoundNum++;
				createFix(RTerminal.ARROW_LEFT_S);
				return;
			case '<':
				if (fInput.get(3) == '-') {
					fFoundNum++;
					fFoundNum++;
					createFix(RTerminal.ARROW_LEFT_D);
					return;
				}
			default:
				createFix(RTerminal.REL_LT);
				return;
			}
		case '=':
			if (fInput.get(2) == '=') {
				fFoundNum++;
				createFix(RTerminal.REL_EQ);
				return;
			}
			createFix(RTerminal.EQUAL);
			return;
		case '>':
			if (fInput.get(2) == '=') {
				fFoundNum++;
				createFix(RTerminal.REL_GE);
				return;
			}
			createFix(RTerminal.REL_LT);
			return;
		case '?':
			createFix(RTerminal.QUESTIONMARK);
			return;
		case '@':
			createFix(RTerminal.SUB_NAMED_SLOT);
			return;
		case '[':
			if (fInput.get(2) == '[') {
				fFoundNum++;
				createFix(RTerminal.SUB_INDEXED_D_OPEN);
				return;
			}
			createFix(RTerminal.SUB_INDEXED_S_OPEN);
			return;
		case ']':
			createFix(RTerminal.SUB_INDEXED_CLOSE);
			return;
		case '^':
			createFix(RTerminal.POWER);
			return;
		case 'A':
		case 'B':
		case 'C':
		case 'D':
		case 'E':
		case 'G':
		case 'H':
		case 'J':
		case 'K':
		case 'L':
		case 'M':
		case 'O':
		case 'P':
		case 'Q':
		case 'R':
		case 'S':
		case 'U':
		case 'V':
		case 'W':
		case 'X':
		case 'Y':
		case 'Z':
		case 'a':
		case 'c':
		case 'd':
		case 'g':
		case 'h':
		case 'j':
		case 'k':
		case 'l':
		case 'm':
		case 'o':
		case 'p':
		case 'q':
		case 's':
		case 't':
		case 'u':
		case 'v':
		case 'x':
		case 'y':
		case 'z':
			scanIdentifier();
			createSymbolToken();
			return;
		case 'F':
			scanIdentifier();
			if (fFoundNum == 5
					&& fInput.subequals(2, C1_FALSE)) {
				createFix(RTerminal.FALSE);
				return;
			}
			createSymbolToken();
			return;
		case 'I':
			scanIdentifier();
			if (fFoundNum == 3
					&& fInput.subequals(2, 'n', 'f')) {
				createFix(RTerminal.INF);
				return;
			}
			createSymbolToken();
			return;
		case 'N':
			scanIdentifier();
			switch(fFoundNum) {
			case 2:
				if (fInput.get(2) == 'A') {
					createFix(RTerminal.NA);
					return;
				}
				break;
			case 3:
				if (fInput.subequals(2, 'a', 'N')) {
					createFix(RTerminal.NAN);
					return;
				}
				break;
			case 4:
				if (fInput.subequals(2, 'U', 'L', 'L')) {
					createFix(RTerminal.NULL);
					return;
				}
				break;
			case 7:
				if (fInput.subequals(2, C1_NA_real_)) {
					createFix(RTerminal.NA_REAL);
					return;
				}
				break;
			case 11:
				if (fInput.subequals(2, C1_NA_integer_)) {
					createFix(RTerminal.NA_INT);
					return;
				}
				if (fInput.subequals(2, C1_NA_complex_)) {
					createFix(RTerminal.NA_CPLX);
					return;
				}
				break;
			case 13:
				if (fInput.subequals(2, C1_NA_character_)) {
					createFix(RTerminal.NA_CHAR);
					return;
				}
				break;
			}
			createSymbolToken();
			return;
		case 'T':
			scanIdentifier();
			if (fFoundNum == 4
					&& fInput.subequals(2, 'R', 'U', 'E')) {
				createFix(RTerminal.TRUE);
				return;
			}
			createSymbolToken();
			return;
		case 'b':
			scanIdentifier();
			if (fFoundNum == 5
					&& fInput.subequals(2, C1_break)) {
				createFix(RTerminal.BREAK);
				return;
			}
			createSymbolToken();
			return;
		case 'i':
			scanIdentifier();
			if (fFoundNum == 2) {
				if (fInput.get(2) == 'f') {
					createFix(RTerminal.IF);
					return;
				}
				if (fInput.get(2) == 'n') {
					createFix(RTerminal.IN);
					return;
				}
			}
			createSymbolToken();
			return;
		case 'e':
			scanIdentifier();
			if (fFoundNum == 4
					&& fInput.subequals(2, 'l', 's', 'e')) {
				createFix(RTerminal.ELSE);
				return;
			}
			createSymbolToken();
			return;
		case 'n':
			scanIdentifier();
			if (fFoundNum == 4
					&& fInput.subequals(2, 'e', 'x', 't')) {
				createFix(RTerminal.NEXT);
				return;
			}
			createSymbolToken();
			return;
		case 'f':
			scanIdentifier();
			switch (fFoundNum) {
			case 3:
				if (fInput.subequals(2, 'o', 'r')) {
					createFix(RTerminal.FOR);
					return;
				}
				break;
			case 8:
				if (fInput.subequals(2, C1_function)) {
					createFix(RTerminal.FUNCTION);
					return;
				}
				break;
			}
			createSymbolToken();
			return;
		case 'r':
			scanIdentifier();
			if (fFoundNum == 6
					&& fInput.subequals(2, C1_repeat)) {
				createFix(RTerminal.REPEAT);
				return;
			}
			createSymbolToken();
			return;
		case 'w':
			scanIdentifier();
			if (fFoundNum == 5
					&& fInput.subequals(2, C1_while)) {
				createFix(RTerminal.WHILE);
				return;
			}
			createSymbolToken();
			return;
		case '{':
			createFix(RTerminal.BLOCK_OPEN);
			return;
		case '|':
			if (fInput.get(2) == '|') {
				fFoundNum++;
				createFix(RTerminal.OR_D);
				return;
			}
			createFix(RTerminal.OR);
			return;
		case '}':
			createFix(RTerminal.BLOCK_CLOSE);
			return;
		case '~':
			createFix(RTerminal.TILDE);
			return;
		case '`':
			LOOP: while (true) {
				switch (fInput.get(++fFoundNum)) {
				case '\\':
					if (fInput.get(++fFoundNum) == SourceParseInput.EOF) {
						fFoundNum--;
					}
					continue LOOP;
				case '`':
					createQuotedSymbolToken(RTerminal.SYMBOL_G, STATUS_OK);
					return;
				case '\r':
					if (fInput.get(++fFoundNum) != '\n') {
						fFoundNum--;
					}
					handleNewLine(fInput.getIndex()+fInput.getLength(fFoundNum));
					continue LOOP;
				case '\n':
					handleNewLine(fInput.getIndex()+fInput.getLength(fFoundNum));
					continue LOOP;
				case SourceParseInput.EOF:
					fFoundNum--;
					createQuotedSymbolToken(RTerminal.SYMBOL_G, STATUS2_SYNTAX_TOKEN_NOT_CLOSED);
					return;
				default:
					continue LOOP;
				}
			}
		case 0x000:
		case 0x001:
		case 0x002:
		case 0x003:
		case 0x004:
		case 0x005:
		case 0x006:
		case 0x007:
		case 0x008:
		case 0x00B:
		case 0x00E:
		case 0x00F:
		case 0x010:
		case 0x011:
		case 0x012:
		case 0x013:
		case 0x014:
		case 0x015:
		case 0x016:
		case 0x017:
		case 0x018:
		case 0x019:
		case 0x01A:
		case 0x01B:
		case 0x01C:
		case 0x01D:
		case 0x01E:
		case 0x01F:
		case 0x07F:
		case 0x080:
		case 0x081:
		case 0x082:
		case 0x083:
		case 0x084:
		case 0x085:
		case 0x086:
		case 0x087:
		case 0x088:
		case 0x089:
		case 0x08A:
		case 0x08B:
		case 0x08C:
		case 0x08D:
		case 0x08E:
		case 0x08F:
		case 0x090:
		case 0x091:
		case 0x092:
		case 0x093:
		case 0x094:
		case 0x095:
		case 0x096:
		case 0x097:
		case 0x098:
		case 0x099:
		case 0x09A:
		case 0x09B:
		case 0x09C:
		case 0x09D:
		case 0x09E:
		case 0x09F:
		case 0x0A0:
		case 0x0A1:
		case 0x0A2:
		case 0x0A3:
		case 0x0A4:
		case 0x0A5:
		case 0x0A6:
		case 0x0A7:
		case 0x0A8:
		case 0x0A9:
		case 0x0AA:
		case 0x0AB:
		case 0x0AC:
		case 0x0AD:
		case 0x0AE:
		case 0x0AF:
		case 0x0B0:
		case 0x0B1:
		case 0x0B2:
		case 0x0B3:
		case 0x0B4:
		case 0x0B5:
		case 0x0B6:
		case 0x0B7:
		case 0x0B8:
		case 0x0B9:
		case 0x0BA:
		case 0x0BB:
		case 0x0BC:
		case 0x0BD:
		case 0x0BE:
		case 0x0BF:
			break;
		default:
			if (Character.isLetterOrDigit(c1)) {
				scanIdentifier();
				createSymbolToken();
				return;
			}
			break;
		}
		consumeUnknown();
	}

Output:
	protected void searchNext1(final int c1) {
		switch(c1) {
		case SourceParseInput.EOF:
			fFoundNum--;
			createFix(RTerminal.EOF);
			return;
		case '\r':
			if (fInput.get(2) == '\n') {
				fFoundNum++;
				handleNewLine(fInput.getIndex()+fInput.getLength(2));
				createLinebreakToken("\r\n");
				return;
			}
			handleNewLine(fInput.getIndex()+fInput.getLength(1));
			createLinebreakToken("\r");
			return;
		case '\n':
		case '\f':
			handleNewLine(fInput.getIndex()+fInput.getLength(1));
			createLinebreakToken("\n");
			return;
		case ' ':
		case '\t':
			LOOP: while (true) {
				switch (fInput.get(++fFoundNum)) {
				case ' ':
				case '\t':
					continue LOOP;
				default:
					fFoundNum--;
					createWhitespaceToken();
					return;
				}
			}
		case '!':
			if (fInput.get(2) == '=') {
				fFoundNum++;
				createFix(RTerminal.REL_NE);
				return;
			}
			createFix(RTerminal.NOT);
			return;
		case '\"':
			LOOP: while (true) {
				switch (fInput.get(++fFoundNum)) {
				case '\\':
					if (fInput.get(++fFoundNum) == SourceParseInput.EOF) {
						fFoundNum--;
					}
					continue LOOP;
				case '\"':
					createStringToken(RTerminal.STRING_D, STATUS_OK);
					return;
				case '\r':
					if (fInput.get(++fFoundNum) != '\n') {
						fFoundNum--;
					}
					handleNewLine(fInput.getIndex()+fInput.getLength(fFoundNum));
					continue LOOP;
				case '\n':
					handleNewLine(fInput.getIndex()+fInput.getLength(fFoundNum));
					continue LOOP;
				case SourceParseInput.EOF:
					fFoundNum--;
					createStringToken(RTerminal.STRING_D, STATUS2_SYNTAX_TOKEN_NOT_CLOSED);
					return;
				default:
					continue LOOP;
				}
			}
		case '#':
			final RTerminal type;
			if (fInput.get(2) == '\'') {
				type = RTerminal.ROXYGEN_COMMENT;
				fFoundNum++;
			}
			else {
				type = RTerminal.COMMENT;
			}
			LOOP: while (true) {
				switch (fInput.get(++fFoundNum)) {
				case SourceParseInput.EOF:
				case '\r':
				case '\n':
					fFoundNum--;
					createCommentToken(type);
					return;
				default:
					continue LOOP;
				}
			}
		case '$':
			createFix(RTerminal.SUB_NAMED_PART);
			return;
		case '%':
			LOOP: while (true) {
				switch (fInput.get(++fFoundNum)) {
				case '%':
					createSpecialToken(STATUS_OK);
					return;
				case '\n':
				case '\r':
				case SourceParseInput.EOF:
					fFoundNum--;
					createSpecialToken(STATUS2_SYNTAX_TOKEN_NOT_CLOSED);
					return;
				default:
					continue LOOP;
				}
			}
		case '&':
			if (fInput.get(2) == '&') {
				fFoundNum++;
				createFix(RTerminal.AND_D);
				return;
			}
			createFix(RTerminal.AND);
			return;
		case '\'':
			LOOP: while (true) {
				switch (fInput.get(++fFoundNum)) {
				case '\\':
					if (fInput.get(++fFoundNum) == SourceParseInput.EOF) {
						fFoundNum--;
					}
					continue LOOP;
				case '\'':
					createStringToken(RTerminal.STRING_S, STATUS_OK);
					return;
				case '\r':
					if (fInput.get(++fFoundNum) != '\n') {
						fFoundNum--;
					}
					handleNewLine(fInput.getIndex()+fInput.getLength(fFoundNum));
					continue LOOP;
				case '\n':
					handleNewLine(fInput.getIndex()+fInput.getLength(fFoundNum));
					continue LOOP;
				case SourceParseInput.EOF:
					fFoundNum--;
					createStringToken(RTerminal.STRING_S, STATUS2_SYNTAX_TOKEN_NOT_CLOSED);
					return;
				default:
					continue LOOP;
				}
			}
		case '(':
			createFix(RTerminal.GROUP_OPEN);
			return;
		case ')':
			createFix(RTerminal.GROUP_CLOSE);
			return;
		case '*':
			createFix(RTerminal.MULT);
			return;
		case '+':
			createFix(RTerminal.PLUS);
			return;
		case ',':
			createFix(RTerminal.COMMA);
			return;
		case '-':
			if (fInput.get(2) == '>') {
				fFoundNum++;
				if (fInput.get(3) == '>') {
					fFoundNum++;
					createFix(RTerminal.ARROW_RIGHT_D);
					return;
				}
				createFix(RTerminal.ARROW_RIGHT_S);
				return;
			}
			createFix(RTerminal.MINUS);
			return;
		case '.':
			switch (fInput.get(2)) {
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
				fFoundNum++;
				consumeNumberInFloat();
				return;
			default:
				scanIdentifier();
				createSymbolToken();
				return;
			}
		case '/':
			createFix(RTerminal.DIV);
			return;
		case '0':
			if (fInput.get(2) == 'x') {
				fFoundNum++;
				consumeNumberInHex();
				return;
			}
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
			consumeNumberInDec();
			return;
		case ':':
			if (fInput.get(2) == ':') {
				fFoundNum++;
				if (fInput.get(3) == ':') {
					fFoundNum++;
					createFix(RTerminal.NS_GET_INT);
					return;
				}
				createFix(RTerminal.NS_GET);
				return;
			}
			createFix(RTerminal.SEQ);
			return;
		case ';':
			createFix(RTerminal.SEMI);
			return;
		case '<':
			switch (fInput.get(2)) {
			case '=':
				fFoundNum++;
				createFix(RTerminal.REL_LE);
				return;
			case '-':
				fFoundNum++;
				createFix(RTerminal.ARROW_LEFT_S);
				return;
			case '<':
				if (fInput.get(3) == '-') {
					fFoundNum++;
					fFoundNum++;
					createFix(RTerminal.ARROW_LEFT_D);
					return;
				}
			default:
				createFix(RTerminal.REL_LT);
				return;
			}
		case '=':
			if (fInput.get(2) == '=') {
				fFoundNum++;
				createFix(RTerminal.REL_EQ);
				return;
			}
			createFix(RTerminal.EQUAL);
			return;
		case '>':
			if (fInput.get(2) == '=') {
				fFoundNum++;
				createFix(RTerminal.REL_GE);
				return;
			}
			createFix(RTerminal.REL_LT);
			return;
		case '?':
			createFix(RTerminal.QUESTIONMARK);
			return;
		case '@':
			createFix(RTerminal.SUB_NAMED_SLOT);
			return;
		case '[':
			if (fInput.get(2) == '[') {
				fFoundNum++;
				createFix(RTerminal.SUB_INDEXED_D_OPEN);
				return;
			}
			createFix(RTerminal.SUB_INDEXED_S_OPEN);
			return;
		case ']':
			createFix(RTerminal.SUB_INDEXED_CLOSE);
			return;
		case '^':
			createFix(RTerminal.POWER);
			return;
		case 'A':
		case 'B':
		case 'C':
		case 'D':
		case 'E':
		case 'G':
		case 'H':
		case 'J':
		case 'K':
		case 'L':
		case 'M':
		case 'O':
		case 'P':
		case 'Q':
		case 'R':
		case 'S':
		case 'U':
		case 'V':
		case 'W':
		case 'X':
		case 'Y':
		case 'Z':
		case 'a':
		case 'c':
		case 'd':
		case 'g':
		case 'h':
		case 'j':
		case 'k':
		case 'l':
		case 'm':
		case 'o':
		case 'p':
		case 'q':
		case 's':
		case 't':
		case 'u':
		case 'v':
		case 'x':
		case 'y':
		case 'z':
			scanIdentifier();
			createSymbolToken();
			return;
		case 'F':
			scanIdentifier();
			if (fFoundNum == 5
					&& fInput.subequals(2, C1_FALSE)) {
				createFix(RTerminal.FALSE);
				return;
			}
			createSymbolToken();
			return;
		case 'I':
			scanIdentifier();
			if (fFoundNum == 3
					&& fInput.subequals(2, 'n', 'f')) {
				createFix(RTerminal.INF);
				return;
			}
			createSymbolToken();
			return;
		case 'N':
			scanIdentifier();
			switch(fFoundNum) {
			case 2:
				if (fInput.get(2) == 'A') {
					createFix(RTerminal.NA);
					return;
				}
				break;
			case 3:
				if (fInput.subequals(2, 'a', 'N')) {
					createFix(RTerminal.NAN);
					return;
				}
				break;
			case 4:
				if (fInput.subequals(2, 'U', 'L', 'L')) {
					createFix(RTerminal.NULL);
					return;
				}
				break;
			case 8:
				if (fInput.subequals(2, C1_NA_real_)) {
					createFix(RTerminal.NA_REAL);
					return;
				}
				break;
			case 11:
				if (fInput.subequals(2, C1_NA_integer_)) {
					createFix(RTerminal.NA_INT);
					return;
				}
				if (fInput.subequals(2, C1_NA_complex_)) {
					createFix(RTerminal.NA_CPLX);
					return;
				}
				break;
			case 13:
				if (fInput.subequals(2, C1_NA_character_)) {
					createFix(RTerminal.NA_CHAR);
					return;
				}
				break;
			}
			createSymbolToken();
			return;
		case 'T':
			scanIdentifier();
			if (fFoundNum == 4
					&& fInput.subequals(2, 'R', 'U', 'E')) {
				createFix(RTerminal.TRUE);
				return;
			}
			createSymbolToken();
			return;
		case 'b':
			scanIdentifier();
			if (fFoundNum == 5
					&& fInput.subequals(2, C1_break)) {
				createFix(RTerminal.BREAK);
				return;
			}
			createSymbolToken();
			return;
		case 'i':
			scanIdentifier();
			if (fFoundNum == 2) {
				if (fInput.get(2) == 'f') {
					createFix(RTerminal.IF);
					return;
				}
				if (fInput.get(2) == 'n') {
					createFix(RTerminal.IN);
					return;
				}
			}
			createSymbolToken();
			return;
		case 'e':
			scanIdentifier();
			if (fFoundNum == 4
					&& fInput.subequals(2, 'l', 's', 'e')) {
				createFix(RTerminal.ELSE);
				return;
			}
			createSymbolToken();
			return;
		case 'n':
			scanIdentifier();
			if (fFoundNum == 4
					&& fInput.subequals(2, 'e', 'x', 't')) {
				createFix(RTerminal.NEXT);
				return;
			}
			createSymbolToken();
			return;
		case 'f':
			scanIdentifier();
			switch (fFoundNum) {
			case 3:
				if (fInput.subequals(2, 'o', 'r')) {
					createFix(RTerminal.FOR);
					return;
				}
				break;
			case 8:
				if (fInput.subequals(2, C1_function)) {
					createFix(RTerminal.FUNCTION);
					return;
				}
				break;
			}
			createSymbolToken();
			return;
		case 'r':
			scanIdentifier();
			if (fFoundNum == 6
					&& fInput.subequals(2, C1_repeat)) {
				createFix(RTerminal.REPEAT);
				return;
			}
			createSymbolToken();
			return;
		case 'w':
			scanIdentifier();
			if (fFoundNum == 5
					&& fInput.subequals(2, C1_while)) {
				createFix(RTerminal.WHILE);
				return;
			}
			createSymbolToken();
			return;
		case '{':
			createFix(RTerminal.BLOCK_OPEN);
			return;
		case '|':
			if (fInput.get(2) == '|') {
				fFoundNum++;
				createFix(RTerminal.OR_D);
				return;
			}
			createFix(RTerminal.OR);
			return;
		case '}':
			createFix(RTerminal.BLOCK_CLOSE);
			return;
		case '~':
			createFix(RTerminal.TILDE);
			return;
		case '`':
			LOOP: while (true) {
				switch (fInput.get(++fFoundNum)) {
				case '\\':
					if (fInput.get(++fFoundNum) == SourceParseInput.EOF) {
						fFoundNum--;
					}
					continue LOOP;
				case '`':
					createQuotedSymbolToken(RTerminal.SYMBOL_G, STATUS_OK);
					return;
				case '\r':
					if (fInput.get(++fFoundNum) != '\n') {
						fFoundNum--;
					}
					handleNewLine(fInput.getIndex()+fInput.getLength(fFoundNum));
					continue LOOP;
				case '\n':
					handleNewLine(fInput.getIndex()+fInput.getLength(fFoundNum));
					continue LOOP;
				case SourceParseInput.EOF:
					fFoundNum--;
					createQuotedSymbolToken(RTerminal.SYMBOL_G, STATUS2_SYNTAX_TOKEN_NOT_CLOSED);
					return;
				default:
					continue LOOP;
				}
			}
		case 0x000:
		case 0x001:
		case 0x002:
		case 0x003:
		case 0x004:
		case 0x005:
		case 0x006:
		case 0x007:
		case 0x008:
		case 0x00B:
		case 0x00E:
		case 0x00F:
		case 0x010:
		case 0x011:
		case 0x012:
		case 0x013:
		case 0x014:
		case 0x015:
		case 0x016:
		case 0x017:
		case 0x018:
		case 0x019:
		case 0x01A:
		case 0x01B:
		case 0x01C:
		case 0x01D:
		case 0x01E:
		case 0x01F:
		case 0x07F:
		case 0x080:
		case 0x081:
		case 0x082:
		case 0x083:
		case 0x084:
		case 0x085:
		case 0x086:
		case 0x087:
		case 0x088:
		case 0x089:
		case 0x08A:
		case 0x08B:
		case 0x08C:
		case 0x08D:
		case 0x08E:
		case 0x08F:
		case 0x090:
		case 0x091:
		case 0x092:
		case 0x093:
		case 0x094:
		case 0x095:
		case 0x096:
		case 0x097:
		case 0x098:
		case 0x099:
		case 0x09A:
		case 0x09B:
		case 0x09C:
		case 0x09D:
		case 0x09E:
		case 0x09F:
		case 0x0A0:
		case 0x0A1:
		case 0x0A2:
		case 0x0A3:
		case 0x0A4:
		case 0x0A5:
		case 0x0A6:
		case 0x0A7:
		case 0x0A8:
		case 0x0A9:
		case 0x0AA:
		case 0x0AB:
		case 0x0AC:
		case 0x0AD:
		case 0x0AE:
		case 0x0AF:
		case 0x0B0:
		case 0x0B1:
		case 0x0B2:
		case 0x0B3:
		case 0x0B4:
		case 0x0B5:
		case 0x0B6:
		case 0x0B7:
		case 0x0B8:
		case 0x0B9:
		case 0x0BA:
		case 0x0BB:
		case 0x0BC:
		case 0x0BD:
		case 0x0BE:
		case 0x0BF:
			break;
		default:
			if (Character.isLetterOrDigit(c1)) {
				scanIdentifier();
				createSymbolToken();
				return;
			}
			break;
		}
		consumeUnknown();
	}


Input:
	private boolean Save()
	{
		if(this._location == null)
			this._location = new FrontendLocation();
		this._location.Name = this.GetName();
		this._location.Address = this.GetAddress();
		this._location.Port = this.GetPort();
		AlertDialog.Builder builder = new AlertDialog.Builder(this);
		builder.setTitle(R.string.error_input_str);
		builder.setNeutralButton(R.string.ok_str, new DialogInterface.OnClickListener(){
			public void onClick(DialogInterface dialog, int which) {
			}});
		if(this._location.Name == null)
		{
			builder.setMessage(R.string.error_invalid_name_str);
			builder.show();
		}
		else if(this._location.Address == null)
		{
			builder.setMessage(R.string.error_invalid_address_str);
			builder.show();
		}
		else
		{
			if(this._location.Port <= 0)
				this._location.Port = MythCom.DEFAULT_MYTH_PORT;
			LocationDbAdapter adapter = new LocationDbAdapter(this);
			adapter.open();
			if(this._location.ID == -1)
			{
				this._location.ID = (int) adapter.createFrontendLocation(this._location.Name, this._location.Address, this._location.Port);
			}
			else
			{
				return adapter.updateFrontendLocation(this._location.ID, this._location.Name, this._location.Address, this._location.Port);
			}
			adapter.close();
			return true;
		}
		return false;
	}

Output:
	private boolean Save()
	{
		if(this._location == null)
			this._location = new FrontendLocation();
		this._location.Name = this.GetName();
		this._location.Address = this.GetAddress();
		this._location.Port = this.GetPort();
		AlertDialog.Builder builder = new AlertDialog.Builder(this);
		builder.setTitle(R.string.error_input_str);
		builder.setNeutralButton(R.string.ok_str, new DialogInterface.OnClickListener(){
			public void onClick(DialogInterface dialog, int which) {
			}});
		if(this._location.Name.trim().equals(""))
		{
			builder.setMessage(R.string.error_invalid_name_str);
			builder.show();
		}
		else if(this._location.Address.trim().equals(""))
		{
			builder.setMessage(R.string.error_invalid_address_str);
			builder.show();
		}
		else
		{
			if(this._location.Port <= 0)
				this._location.Port = MythCom.DEFAULT_MYTH_PORT;
			LocationDbAdapter adapter = new LocationDbAdapter(this);
			adapter.open();
			if(this._location.ID == -1)
			{
				this._location.ID = (int) adapter.createFrontendLocation(this._location.Name, this._location.Address, this._location.Port);
			}
			else
			{
				return adapter.updateFrontendLocation(this._location.ID, this._location.Name, this._location.Address, this._location.Port);
			}
			adapter.close();
			return true;
		}
		return false;
	}


Input:
	private void postAbsenceInfo(HttpServletRequest req,
			HttpServletResponse resp) throws ServletException, IOException {
		DataTrain train = DataTrain.depart();
		AbsenceManager ac = train.absences();
		DateTimeZone zone = train.appData().get().getTimeZone();
		boolean validForm = true;
		List<String> errors = new LinkedList<String>();
		if (!ValidationUtil.isPost(req)) {
			validForm = false;
		} else {
			String absid = req.getParameter("absenceid");
			if (req.getParameter("delete") != null) {
				deleteAbsence(absid, ac, req, resp);
				return;
			}
			long aid;
			Absence toUpdate = null;
			if (absid != null) {
				String type = req.getParameter("Type");
				String status = req.getParameter("Status");
				String eventid = req.getParameter("eventid");
				Event event = null;
				try {
					long eid = Long.parseLong(eventid);
					event = train.events().get(eid);
				} catch (NumberFormatException nfe) {
					errors.add("No event to add. Can't create absence.");
				}
				if (absid.equals("new")) {
					String sid = req.getParameter("studentid");
					User student = train.users().get(sid);
					Absence.Type atype = Absence.Type.valueOf(type);
					if (student != null) {
						DateTime time = Util.parseDateTime(
								req.getParameter("date") + " "
										+ req.getParameter("time"), train
										.appData().get().getTimeZone());
						switch (atype) {
						case Absence:
							toUpdate = ac.createOrUpdateAbsence(student, event);
							break;
						case Tardy:
							toUpdate = ac.createOrUpdateTardy(student, time);
							break;
						case EarlyCheckOut:
							toUpdate = ac.createOrUpdateEarlyCheckout(student,
									time);
							break;
						}
					}
				} else {
					aid = Long.parseLong(absid);
					toUpdate = ac.get(aid);
				}
				if (toUpdate != null) {
					try {
						LocalTime d = Util.parseTimeOnly(
								req.getParameter("time"), train.appData().get()
										.getTimeZone());
						switch (toUpdate.getType()) {
						case EarlyCheckOut:
							toUpdate.setCheckout(d.toDateTime(toUpdate
									.getCheckout(zone).toDateMidnight()));
							break;
						case Tardy:
							toUpdate.setCheckin(d.toDateTime(toUpdate
									.getCheckin(zone).toDateMidnight()));
							break;
						default:
							throw new IllegalStateException();
						}
						toUpdate.setType(Absence.Type.valueOf(type));
						toUpdate.setStatus(Absence.Status.valueOf(status));
					} catch (ValidationExceptions e) {
						validForm = false;
						errors.add("Invalid Input: The input DateTime was invalid.");
					} catch (IllegalArgumentException e) {
						validForm = false;
						errors.add("Invalid Input: The input DateTime is invalid.");
					} catch (IllegalStateException e) {
						validForm = false;
						errors.add("Invalid Input: Cannot set time for absence");
					}
				} else {
					validForm = false;
					errors.add("Could not find the Absence to update");
				}
			} else {
				validForm = false;
				errors.add("Could not find the Absence to update");
			}
			if (validForm) {
				ac.updateAbsence(toUpdate);
				viewAbsence(req, resp, errors, "Successfully updated absence");
			} else {
				viewAbsence(req, resp, errors, "");
			}
		}
	}

Output:
	private void postAbsenceInfo(HttpServletRequest req,
			HttpServletResponse resp) throws ServletException, IOException {
		DataTrain train = DataTrain.depart();
		AbsenceManager ac = train.absences();
		DateTimeZone zone = train.appData().get().getTimeZone();
		boolean validForm = true;
		List<String> errors = new LinkedList<String>();
		if (!ValidationUtil.isPost(req)) {
			validForm = false;
		} else {
			String absid = req.getParameter("absenceid");
			if (req.getParameter("delete") != null) {
				deleteAbsence(absid, ac, req, resp);
				return;
			}
			long aid;
			Absence toUpdate = null;
			if (absid != null) {
				String type = req.getParameter("Type");
				String status = req.getParameter("Status");
				String eventid = req.getParameter("eventid");
				Event event = null;
				try {
					long eid = Long.parseLong(eventid);
					event = train.events().get(eid);
				} catch (NumberFormatException nfe) {
					errors.add("No event to add. Can't create absence.");
				}
				if (absid.equals("new")) {
					String sid = req.getParameter("studentid");
					User student = train.users().get(sid);
					Absence.Type atype = Absence.Type.valueOf(type);
					if (student != null) {
						DateTime time = Util.parseDateTime(
								req.getParameter("date") + " "
										+ req.getParameter("time"), train
										.appData().get().getTimeZone());
						switch (atype) {
						case Absence:
							toUpdate = ac.createOrUpdateAbsence(student, event);
							break;
						case Tardy:
							toUpdate = ac.createOrUpdateTardy(student, time);
							break;
						case EarlyCheckOut:
							toUpdate = ac.createOrUpdateEarlyCheckout(student,
									time);
							break;
						}
					}
				} else {
					aid = Long.parseLong(absid);
					toUpdate = ac.get(aid);
				}
				if (toUpdate != null) {
					try {
						String time = req.getParameter("time");
						LocalTime d = null;
						if (time != null && !time.equals("")) {
							d = Util.parseTimeOnly(time, train.appData().get()
									.getTimeZone());
						}
						if (d == null
								&& toUpdate.getType() != Absence.Type.Absence) {
							throw new IllegalArgumentException();
						}
						switch (toUpdate.getType()) {
						case EarlyCheckOut:
							toUpdate.setCheckout(d.toDateTime(toUpdate
									.getCheckout(zone).toDateMidnight()));
							break;
						case Tardy:
							toUpdate.setCheckin(d.toDateTime(toUpdate
									.getCheckin(zone).toDateMidnight()));
							break;
						case Absence:
							break;
						default:
							throw new IllegalStateException();
						}
						toUpdate.setType(Absence.Type.valueOf(type));
						toUpdate.setStatus(Absence.Status.valueOf(status));
					} catch (ValidationExceptions e) {
						validForm = false;
						errors.add("Invalid Input: The input DateTime was invalid.");
					} catch (IllegalArgumentException e) {
						validForm = false;
						errors.add("Invalid Input: The input DateTime is invalid.");
					} catch (IllegalStateException e) {
						validForm = false;
						errors.add("Invalid Input: Cannot set time for absence");
					}
				} else {
					validForm = false;
					errors.add("Could not find the Absence to update");
				}
			} else {
				validForm = false;
				errors.add("Could not find the Absence to update");
			}
			if (validForm) {
				ac.updateAbsence(toUpdate);
				viewAbsence(req, resp, errors, "Successfully updated absence");
			} else {
				viewAbsence(req, resp, errors, "");
			}
		}
	}


Input:
	public static Result register(){
		Form<Register> registerForm = form(Register.class).bindFromRequest();
		Pattern pattern = Pattern.compile("[^a-z ]", Pattern.CASE_INSENSITIVE);
		Matcher matcher = pattern.matcher(registerForm.get().name);
		List<Link> breadcrumbs = new ArrayList<Link>();
		breadcrumbs.add(new Link("Home", "/"));
		breadcrumbs.add(new Link("Sign Up", "/signup"));
		if(!registerForm.get().email.isEmpty()){
			if(Ebean.find(UserModel.class).where().eq(
					"email",registerForm.get().email).findUnique() != null){
				flash("error", EMessages.get(EMessages.get("register.same_email")));
				return badRequest(register.render((EMessages.get("register.title")), breadcrumbs, registerForm));
			}
		}
		if(registerForm.hasErrors()){
			flash("error", EMessages.get(EMessages.get("error.text")));
			return badRequest(register.render((EMessages.get("register.title")), breadcrumbs, form(Register.class).bindFromRequest()));
		}
		if(matcher.find()){
			flash("error", EMessages.get(EMessages.get("error.invalid_symbols")));
			return badRequest(register.render((EMessages.get("register.title")), breadcrumbs, form(Register.class).bindFromRequest()));
		}
		pattern = Pattern.compile("[^a-z._+@0-9!#$%&'*+-/=?^_`{|}~]");
		matcher = pattern.matcher(registerForm.get().email);
		if(matcher.find()){
			flash("error", EMessages.get(EMessages.get("error.invalid_email")));
			return badRequest(register.render((EMessages.get("register.title")), breadcrumbs, form(Register.class).bindFromRequest()));
		}
		try{
			new SimpleDateFormat("yyyy/mm/dd").parse(registerForm.get().bday);
		}catch(Exception e){
			flash("error", EMessages.get(EMessages.get("error.invalid_date")));
			return badRequest(register.render((EMessages.get("register.title")), breadcrumbs, form(Register.class).bindFromRequest()));
		}
		String bebrasID = null;
		try {
			bebrasID = AuthenticationManager.getInstance().createUser(registerForm);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return ok(registerLandingPage.render(EMessages.get("info.success"), new ArrayList<Link>(), bebrasID));
	}

Output:
	public static Result register(){
		Form<Register> registerForm = form(Register.class).bindFromRequest();
		Pattern pattern = Pattern.compile("[^a-z ]", Pattern.CASE_INSENSITIVE);
		Matcher matcher = pattern.matcher(registerForm.get().name);
		List<Link> breadcrumbs = new ArrayList<Link>();
		breadcrumbs.add(new Link("Home", "/"));
		breadcrumbs.add(new Link("Sign Up", "/signup"));
		if(!registerForm.get().email.isEmpty()){
			if(Ebean.find(UserModel.class).where().eq(
					"email",registerForm.get().email).findUnique() != null){
				flash("error", EMessages.get(EMessages.get("register.same_email")));
				return badRequest(register.render((EMessages.get("register.title")), breadcrumbs, registerForm));
			}
		}
		if(registerForm.hasErrors()){
			flash("error", EMessages.get(EMessages.get("error.text")));
			return badRequest(register.render((EMessages.get("register.title")), breadcrumbs, registerForm));
		}
		if(matcher.find()){
			flash("error", EMessages.get(EMessages.get("error.invalid_symbols")));
			return badRequest(register.render((EMessages.get("register.title")), breadcrumbs, registerForm));
		}
		pattern = Pattern.compile("[^a-z._+@0-9!#$%&'*+-/=?^_`{|}~]");
		matcher = pattern.matcher(registerForm.get().email);
		if(matcher.find()){
			flash("error", EMessages.get(EMessages.get("error.invalid_email")));
			return badRequest(register.render((EMessages.get("register.title")), breadcrumbs, registerForm));
		}
		try{
			new SimpleDateFormat("yyyy/mm/dd").parse(registerForm.get().bday);
		}catch(Exception e){
			flash("error", EMessages.get(EMessages.get("error.invalid_date")));
			return badRequest(register.render((EMessages.get("register.title")), breadcrumbs, registerForm));
		}
		String bebrasID = null;
		try {
			bebrasID = AuthenticationManager.getInstance().createUser(registerForm);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return ok(registerLandingPage.render(EMessages.get("info.success"), new ArrayList<Link>(), bebrasID));
	}


Input:
    public void fillCurrentUserSubjectList(Subject[] subjects) {
        UserDetails userDetails = (UserDetails) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
        Person person = personDAO.findByUsername(userDetails.getUsername());
        LOGGER.debug("User: " + person.getUsername() + " [" + person.getIndeks() + "] submitted subjects: " +
                Arrays.asList(subjects));
        final List<Subject> toRemove = new ArrayList<>();
        final List<Subject> personSubjects = person.getSubjects();
        for (Subject s : personSubjects) {
            boolean contained = false;
            for (Subject s2 : subjects) {
                if (s2.equals(s)) {
                    contained = true;
                    break;
                }
            }
            if (!contained) {
                toRemove.add(s);
            }
        }
        LOGGER.debug("To remove list computed: " + toRemove);
        for (Subject s : toRemove) {
            s = getByPK(s.getSubjectID());
            final List<Term> termsBySubject = termDAO.getTermsBySubject(s);
            LOGGER.debug("Terms of subject: " + s + " retrieved");
            for (Term t : termsBySubject) {
                final StudentPointsPerTerm byPersonAndTerm = pointsDAO.getByPersonAndTerm(person, t);
                if (byPersonAndTerm != null) {
                    pointsDAO.remove(byPersonAndTerm);
                    LOGGER.debug("Points of term: " + t + " removed");
                }
            }
            s.getPersons().remove(person);
            LOGGER.debug("Person removed from subject");
        }
        personSubjects.removeAll(toRemove);
        LOGGER.debug("Unnecessary subjects removed");
        for (Subject subject : subjects) {
            subject.addPerson(person);
            person.addSubject(subject);
            LOGGER.debug("add new subject to student: " + subject);
        }
        em.merge(person);
        LOGGER.debug("Person updated");
    }

Output:
    public void fillCurrentUserSubjectList(Subject[] subjects) {
        UserDetails userDetails = (UserDetails) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
        Person person = personDAO.findByUsername(userDetails.getUsername());
        LOGGER.debug("User: " + person.getUsername() + " [" + person.getIndeks() + "] submitted subjects: " +
                Arrays.asList(subjects));
        final List<Subject> toRemove = new ArrayList<>();
        final List<Subject> personSubjects = person.getSubjects();
        for (Subject s : personSubjects) {
            boolean contained = false;
            for (Subject s2 : subjects) {
                if (s2.equals(s)) {
                    contained = true;
                    break;
                }
            }
            if (!contained) {
                toRemove.add(s);
            }
        }
        LOGGER.debug("To remove list computed: " + toRemove);
        for (Subject s : toRemove) {
            s = getByPK(s.getSubjectID());
            final List<Term> termsBySubject = termDAO.getTermsBySubject(s);
            LOGGER.debug("Terms of subject: " + s + " retrieved");
            for (Term t : termsBySubject) {
                final StudentPointsPerTerm byPersonAndTerm = pointsDAO.getByPersonAndTerm(person, t);
                if (byPersonAndTerm != null) {
                    pointsDAO.remove(byPersonAndTerm);
                    LOGGER.debug("Points of term: " + t + " removed");
                }
            }
            s.getPersons().remove(person);
            LOGGER.debug("Person removed from subject");
        }
        personSubjects.removeAll(toRemove);
        LOGGER.debug("Unnecessary subjects removed");
        for (Subject subject : subjects) {
            subject = getByPK(subject.getSubjectID());
            subject.addPerson(person);
            person.addSubject(subject);
            LOGGER.debug("add new subject to student: " + subject);
        }
        em.merge(person);
        LOGGER.debug("Person updated");
    }


Input:
    protected final void addAnnotationsBuilder() {
    	Descriptor descriptor = AnnotationsControllerManager.INSTANCE.getDescriptor(ProjectUtilities.getProject(model.getStringProperty(PROJECT_NAME)));
    	if (descriptor!=null)
    		return;
        try {
            IConfigurationElement[] configurationElements = Platform.getExtensionRegistry().getConfigurationElementsFor(TEMPLATE_EMITTER);
            String builderID = configurationElements[0].getNamespace() + "." + configurationElements[0].getAttribute(BUILDER_ID);
            IProject project = ProjectUtilities.getProject(model.getProperty(PROJECT_NAME));
            IProjectDescription description = project.getDescription();
            ICommand[] commands = description.getBuildSpec();
            boolean found = false;
            for (int i = 0; i < commands.length; ++i) {
                if (commands[i].getBuilderName().equals(builderID)) {
                    found = true;
                    break;
                }
            }
            if (!found) {
                ICommand command = description.newCommand();
                command.setBuilderName(builderID);
                ICommand[] newCommands = new ICommand[commands.length + 1];
                System.arraycopy(commands, 0, newCommands, 0, commands.length);
                newCommands[commands.length] = command;
                IProjectDescription desc = project.getDescription();
                desc.setBuildSpec(newCommands);
                project.setDescription(desc, null);
            }
        } catch (Exception e) {
        }
    }

Output:
    protected final void addAnnotationsBuilder() {
    	Descriptor descriptor = AnnotationsControllerManager.INSTANCE.getDescriptor(ProjectUtilities.getProject(model.getStringProperty(PROJECT_NAME)));
    	if (descriptor!=null)
    		return;
        try {
            IConfigurationElement[] configurationElements = Platform.getExtensionRegistry().getConfigurationElementsFor(TEMPLATE_EMITTER);
            String builderID = configurationElements[0].getNamespace() + "." + configurationElements[0].getAttribute(BUILDER_ID);
            IProject project = ProjectUtilities.getProject(model.getProperty(PROJECT_NAME));
            if(project != null && project.isAccessible()) {
            IProjectDescription description = project.getDescription();
            ICommand[] commands = description.getBuildSpec();
            boolean found = false;
            for (int i = 0; i < commands.length; ++i) {
                if (commands[i].getBuilderName().equals(builderID)) {
                    found = true;
                    break;
                }
            }
            if (!found) {
                ICommand command = description.newCommand();
                command.setBuilderName(builderID);
                ICommand[] newCommands = new ICommand[commands.length + 1];
                System.arraycopy(commands, 0, newCommands, 0, commands.length);
                newCommands[commands.length] = command;
                IProjectDescription desc = project.getDescription();
                desc.setBuildSpec(newCommands);
                project.setDescription(desc, null);
            }
           }
        } catch (Exception e) {
        }
    }


Input:
    public final SixteenSegment build() {
        final SixteenSegment CONTROL = new SixteenSegment();
        for (String key : properties.keySet()) {
            if("prefWidth".equals(key)) {
                CONTROL.setPrefWidth(((DoubleProperty) properties.get(key)).get());
            } else if("prefHeight".equals(key)) {
                CONTROL.setPrefHeight(((DoubleProperty) properties.get(key)).get());
            } else if("minWidth".equals(key)) {
                CONTROL.setMinWidth(((DoubleProperty) properties.get(key)).get());
            } else if("minHeight".equals(key)) {
                CONTROL.setMinHeight(((DoubleProperty) properties.get(key)).get());
            } else if("maxWidth".equals(key)) {
                CONTROL.setMaxWidth(((DoubleProperty) properties.get(key)).get());
            } else if("maxHeight".equals(key)) {
                CONTROL.setMaxHeight(((DoubleProperty) properties.get(key)).get());
            } else if("scaleX".equals(key)) {
                CONTROL.setScaleX(((DoubleProperty) properties.get(key)).get());
            } else if("scaleY".equals(key)) {
                CONTROL.setScaleY(((DoubleProperty) properties.get(key)).get());
            } else if ("layoutX".equals(key)) {
                CONTROL.setLayoutX(((DoubleProperty) properties.get(key)).get());
            } else if ("layoutY".equals(key)) {
                CONTROL.setLayoutY(((DoubleProperty) properties.get(key)).get());
            } else if ("translateX".equals(key)) {
                CONTROL.setTranslateX(((DoubleProperty) properties.get(key)).get());
            } else if ("translateY".equals(key)) {
                CONTROL.setTranslateY(((DoubleProperty) properties.get(key)).get());
            } else if ("styleClass".equals(key)) {
                CONTROL.getStyleClass().setAll("seven-segment", ((StringProperty) properties.get(key)).get());
            } else if ("segmentStyle".equals(key)) {
                CONTROL.setSegmentStyle(((ObjectProperty<SixteenSegment.SegmentStyle>) properties.get(key)).get());
            } else if ("characterString".equals(key)) {
                CONTROL.setCharacter(((StringProperty) properties.get(key)).get());
            } else if ("characterChar".equals(key)) {
                CONTROL.setCharacter(((ObjectProperty<Character>) properties.get(key)).get());
            } else if ("characterInt".equals(key)) {
                CONTROL.setCharacter(((IntegerProperty) properties.get(key)).get());
            } else if ("dotOn".equals(key)) {
                CONTROL.setDotOn(((BooleanProperty) properties.get(key)).get());
            }
        }
        return CONTROL;
    }

Output:
    public final SixteenSegment build() {
        final SixteenSegment CONTROL = new SixteenSegment();
        for (String key : properties.keySet()) {
            if("prefWidth".equals(key)) {
                CONTROL.setPrefWidth(((DoubleProperty) properties.get(key)).get());
            } else if("prefHeight".equals(key)) {
                CONTROL.setPrefHeight(((DoubleProperty) properties.get(key)).get());
            } else if("minWidth".equals(key)) {
                CONTROL.setMinWidth(((DoubleProperty) properties.get(key)).get());
            } else if("minHeight".equals(key)) {
                CONTROL.setMinHeight(((DoubleProperty) properties.get(key)).get());
            } else if("maxWidth".equals(key)) {
                CONTROL.setMaxWidth(((DoubleProperty) properties.get(key)).get());
            } else if("maxHeight".equals(key)) {
                CONTROL.setMaxHeight(((DoubleProperty) properties.get(key)).get());
            } else if("scaleX".equals(key)) {
                CONTROL.setScaleX(((DoubleProperty) properties.get(key)).get());
            } else if("scaleY".equals(key)) {
                CONTROL.setScaleY(((DoubleProperty) properties.get(key)).get());
            } else if ("layoutX".equals(key)) {
                CONTROL.setLayoutX(((DoubleProperty) properties.get(key)).get());
            } else if ("layoutY".equals(key)) {
                CONTROL.setLayoutY(((DoubleProperty) properties.get(key)).get());
            } else if ("translateX".equals(key)) {
                CONTROL.setTranslateX(((DoubleProperty) properties.get(key)).get());
            } else if ("translateY".equals(key)) {
                CONTROL.setTranslateY(((DoubleProperty) properties.get(key)).get());
            } else if ("styleClass".equals(key)) {
                CONTROL.getStyleClass().setAll("sixteen-segment", ((StringProperty) properties.get(key)).get());
            } else if ("segmentStyle".equals(key)) {
                CONTROL.setSegmentStyle(((ObjectProperty<SixteenSegment.SegmentStyle>) properties.get(key)).get());
            } else if ("characterString".equals(key)) {
                CONTROL.setCharacter(((StringProperty) properties.get(key)).get());
            } else if ("characterChar".equals(key)) {
                CONTROL.setCharacter(((ObjectProperty<Character>) properties.get(key)).get());
            } else if ("characterInt".equals(key)) {
                CONTROL.setCharacter(((IntegerProperty) properties.get(key)).get());
            } else if ("dotOn".equals(key)) {
                CONTROL.setDotOn(((BooleanProperty) properties.get(key)).get());
            }
        }
        return CONTROL;
    }


Input:
    public static void populate(Object bean, String prefix, String suffix,
        HttpServletRequest request)
        throws ServletException {
        HashMap properties = new HashMap();
        Enumeration names = null;
        Map multipartParameters = null;
        String contentType = request.getContentType();
        String method = request.getMethod();
        boolean isMultipart = false;
        if (bean instanceof ActionForm) {
            ((ActionForm) bean).setMultipartRequestHandler(null);
        }
        MultipartRequestHandler multipartHandler = null;
        if ((contentType != null)
            && (contentType.startsWith("multipart/form-data"))
            && (method.equalsIgnoreCase("POST"))) {
            ActionServletWrapper servlet;
            if (bean instanceof ActionForm) {
                servlet = ((ActionForm) bean).getServletWrapper();
            } else {
                throw new ServletException("bean that's supposed to be "
                    + "populated from a multipart request is not of type "
                    + "\"org.apache.struts.action.ActionForm\", but type "
                    + "\"" + bean.getClass().getName() + "\"");
            }
            multipartHandler = getMultipartHandler(request);
            if (multipartHandler != null) {
                isMultipart = true;
                servlet.setServletFor(multipartHandler);
                multipartHandler.setMapping((ActionMapping) request
                    .getAttribute(Globals.MAPPING_KEY));
                multipartHandler.handleRequest(request);
                Boolean maxLengthExceeded =
                    (Boolean) request.getAttribute(MultipartRequestHandler.ATTRIBUTE_MAX_LENGTH_EXCEEDED);
                if ((maxLengthExceeded != null)
                    && (maxLengthExceeded.booleanValue())) {
                    return;
                }
                multipartParameters =
                    getAllParametersForMultipartRequest(request,
                        multipartHandler);
                names = Collections.enumeration(multipartParameters.keySet());
            }
        }
        if (!isMultipart) {
            names = request.getParameterNames();
        }
        while (names.hasMoreElements()) {
            String name = (String) names.nextElement();
            String stripped = name;
            if (prefix != null) {
                if (!stripped.startsWith(prefix)) {
                    continue;
                }
                stripped = stripped.substring(prefix.length());
            }
            if (suffix != null) {
                if (!stripped.endsWith(suffix)) {
                    continue;
                }
                stripped =
                    stripped.substring(0, stripped.length() - suffix.length());
            }
            Object parameterValue = null;
            if (isMultipart) {
                parameterValue = multipartParameters.get(name);
            } else {
                parameterValue = request.getParameterValues(name);
            }
            if (!(stripped.startsWith("org.apache.struts."))) {
                properties.put(stripped, parameterValue);
            }
        }
        try {
            BeanUtils.populate(bean, properties);
        } catch (Exception e) {
            throw new ServletException("BeanUtils.populate", e);
        } finally {
            if (multipartHandler != null) {
                ((ActionForm) bean).setMultipartRequestHandler(multipartHandler);
            }
        }
    }

Output:
    public static void populate(Object bean, String prefix, String suffix,
        HttpServletRequest request)
        throws ServletException {
        HashMap properties = new HashMap();
        Enumeration names = null;
        Map multipartParameters = null;
        String contentType = request.getContentType();
        String method = request.getMethod();
        boolean isMultipart = false;
        if (bean instanceof ActionForm) {
            ((ActionForm) bean).setMultipartRequestHandler(null);
        }
        MultipartRequestHandler multipartHandler = null;
        if ((contentType != null)
            && (contentType.startsWith("multipart/form-data"))
            && (method.equalsIgnoreCase("POST"))) {
            ActionServletWrapper servlet;
            if (bean instanceof ActionForm) {
                servlet = ((ActionForm) bean).getServletWrapper();
            } else {
                throw new ServletException("bean that's supposed to be "
                    + "populated from a multipart request is not of type "
                    + "\"org.apache.struts.action.ActionForm\", but type "
                    + "\"" + bean.getClass().getName() + "\"");
            }
            multipartHandler = getMultipartHandler(request);
            if (multipartHandler != null) {
                isMultipart = true;
                servlet.setServletFor(multipartHandler);
                multipartHandler.setMapping((ActionMapping) request
                    .getAttribute(Globals.MAPPING_KEY));
                multipartHandler.handleRequest(request);
                Boolean maxLengthExceeded =
                    (Boolean) request.getAttribute(MultipartRequestHandler.ATTRIBUTE_MAX_LENGTH_EXCEEDED);
                if ((maxLengthExceeded != null)
                    && (maxLengthExceeded.booleanValue())) {
                    ((ActionForm) bean).setMultipartRequestHandler(multipartHandler);
                    return;
                }
                multipartParameters =
                    getAllParametersForMultipartRequest(request,
                        multipartHandler);
                names = Collections.enumeration(multipartParameters.keySet());
            }
        }
        if (!isMultipart) {
            names = request.getParameterNames();
        }
        while (names.hasMoreElements()) {
            String name = (String) names.nextElement();
            String stripped = name;
            if (prefix != null) {
                if (!stripped.startsWith(prefix)) {
                    continue;
                }
                stripped = stripped.substring(prefix.length());
            }
            if (suffix != null) {
                if (!stripped.endsWith(suffix)) {
                    continue;
                }
                stripped =
                    stripped.substring(0, stripped.length() - suffix.length());
            }
            Object parameterValue = null;
            if (isMultipart) {
                parameterValue = multipartParameters.get(name);
            } else {
                parameterValue = request.getParameterValues(name);
            }
            if (!(stripped.startsWith("org.apache.struts."))) {
                properties.put(stripped, parameterValue);
            }
        }
        try {
            BeanUtils.populate(bean, properties);
        } catch (Exception e) {
            throw new ServletException("BeanUtils.populate", e);
        } finally {
            if (multipartHandler != null) {
                ((ActionForm) bean).setMultipartRequestHandler(multipartHandler);
            }
        }
    }


Input:
    private String getIPFrom_chinaz(final String hostName)
    {
        String ipAddress = null;
        String url = UrlManager.URL_CHINAZ_IP + "?IP=" + hostName;
        NetDataGetter getter;
        try
        {
            getter = new NetDataGetter(url);
            String html = getter.getStringData();
            Pattern resultPattern = Pattern.compile("查询结果\\[1\\](.+)</");
            Matcher resultMatcher = resultPattern.matcher(html);
            if (resultMatcher.find())
            {
                String result = resultMatcher.group();
                Pattern ipPattern = Pattern.compile("((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)\\.){3}(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|[1-9])");
                Matcher ipMatcher = ipPattern.matcher(result);
                if (ipMatcher.find())
                {
                    ipAddress = ipMatcher.group();
                }
            }
        }
        catch (MalformedURLException e)
        {
            e.printStackTrace();
        }
        if (!Utility.isIPAddress(ipAddress))
            return null;
        return ipAddress;
    }

Output:
    private String getIPFrom_chinaz(final String hostName)
    {
        String ipAddress = null;
        String url = UrlManager.URL_CHINAZ_IP + "?IP=" + hostName;
        NetDataGetter getter;
        try
        {
            getter = new NetDataGetter(url);
            String html = getter.getStringData();
            if (html == null)
                return null;
            Pattern resultPattern = Pattern.compile("查询结果\\[1\\](.+)</");
            Matcher resultMatcher = resultPattern.matcher(html);
            if (resultMatcher.find())
            {
                String result = resultMatcher.group();
                Pattern ipPattern = Pattern.compile("((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)\\.){3}(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|[1-9])");
                Matcher ipMatcher = ipPattern.matcher(result);
                if (ipMatcher.find())
                {
                    ipAddress = ipMatcher.group();
                }
            }
        }
        catch (MalformedURLException e)
        {
            e.printStackTrace();
        }
        if (!Utility.isIPAddress(ipAddress))
            return null;
        return ipAddress;
    }


Input:
	public void testExtractingEpisodes() throws Exception {
		List<Episode> episodes = new C4EpisodesExtractor(new NullAdapterLog()).includeBroadcasts().includeOnDemands().extract(fourOdFeed.build());
		Episode firstEpisode = (Episode) Iterables.get(episodes, 0);
		assertThat(firstEpisode.getCanonicalUri(), is("http://www.channel4.com/programmes/ramsays-kitchen-nightmares/episode-guide/series-1/episode-1"));
		assertThat(firstEpisode.getAliases(), is((Set<String>) ImmutableSet.of("http://www.channel4.com/programmes/ramsays-kitchen-nightmares/4od#2922045", "tag:www.channel4.com,2009:/programmes/ramsays-kitchen-nightmares/4od%232922045")));
		assertThat(firstEpisode.getCurie(), is("c4:ramsays-kitchen-nightmares-series-1-episode-1"));
		assertThat(firstEpisode.getTitle(), is("Series 1 Episode 1"));
		assertThat(firstEpisode.getPublisher(), is(Publisher.C4));
		assertThat(firstEpisode.getSeriesNumber(), is(1));
		assertThat(firstEpisode.getEpisodeNumber(), is(1));
		assertThat(firstEpisode.getDescription(), startsWith("Gordon Ramsay visits Bonapartes in Silsden, West Yorkshire."));
		assertThat(firstEpisode.getThumbnail(), is("http://www.channel4.com/assets/programmes/images/ramsays-kitchen-nightmares/series-1/ramsays-kitchen-nightmares-s1-20090617160732_200x113.jpg"));
		assertThat(firstEpisode.getImage(), is("http://www.channel4.com/assets/programmes/images/ramsays-kitchen-nightmares/series-1/ramsays-kitchen-nightmares-s1-20090617160732_625x352.jpg"));
		assertThat(firstEpisode.getLastUpdated(), is(new DateTime("2010-04-27T09:49:40.803Z", DateTimeZones.UTC)));
		Version firstEpisodeVersion = Iterables.get(firstEpisode.getVersions(), 0);
		assertThat(firstEpisodeVersion.getDuration(), is((48 * 60) + 55));
		assertThat(firstEpisodeVersion.getRating(), is("http://ref.atlasapi.org/ratings/simple/adult"));
		assertThat(firstEpisodeVersion.getRatingText(), is("Strong language throughout"));
		assertThat(firstEpisodeVersion.getBroadcasts(), is(Collections.<Broadcast>emptySet()));
		Encoding firstEpsiodeEncoding = Iterables.get(firstEpisodeVersion.getManifestedAs(), 0);
		Location firstEpsiodeLocation = Iterables.get(firstEpsiodeEncoding.getAvailableAt(), 0);
		assertThat(firstEpsiodeLocation.getUri(), is("http://www.channel4.com/programmes/ramsays-kitchen-nightmares/4od#2922045"));
		assertThat(firstEpsiodeLocation.getAliases(), is((Set<String>) ImmutableSet.of("tag:www.channel4.com,2009:/programmes/ramsays-kitchen-nightmares/4od%232922045")));
		assertThat(firstEpsiodeLocation.getTransportType(), is(TransportType.LINK));
		Policy firstEpisodePolicy = firstEpsiodeLocation.getPolicy();
		assertThat(firstEpisodePolicy.getAvailabilityStart(), is(new LocalDate(2009, 07, 01).toDateTimeAtStartOfDay()));
		assertThat(firstEpisodePolicy.getAvailabilityEnd(), is(new LocalDate(2010, 12, 31).plusDays(1).toDateTimeAtStartOfDay()));
		assertThat(firstEpisodePolicy.getAvailableCountries(), is((Set<Country>) Sets.newHashSet(Countries.GB, Countries.IE)));
		Episode episodeWithABroadcast = (Episode) Iterables.get(episodes, 4);
		Version episodeWithABroadcastVersion = Iterables.get(episodeWithABroadcast.getVersions(), 0);
		Broadcast episodeWithABroadcastBroadcast = Iterables.get(episodeWithABroadcastVersion.getBroadcasts(), 0);
		assertThat(episodeWithABroadcastBroadcast.getTransmissionTime(), is(new DateTime("2009-06-10T23:05:00.000Z")));
		assertThat(episodeWithABroadcastBroadcast.getBroadcastOn(), is("http://www.channel4.com/more4"));
	}

Output:
	public void testExtractingEpisodes() throws Exception {
		List<Episode> episodes = new C4EpisodesExtractor(new NullAdapterLog()).includeBroadcasts().includeOnDemands().extract(fourOdFeed.build());
		Episode firstEpisode = (Episode) Iterables.get(episodes, 0);
		assertThat(firstEpisode.getCanonicalUri(), is("http://www.channel4.com/programmes/ramsays-kitchen-nightmares/episode-guide/series-1/episode-1"));
		assertThat(firstEpisode.getAliases(), is((Set<String>) ImmutableSet.of("http://www.channel4.com/programmes/ramsays-kitchen-nightmares/4od#2922045")));
		assertThat(firstEpisode.getCurie(), is("c4:ramsays-kitchen-nightmares-series-1-episode-1"));
		assertThat(firstEpisode.getTitle(), is("Series 1 Episode 1"));
		assertThat(firstEpisode.getPublisher(), is(Publisher.C4));
		assertThat(firstEpisode.getSeriesNumber(), is(1));
		assertThat(firstEpisode.getEpisodeNumber(), is(1));
		assertThat(firstEpisode.getDescription(), startsWith("Gordon Ramsay visits Bonapartes in Silsden, West Yorkshire."));
		assertThat(firstEpisode.getThumbnail(), is("http://www.channel4.com/assets/programmes/images/ramsays-kitchen-nightmares/series-1/ramsays-kitchen-nightmares-s1-20090617160732_200x113.jpg"));
		assertThat(firstEpisode.getImage(), is("http://www.channel4.com/assets/programmes/images/ramsays-kitchen-nightmares/series-1/ramsays-kitchen-nightmares-s1-20090617160732_625x352.jpg"));
		assertThat(firstEpisode.getLastUpdated(), is(new DateTime("2010-04-27T09:49:40.803Z", DateTimeZones.UTC)));
		Version firstEpisodeVersion = Iterables.get(firstEpisode.getVersions(), 0);
		assertThat(firstEpisodeVersion.getDuration(), is((48 * 60) + 55));
		assertThat(firstEpisodeVersion.getRating(), is("http://ref.atlasapi.org/ratings/simple/adult"));
		assertThat(firstEpisodeVersion.getRatingText(), is("Strong language throughout"));
		assertThat(firstEpisodeVersion.getBroadcasts(), is(Collections.<Broadcast>emptySet()));
		Encoding firstEpsiodeEncoding = Iterables.get(firstEpisodeVersion.getManifestedAs(), 0);
		Location firstEpsiodeLocation = Iterables.get(firstEpsiodeEncoding.getAvailableAt(), 0);
		assertThat(firstEpsiodeLocation.getUri(), is("http://www.channel4.com/programmes/ramsays-kitchen-nightmares/4od#2922045"));
		assertThat(firstEpsiodeLocation.getAliases(), is((Set<String>) ImmutableSet.of("tag:www.channel4.com,2009:/programmes/ramsays-kitchen-nightmares/4od%232922045")));
		assertThat(firstEpsiodeLocation.getTransportType(), is(TransportType.LINK));
		Policy firstEpisodePolicy = firstEpsiodeLocation.getPolicy();
		assertThat(firstEpisodePolicy.getAvailabilityStart(), is(new LocalDate(2009, 07, 01).toDateTimeAtStartOfDay()));
		assertThat(firstEpisodePolicy.getAvailabilityEnd(), is(new LocalDate(2010, 12, 31).plusDays(1).toDateTimeAtStartOfDay()));
		assertThat(firstEpisodePolicy.getAvailableCountries(), is((Set<Country>) Sets.newHashSet(Countries.GB, Countries.IE)));
		Episode episodeWithABroadcast = (Episode) Iterables.get(episodes, 4);
		Version episodeWithABroadcastVersion = Iterables.get(episodeWithABroadcast.getVersions(), 0);
		Broadcast episodeWithABroadcastBroadcast = Iterables.get(episodeWithABroadcastVersion.getBroadcasts(), 0);
		assertThat(episodeWithABroadcastBroadcast.getTransmissionTime(), is(new DateTime("2009-06-10T23:05:00.000Z")));
		assertThat(episodeWithABroadcastBroadcast.getBroadcastOn(), is("http://www.channel4.com/more4"));
	}


Input:
  public TimestampSpec(
      @JsonProperty("column") String timestampColumn,
      @JsonProperty("format") String format
  )
  {
    this.timestampColumn = timestampColumn.toLowerCase();
    this.timestampFormat = format == null ? defaultFormat : format;
    this.timestampConverter = ParserUtils.createTimestampParser(timestampFormat);
  }

Output:
  public TimestampSpec(
      @JsonProperty("column") String timestampColumn,
      @JsonProperty("format") String format
  )
  {
    this.timestampColumn = timestampColumn.toLowerCase();
    this.timestampFormat = format == null ? defaultFormat : format.toLowerCase();
    this.timestampConverter = ParserUtils.createTimestampParser(timestampFormat);
  }


Input:
	public boolean reloadSettings() {
		final Set<String> oldForceEnableLater = new LinkedHashSet<String>();
		oldForceEnableLater.addAll(settings.forceEnableLater);
		File file = new File(getDataFolder() , "cncp.yml");
		CompatConfig cfg = new NewConfig(file);
		cfg.load();
		if (Settings.addDefaults(cfg)) cfg.save();
		settings.fromConfig(cfg);
		hookPlayerClass.setClassNames(settings.exemptPlayerClassNames);
		hookPlayerClass.setExemptAll(settings.exemptAllPlayerClassNames);
		hookPlayerClass.setPlayerClassName(settings.playerClassName);
		Server server = getServer();
		Logger logger = server.getLogger();
		for (String plgName : settings.loadPlugins){
			try{
				if (CompatNoCheatPlus.enablePlugin(plgName)){
					System.out.println("[cncp] Ensured that the following plugin is enabled: " + plgName);
				}
			}
			catch (Throwable t){
				logger.severe("[cncp] Failed to enable the plugin: " + plgName);
				logger.severe(Utils.toString(t));
			}
		}
		BukkitScheduler sched = server.getScheduler();
		for (String plgName : settings.forceEnableLater){
			if (!oldForceEnableLater.remove(plgName)) oldForceEnableLater.add(plgName);
		}
		if (!oldForceEnableLater.isEmpty()){
			System.out.println("[cncp] Schedule task to re-enable plugins later...");
			sched.scheduleSyncDelayedTask(this, new Runnable() {
				@Override
				public void run() {
					for (String plgName : oldForceEnableLater){
						try{
							if (disablePlugin(plgName)){
								if (enablePlugin(plgName)) System.out.println("[cncp] Re-enabled plugin: " + plgName);
								else System.out.println("[cncp] Could not re-enable plugin: "+plgName);
							}
							else{
								System.out.println("[cncp] Could not disable plugin (already disabled?): "+plgName);
							}
						}
						catch(Throwable t){
						}
					}
				}
			});
		}
		return true;
	}

Output:
	public boolean reloadSettings() {
		final Set<String> oldForceEnableLater = new LinkedHashSet<String>();
		oldForceEnableLater.addAll(settings.forceEnableLater);
		File file = new File(getDataFolder() , "cncp.yml");
		CompatConfig cfg = new NewConfig(file);
		cfg.load();
		if (Settings.addDefaults(cfg)) cfg.save();
		settings.fromConfig(cfg);
		hookPlayerClass.setClassNames(settings.exemptPlayerClassNames);
		hookPlayerClass.setExemptAll(settings.exemptAllPlayerClassNames);
		hookPlayerClass.setPlayerClassName(settings.playerClassName);
		hookPlayerClass.setCheckSuperClass(settings.exemptSuperClass);
		Server server = getServer();
		Logger logger = server.getLogger();
		for (String plgName : settings.loadPlugins){
			try{
				if (CompatNoCheatPlus.enablePlugin(plgName)){
					System.out.println("[cncp] Ensured that the following plugin is enabled: " + plgName);
				}
			}
			catch (Throwable t){
				logger.severe("[cncp] Failed to enable the plugin: " + plgName);
				logger.severe(Utils.toString(t));
			}
		}
		BukkitScheduler sched = server.getScheduler();
		for (String plgName : settings.forceEnableLater){
			if (!oldForceEnableLater.remove(plgName)) oldForceEnableLater.add(plgName);
		}
		if (!oldForceEnableLater.isEmpty()){
			System.out.println("[cncp] Schedule task to re-enable plugins later...");
			sched.scheduleSyncDelayedTask(this, new Runnable() {
				@Override
				public void run() {
					for (String plgName : oldForceEnableLater){
						try{
							if (disablePlugin(plgName)){
								if (enablePlugin(plgName)) System.out.println("[cncp] Re-enabled plugin: " + plgName);
								else System.out.println("[cncp] Could not re-enable plugin: "+plgName);
							}
							else{
								System.out.println("[cncp] Could not disable plugin (already disabled?): "+plgName);
							}
						}
						catch(Throwable t){
						}
					}
				}
			});
		}
		return true;
	}


Input:
    public void testLoggerConfig() throws Exception {
        Logger logger = Logger.getLogger("foo.bar.zot");
        HtmlPage page = new WebClient().goTo("log/all");
        HtmlForm form = page.getFormByName("configLogger");
        form.getInputByName("name").setValueAttribute("foo.bar.zot");
        form.getSelectByName("level").getOptionByValue("finest").setSelected(true);
        submit(form);
        assertEquals(logger.getLevel(), Level.FINEST);
    }

Output:
    public void testLoggerConfig() throws Exception {
        Logger logger = Logger.getLogger("foo.bar.zot");
        HtmlPage page = new WebClient().goTo("log/levels");
        HtmlForm form = page.getFormByName("configLogger");
        form.getInputByName("name").setValueAttribute("foo.bar.zot");
        form.getSelectByName("level").getOptionByValue("finest").setSelected(true);
        submit(form);
        assertEquals(logger.getLevel(), Level.FINEST);
    }


Input:
        public String searchSchema(final SearchConditions searchConditions) {
            String union = " union all ";
            String clientExactMatchSql = " (select 'CLIENT' as entityType, c.id as entityId, c.display_name as entityName, c.external_id as entityExternalId, c.account_no as entityAccountNo "
                    + " , c.office_id as parentId, o.name as parentName "
                    + " from m_client c join m_office o on o.id = c.office_id where o.hierarchy like :hierarchy and (c.account_no like :search or c.display_name like :search or c.external_id like :search)) ";
            String clientMatchSql = " (select 'CLIENT' as entityType, c.id as entityId, c.display_name as entityName, c.external_id as entityExternalId, c.account_no as entityAccountNo "
                    + " , c.office_id as parentId, o.name as parentName "
                    + " from m_client c join m_office o on o.id = c.office_id where o.hierarchy like :hierarchy and (c.account_no like :partialSearch and c.account_no not like :search) or "
                    + "(c.display_name like :partialSearch and c.display_name not like :search) or "
                    + "(c.external_id like :partialSearch and c.external_id not like :search))";
            String loanExactMatchSql = " (select 'LOAN' as entityType, l.id as entityId, pl.name as entityName, l.external_id as entityExternalId, l.account_no as entityAccountNo "
                    + " , c.id as parentId, c.display_name as parentName "
                    + " from m_loan l join m_client c on l.client_id = c.id join m_office o on o.id = c.office_id join m_product_loan pl on pl.id=l.product_id where o.hierarchy like :hierarchy and l.account_no like :search) ";
            String loanMatchSql = " (select 'LOAN' as entityType, l.id as entityId, pl.name as entityName, l.external_id as entityExternalId, l.account_no as entityAccountNo "
                    + " , c.id as parentId, c.display_name as parentName "
                    + " from m_loan l join m_client c on l.client_id = c.id join m_office o on o.id = c.office_id join m_product_loan pl on pl.id=l.product_id where o.hierarchy like :hierarchy and l.account_no like :partialSearch and l.account_no not like :search) ";
            String clientIdentifierExactMatchSql = " (select 'CLIENTIDENTIFIER' as entityType, ci.id as entityId, ci.document_key as entityName, "
                    + " null as entityExternalId, null as entityAccountNo, c.id as parentId, c.display_name as parentName "
                    + " from m_client_identifier ci join m_client c on ci.client_id=c.id join m_office o on o.id = c.office_id "
                    + " where o.hierarchy like :hierarchy and ci.document_key like :search) ";
            String clientIdentifierMatchSql = " (select 'CLIENTIDENTIFIER' as entityType, ci.id as entityId, ci.document_key as entityName, "
                    + " null as entityExternalId, null as entityAccountNo, c.id as parentId, c.display_name as parentName "
                    + " from m_client_identifier ci join m_client c on ci.client_id=c.id join m_office o on o.id = c.office_id "
                    + " where o.hierarchy like :hierarchy and ci.document_key like :partialSearch and ci.document_key not like :search) ";
            String groupExactMatchSql = " (select 'GROUP' as entityType, g.id as entityId, g.display_name as entityName, g.external_id as entityExternalId, NULL as entityAccountNo "
                    + " , g.office_id as parentId, o.name as parentName "
                    + " from m_group g join m_office o on o.id = g.office_id where o.hierarchy like :hierarchy and g.display_name like :search) ";
            String groupMatchSql = " (select 'GROUP' as entityType, g.id as entityId, g.display_name as entityName, g.external_id as entityExternalId, NULL as entityAccountNo "
                    + " , g.office_id as parentId, o.name as parentName "
                    + " from m_group g join m_office o on o.id = g.office_id where o.hierarchy like :hierarchy and g.display_name like :partialSearch and g.display_name not like :search) ";
            StringBuffer sql = new StringBuffer();
            if (searchConditions.isClientSearch()) {
                sql.append(clientExactMatchSql).append(union);
            }
            if (searchConditions.isLoanSeach()) {
                sql.append(loanExactMatchSql).append(union);
            }
            if(searchConditions.isClientIdentifierSearch()){
                sql.append(clientIdentifierExactMatchSql).append(union);
            }
            if (searchConditions.isGroupSearch()) {
                sql.append(groupExactMatchSql).append(union);
            }
            if (searchConditions.isClientSearch()) {
                sql.append(clientMatchSql).append(union);
            }
            if (searchConditions.isLoanSeach()) {
                sql.append(loanMatchSql).append(union);
            }
            if(searchConditions.isClientIdentifierSearch()){
                sql.append(clientIdentifierMatchSql).append(union);
            }
            if (searchConditions.isGroupSearch()) {
                sql.append(groupMatchSql).append(union);
            }
            sql.replace(sql.lastIndexOf(union), sql.length(), "");
            return sql.toString();
        }

Output:
        public String searchSchema(final SearchConditions searchConditions) {
            String union = " union all ";
            String clientExactMatchSql = " (select 'CLIENT' as entityType, c.id as entityId, c.display_name as entityName, c.external_id as entityExternalId, c.account_no as entityAccountNo "
                    + " , c.office_id as parentId, o.name as parentName "
                    + " from m_client c join m_office o on o.id = c.office_id where o.hierarchy like :hierarchy and (c.account_no like :search or c.display_name like :search or c.external_id like :search)) ";
            String clientMatchSql = " (select 'CLIENT' as entityType, c.id as entityId, c.display_name as entityName, c.external_id as entityExternalId, c.account_no as entityAccountNo "
                    + " , c.office_id as parentId, o.name as parentName "
                    + " from m_client c join m_office o on o.id = c.office_id where o.hierarchy like :hierarchy and (c.account_no like :partialSearch and c.account_no not like :search) or "
                    + "(c.display_name like :partialSearch and c.display_name not like :search) or "
                    + "(c.external_id like :partialSearch and c.external_id not like :search))";
            String loanExactMatchSql = " (select 'LOAN' as entityType, l.id as entityId, pl.name as entityName, l.external_id as entityExternalId, l.account_no as entityAccountNo "
                    + " , c.id as parentId, c.display_name as parentName "
                    + " from m_loan l join m_client c on l.client_id = c.id join m_office o on o.id = c.office_id join m_product_loan pl on pl.id=l.product_id where o.hierarchy like :hierarchy and l.account_no like :search) ";
            String loanMatchSql = " (select 'LOAN' as entityType, l.id as entityId, pl.name as entityName, l.external_id as entityExternalId, l.account_no as entityAccountNo "
                    + " , c.id as parentId, c.display_name as parentName "
                    + " from m_loan l join m_client c on l.client_id = c.id join m_office o on o.id = c.office_id join m_product_loan pl on pl.id=l.product_id where o.hierarchy like :hierarchy and l.account_no like :partialSearch and l.account_no not like :search) ";
            String clientIdentifierExactMatchSql = " (select 'CLIENTIDENTIFIER' as entityType, ci.id as entityId, ci.document_key as entityName, "
                    + " null as entityExternalId, null as entityAccountNo, c.id as parentId, c.display_name as parentName "
                    + " from m_client_identifier ci join m_client c on ci.client_id=c.id join m_office o on o.id = c.office_id "
                    + " where o.hierarchy like :hierarchy and ci.document_key like :search) ";
            String clientIdentifierMatchSql = " (select 'CLIENTIDENTIFIER' as entityType, ci.id as entityId, ci.document_key as entityName, "
                    + " null as entityExternalId, null as entityAccountNo, c.id as parentId, c.display_name as parentName "
                    + " from m_client_identifier ci join m_client c on ci.client_id=c.id join m_office o on o.id = c.office_id "
                    + " where o.hierarchy like :hierarchy and ci.document_key like :partialSearch and ci.document_key not like :search) ";
            String groupExactMatchSql = " (select IF(g.level_id=1,'CENTER','GROUP') as entityType, g.id as entityId, g.display_name as entityName, g.external_id as entityExternalId, NULL as entityAccountNo "
                    + " , g.office_id as parentId, o.name as parentName "
                    + " from m_group g join m_office o on o.id = g.office_id where o.hierarchy like :hierarchy and g.display_name like :search) ";
            String groupMatchSql = " (select IF(g.level_id=1,'CENTER','GROUP') as entityType, g.id as entityId, g.display_name as entityName, g.external_id as entityExternalId, NULL as entityAccountNo "
                    + " , g.office_id as parentId, o.name as parentName "
                    + " from m_group g join m_office o on o.id = g.office_id where o.hierarchy like :hierarchy and g.display_name like :partialSearch and g.display_name not like :search) ";
            StringBuffer sql = new StringBuffer();
            if (searchConditions.isClientSearch()) {
                sql.append(clientExactMatchSql).append(union);
            }
            if (searchConditions.isLoanSeach()) {
                sql.append(loanExactMatchSql).append(union);
            }
            if(searchConditions.isClientIdentifierSearch()){
                sql.append(clientIdentifierExactMatchSql).append(union);
            }
            if (searchConditions.isGroupSearch()) {
                sql.append(groupExactMatchSql).append(union);
            }
            if (searchConditions.isClientSearch()) {
                sql.append(clientMatchSql).append(union);
            }
            if (searchConditions.isLoanSeach()) {
                sql.append(loanMatchSql).append(union);
            }
            if(searchConditions.isClientIdentifierSearch()){
                sql.append(clientIdentifierMatchSql).append(union);
            }
            if (searchConditions.isGroupSearch()) {
                sql.append(groupMatchSql).append(union);
            }
            sql.replace(sql.lastIndexOf(union), sql.length(), "");
            return sql.toString();
        }


Input:
    public void execute(Request req) throws ServiceException {
        GetMapRequest request = (GetMapRequest) req;
        final String outputFormat = request.getFormat();
        this.delegate = getDelegate(outputFormat, wms);
		final MapLayerInfo[] layers = request.getLayers();
		final Style[] styles = (Style[]) request.getStyles().toArray(
				new Style[] {});
		final Filter[] filters = (request.getFilters() != null ? (Filter[]) request.getFilters().toArray(
				new Filter[] {}) : null);
        map = new WMSMapContext(request);
		final Envelope env = request.getBbox();
		if (env.isNull() || (env.getWidth() <= 0) || (env.getHeight() <= 0)) {
			throw new WmsException(new StringBuffer(
					"The request bounding box has zero area: ").append(env)
					.toString());
		}
		final CoordinateReferenceSystem mapcrs = request.getCrs();
		if (mapcrs != null)
			map.setAreaOfInterest(env, mapcrs);
		else
			map.setAreaOfInterest(env, DefaultGeographicCRS.WGS84);
		map.setMapWidth(request.getWidth());
		map.setMapHeight(request.getHeight());
		map.setBgColor(request.getBgColor());
		map.setTransparent(request.isTransparent());
		if (request.getWidth() <= 0 || request.getHeight() <= 0
				|| map.getAreaOfInterest().getLength(0) <= 0
				|| map.getAreaOfInterest().getLength(1) <= 0) {
			if (LOGGER.isLoggable(Level.FINE))
				LOGGER
						.fine("We are not going to render anything because either the are is null ar the dimensions are not positive.");
			return;
		}
		if (LOGGER.isLoggable(Level.FINE)) {
			LOGGER.fine("setting up map");
		}
		try {
			MapLayer layer;
			boolean cachingPossible = request.getHttpServletRequest()
					.getMethod().equals("GET");
			int maxAge = Integer.MAX_VALUE;
			FeatureSource source;
			AbstractGridCoverage2DReader reader;
			Style style;
			Filter definitionFilter, optionalFilter;
			Query definitionQuery;
			int nma;
			final int length = layers.length;
			for (int i = 0; i < length; i++) {
				style = styles[i];
				try {
					optionalFilter = filters[i];
				} catch (Exception e) {
					optionalFilter = null;
				}
				if (layers[i].getType() == MapLayerInfo.TYPE_VECTOR) {
					if (cachingPossible) {
						if (layers[i].getFeature().isCachingEnabled()) {
							nma = Integer.parseInt(layers[i].getFeature()
									.getCacheMaxAge());
							if (nma < maxAge)
								maxAge = nma;
						} else {
							cachingPossible = false;
						}
					}
					try {
						source = layers[i].getFeature().getFeatureSource();
						if (layers[i].getBoundingBox() instanceof ReferencedEnvelope) {
							final ReferencedEnvelope bbox = (ReferencedEnvelope) layers[i].getBoundingBox();
							if(CRS.equalsIgnoreMetadata(bbox.getCoordinateReferenceSystem(), mapcrs)) {
								if (!layers[i].getBoundingBox().intersects(env)) {
									continue;
								}
							} else {
								ReferencedEnvelope prjEnv = new ReferencedEnvelope(env, mapcrs).transform(bbox.getCoordinateReferenceSystem(), true);
								if (!layers[i].getBoundingBox().intersects(prjEnv)) {
									continue;
								}
							}
						}
					} catch (IOException exp) {
						if (LOGGER.isLoggable(Level.SEVERE)) {
							LOGGER.log(Level.SEVERE, new StringBuffer(
									"Getting feature source: ").append(
									exp.getMessage()).toString(), exp);
						}
						throw new WmsException(null, new StringBuffer(
								"Internal error : ").append(exp.getMessage())
								.toString());
					} catch (FactoryException exp) {
						if (LOGGER.isLoggable(Level.SEVERE)) {
							LOGGER.log(Level.SEVERE, new StringBuffer(
									"Getting feature source: ").append(
									exp.getMessage()).toString(), exp);
						}
						throw new WmsException(null, new StringBuffer(
								"Internal error : ").append(exp.getMessage())
								.toString());
					}
					layer = new DefaultMapLayer(source, style);
					layer.setTitle(layers[i].getName());
					definitionFilter = layers[i].getFeature().getDefinitionQuery();
					if (definitionFilter != null) {
						definitionQuery = new DefaultQuery(source.getSchema()
								.getTypeName(), definitionFilter);
						layer.setQuery(definitionQuery);
					} else if (optionalFilter != null) {
						definitionQuery = new DefaultQuery(source.getSchema().getTypeName(), optionalFilter);
						layer.setQuery(definitionQuery);
					}
					map.addLayer(layer);
				} else if (layers[i].getType() == MapLayerInfo.TYPE_RASTER) {
					reader = (AbstractGridCoverage2DReader) layers[i]
							.getCoverage().getReader();
					if (reader != null) {
						final ParameterValueGroup params = reader.getFormat().getReadParameters();
						layer = new DefaultMapLayer(DataUtilities.wrapGcReader(reader, CoverageUtils.getParameters(params, layers[i].getCoverage().getParameters())), style);
						layer.setTitle(layers[i].getName());
						layer.setQuery(Query.ALL);
						map.addLayer(layer);
					} else
						throw new WmsException(
								null,
								new StringBuffer(
										"Internal error : unable to get reader for this coverage layer ")
										.append(layers[i].toString())
										.toString());
				}
			}
			this.delegate.produceMap(map);
			if (cachingPossible)
				responseHeaders.put("Cache-Control: max-age", maxAge + "s");
			String contentDisposition = this.delegate.getContentDisposition();
	        if (contentDisposition != null) {
	        	this.headerContentDisposition = contentDisposition;
	        }
		} catch (ClassCastException e) {
			if (LOGGER.isLoggable(Level.WARNING)) {
				LOGGER.log(Level.SEVERE, new StringBuffer(
						"Getting feature source: ").append(e.getMessage())
						.toString(), e);
			}
			throw new WmsException(e, new StringBuffer("Internal error : ")
					.append(e.getMessage()).toString(), "");
		} catch (TransformException e) {
			throw new WmsException(e, new StringBuffer("Internal error : ")
					.append(e.getMessage()).toString(), "");
		} catch (FactoryConfigurationError e) {
			throw new WmsException(e, new StringBuffer("Internal error : ")
					.append(e.getMessage()).toString(), "");
		} catch (SchemaException e) {
			throw new WmsException(e, new StringBuffer("Internal error : ")
					.append(e.getMessage()).toString(), "");
		} catch (IllegalAttributeException e) {
			throw new WmsException(e, new StringBuffer("Internal error : ")
					.append(e.getMessage()).toString(), "");
		} finally {
			try {
			} catch (Exception e)
			{
				if (LOGGER.isLoggable(Level.SEVERE)) {
					LOGGER.log(Level.SEVERE, new StringBuffer(
							"Getting feature source: ").append(e.getMessage())
							.toString(), e);
				}
			}
		}
	}

Output:
    public void execute(Request req) throws ServiceException {
        GetMapRequest request = (GetMapRequest) req;
        final String outputFormat = request.getFormat();
        this.delegate = getDelegate(outputFormat, wms);
		final MapLayerInfo[] layers = request.getLayers();
		final Style[] styles = (Style[]) request.getStyles().toArray(
				new Style[] {});
		final Filter[] filters = (request.getFilters() != null ? (Filter[]) request.getFilters().toArray(
				new Filter[] {}) : null);
        map = new WMSMapContext(request);
		final Envelope env = request.getBbox();
		if (env.isNull() || (env.getWidth() <= 0) || (env.getHeight() <= 0)) {
			throw new WmsException(new StringBuffer(
					"The request bounding box has zero area: ").append(env)
					.toString());
		}
		final CoordinateReferenceSystem mapcrs = request.getCrs();
		if (mapcrs != null)
			map.setAreaOfInterest(env, mapcrs);
		else
			map.setAreaOfInterest(env, DefaultGeographicCRS.WGS84);
		map.setMapWidth(request.getWidth());
		map.setMapHeight(request.getHeight());
		map.setBgColor(request.getBgColor());
		map.setTransparent(request.isTransparent());
		if (request.getWidth() <= 0 || request.getHeight() <= 0
				|| map.getAreaOfInterest().getLength(0) <= 0
				|| map.getAreaOfInterest().getLength(1) <= 0) {
			if (LOGGER.isLoggable(Level.FINE))
				LOGGER
						.fine("We are not going to render anything because either the are is null ar the dimensions are not positive.");
			return;
		}
		if (LOGGER.isLoggable(Level.FINE)) {
			LOGGER.fine("setting up map");
		}
		try {
			MapLayer layer;
			boolean cachingPossible = request.getHttpServletRequest()
					.getMethod().equals("GET");
			int maxAge = Integer.MAX_VALUE;
			FeatureSource source;
			AbstractGridCoverage2DReader reader;
			Style style;
			Filter definitionFilter, optionalFilter;
			Query definitionQuery;
			int nma;
			final int length = layers.length;
			for (int i = 0; i < length; i++) {
				style = styles[i];
				try {
					optionalFilter = filters[i];
				} catch (Exception e) {
					optionalFilter = null;
				}
				if (layers[i].getType() == MapLayerInfo.TYPE_VECTOR) {
					if (cachingPossible) {
						if (layers[i].getFeature().isCachingEnabled()) {
							nma = Integer.parseInt(layers[i].getFeature()
									.getCacheMaxAge());
							if (nma < maxAge)
								maxAge = nma;
						} else {
							cachingPossible = false;
						}
					}
					try {
						source = layers[i].getFeature().getFeatureSource();
					} catch (IOException exp) {
						if (LOGGER.isLoggable(Level.SEVERE)) {
							LOGGER.log(Level.SEVERE, new StringBuffer(
									"Getting feature source: ").append(
									exp.getMessage()).toString(), exp);
						}
						throw new WmsException(null, new StringBuffer(
								"Internal error : ").append(exp.getMessage())
								.toString());
                    }
					layer = new DefaultMapLayer(source, style);
					layer.setTitle(layers[i].getName());
					definitionFilter = layers[i].getFeature().getDefinitionQuery();
					if (definitionFilter != null) {
						definitionQuery = new DefaultQuery(source.getSchema()
								.getTypeName(), definitionFilter);
						layer.setQuery(definitionQuery);
					} else if (optionalFilter != null) {
						definitionQuery = new DefaultQuery(source.getSchema().getTypeName(), optionalFilter);
						layer.setQuery(definitionQuery);
					}
					map.addLayer(layer);
				} else if (layers[i].getType() == MapLayerInfo.TYPE_RASTER) {
					reader = (AbstractGridCoverage2DReader) layers[i]
							.getCoverage().getReader();
					if (reader != null) {
						final ParameterValueGroup params = reader.getFormat().getReadParameters();
						layer = new DefaultMapLayer(DataUtilities.wrapGcReader(reader, CoverageUtils.getParameters(params, layers[i].getCoverage().getParameters())), style);
						layer.setTitle(layers[i].getName());
						layer.setQuery(Query.ALL);
						map.addLayer(layer);
					} else
						throw new WmsException(
								null,
								new StringBuffer(
										"Internal error : unable to get reader for this coverage layer ")
										.append(layers[i].toString())
										.toString());
				}
			}
			this.delegate.produceMap(map);
			if (cachingPossible)
				responseHeaders.put("Cache-Control: max-age", maxAge + "s");
			String contentDisposition = this.delegate.getContentDisposition();
	        if (contentDisposition != null) {
	        	this.headerContentDisposition = contentDisposition;
	        }
		} catch (ClassCastException e) {
			if (LOGGER.isLoggable(Level.WARNING)) {
				LOGGER.log(Level.SEVERE, new StringBuffer(
						"Getting feature source: ").append(e.getMessage())
						.toString(), e);
			}
			throw new WmsException(e, new StringBuffer("Internal error : ")
					.append(e.getMessage()).toString(), "");
		} catch (TransformException e) {
			throw new WmsException(e, new StringBuffer("Internal error : ")
					.append(e.getMessage()).toString(), "");
		} catch (FactoryConfigurationError e) {
			throw new WmsException(e, new StringBuffer("Internal error : ")
					.append(e.getMessage()).toString(), "");
		} catch (SchemaException e) {
			throw new WmsException(e, new StringBuffer("Internal error : ")
					.append(e.getMessage()).toString(), "");
		} catch (IllegalAttributeException e) {
			throw new WmsException(e, new StringBuffer("Internal error : ")
					.append(e.getMessage()).toString(), "");
		} finally {
			try {
			} catch (Exception e)
			{
				if (LOGGER.isLoggable(Level.SEVERE)) {
					LOGGER.log(Level.SEVERE, new StringBuffer(
							"Getting feature source: ").append(e.getMessage())
							.toString(), e);
				}
			}
		}
	}


Input:
  public static FixedData[] parse( RDFReader rdr ) throws Exception
  {
    java.util.List< FixedData > work = new ArrayList< FixedData >();
    java.util.List< Short > temp = new ArrayList< Short >();
    String line;
    int address = -1;
    int value = -1;
    while ( true )
    {
      line = rdr.readLine();
      if ( ( line == null ) || ( line.length() == 0 ) )
        break;
      StringTokenizer st = new StringTokenizer( line, ",; \t" );
      String token = st.nextToken();
      while ( true )
      {
        if ( token.charAt( 0 ) == '=' )
        {
          token = token.substring( 1 );
          if ( address != -1 )
          {
            short[] b = new short[ temp.size() ];
            int i = 0;
            for ( Short val : temp )
            {
              b[ i++ ] = val.shortValue();
            }
            work.add( new FixedData( address, b ) );
            temp.clear();
          }
          address = value;
          value = -1;
          if ( token.length() != 0 )
            continue;
        }
        else
        {
          int equal = token.indexOf( '=' );
          String saved = token;
          if ( equal != -1 )
          {
            token = token.substring( 0, equal );
          }
          if ( value != -1 )
          {
            temp.add( new Short( ( short )value ) );
          }
          value = RDFReader.parseNumber( token );
          if ( equal != -1 )
          {
            token = saved.substring( equal );
            continue;
          }
        }
        if ( !st.hasMoreTokens() )
          break;
        token = st.nextToken();
      }
    }
    temp.add( new Short( ( short )value ) );
    short[] b = new short[ temp.size() ];
    int j = 0;
    for ( Short by : temp )
    {
      b[ j++ ] = by.shortValue();
    }
    work.add( new FixedData( address, b ) );
    return work.toArray( new FixedData[ work.size() ] );
  }

Output:
  public static FixedData[] parse( RDFReader rdr ) throws Exception
  {
    java.util.List< FixedData > work = new ArrayList< FixedData >();
    java.util.List< Short > temp = new ArrayList< Short >();
    String line;
    int address = -1;
    int value = -1;
    while ( true )
    {
      line = rdr.readLine();
      if ( ( line == null ) || ( line.length() == 0 ) )
        break;
      StringTokenizer st = new StringTokenizer( line, ",; \t" );
      String token = st.nextToken();
      while ( true )
      {
        if ( token.charAt( 0 ) == '=' )
        {
          token = token.substring( 1 );
          if ( address != -1 )
          {
            short[] b = new short[ temp.size() ];
            int i = 0;
            for ( Short val : temp )
            {
              b[ i++ ] = val.shortValue();
            }
            work.add( new FixedData( address, b ) );
            temp.clear();
          }
          address = value;
          value = -1;
          if ( token.length() != 0 )
            continue;
        }
        else
        {
          int equal = token.indexOf( '=' );
          String saved = token;
          if ( equal != -1 )
          {
            token = token.substring( 0, equal );
          }
          if ( value != -1 )
          {
            temp.add( new Short( ( short )value ) );
          }
          value = RDFReader.parseNumber( token );
          if ( equal != -1 )
          {
            token = saved.substring( equal );
            continue;
          }
        }
        if ( !st.hasMoreTokens() )
          break;
        token = st.nextToken();
      }
    }
    temp.add( new Short( ( short )value ) );
    short[] b = new short[ temp.size() ];
    int j = 0;
    for ( Short by : temp )
    {
      b[ j++ ] = by.shortValue();
    }
    if ( address != -1 )
    {
      work.add( new FixedData( address, b ) );
    }
    return work.toArray( new FixedData[ work.size() ] );
  }