Nzen avatar Nzen committed 5e565c8

Seems to work, need to cut debug

BHow do I_sinning go down you nnnn.

Crliest paragraph at bottom because cygwin's vim's up down is blown. This doesn't match the cheat sheet I'm looking at. Anyway, I_also extracted test_lex and test_trie classes to declutter the test suite class.
C
D
A
B
BNo man. No. Down arrow != insert line above this line.
Dseriously vim.
I'm pretty pleased with the changes I made tonight. That generally involved fixing FlatTrie's check_flag() and check_down_trie(). That means the next actions are to cut all the debug flag output, make sure the output complies with spec and submit it if she will still take it. ()

Comments (0)

Files changed (10)

-
-public class FakeTrie extends Storage
-{
-	// serves as stub to test Lexer without a real FlatTrie
-	// use a var with a $, just for total sake
-	boolean keymode;
-	public FakeTrie( )
-	{
-		keymode = true; // for check flag()
-	}
-
-	@Override
-	public T_Flag determine_char( char to_validate )
-	{
-		switch ( to_validate )
-		{
-		case '1' :
-			return T_Flag.f_seen;
-		case '2' :
-			return T_Flag.f_unseen;
-		case '3' :
-			return T_Flag.f_diff_flag;
-		default :
-			return T_Flag.f_unseen;
-		}
-	}
-
-	@Override
-	public boolean in_alphabet( char only_b )
-	{
-		return ( only_b == 'b' );
-	}
-
-	@Override
-	public void reveal_thyself()
-	{
-		System.out.println( "I'm a fake trie" );
-	}
-
-	@Override
-	public T_Flag check_flag( char a_flag )
-	{
-		keymode = ! keymode;
-		return ( keymode ) ? T_Flag.f_diff_flag : T_Flag.f_seen;
-	}
-
-	@Override
-	public void reveal_thyself( boolean overloading )
-	{
-		// TODO Auto-generated method stub
-		
-	}
-
-}
+
+public class FakeTrie extends Storage
+{
+	// serves as stub to test Lexer without a real FlatTrie
+	// use a var with a $, just for total sake
+	boolean keymode;
+	public FakeTrie( )
+	{
+		keymode = true; // for check flag()
+	}
+
+	@Override
+	public T_Flag determine_char( char to_validate )
+	{
+		switch ( to_validate )
+		{
+		case '1' :
+			return T_Flag.f_seen;
+		case '2' :
+			return T_Flag.f_unseen;
+		case '3' :
+			return T_Flag.f_diff_flag;
+		default :
+			return T_Flag.f_unseen;
+		}
+	}
+
+	@Override
+	public boolean in_alphabet( char only_b )
+	{
+		return ( only_b == 'b' );
+	}
+
+	@Override
+	public void reveal_thyself()
+	{
+		System.out.println( "I'm a fake trie" );
+	}
+
+	@Override
+	public T_Flag check_flag( char a_flag )
+	{
+		keymode = ! keymode;
+		return ( keymode ) ? T_Flag.f_diff_flag : T_Flag.f_seen;
+	}
+
+	@Override
+	public void reveal_thyself( boolean overloading )
+	{
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public boolean t_matches_state( T_Flag should_be )
+	{
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+}
 	private StringBuilder rest_stacked; // RENAME to symbols
 	private ArrayList<Integer> skip_list; // RENAME to next ; add(index, thing);
 	private int next_open;
-	private int view_pointer; 
+	private int focus; 
 	private String debug;
 
 	public FlatTrie( String first_char_alphabet, String end_flags )
 		end = end_flags; // check if I use this
 		state = T_Flag.initial;
 		next_open = 0;
-		view_pointer = -1; // so it underflows if not correct
+		focus = -1; // so it underflows if not correct
 		first_char = new int[ sigma.length() ];
 		rest_stacked = new StringBuilder( conspicuous_consumption );
 		skip_list = new ArrayList<Integer>( conspicuous_consumption );
 			case saving :
 				return save_char( to_validate );
 			case checking :
-				return check_down_the_trie( view_pointer, to_validate ); // will recur
+				return check_down_the_trie( focus, to_validate ); // will recur
 			default :
 				return T_Flag.checking;
 		}
 
 	private T_Flag first_used( int where )
 	{
-		view_pointer = first_char[ where ];
+		focus = first_char[ where ];
 		return T_Flag.f_seen;
 	}
 
 	private T_Flag save_first( int look_here, char is_new )
 	{
 		first_char[ look_here ] = next_open;
-		view_pointer = next_open;
+		focus = next_open;
 		return T_Flag.f_unseen;
 	}
 
 	{
 		rest_stacked.setCharAt( next_open, ready ); // switch to append?
 		next_open++;
-		if ( end_of_id( ready ) ) // needed, given client uses check flag? 
-		{
-			state = T_Flag.initial;
-			reset();
-		}
 		return T_Flag.f_unseen;
 	}
 
-	private boolean end_of_id( char to_check )
-	{
-		return ( end.indexOf( to_check ) >= 0 );
-	}
-
 	private T_Flag check_down_the_trie( int skip_ind, char hmm )
 	{
-		if ( skip_ind <= 0 ) // that's why I reset to -1
-		{
-			state = T_Flag.saving;
-			return save_char( hmm );
-		}
 		char presently = rest_stacked.charAt( skip_ind );
-		if ( match( hmm, presently ) )
+		if ( hmm == presently )
 			return compare_more_later( skip_ind );
 		else if ( more_to_try( skip_ind ) )
 			return check_down_the_trie( skip_list.get( skip_ind ), hmm );
 		else
 		{
 			state = T_Flag.saving;
+			skip_list.set( skip_ind, next_open );
 			return save_char( hmm );
 		}
 	}
 
-	private boolean match( char alpha, char omega )
-	{
-		return alpha == omega; // %^B
-	} // alpha is new, omega is saved
-
-	private T_Flag compare_more_later( int skipped_to )
+	private T_Flag compare_more_later( int skip_ind )
 	{
-		if ( end_of_id( rest_stacked.charAt(skipped_to) ) )
-		{
-			state = T_Flag.initial;
-			return T_Flag.f_seen;
-		}
-		else // normal char
-		{
-			view_pointer = skipped_to + 1;
+			focus = skip_ind + 1;
 			return T_Flag.f_seen;
-		}
 	}
 
 	// for lexer: diff flag signifies *, seen signifies @, unseen signifies ?
 	{
 		System.out.print( debug + a_flag + ", " ); // // //
 		debug = " {";
+		int old_focus = focus;
+		reset(); // needed?
 		if ( a_flag == end.charAt( 0 ) ) // keymode hack
 		{
 			save_char( a_flag );
 		else // checking
 		{
 			state = T_Flag.initial;
-			return match( rest_stacked.charAt( view_pointer ), a_flag ) ?
-					T_Flag.f_seen : T_Flag.f_unseen;
+			return ( rest_stacked.charAt( old_focus ) == a_flag ) ?
+					T_Flag.f_seen : T_Flag.f_diff_flag;
 		}
 	}
 
+	public boolean t_matches_state( T_Flag client_thinks )
+	{
+		return state == client_thinks;
+	}
+
 	// only a single first char can point at 0
 	private boolean more_to_try( int skip_ind )
 	{
 			skip_list.set( skip_ind, 0 );
 			left = false;
 		}
-		
 		return left;
 	}
 
 	public void reset()
 	{
 		//  done in between identifiers
-		view_pointer = -1;
+		focus = -1;
 	}
 
 	public void reveal_thyself()
 		int half_alpha = letras.length() / 2;
 		int new_low = 0;
 		int upper = rest_stacked.lastIndexOf( "?" ) + 1;
-	//	upper = ( upper < 0 ) ? rest_stacked.length() : 40; // cut
 		String storage = rest_stacked.substring( 0, upper );
 
 		int first_lim = half_alpha * 2 - 1;
 		{
 			print_with_firsts( letras, new_low, half_alpha, storage );
 			new_low = half_alpha + 1;
-			half_alpha *= 2;
+			half_alpha += half_alpha - 1;
 		}
 		int new_lim = storage.length() - 1;
 		// sin printing this is hard.
-		for ( int times = 3; times > 0; times-- )
+		for ( int times = 8; times > 0; times-- )
 			new_low = print_sans_sigma( new_lim, new_low, storage, times );
 	}
 
 			sys_print_skip( a_search );
 	}
 
