Commits

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. ()

  • Participants
  • Parent commits f49430c

Comments (0)

Files changed (10)

File FakeTrie.java

-
-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;
+	}
+
+}

File FlatTrie.java

 	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 );
 	}
 }
 

File LexTester.java

+
+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;

File Project2.java

 	{
 		//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();
 	}
 }

File Storage.java

 	public abstract void reveal_thyself();
 
 	public abstract void reveal_thyself( boolean overloading );
+
+	public abstract boolean t_matches_state( T_Flag should_be );
 }

File TestSuite.java

 
 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";

File TrieTester.java

+
+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|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|   _|