#include <stddef.h>
#include <stdint.h>
#include <stdlib.h> 
#include <stdbool.h>
#include <string.h>
#include <stdio.h>

const char s[4096];

struct nfa_stack
{
	void *data;
	unsigned long sz;
};

struct nfa_bp_rec
{
	long state;
	const char *p;
	long popTrans;
	long q_2;
};

static const char  _genrep_key_offsets [] = { 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 0 ,  };
static const unsigned char  _genrep_trans_keys [] = { 97u, 97u, 0u,  };
static const char  _genrep_single_lengths [] = { 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0 ,  };
static const char  _genrep_range_lengths [] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ,  };
static const char  _genrep_index_offsets [] = { 0, 0, 1, 3, 4, 5, 6, 8, 9, 10, 0 ,  };
static const char  _genrep_trans_cond_spaces [] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 0 ,  };
static const char  _genrep_trans_offsets [] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0 ,  };
static const char  _genrep_trans_lengths [] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0 ,  };
static const char  _genrep_cond_keys [] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 ,  };
static const char  _genrep_cond_targs [] = { 0, 3, 0, 0, 0, 0, 7, 0, 0, 9, 0, 0 ,  };
static const char  _genrep_cond_actions [] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0 ,  };
static const char  _genrep_nfa_targs [] = { 0, 1, 2, 3, 5, 2, 4, 1, 6, 3, 8, 6, 4, 0 ,  };
static const char  _genrep_nfa_offsets [] = { 0, 1, 0, 3, 0, 7, 0, 9, 0, 0, 0 ,  };
static const char  _genrep_nfa_push_actions [] = { 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0 ,  };
static const char  _genrep_nfa_pop_trans [] = { 0, 0, 4, 0, 7, 6, 5, 0, 4, 0, 7, 6, 5, 0 ,  };
static const int  genrep_start  = 1;
static const int  genrep_first_final  = 9;
static const int  genrep_error  = 0;
static const int  genrep_en_main  = 1;
int test( const char *p )
{
	int len = strlen( p ) + 1;
	const char *pe = p + len;
	const char *eof = pe;
	int cs;
	
	struct nfa_bp_rec *nfa_bp = (struct nfa_bp_rec*) s;
	long nfa_len = 0;
	long nfa_count = 0;
	
	long q_2 = 0;
	
	printf( "testing: %s\n", p );
	
	
	{
		cs = ( int ) genrep_start;
		nfa_len = 0;
	}
	
	{
		unsigned int _nfa_cont = 1;
		unsigned int _nfa_repeat = 1;
		while ( _nfa_cont != 0  )
		{
			int _klen;
			const unsigned char  *_keys;
			const char  *_ckeys;
			int _cpc;
			unsigned int _trans;
			unsigned int _cond = 0;
			unsigned int _have = 0;
			unsigned int _cont = 1;
			while ( _cont == 1  )
			{
			
				if ( cs == 0  )
				_cont = 0;
				
				_have = 0;
				if ( p == pe  )
				{
					if ( _have == 0  )
					_cont = 0;
					
				}
				
				if ( _cont == 1  )
				{
					if ( _have == 0  )
					{
						if ( _genrep_nfa_offsets[cs] )
						{
							int alt = 0; 
							int new_recs = _genrep_nfa_targs[( int ) _genrep_nfa_offsets[cs]];
							while ( alt < new_recs  )
							{ 
								nfa_bp[nfa_len].state 
								= _genrep_nfa_targs[( int ) _genrep_nfa_offsets[cs]+ 1 + alt];
								nfa_bp[nfa_len].p 
								= p;
								nfa_bp[nfa_len].popTrans 
								= ( long ) _genrep_nfa_offsets[cs]+ 1 + alt;
								switch ( _genrep_nfa_push_actions[( int ) _genrep_nfa_offsets[cs]+ 1 + alt] ) {
									case 1 :
									{
										nfa_bp[nfa_len].q_2 = q_2;
										
									}
									
									break;
									
								}
								nfa_len += 1;
								alt += 1;
							}
							
						}
						
						_keys = _genrep_trans_keys + _genrep_key_offsets[cs];
						_trans = ( unsigned int  ) _genrep_index_offsets[cs];
						_have = 0;
						_klen = ( int ) _genrep_single_lengths[cs];
						if ( _klen > 0  )
						{
							const unsigned char  *_lower;
							const unsigned char  *_mid;
							const unsigned char  *_upper;
							_lower = _keys;
							_upper = _keys + _klen - 1;
							while ( _upper >= _lower && _have == 0  )
							{
								_mid = _lower + ((_upper-_lower)>> 1);
								if ( ((*( p  ))
								)< (*( _mid  ))
								)
								_upper = _mid - 1;
								
								else if ( ((*( p  ))
								)> (*( _mid  ))
								)
								_lower = _mid + 1;
								
								else
								{
									_trans += ( unsigned int  ) (_mid - _keys);
									_have = 1;
								}
								
							}
							
							if ( _have == 0  )
							{
								_keys += _klen;
								_trans += ( unsigned int  ) _klen;
							}
							
						}
						
						
						if ( _have == 0  )
						{
							_klen = ( int ) _genrep_range_lengths[cs];
							if ( _klen > 0  )
							{
								const unsigned char  *_lower;
								const unsigned char  *_mid;
								const unsigned char  *_upper;
								_lower = _keys;
								_upper = _keys + (_klen<<1)- 2;
								while ( _have == 0 && _lower <= _upper  )
								{
									_mid = _lower + (((_upper-_lower)>> 1)& ~1);
									if ( ((*( p  ))
									)< (*( _mid  ))
									)
									_upper = _mid - 2;
									
									else if ( ((*( p  ))
									)> (*( _mid + 1  ))
									)
									_lower = _mid + 2;
									
									else
									{
										_trans += ( unsigned int  ) ((_mid - _keys)>>1);
										_have = 1;
									}
									
								}
								
								if ( _have == 0  )
								_trans += ( unsigned int  ) _klen;
								
							}
							
						}
						
						
						_ckeys = _genrep_cond_keys + _genrep_trans_offsets[_trans];
						_klen = ( int ) _genrep_trans_lengths[_trans];
						_cond = ( unsigned int  ) _genrep_trans_offsets[_trans];
						_have = 0;
						_cpc = 0;
						switch ( _genrep_trans_cond_spaces[_trans] ) {
							case 0 :
							if ( (p+1 == eof ) )
							_cpc += 1;
							
							
							break;
							
						}
						{
							const char  *_lower;
							const char  *_mid;
							const char  *_upper;
							_lower = _ckeys;
							_upper = _ckeys + _klen - 1;
							while ( _have == 0 && _lower <= _upper  )
							{
								_mid = _lower + ((_upper-_lower)>> 1);
								if ( _cpc < ( int ) (*( _mid  ))
								)
								_upper = _mid - 1;
								
								else if ( _cpc > ( int ) (*( _mid  ))
								)
								_lower = _mid + 1;
								
								else
								{
									_cond += ( unsigned int  ) (_mid - _ckeys);
									_have = 1;
								}
								
							}
							
							if ( _have == 0  )
							{
								cs = 0;
								_cont = 0;
							}
							
						}
					}
					
					if ( _cont == 1  )
					{
						cs = ( int ) _genrep_cond_targs[_cond];
						switch ( _genrep_cond_actions[_cond] ) {
							case 8 :
							{
								printf( "------ MATCH\n" ); 
							}
							
							break;
							
						}
						if ( cs == 0  )
						_cont = 0;
						
						if ( _cont == 1  )
						p += 1;
						
					}
				}
				
			}
			
			_nfa_repeat = 1;
			while ( _nfa_repeat  )
			{
				_nfa_repeat = 0;
				if ( nfa_len > 0  )
				{
					int _pop_test = 1;
					nfa_count += 1;
					nfa_len -= 1;
					p = nfa_bp[nfa_len].p;
					switch ( _genrep_nfa_pop_trans[nfa_bp[nfa_len].popTrans] ) {
						case 4 :
						_pop_test = (({
							q_2 = nfa_bp[nfa_len].q_2;
							1;
						}) );
						if ( !_pop_test  )
						break;
						
						_pop_test = (({  q_2 = 0; 1; })
						);
						
						break;
						case 5 :
						_pop_test = (({
							q_2 = nfa_bp[nfa_len].q_2;
							1;
						}) );
						if ( !_pop_test  )
						break;
						
						_pop_test = (({ 1; })
						);
						
						break;
						case 6 :
						_pop_test = (({
							q_2 = nfa_bp[nfa_len].q_2;
							1;
						}) );
						if ( !_pop_test  )
						break;
						
						_pop_test = (({ ++q_2 < 3; })
						);
						
						break;
						case 7 :
						_pop_test = (({
							q_2 = nfa_bp[nfa_len].q_2;
							1;
						}) );
						if ( !_pop_test  )
						break;
						
						_pop_test = (({ ++q_2 >= 2; })
						);
						
						break;
						
					}
					if ( _pop_test  )
					{
						cs = nfa_bp[nfa_len].state;
						_nfa_cont = 1;
						_nfa_repeat = 0;
					}
					
					else
					{
						_nfa_cont = 0;
						_nfa_repeat = 1;
					}
					
				}
				
				else
				{
					_nfa_cont = 0;
					_nfa_repeat = 0;
				}
				
			}
			
		}
		
	}
	return 0;
}

int main()
{
	test( "a" );
	test( "aa" );
	test( "aaa" );
	test( "aaaa" );
	test( "aaaaa" );
	test( "aaaaaa" );
	test( "aaaaaaa" );
	test( "aaaaaaaa" );
	return 0;
}