-	private char int_to_char( Integer number )
+	private String int_to_char( Integer number )
 	{
-		return number.toString().charAt( 0 );
+		return number.toString();
 	}
 
 	private void print_with_firsts( String letras, int new_low, int half_alpha, String storage  )
 	{
 		System.out.print( "\n\t" ); // alpha
 		for ( int a_search = new_low; a_search <= half_alpha; a_search++ )
-			System.out.printf( "%3c|", letras.charAt( a_search ) );
+			System.out.printf( "%4c|", letras.charAt( a_search ) );
 		System.out.print( "\nFirst\t" );
 		for ( int a_search = new_low; a_search <= half_alpha; a_search++ )
-			System.out.printf( "%3d|", first_char[ sigma.stored_in( letras.charAt( a_search ) ) ] );
+			System.out.printf( "%4d|", first_char[ sigma.stored_in( letras.charAt( a_search ) ) ] );
 		System.out.print( "\n\t" );
 		for ( int a_search = new_low; a_search <= half_alpha; a_search++ )
-			System.out.print( "- - - " );
+			System.out.print( "- - " );
 		System.out.print( "\nrest\t" );
 		for ( int a_search = new_low; a_search <= half_alpha; a_search++ )
-			System.out.printf( "%3c|", storage.charAt( a_search ) );
+			System.out.printf( "%4c|", storage.charAt( a_search ) );
 		System.out.print( "\nskip\t" );
 		for ( int a_search = new_low; a_search <= half_alpha; a_search++ )
 			sys_print_skip( a_search );
 		int mid_lim = ( new_lim - new_low ) / times + new_low;
 		System.out.print( "\nrest\t" );
 		for ( int a_search = new_low; a_search <= mid_lim; a_search++ )
-			System.out.printf( "%3c|", storage.charAt( a_search ) );
+			System.out.printf( "%4c|", storage.charAt( a_search ) );
 		System.out.print( "\nskip\t" );
 		for ( int a_search = new_low; a_search <= mid_lim; a_search++ )
 		{
 	private void sys_print_skip( int ind )
 	{
 		boolean used = skip_list.get( ind ) > 0;
-		char either = used ? int_to_char( skip_list.get( ind ) ): '_';
-		System.out.printf( "%3c|", either );
+		String either = used ? int_to_char( skip_list.get( ind ) ): "_";
+		System.out.printf( "%4s|", either );
 	}
 }
 
+
+public class LexTester
+{
+	// current idea is constrained lang & input.
+	//later try dependency problem with fake trie 
+
+	public boolean t_l_first_var( Lexer grammer_nazi, String first_var )
+	{
+		boolean cc = true;
+		IterableString var_1 = new IterableString( first_var );
+		L_Flag id = L_Flag.id_text;
+		L_Flag btwx = L_Flag.between;
+		//L_Flag line = L_F.new_line;
+		L_Flag[] st_should_pass = { id, id, id, btwx };
+		char flag_;
+		int nn = 0;
+		// has ending, so state should be between after
+		for ( Character let : var_1 )
+		{
+			flag_ = grammer_nazi.lex_char( let );
+			if ( ! grammer_nazi.t_matches_current_state( st_should_pass[nn] ) )
+			{
+				System.out.println( "lex: didnt move to between state" );
+				cc = false;
+			}
+			nn++;
+			System.out.print( flag_ ); // debug
+		}
+		return cc;
+	}
+
+	public void t_l_many_vars( Lexer grammer_nazi, char more )
+	{
+		IterableString key_n_var = new IterableString( "axe l boo ace" + '\n' ); // woo fancy
+		int linel = 5;
+		for ( Character let : key_n_var )
+		{
+			if ( let == ' ' )
+			{
+				if ( linel % 5 == 4 )
+				{
+					System.out.println();
+					linel = 0;
+				}
+				else
+					linel--;
+			}
+			char now_is = grammer_nazi.lex_char( let );
+			if ( now_is == more )
+				System.out.print( grammer_nazi.snag_buffer() );
+			else
+				System.out.print( now_is );
+		}
+	}
+
+	public void prep_lex_keys( Lexer grammer_nazi )
+	{
+		IterableString key_1 = new IterableString( "axe " );
+		IterableString key_2 = new IterableString( "bool " );
+		// turns out that yak shaving may not have been totally useless
+		for ( Character in_str : key_1 )
+			grammer_nazi.enter_key( in_str );
+		for ( Character in_str : key_2 )
+			grammer_nazi.enter_key( in_str );
+		grammer_nazi.toggle_key_mode();
+	}
+
+	public boolean t_lex_endl_rej_bad( Lexer grammer_nazi, char nil )
+	{
+		char uu = grammer_nazi.lex_char( 'd' );
+		//if ( grammer_nazi.lex_char( 'd' ) != nil )
+		if ( uu != nil )
+		{
+			System.out.println( "lex: accepted non sigma-" + uu );
+			return false;
+		}
+		else if ( grammer_nazi.lex_char( '\n' ) != nil )
+		{
+			System.out.println( "lex: accepted preceeding endl" );
+			return false;
+		}
+		else if ( grammer_nazi.lex_char( '8' ) != nil )
+		{
+			System.out.println( "lex: accepted number" );
+			return false;
+		}
+		else
+			return true;
+	}
+}
 	}
 
 	// only sensible with testmode & fake trie
-	public boolean t_ch_ch_endl( )
-	{
-		
-		return false;
-	}
-
-	public boolean t_ch_ch_id( )
-	{
-		return false;
-	}
-
-	public boolean t_ch_ch_btwx( )
-	{
-		return false;
-	}
-
 	boolean t_matches_current_state( L_Flag from_out )
 	{
 		return state == from_out;
 	{
 		//run( get_file_names( args[0] ) );
 		//run( args );
-		run_tests();
-		//run( new String[] { "InputFile1.txt", "arg.java" } );
-		return;
+		//run_tests();
+		run( new String[] { "InputFile1.txt", "Project2.java" } );
 	}
 
 	static void run( String[] file_list )
 			}
 			nn++;
 		}
-		// ?? noticed last true has no *. eof isn't sent so add this
+		// eof isn't sent for last key, so add this:
 		java_lexer.enter_key( '\n' );
 		of_keys.close();
 		java_lexer.toggle_key_mode();
 		TestSuite for_classes = new TestSuite();
 		//for_classes.test_alphabet();
 		//for_classes.test_loader( "monkey.txt" ); // human checked quine, not a test
-		//for_classes.test_lexer();
-		for_classes.test_trie();
+		for_classes.test_lexer();
+		//for_classes.test_trie();
 		//for_classes.test_iterable_string();
 	}
 }
 	public abstract void reveal_thyself();
 
 	public abstract void reveal_thyself( boolean overloading );
+
+	public abstract boolean t_matches_state( T_Flag should_be );
 }
 
 public class TestSuite
 {
-
 	public void test_alphabet()
 	{
 		System.out.println( " - Alphabet" );
 		this_file.close();
 	}
 
-	// current idea is constrained lang & input.
-	//later try dependency problem with fake trie 
 	public void test_lexer( )
 	{
+		LexTester words = new LexTester ();
 		System.out.println( " - Lexer" );
 		char nil = '_';
 		char more = '^';
 		final String letras = "axecbol";
 		boolean no_complaints = true;
 		Lexer grammer_nazi = new Lexer( letras, nil, more ); // alphabet
-		prep_lex_keys( grammer_nazi );
-		no_complaints = t_lex_endl_rej_bad( grammer_nazi, nil );
+		words.prep_lex_keys( grammer_nazi );
+		no_complaints = words.t_lex_endl_rej_bad( grammer_nazi, nil );
 
 		// add words? test the stuff inside?
 		
 		String first_v = "ace ";
-		no_complaints = t_l_first_var( grammer_nazi, first_v ) && no_complaints;
+		no_complaints = words.t_l_first_var( grammer_nazi, first_v ) && no_complaints;
 
-		t_l_many_vars( grammer_nazi, more ); // just dumps in data
+		words.t_l_many_vars( grammer_nazi, more ); // just dumps in data
 		
 		if ( no_complaints )
 			System.out.println( "\nno tests tripped" );
-		grammer_nazi.surrender_internals( ); // just activating small version
-	}
-	/*
-	//for ( int ind = flags.length() -1; ind >= 0; ind-- )
-	{
-		if ( flags.charAt( ind ) != f_should_be.charAt( ind ) )
-		{
-			System.out.print( "lex: v_1, unexpected flag " );
-			System.out.printf( "e>%c r>%c\n",
-					f_should_be.charAt( ind ), flags.charAt( ind ) );
-			no_complaints = false;
-		}
-	}
-	unseen : 'N';
-	seen : '-';
-	diff_flag : 'F';*/
-
-	private boolean t_l_first_var( Lexer grammer_nazi, String first_var )
-	{
-		boolean cc = true;
-		IterableString var_1 = new IterableString( first_var );
-		L_Flag id = L_Flag.id_text;
-		L_Flag btwx = L_Flag.between;
-		L_Flag line = L_Flag.new_line;
-		L_Flag[] st_should_pass = { id, id, id, btwx };
-		char flag_;
-		int nn = 0;
-		// has ending, so state should be between after
-		for ( Character let : var_1 )
-		{
-			flag_ = grammer_nazi.lex_char( let );
-			if ( ! grammer_nazi.t_matches_current_state( st_should_pass[nn] ) )
-			{
-				System.out.println( "lex: didnt move to between state" );
-				cc = false;
-			}
-			nn++;
-			System.out.print( flag_ ); // debug
-		}
-		return cc;
-	}
-
-	private void t_l_many_vars( Lexer grammer_nazi, char more )
-	{
-		IterableString key_n_var = new IterableString( "axe l boo ace" + '\n' ); // woo fancy
-		int linel = 5;
-		for ( Character let : key_n_var )
-		{
-			if ( let == ' ' )
-			{
-				if ( linel % 5 == 4 )
-				{
-					System.out.println();
-					linel = 0;
-				}
-				else
-					linel--;
-			}
-			char now_is = grammer_nazi.lex_char( let );
-			if ( now_is == more )
-				System.out.print( grammer_nazi.snag_buffer() );
-			else
-				System.out.print( now_is );
-		}
+		grammer_nazi.surrender_internals( );
 	}
 
-	private void prep_lex_keys( Lexer grammer_nazi )
-	{
-		IterableString key_1 = new IterableString( "axe " );
-		IterableString key_2 = new IterableString( "bool " );
-		// turns out that yak shaving may not have been totally useless
-		for ( Character in_str : key_1 )
-			grammer_nazi.enter_key( in_str );
-		for ( Character in_str : key_2 )
-			grammer_nazi.enter_key( in_str );
-		grammer_nazi.toggle_key_mode();
-	}
-
-	private boolean t_lex_endl_rej_bad( Lexer grammer_nazi, char nil )
-	{
-		char uu = grammer_nazi.lex_char( 'd' );
-		//if ( grammer_nazi.lex_char( 'd' ) != nil )
-		if ( uu != nil )
-		{
-			System.out.println( "lex: accepted non sigma-" + uu );
-			return false;
-		}
-		else if ( grammer_nazi.lex_char( '\n' ) != nil )
-		{
-			System.out.println( "lex: accepted preceeding endl" );
-			return false;
-		}
-		else if ( grammer_nazi.lex_char( '8' ) != nil )
-		{
-			System.out.println( "lex: accepted number" );
-			return false;
-		}
-		else
-			return true;
-	}
-
-	public void test_trie() // haha, pun
+	public void test_trie( )
 	{
+		TrieTester ram = new TrieTester();
 		String alpha = "etaolin";
 		String flags = "*?";
 		Storage delta = new FlatTrie( alpha, flags );
 		boolean worked = true;
 		System.out.println( " - Trie" );
 		
-		worked = t_t_save_keys( delta, keys, flags.charAt( 0 ) );
-		worked = t_t_save_first_var( delta, vars[ 0 ], flags.charAt( 1 ) ) && worked;
-		worked = t_t_repeat_first_var( delta, vars[ 0 ], flags.charAt( 1 ) ) && worked;
-		worked = t_t_repeat_key( delta, keys[ 0 ], flags.charAt( 1 ) ) && worked;
+		worked = ram.t_t_save_keys( delta, keys, flags.charAt( 0 ) );
+		worked = ram.t_t_save_first_var( delta, vars[ 0 ], flags.charAt( 1 ) ) && worked;
+		worked = ram.t_t_repeat_first_var( delta, vars[ 0 ], flags.charAt( 1 ) ) && worked;
+		worked = ram.t_t_repeat_key( delta, keys[ 0 ], flags.charAt( 1 ) ) && worked;
 		
 		if ( worked )
 			System.out.println( "\n didn't trip tests" );
-		t_t_dump_for_reveal( delta );
+		ram.t_t_dump_for_reveal( delta );
 		delta.reveal_thyself(); //not until it's bigger than the alphabet
 	}
 
-	private boolean t_t_save_keys( Storage delta, String[] reserved, char k_f )
-	{
-		final boolean fail = false;
-		T_Flag shoul_b_diff;
-		for ( String nn : reserved )
-		{
-			IterableString keys = new IterableString( nn );
-			for ( Character ch : keys )
-			{
-				delta.determine_char( ch );
-			}
-			shoul_b_diff = delta.check_flag( k_f );
-			if ( shoul_b_diff != T_Flag.f_diff_flag )
-			{
-				System.out.println( "Tr: saving key didn't give diff flag" );
-				return fail;
-			}
-			System.out.print( "} " );
-		}
-		return !fail;
-	}
-
-	private boolean t_t_save_first_var( Storage delta, String var, char n_f )
-	{
-		final boolean fail = false;
-		T_Flag said;
-		IterableString iable = new IterableString( var );
-		for ( Character ind : iable )
-		{
-			said = delta.determine_char( ind );
-			if ( said != T_Flag.f_unseen )
-			{
-				System.out.println( "Tr: all new var didn't give all T_F unseen" );
-				return fail;
-			}
-		}
-		said = delta.check_flag( n_f );
-		if ( said != T_Flag.f_unseen )
-		{
-			System.out.println( "Tr: saving new char's flag didn't give unseen" );
-			return fail;
-		}
-		else
-			System.out.println( "?} " );
-		return !fail;
-	}
-
-	
-// consider confirming the state Trie is in when closing.
-private boolean t_t_repeat_first_var( Storage delta, String var, char n_f )
-	{
-		final boolean fail = false;
-		T_Flag report;
-		IterableString iable = new IterableString( var );
-		for ( Character ind : iable )
-		{
-			report = delta.determine_char( ind );
-			if ( report != T_Flag.f_seen )
-			{
-				System.out.println( "Tr: seen char not giving seen" );
-				return fail;
-			}
-		}
-		report = delta.check_flag( n_f );
-		if ( report != T_Flag.f_seen )
-		{
-			System.out.println( "Tr: saving new char's flag didn't give unseen" );
-			return fail;
-		}
-		else
-			System.out.println( "@} " );
-		return !fail;
-	}
-
-	private boolean t_t_repeat_key( Storage delta, String key, char n_f )
-	{
-		final boolean fail = false;
-		T_Flag report;
-		IterableString repeat = new IterableString( key );
-		for ( Character ind : repeat )
-		{
-			report = delta.determine_char( ind );
-			if ( report != T_Flag.f_seen )
-			{
-				System.out.println( "Tr: key not giving seen: " + ind ); // tripping this. why?
-				return fail;
-			}
-		}
-		report = delta.check_flag( n_f );
-		if ( report != T_Flag.f_diff_flag )
-		{
-			System.out.println( "Tr: ending key didn't produce diff flag" ); // also trips this
-			return fail;
-		}
-		else
-			System.out.println( "*} " ); // debug & lex sim
-		return !fail;
-	}
-
-	// if trie isn't big enough the printing overflows.
-	// shouldn't be a problem it gets real input
-	private void t_t_dump_for_reveal( Storage delta )
-	{
-		IterableString nn = new IterableString( "llleto tali sopa nit" );
-		for ( Character uu : nn )
-			delta.determine_char( uu );
-		delta.check_flag( '?' );
-	}
-
 	public void test_iterable_string( )
 	{
 		String control = "into the grinder";
+
+public class TrieTester
+{
+
+	public boolean t_t_state_matches( Storage delta, T_Flag should_be )
+	{
+		return delta.t_matches_state( should_be );
+	}
+
+	public boolean t_t_save_keys( Storage delta, String[] reserved, char k_f )
+	{
+		final boolean fail = false;
+		boolean worked = !fail;
+		T_Flag shoul_b_diff;
+		for ( String nn : reserved )
+		{
+			IterableString keys = new IterableString( nn );
+			for ( Character ch : keys )
+			{
+				delta.determine_char( ch );
+				if ( ! t_t_state_matches( delta, T_Flag.saving ) )
+				{
+					System.out.println( "Tr: saving key not in save mode" );
+					worked = fail;
+				}
+			}
+			shoul_b_diff = delta.check_flag( k_f );
+			if ( shoul_b_diff != T_Flag.f_diff_flag )
+			{
+				System.out.println( "Tr: saving key didn't give diff flag" );
+				worked = fail;
+			}
+			else if ( ! t_t_state_matches( delta, T_Flag.initial ) )
+			{
+				System.out.println( "Tr: ending key didn't change to init state" );
+				worked = fail;
+			}
+			System.out.print( "} " );
+		}
+		return worked; // returning at first problem hid later problems
+	}
+
+	public boolean t_t_save_first_var( Storage delta, String var, char n_f )
+	{
+		final boolean fail = false;
+		T_Flag said;
+		IterableString iable = new IterableString( var );
+		for ( Character ind : iable )
+		{
+			said = delta.determine_char( ind );
+			if ( said != T_Flag.f_unseen )
+			{
+				System.out.println( "Tr: all new var didn't give all T_F unseen" );
+				return fail;
+			}
+		}
+		said = delta.check_flag( n_f );
+		if ( said != T_Flag.f_unseen )
+		{
+			System.out.println( "Tr: saving new char's flag didn't give unseen" );
+			return fail;
+		}
+		else
+			System.out.println( "?} " );
+		return !fail;
+	}
+	
+	// consider confirming the state Trie is in when closing.
+	public boolean t_t_repeat_first_var( Storage delta, String var, char n_f )
+	{
+		final boolean fail = false;
+		T_Flag report;
+		IterableString iable = new IterableString( var );
+		for ( Character ind : iable )
+		{
+			report = delta.determine_char( ind );
+			if ( report != T_Flag.f_seen )
+			{
+				System.out.println( "Tr: seen char not giving seen" );
+				return fail;
+			}
+		}
+		report = delta.check_flag( n_f );
+		if ( report != T_Flag.f_seen )
+		{
+			System.out.println( "Tr: saving new char's flag didn't give unseen" );
+			return fail;
+		}
+		else
+			System.out.println( "@} " );
+		return !fail;
+	}
+
+	public boolean t_t_repeat_key( Storage delta, String key, char n_f )
+	{
+		final boolean fail = false;
+		boolean worked = true;
+		T_Flag report;
+		IterableString repeat = new IterableString( key );
+		for ( Character ind : repeat )
+		{
+			report = delta.determine_char( ind );
+			if ( report != T_Flag.f_seen )
+			{
+				System.out.println( "Tr: key not giving seen: " + ind ); // tripping this. why?
+				worked = fail;
+			}
+			worked = t_t_check_state( delta, T_Flag.checking,
+					"matching key not in check mode" ) && worked;
+		}
+		report = delta.check_flag( n_f );
+		if ( report != T_Flag.f_diff_flag )
+		{
+			System.out.println( "Tr: ending key didn't produce diff flag" ); // also trips this
+			worked = fail;
+		}
+		else
+			System.out.println( "*} " ); // debug & lex sim
+		return worked;
+	}
+
+	public boolean t_t_check_state( Storage delta, T_Flag expected, String error )
+	{
+		if ( ! t_t_state_matches( delta, expected ) )
+		{
+			System.out.println( "Tr: " + error );
+			return false;
+		}
+		return true;
+	}
+
+	// if trie isn't big enough the printing overflows.
+	// shouldn't be a problem when it gets real input
+	public void t_t_dump_for_reveal( Storage delta )
+	{
+		IterableString nn = new IterableString( "llleto tali sopa nit" );
+		for ( Character uu : nn )
+			delta.determine_char( uu );
+		delta.check_flag( '?' );
+	}
+}
 
 You can copy/use this code at your own risk, provided it isn't for a school project. In that case, you can only view it as reference material.
 
-Doesn't flag correctly. Run with java 1.6+
+Seems to work, but has massive debug output too. Run with java 1.6+
+
 * javac Project2.java
 * java Project2 [file1] [file2]
- - Trie
-  {ate*, }   {tat?, ?}
-  {tat?, @}
- Tr: key not giving seen: t
- {atllleto tali sopa nit?,
-          t|  e|  a|  n|
-First     3| -1|  0| -1|
-        - - - - - - - - - - - -
-rest      t|  e|  *|  a|
-skip      _|  _|  _|  _|
-
-          o|  l|  i|
-First    -1| -1| -1|
-        - - - - - - - - -
-rest      t|  ?|  t|
-skip      _|  _|  _|
-
-rest      l|  l|  l|  e|  t|  o|   |
-skip      _|  _|  _|  _|  _|  _|  _|
-
-rest      t|  a|  l|  i|   |  s|  o|
-skip      _|  _|  _|  _|  _|  _|  _|
-
-rest      p|  a|   |  n|  i|  t|  ?|
-skip      _|  _|  _|  _|  _|  _|  _|
+ 
+ {abstract*, }   {assert*, }   {boolean*, }   {break*, }   {byte*, }   {case*, }   {catch*, }
+ 
+ {char*, }   {class*, }   {const*, }   {continue*, }   {default*, }   {do*, }   {double*, }
+  {else*, }  
+ {Enum*, }   {extends*, }   {final*, }   {finally*, }   {float*, }   {for*, }
+  {goto*, }   {if*, }  
+ {implements*, }   {import*, }   {instanceof*, }   {int*, }
+  {interface*, }   {long*, }   {native*, }  
+ {new*, }   {package*, }   {private*, }
+  {protected*, }   {public*, }   {return*, }   {short*, }  
+ {static*, }   {super*, }
+  {switch*, }   {synchronized*, }   {this*, }   {throw*, }  
+ {throws*, }
+  {transient*, }   {try*, }   {void*, }   {volatile*, }   {while*, }
+  {false*, }   {null*, }  
+ {true*, }
+
+ import {import?, ------F}*  java {java?, NNNNN}?  util {util?, NNNNN}?  Arrays {Arrays?, NNNNNNN}?
+ public {public?, ------F}*  class {class?, -----F}*  Project2 {Project2?, NNNNNNNNN} ?
+ static {static?, ------F}*  final {final?, -----F}*  int {int?, ---F}*  key_ind {key_ind?, NNNNNNNN}?
+ static {static?, ------F}*  final {final?, -----F}*  int {int?, ---F}*  input_ind {input_ind?, --NNNNNNNN}?  key_ind {key_ind?, --------}@
+ static {static?, ------F}*  final {final?, -----F}*  char {char?, ----F}*  nothing {nothing?, -NNNNNNN}?
+ static {static?, ------F}*  final {final?, -----F}*  char {char?, ----F}*  read_several {read_several?, --NNNNNNNNNNN}?
+ static {static?, ------F}*  final {final?, -----F}*  String {String?, NNNNNNN}?  fabet {fabet?, --NNNN}?  abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$ {abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$?, --NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN}?
+ looks {looks?, --NNNN}?  like {like?, -NNNN}?  put {put?, --NN}?  you {you?, NNNN}?  files {files?, --NNNN}?  in {in?, --F}*  line {line?, --NNN}?  pipe {pipe?, -NNNN}?  is {is?, -NN}?  safe {safe?, -NNNN}?
+ public {public?, ------F}*  static {static?, ------F}*  void {void?, ----F}*  main {main?, NNNNN}?  String {String?, -------}@  args {args?, -NNNN}?
+ run {run?, -NNN}?  get_file_names {get_file_names?, -NNNNNNNNNNNNNN}?  args {args?, -----}@
+ run {run?, ----}@  args {args?, -----}@
+ run_tests {run_tests?, ---NNNNNNN}?
+ run {run?, ----}@  new {new?, ---F}*  String {String?, -------}@  InputFile1 {InputFile1?, NNNNNNNNNNN}?  txt {txt?, -NNN}?  Project2 {Project2?, ---------}@  java {java?, -----}@
+ static {static?, ------F}*  void {void?, ----F}*  run {run?, ----}@  String {String?, -------}@  file_list {file_list?, ----NNNNNN}?
+ Lexer {Lexer?, NNNNNN}?  java_lexer {java_lexer?, ----NNNNNNN}?  new {new?, ---F}*  Lexer {Lexer?, ------}@  fabet {fabet?, ------}@  nothing {nothing?, --------}@  read_several {read_several?, -------------}@
+ save_key_words {save_key_words?, --NNNNNNNNNNNNN}?  file_list {file_list?, ----------}@  key_ind {key_ind?, --------}@  java_lexer {java_lexer?, -----------}@
+ flag_program {flag_program?, --NNNNNNNNNNN}?  file_list {file_list?, ----------}@  input_ind {input_ind?, ----------}@  java_lexer {java_lexer?, -----------}@
+ emit_saved_data {emit_saved_data?, -NNNNNNNNNNNNNNN}?  java_lexer {java_lexer?, -----------}@
+ return {return?, ------F}*
+ static {static?, ------F}*  String {String?, -------}@  get_file_names {get_file_names?, ---------------}@  String {String?, -------}@  list_file {list_file?, --NNNNNNNN}?
+ new {new?, ---F}*  WordLoader {WordLoader?, NNNNNNNNNNN}?
+ open {open?, NNNNN}?  list {list?, ----F} *
+ first {first?, --NNNN}?  line {line?, -----}@  is {is?, ---}@  number {number?, --NNNNN}?  of {of?, -NN}?  files {files?, ------}@
+ save {save?, ----F}*  list {list?, ----F} *
+ close {close?, --NNNN}?  list {list?, ----F} *
+ int {int?, ---F}*  many {many?, --NNN}?  get_lines {get_lines?, ----NNNNNN}?  list_file {list_file?, ----------}@
+ WordLoader {WordLoader?, -----------}@  for_file_names {for_file_names?, ---NNNNNNNNNNNN}?  new {new?, ---F}*  WordLoader {WordLoader?, -----------}@
+ for_file_names {for_file_names?, ---------------}@  open {open?, -----}@  list_file {list_file?, ----------}@
+ String {String?, -------}@  key_n_input {key_n_input?, ----NNNNNNNN}?  new {new?, ---F}*  String {String?, -------}@  many {many?, -----}@
+ key_n_input {key_n_input?, ------------}@  for_file_names {for_file_names?, ---------------}@  readLine {readLine?, ----NNNNN}?
+ key_n_input {key_n_input?, ------------}@  for_file_names {for_file_names?, ---------------}@  readLine {readLine?, ---------}@
+ for_file_names {for_file_names?, ---------------}@  close {close?, ------}@
+ return {return?, ------F}*  key_n_input {key_n_input?, ------------}@
+ mm {mm?, -NN}?  premature {premature?, --NNNNNNNN}?  functionality {functionality?, -NNNNNNNNNNNNN} ?
+ static {static?, ------F}*  int {int?, ---F}*  get_lines {get_lines?, ----------}@  String {String?, -------}@  file_yeah {file_yeah?, -----NNNNN}?
+ int {int?, ---F}*  wasteful {wasteful?, -NNNNNNNN}?
+ WordLoader {WordLoader?, -----------}@  file_count {file_count?, -----NNNNNN}?  new {new?, ---F}*  WordLoader {WordLoader?, -----------}@
+ file_count {file_count?, -----------}@  open {open?, -----}@  file_yeah {file_yeah?, ----------}@
+ for {for?, ---F}*  file_count {file_count?, -----------}@  moreLines {moreLines?, -NNNNNNNNN}?  file_count {file_count?, -----------}@  readLine {readLine?, ---------}@
+ wasteful {wasteful?, ---------}@
+ file_count {file_count?, -----------}@  close {close?, ------}@
+ return {return?, ------F}*  wasteful {wasteful?, ---------}@
+ static {static?, ------F}*  void {void?, ----F}*  save_key_words {save_key_words?, ---------------}@  String {String?, -------}@  keyw_file {keyw_file?, ---NNNNNNN}?  Lexer {Lexer?, ------}@  java_lexer {java_lexer?, -----------}@
+ Loader {Loader?, -NNNNNN}?  of_keys {of_keys?, --NNNNNN}?  new {new?, ---F}*  Loader {Loader?, -------}@
+ of_keys {of_keys?, --------}@  open {open?, -----}@  keyw_file {keyw_file?, ----------}@
+ int {int?, ---F}*  nn {nn?, -NN}?
+ while {while?, -----F}*  of_keys {of_keys?, --------}@  has_more {has_more?, NNNNNNNNN}?
+ java_lexer {java_lexer?, -----------}@  enter_key {enter_key?, -NNNNNNNNN}?  of_keys {of_keys?, --------}@  read_next {read_next?, -----NNNNN}?
+ if {if?, --F}*  nn {nn?, ---}@
+ nn {nn?, ---}@
+ System {System?, -NNNNNN}?  out {out?, -NNN}?  println {println?, ---NNNNN}?
+ nn {nn?, ---}@
+ eof {eof?, -NNN}?  isn {isn?, --NN}?  t {t?, -F}*  sent {sent?, -NNNN}?  for {for?, ---F}*  last {last?, -NNNN}?  key {key?, ---F}*  so {so?, -NN}?  add {add?, -NNN}?  this {this?, ----F}*
+ java_lexer {java_lexer?, -----------}@  enter_key {enter_key?, ----------}@  n {n?, -F}*
+ of_keys {of_keys?, --------}@  close {close?, ------}@
+ java_lexer {java_lexer?, -----------}@  toggle_key_mode {toggle_key_mode?, -NNNNNNNNNNNNNNN}?
+ System {System?, -------}@  out {out?, ----}@  println {println?, --------}@
+ static {static?, ------F}*  void {void?, ----F}*  flag_program {flag_program?, -------------}@  String {String?, -------}@  other_file {other_file?, -NNNNNNNNNN}?  Lexer {Lexer?, ------}@  java_lexer {java_lexer?, -----------}@
+ char {char?, ----F}*  peek {peek?, -NNNN}?
+ char {char?, ----F}*  became {became?, -NNNNNN}?
+ Loader {Loader?, -------}@  generic {generic?, --NNNNNN}?  new {new?, ---F}*  Loader {Loader?, -------}@
+ generic {generic?, --------}@  open {open?, -----}@  other_file {other_file?, -----------}@
+ while {while?, -----F}*  generic {generic?, --------}@  has_more {has_more?, ---------}@
+ peek {peek?, -----}@  generic {generic?, --------}@  read_next {read_next?, ----------}@
+ became {became?, -------}@  java_lexer {java_lexer?, -----------}@  lex_char {lex_char?, -NNNNNNNN}?  peek {peek?, -----}@
+ if {if?, --F}*  became {became?, -------}@  nothing {nothing?, --------}@
+ continue {continue?, --------F}*
+ else {else?, ----F}*  if {if?, --F}*  became {became?, -------}@  read_several {read_several?, -------------}@
+ System {System?, -------}@  out {out?, ----}@  print {print?, -----F}*  java_lexer {java_lexer?, -----------}@  snag_buffer {snag_buffer?, -NNNNNNNNNNN}?
+ else {else?, ----F} *
+ System {System?, -------}@  out {out?, ----}@  print {print?, -----F}*  became {became?, -------}@
+ generic {generic?, --------}@  close {close?, ------}@
+ private {private?, -------F}*  static {static?, ------F}*  void {void?, ----F}*  emit_saved_data {emit_saved_data?, ----------------}@  Lexer {Lexer?, ------}@  java_lexer {java_lexer?, -----------}@
+ java_lexer {java_lexer?, -----------}@  surrender_internals {surrender_internals?, --NNNNNNNNNNNNNNNNNN}?
+ static {static?, ------F}*  void {void?, ----F}*  run_tests {run_tests?, ----------}@
+ TestSuite {TestSuite?, NNNNNNNNNN}?  for_classes {for_classes?, ----NNNNNNNN}?  new {new?, ---F}*  TestSuite {TestSuite?, ----------}@
+ for_classes {for_classes?, ------------}@  test_alphabet {test_alphabet?, -NNNNNNNNNNNNN}?
+ for_classes {for_classes?, ------------}@  test_loader {test_loader?, -----NNNNNNN}?  monkey {monkey?, --NNNNN}?  txt {txt?, ----}@  human {human?, -NNNNN}?  checked {checked?, --NNNNNN}?  quine {quine?, NNNNNN}?  not {not?, ---F}*  a {a?, -F}*  test {test?, ----F} *
+ for_classes {for_classes?, ------------}@  test_lexer {test_lexer?, ------NNNNN}?
+ for_classes {for_classes?, ------------}@  test_trie {test_trie?, -----NNNNN}?
+ for_classes {for_classes?, ------------}@  test_iterable_string {test_iterable_string?, -----NNNNNNNNNNNNNNNN}?
+
+	   $|   D|   E|   F|   G|   A|   B|   C|   L|   M|   N|   O|   H|   I|   J|   K|   U|   T|   W|   V|   Q|   P|   S|   R|   _|   Y|   X|   Z|
+First	  -1|  -1|  76|  -1|  -1| 280|  -1|  -1| 471|  -1|  -1|  -1|  -1| 452|  -1|  -1|  -1| 797| 530|  -1|  -1| 286| 327|  -1|  -1|  -1|  -1|  -1|
+	- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+rest	   b|   s|   t|   r|   a|   c|   t|   *|   s|   s|   e|   r|   t|   *|   o|   o|   l|   e|   a|   n|   *|   r|   e|   a|   k|   *|   y|   t|
+skip	   8| 337|   _|   _|   _|   _|   _|   _| 424|   _|   _|   _|   _|   _|  21|   _|   _|   _|   _|   _|   _|  26|   _|   _|   _|   _| 748|   _|
+
+	   f|   g|   d|   e|   b|   c|   a|   n|   o|   l|   m|   j|   k|   h|   i|   w|   v|   u|   t|   s|   r|   q|   p|   z|   y|   x|
+First	  87| 103|  58|  72|  14|  30|   0| 146| 540| 142| 420| 272| 294| 665| 107| 255| 244| 276| 223| 189| 183| 850| 155|  -1| 400|  -1|
+	- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+rest	   e|   *|   a|   s|   e|   *|   t|   c|   h|   *|   h|   a|   r|   *|   l|   a|   s|   s|   *|   o|   n|   s|   t|   *|   t|   i|
+skip	   _|   _|  38|  34|   _|   _|   _|   _|   _|   _|  42| 844|   _|   _|  47| 555|   _|   _|   _|   _|   _|  52|   _|   _|   _|   _|
+
+rest	   n|   u|   e|   *|   e|   f|   a|   u|   l|   t|   *|   o|   *|   u|   b|   l|   e|   *|   l|   s|   e|   *|   n|   u|   m|   *|   x|   t|   e|   n|   d|   s|   *|   i|   n|   a|   l|   *|   l|   y|   *|   l|   o|   a|   t|   *|   o|   r|   *|   o|   t|   o|   *|   f|   *|   m|   p|   l|   e|   m|   e|   n|   t|   s|   *|   o|   r|   t|   *|   n|   s|   t|   a|   n|   c|   e|   o|   f|   *|   t|   *|   e|   r|   f|   a|   c|   e|   *|   o|   n|   g|   *|   a|   t|   i|   v|   e|   *|   e|   w|   *|   a|   c|   k|
+skip	   _|   _|   _|   _|  65|   _|   _|   _|   _|   _|   _|   _|  67|   _|   _|   _|   _|   _|  80|   _|   _|   _|   _|   _|   _|   _| 507|   _|   _|   _|   _|   _|   _|  95| 403|   _|   _|  92|   _|   _|   _| 100| 496|   _|   _|   _| 260|   _| 568| 431|   _|   _|   _| 109|   _| 123|   _| 119|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _| 414| 133|   _|   _|   _|   _|   _|   _|   _|   _| 301| 135|   _|   _|   _|   _|   _|   _|   _| 394| 390|   _|   _| 152|   _|   _|   _|   _|   _| 265|   _|   _| 162|   _|   _|
+
+rest	   a|   g|   e|   *|   r|   i|   v|   a|   t|   e|   *|   o|   t|   e|   c|   t|   e|   d|   *|   u|   b|   l|   i|   c|   *|   e|   t|   u|   r|   n|   *|   h|   o|   r|   t|   *|   t|   a|   t|   i|   c|   *|   u|   p|   e|   r|   *|   w|   i|   t|   c|   h|   *|   y|   n|   c|   h|   r|   o|   n|   i|   z|   e|   d|   *|   h|   i|   s|   *|   r|   o|   w|   *|   s|   *|   r|   a|   n|   s|   i|   e|   n|   t|   *|   y|   *|   o|   i|   d|   *|   l|   a|   t|   i|   l|   e|   *|   h|   i|   l|   e|   *|   a|   l|
+skip	   _|   _|   _|   _| 177| 169| 696|   _|   _|   _|   _| 595|   _|   _|   _|   _|   _|   _|   _| 410| 398|   _|   _|   _|   _| 428| 316|   _|   _|   _|   _| 194|   _|   _|   _|   _| 200|   _|   _|   _|   _|   _| 205| 779|   _|   _|   _| 211|   _|   _|   _|   _|   _| 416|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _| 233| 227|   _|   _|   _|   _|   _| 231|   _|   _| 462| 242|   _|   _|   _|   _|   _|   _|   _| 269|   _|   _| 248|   _|   _|   _|   _|   _|   _|   _|   _|   _| 621|   _|   _|   _|   _| 603| 333|
+
+rest	   s|   e|   *|   u|   l|   l|   *|   u|   e|   *|   a|   v|   a|   ?|   t|   i|   l|   ?|   r|   r|   a|   y|   s|   ?|   r|   o|   j|   e|   c|   t|   2|   ?|   e|   y|   _|   i|   n|   d|   ?|   p|   u|   t|   _|   i|   n|   d|   ?|   o|   t|   h|   i|   n|   g|   ?|   a|   d|   _|   s|   e|   v|   e|   r|   a|   l|   ?|   t|   r|   i|   n|   g|   ?|   b|   e|   t|   ?|   c|   d|   e|   f|   g|   h|   i|   j|   k|   l|   m|   n|   o|   p|   q|   r|   s|   t|   u|   v|   w|   x|   y|   z|   A|   B|   C|   D|   E|
+skip	   _|   _|   _| 309| 548|   _|   _|   _|   _|   _|   _|   _|   _| 476|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _| 644| 580|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _| 663|   _|   _|   _|   _|   _|   _|   _|   _| 588| 682|   _|   _|   _|   _|   _|   _|   _| 687|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|
+
+rest	   F|   G|   H|   I|   J|   K|   L|   M|   N|   O|   P|   Q|   R|   S|   T|   U|   V|   W|   X|   Y|   Z|   _|   $|   ?|   o|   k|   s|   ?|   i|   k|   e|   ?|   t|   ?|   o|   u|   ?|   l|   e|   s|   ?|   n|   e|   ?|   i|   p|   e|   ?|   s|   ?|   a|   f|   e|   ?|   a|   i|   n|   ?|   r|   g|   s|   ?|   u|   n|   ?|   e|   t|   _|   f|   i|   l|   e|   _|   n|   a|   m|   e|   s|   ?|   _|   t|   e|   s|   t|   s|   ?|   n|   p|   u|   t|   F|   i|   l|   e|   1|   ?|   x|   t|   ?|   _|   l|   i|   s|
+skip	   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _| 710| 407|   _|   _|   _|   _|   _|   _|   _| 544|   _| 465|   _| 522|   _|   _| 744|   _|   _|   _|   _| 704| 706| 483|   _|   _| 593| 559|   _|   _| 716|   _|   _|   _|   _|   _| 445|   _| 754|   _| 562|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _| 719|   _|   _|   _| 616|   _|   _|
+
+rest	   t|   ?|   e|   x|   e|   r|   ?|   _|   l|   e|   x|   e|   r|   ?|   v|   e|   _|   k|   e|   y|   _|   w|   o|   r|   d|   s|   ?|   a|   g|   _|   p|   r|   o|   g|   r|   a|   m|   ?|   m|   i|   t|   _|   s|   a|   v|   e|   d|   _|   d|   a|   t|   a|   ?|   s|   t|   _|   f|   i|   l|   e|   ?|   o|   r|   d|   L|   o|   a|   d|   e|   r|   ?|   p|   e|   n|   ?|   r|   s|   t|   ?|   m|   b|   e|   r|   ?|   f|   ?|   o|   s|   e|   ?|   n|   y|   ?|   l|   i|   n|   e|   s|   ?|   _|   f|   i|   l|
+skip	   _|   _| 651|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _| 673|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _| 553|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _| 693| 657|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _| 806|   _|   _|
+
+rest	   e|   _|   n|   a|   m|   e|   s|   ?|   n|   _|   i|   n|   p|   u|   t|   ?|   L|   i|   n|   e|   ?|   m|   ?|   e|   m|   a|   t|   u|   r|   e|   ?|   u|   n|   c|   t|   i|   o|   n|   a|   l|   i|   t|   y|   ?|   y|   e|   a|   h|   ?|   a|   s|   t|   e|   f|   u|   l|   ?|   c|   o|   u|   n|   t|   ?|   o|   r|   e|   L|   i|   n|   e|   s|   ?|   w|   _|   f|   i|   l|   e|   ?|   o|   a|   d|   e|   r|   ?|   _|   k|   e|   y|   s|   ?|   n|   ?|   a|   s|   _|   m|   o|   r|   e|   ?|   n|   t|
+skip	   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _| 635|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _| 629|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _| 834|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _| 839|   _|   _|   _|   _|   _|   _|   _| 701|   _|
+
+rest	   e|   r|   _|   k|   e|   y|   ?|   n|   e|   x|   t|   ?|   y|   s|   t|   e|   m|   ?|   u|   t|   ?|   n|   t|   l|   n|   ?|   o|   f|   ?|   n|   ?|   e|   n|   t|   ?|   a|   s|   t|   ?|   o|   ?|   d|   d|   ?|   o|   g|   g|   l|   e|   _|   k|   e|   y|   _|   m|   o|   d|   e|   ?|   t|   h|   e|   r|   _|   f|   i|   l|   e|   ?|   e|   e|   k|   ?|   e|   c|   a|   m|   e|   ?|   n|   e|   r|   i|   c|   ?|   e|   x|   _|   c|   h|   a|   r|   ?|   n|   a|   g|   _|   b|   u|   f|   f|   e|   r|
+skip	   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _| 734|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _| 714|   _|   _|   _| 760|   _|   _|   _| 768|   _|   _|   _|   _| 814|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|
+
+rest	   ?|   r|   r|   e|   n|   d|   e|   r|   _|   i|   n|   t|   e|   r|   n|   a|   l|   s|   ?|   e|   s|   t|   S|   u|   i|   t|   e|   ?|   c|   l|   a|   s|   s|   e|   s|   ?|   e|   s|   t|   _|   a|   l|   p|   h|   a|   b|   e|   t|   ?|   l|   o|   a|   d|   e|   r|   ?|   n|   k|   e|   y|   ?|   u|   m|   a|   n|   ?|   e|   c|   k|   e|   d|   ?|   u|   i|   n|   e|   ?|   e|   x|   e|   r|   ?|   t|   r|   i|   e|   ?|   i|   t|   e|   r|   a|   b|   l|   e|   _|   s|   t|   r|   i|   n|   g|   ?|
+skip	   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _| 827|   _|   _|   _|   _|   _|   _|   _|   _| 860| 855|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _| 865|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.